函数参数/作用域/args/kwargs
1.参数
1.1参数基本知识
任意个数
-
任意类型
func("1",True)
1.2位置传参(调用函数并传入参数)
def func(a1,a2):
pass
func(1)#缺少位置参数
func(1,2,3)#多了位置参数
1.3关键字传参
def func(a1,a2):
pass
func(a2=99,a1=2)#根据形参名字传入值
1.4关键字传参和位置传参可以混合使用
注意：位置参数在前 关键字参数在后，总和参数个数要和函数参数个数相等
def func(a1,a2,a3):
pass
func(1,a2=3,a3=9)#根据形参名字传入值
func(a1=1,3,9)#报错 关键字参数在前
func(1,a1=2,a3=9)#报错 a1得到多个值
func(1,a2=0,9)#报错 关键字在前
1.5默认参数[定义]
参照open()函数
注意：如果默认值是可变类型
def func(a1,a2=9)#a2可传可不传
pass
func(1,2)#给a2传新值 覆盖默认值
func(1)#默认a2=9
1.6 万能参数(*args）—>arguments 多个参数
args：接受n个位置参数
可以接受任意类型参数，并转换为元组
-
调用时候无*
#args循环遍历每个位置参数 一个一个放入args中 并转换为元组
def func(*args):
print(args) func(1) # (1,)
func(1, 2, 3) # (1,2,3)
func(1, 2, [1, 23], "True", "alex")
func((1, 2, 3))
# 该元组作为一个单元素传入 -->元组嵌套((1，2，3),))
#(1,)
# (1, 2, 3)
# (1, 2, [1, 23], 'True', 'alex')
# ((1, 2, 3),)) -
调用时有：直接将后面的位置参数转换为元组
def func(*args):
print(args) func(*(1, 2, 3)) # 打散传入元组 变成多个变量传入args -->(1,2,3)
func(*[1, 2, 3]) # args原理是 循环遍历每个元素 添加到元组中(1，2，3)
#(1, 2, 3)
#(1, 2, 3) -
只能用位置传参
def func(a1,*args,a2):
pass
func(1,2,3,4,a2=0)#a2只能关键字传参
#a1=1 args=(2,3,4)
1.7键值万能参数(**kwargs)
-
接收任意个关键字参数
def func(**kwargs):
print(kwargs) func(k1=1,k2="gao")#kwargs={"k1":1,"k2":"gao"} -
调用时有*
def func(**kwargs):
print(kwargs)
func(**{"k1":1,"k2":"gao"})#kwargs=kwargs={"k1":1,"k2":"gao"} -
调用时候无*
def func(**kwargs):
print(kwargs)
func(k1=1,k2="gao")#kwargs={"k1":1,"k2":"gao"} 只能用关键字传参
-
综合应用
def func(*args,**kwargs):
print(args,kwargs)
func(*[1,2,3],k1=2,k5=9,k19=999)#(1,2,3) {"k5":9,"k19":999}
func(*[1,2,3],**{"k1":"1","k2":2})#(1,2,3){"k1":"1","k2":2}
func(11,22,*[1,2,3],k11=333,k33="bb")#(11,22,1,2,3) {"k11":333,"k3":"bb"}#5.看代码写结果 # def func(name,age=19,email='123@qq.com'):
# pass # a. 执行 func('alex') ,判断是否可执行，如可以请问 name、age、email 的值分别是？
#可行 name=alex age=19 email=123@qq.com # b. 执行 func('alex',20) ,判断是否可执行，如可以请问 name、age、email 的值分别是？
#可行 name:alex age:20 email:123@qq.com # c. 执行 func('alex',20,30) ,判断是否可执行，如可以请问 name、age、email 的值分别是？
#可行 name:alex age:20 email:30 # d. 执行 func('alex',email='x@qq.com') ,判断是否可执行，如可以请问 name、age、email 的值分别是？
#可行 name:alex age:19 email:x@qq.com # e. 执行 func('alex',email='x@qq.com',age=99) ,判断是否可执行，如可以请问 name、age、email 的值分别是？
#alex 99 x@qq.com # f. 执行 func(name='alex',99) ,判断是否可执行，如可以请问 name、age、email 的值分别是？
#不可行 关键字参数在前 位置参数在后 # g. 执行 func(name='alex',99,'111@qq.com') ,判断是否可执行，如可以请问 name、age、email 的值分别是？
#不可行
练习
c. 请将执行函数，并实现让args的值为 ([11,22],33) 且 kwargs的值为{'k1':'v1','k2':'v2'}
def func(*args,**kwargs):
print(args)
print(kwargs)
val=func([11,22],33,k1="v1",k2="v2")
val1=func(*[[11,22],33],k1="v1",k2="v2")
#第一种：传入多个位置参数 循环遍历加入args后 变成元组
#第二种：类似强制转换方式 tuple([[11,22],33])将*后面的转换为元组
([11, 22], 33)
{'k1': 'v1', 'k2': 'v2'}
#————————————————————————————————————————————————————————
([11, 22], 33)
{'k1': 'v1', 'k2': 'v2'}
2.作用域
2.1全局作用域
2.1局部作用域
2.3总结
-
一个函数是一个作用域
def func():
x=9
print(x)
func()
print(x)#报错 -
作用域中查找数据规则：优先自己作用域查找，再去自己父级作用域查找，直到找到全局作用域为止
x=10
def func():
x=9
print(x)#9
func()
print(x)#10- 注意：函数的调用顺序
x = 10 def func():
x = 8
print(x) # 8 def func2():
x = 999
print(x) # 999 print(x) # 8
func2() func() # 执行 8 8 999#
x = 10 def func():
x = 8
print(x) # 8 def func2():
x = 999
print(x) # 999 print(x) # 8
func2() #
print(x) # 8
#func2函数执行完毕后 内部局部变量x被销毁掉 所以不会对自己内部的变量进行重新赋值 func() # 执行8 8 999 8 -
子作用域中只是读取或者修改【列表类型等可变类型】父级作用域的值，【默认】无法为父级的变量重新赋值 ，子作用域只是在自己内部重新开辟一块空间，为该变量赋值。但是通过添加global /nonlocal 关键字可以为父级的指定变量重新赋值
NUM=[1,2,3]
def func():
#NUM.append(999)#可以修改父级可变类型的值
print(NUM)#[1,2,3,999] -
global ：找到全局作用域中的变量
name = "gao" def func():
name = "chen"
print(name) # chen def func2():
global name # 找到全局变量name
name = "gao_chen"#为全局变量的name重新赋值
print("val:" + name) # func2内部的name gao_chen print(name) # func 内部的chen
func2() #
print(name) # chen func() # 函数执行
print(name) # gao_chen 内部函数通过global修改lname的值 #chen
#chen
#val:gao_chen
#chen
#gao_chen nonlocal ：找到父级作用域中指定变量 ，【必须是父级作用域 不包括全局作用域】
-
如果父级（父级的父级…..）作用域中不存在 则报错
name = "gao" def func():
name = "chen"
print(name) # chen def func2():
nonlocal name # 找到父级作用域的name(func中的name)
name = "gao_chen"
print("val:" + name) # gao_chen print(name) # chen
func2() #
print(name) # gao_chen func() #
print(name) # gaoname = "gao" def func():
print(name) def func2():
nonlocal name #报错 可以是父级，父级的父级 但是不能是全局
name = "gao_chen"
print("val:" + name) print(name)
func2()
print(name) func() #
print(name) #SyntaxError: no binding for nonlocal 'name' found name = "gao" def func():
name = "hahahaha"
print(name) # hahahaha def func2():
print("val:" + name) # val:hahahaha def inner():
nonlocal name#不报错 父级的父级的name
name = "test" inner() print(name) # hahahaha
func2()
# 其内部函数inner()也会被func2执行 因为inner()内部定义nonlocal关键字
# 所以父级作用域的func()函数的name会被重新赋值
print(name) # test 被局部修改 func() #
print(name) # gao 没有被改变
#hahahaha
#hahahaha
#val:hahahaha
#test
#gao 全局变量尽量大写
3.总结
-
函数类型
- def func()
- def func(a1,a2=None)
- def func(*args,**kwargs)
-
函数参数
-
形参
- def func()
- def func(a1,a2=None)
- def func(*args,**kwargs)
-
实参
位置传参
关键字传参
传参规则： 位置参数在前，关键字参数在后
默认参数
-
万能传参
-
*args:位置传参—>可传任意类型 ——>都会转为元组
- 调用函数时候有*
- 调用函数时候没有*
-
**kwargs:关键字传参——>转为字典
- 调用函数时候有*
- 调用函数时候没有*
-
-
-
作用域
局部和全局
一个函数一个作用域
-
作用域查找规则:
- 自己没有父级 父级再找父级，父级都没有找全局
- 自己->父级->父级->全局[读/修改(可变)]
- 子作用域内不能为父级作用域内的变量重新赋值 只能读取或者修改[可变类型]
-
重新赋值：
- global
- nonlocal
函数嵌套