函数初始后续与进阶

函数参数

位置参数

#位置参数
def my_sum(a,b):
    return a+b
my_sum(1,2)

关键字参数

#关键字传参
def my_sum(a,b):
    return a+b
my_sum(b=1,a=2)

#关键字参数可以和位置参数混合使用
# 位置参数一定要在关键字参数之前

def my_sum(a,b):
    return a+b
#错误使用例子
my_sum(1,a=2)#报错
my_sum(a =1,2)#报错
my_sum(b =1,2)#报错
#正确使用例子
my_sum(2,b=1)

默认参数

# 默认参数
def classmate(name,age=18):#默认参数age，可更改，如果不传参默认十八岁
    print('%s :%s '%(name,age))
#定义函数时 位置参数一定要在默认参数之前
classmate('jcc')#正确

动态参数

#动态参数(用于传多个参数)

#*args 接受的是按照位置传参的值，组织成一个元组
def my_sum(*args):
    sum = 0
    for i in args:
        sum +=i
    print(sum)
    print(args)
my_sum(1,2,3,4,5)

#**kwargs 接受的是按照关键字传参的值，组织成一个字典
def fun(**kwargs):
    print(kwargs)
fun(a=1,b=2,c=4)

两种动态参数混合使用

#同时用*args，**kwargs
def func(*args,**kwargs):
    print(args,kwargs)
func(1,2,3,4,a=1,b=2)#必须先传位置参数，再传关键字参数

动态参数的另一种传参方式

#动态参数的另外一种传参方式
def func1(*args):
    print(args)
list1 = [1,2,3,4,5]
func1(*list1)#在实参的角度，给一个序列（列表，元组等）加上*，就是将这个序列按照顺序打散传入

函数进阶

命名空间

内置命名空间：--python解释器
　　1.python解释器一启动就可以使用的名字存储在内置命名空间
　　2.内置的名字在启动解释器的时候被加载进内存里
全局命名空间：--我们写的代码但不是函数中的代码
　　1.在程序从上到下执行的过程中依次被加入内存中
　　2.放置了设置的所有变量名和函数名
局部命名空间：--函数
　　1.定义在函数中的名字
　　2.调用函数时才会产生名称空间，随着函数执行的结束，该命名空间也随之被收回
在局部：可以使用全局，内置命名空间中的名字
在全局：可以使用内置命名空间中的名字，不能使用局部的
每一个函数都有自己的名称空间，互不影响

作用域

全局作用域--所有代码
局部作用域--函数

a = 1
def func1():
    a=a+1   #报错，对于不可变数据类型，在局部可以查看全局变量，但是不可以直接修改

def func2():
    global a    #加global（声明了一个全局变量）可以修改，尽量避免使用
    a+=1

locals()  globals()

　　locals()
　　查看所有本地命名空间中的名字，放在局部命名空间就打印局部命名空间中的名字
　　globals()
　　查看所有全局命名空间中的名字，和内置命名空间中的名字

函数的嵌套

在嵌套函数中，内部函数可以使用外部函数的变量，但不可以修改（对于不可变数据类型）

# nonlocal：声明一个上层的局部变量，注意 只是局部变量
a = 1
def outer():
    a = 1
    def inner():
        nonlocal a
        a=2
        print('inner %d'%a)
    inner()
    print('outer %d'%a)
outer()
print('local %d'%a)

闭包

 闭包：嵌套函数，内部函数要调用外部函数的变量

def outer():
    a = 1
    def inner():
        print(a)
    print(inner.__closure__)#如果打印出cell，说明是一个闭包函数
    return inner
inner = outer()
inner()#调用inner