3、函数

s1 = 'helloworld'

def my_len(s):   #def定义一个函数的名字叫做my_len.传了一个参数s、函数名不能是关键字、不能已数字开头
    sum = 0
    for i in s:     #s为参数的位置
        sum += 1
    return sum      #返回sum的值

print(my_len(s1))   #调用函数并把s1传入函数中

返回值的三种情况：
1、没有返回值
2、返回一个值
    可以返回任何数据类型
    只要返回了，就可以接收到
    如果在一个程序中有多个return，只执行第一个，后边的都不执行
3、返回多个值
    返回多个值需要多少个变量去接收，多少个返回值就有多少个变量，多了不行，少了也不行
    可以用一个变量去接收，变量的接收值为一个元祖

1、没有返回值
不写return

def func():
    l = ['金老板','二哥']
    for i in l:
        print(i)
print(func())

只写return

def func():
    l = ['金老板','二哥']
    for i in l:
        print(i)
    return   #函数中只要执行了return，则后边的所有操作都不执行
print(func())

返回一个值

def func1():
    return {'k','v'}
print(func1())

返回多个值

def func2():
    return 1,2
r1,r2 = func2()
print(r1,r2)

参数
    没有参数，括号里不写任何数据
    一个餐宿
    多个参数
        位置参数(有多少个参数，函数调用的时候就必须多少个元素，且必须按照参数的顺序来写)
        按照关键字传参

def my_sum(a,b):
    print(a,b)
    res = a+b
    return res

站在实参的角度上：

ret = my_sum(2,1)   #按位置传参
ret = my_sum(b=1,a=2)  #按照关键字传参
ret = my_sum(1,b=2)   #可以混着用，但先必须按照位置传参，再按照关键字传参，不能给同一个变量传多个值
print(ret)

站在形参的角度上：
    位置参数：必须传（多传少传都不行）
    默认参数：可以不传的参数，如果不传就使用默认的参数，如果穿了就是用传的
    动态参数有两种：（可以接受任意个参数）
        *args ：接收的是按照位置传参的值，组织成一个元祖
        **kwargs ： 接收的是按照关键字传参的值，组织成一个字典

def classmate(name,sex='男'):  #默认参数
    print('{}:{}'.format(name,sex))
classmate('二哥','男')
classmate('春哥')
classmate('张三','女')

def sum1(*args): #动态参数
    n = 0
    for i in args:
        n += i
    return n
print(sum1(1,2,3,4))

函数进阶

a = 1
def func():
    print(a)
func()

命名空间和作用域

内置命名空间--Python解释器
    就是Python解释器一启动就可以使用的名字，存储在内置的命名空间中
    内置的名字在启动解释器的时候被加载进内存里
全局命名空间--我们写的代码，不是函数中的代码
    是程序从上到下被执行的过程中一次加载进内存的
    放置了我们设置的所有变量名和函数名
局部命令空间--函数
    就是函数内部定义的名字
    当调用函数的时候才会产生这个名称空间，随着函数执行的结束，这个命名空间就又消失了

在局部：可以使用全局命名空间中的名字、也可以使用内置命名空间的名字
在全局：可以使用内置命名空间中的名字、不能使用局部命名空间中的名字
在内置：不能使用全局和局部的名字

在正常情况下，直接使用内置的名字
当我们在全局定义了和内置命名空间中一样的名字，我们调用是会使用全局的名字
当我自己有的时候，我就不找我的上级要了
如果自己没有就找上级要

def input():
    print('in input now')
def func():
    input()    #调用的全局命名空间中自己定义的input函数
func()

作用域有两种
    全局作用域------作用在全局(包含内置和全局名字空间都属于全局作用域)---globals()
    局部作用域------作用在局部-（函数）局部名字空间中的名字属于局部作用域--locals()

对于不可变数据类型，在局部可是查看全局作用域中的变量
但是不能直接修改
如果想要修改，需要再函数的一开始添加global声明，那么这个变量在局部的所有操作将对全局的变量生效

a = 1
def func():
    global a   #
    a = 2
func()
print(a)   #此刻a=2

a = 1
b = 2
def fun():
    x='aaaa'
    y='bbbbb'
    print(locals())
    print(globals())
fun()
print(globals())
print(locals())

关于globals 永远打印全局的名字
locals输出什么根据locals所在的位置，在全局 就输出全局，在局部就输出局部


函数嵌套：在函数体了去调用宁外一个函数，则叫函数嵌套
实例:比较三个数的大小

def max(a,b):     #定义一个函数比较两个数的大小
    return a if a > b else b    #三元运算

def the_max(x,y,z):
    c = max(x,y)    #调用上边的函数先比较前两个数的大小
    return max(c,z)   #再把上边的结果和最后一个数比较，则返回出最大的数字

print(the_max(1,5,2))

函数的嵌套定义：
内部函数可以使用外部函数的变量

a = 1
def outer():
    a = 1
    def inner():
        b = 2
        print(a)
        print('inner')
        def inner2():
            nonlocal a   #nonlocal   声明了一个上层局部变量
            a += 1
            print(b)
            print('inner2')
        inner2()
    inner()
    print('局部的a:', a)
outer()
print('全局的a',a)

nonlocal  只能用于局部变量，找上层中离当前函数最近一层的局部变量

def func():
    print('123')
func()  #函数名就是内存地址
func2 =func   #函数名可以复制
func2()

l = [func,func2]   #函数名可以作为容器类型的数据
print(l)
for i in l:
    i()


def func():
    print(123)
def wahaha(f):
    f()
    return f       #函数名可以作为函数的返回值
q = wahaha(func)    #函数名可以作为函数的参数
print(q())

闭包
闭包一定是嵌套函数，切内部函数调用外部函数的变量

def outer():
    a = 1
    def inner():    #在这里inner就为一个闭包
        print(a)
    print(inner.__closure__)#打印某函数的closure，结果里边有cell，则该函数是一个闭包
outer()

import  urllib   #导入模块（一个Python文件）
from  urllib.request import urlopen
# ret = urlopen('http://www.xiaohuar.com/').read()
# print(ret)
#用闭包
def get_url():
    url = 'http://www.xiaohuar.com/'
    def get():
        ret = urlopen(url).read()
        print(ret)
    return get

get_func = get_url()
get_func()