目录内容

参数

作用域

函数嵌套

内容详细：

time.sleep()的用法：
import time#使用time模块
result = [1,1]
while True:
num = result[-1] + result[-2]
result.append(num)
if result[-1] >= 100:
break
print(result)
time.sleep(1) # 设置time睡眠时间，每隔一秒打印一次

1.参数

基本参数

任意个数

任意类型

def func(a1,a2,a3):
print(a1,a2,a3)
func(1,"sadf",True)

位置传参

调用函数并传入参数

def func(a1,a2)
print(a1,a2)
func(1,2)

关键字传参

关键字传参数可以和位置参数混合使用

位置传入的参数在前 > 关键字参数在后 == 总参数个数 (永远遵循此规则)

def func(a1,a2):
print(a1,a2)
func(a2=1,a1=2)

#示例：

def func(a1,a2,a3):
print(a1,a2,a3)
#func(a2=1,a1=2,a3=3)
#func(1,a2=2,a3=3)
#func(a1=1,a2=2,3) 错误，位置参数应在前，关键字参数应在后，
#func(1,a2=2,3) 错误，位置参数应在前，关键字参数应在后，

默认参数

调用函数时，默认参数可传可不传

默认参数规则放后面

def func(a1,a2=2,a3=3):
print(a1,a2,a3)
#func(a1=1,a2=2,a3=333)
#func(1)

万能参数（参数打散）

*args(规范使用此变量命名)

可接收任意个数的位置参数，并将参数转换成元组。

函数调用有*，传参会把值打散了传入args元组内，变成元组的各个元素

函数调用无*，传参会把值作为args的第0个元素传入

只能用位置参数传参

def func(*args):
print(args)
#func(1,22,33,(1,2,3),["asf",789],"oiquwer") 都可传入一个值的args，args为（传入值组成的元组tuple）
#func(*(11,22,33)) 结果为(11,22,33)
#func((11,22,33)) 结果为((11,22,33))
def func(a1,*args):
print(a1,args)
# func(1,(11,22,33)) 结果为1，(11,22,33)
# func(1,2,3,4,5,6) 结果为1,(2,3,4,5,6)
**kwargs（规范使用此变量命名）

可接收任意个数的关键字参数，并将参数转换为键值对放入字典中

函数调用有*(必须为两个*)，只能传字典，值为传入的字典

函数调用无*，根据关键字传参，会直接生成键值对加入字典

只能用关键字参数传参

def func(**kwargs):
print(kwargs)
func(k1=1,k2="asdf") #结果为 {'k1': 1, 'k2': 'asdf'}
func(**{"k1":1,"k2":"asdf"}) #结果为 {'k1': 1, 'k2': 'asdf'}

混合使用

可接收任意参数（位置参数+关键字参数）

def func(*args,**kwargs):
print(args,kwargs)
func(1,2,3,k1=55,k2=89)#结果为(1,2,3) {'k1':55,'k2':89}
func(*[1,2,3],k1=55,k2=89)#结果为(1,2,3) {'k1':55,'k2':89}
func(*[1,2,3],**{"k1":55,"k2":89})#结果为(1,2,3) {"k1":55,"k2":89}
func(11,22,*[1,2,3],k1=55,k2=89,**{"k11":55,"k12":89})
#结果为(11, 22, 1, 2, 3) {'k1': 55, 'k2': 89, 'k11': 55, 'k12': 89}

参数重点（掌握）

定义函数(以后常见的函数样式)

def func1(a1,a2):
pass
def func2(a1,a2=None):
pass
def func3(*args,**kwargs):
pass

调用函数（传参）

一定要记住，位置参数在前，关键字参数在后

2.作用域

python中：

py文件：全局作用域

函数：局部作用域

a=1
def func():
x1=666
print(x1)
print(a)
print(b)
b=2
func()# 666,1,2
print("----------分界线1----------")
a = 8888
def func2():
print(a,b) #从上往下执行，如果函数体内有变量在全局更改了，则执行到调用函数的前面才重新赋值
func()
func2() #报错，因为从上往下执行中，b没有值
b=2222
print("----------分界线2----------")
#从上往下执行，如果函数体内有变量在全局更改了，则执行到调用函数的前面才重新赋值
a=1
def func():
x1=666
print(x1)
print(a)
print(b)
b=2
b=222
func()#调用函数时，输出结果为x1=666,a=1,b=222
b=8888
print(b)#输出结果为8888
#错误示例
def func():
x1=666
print(x1)
func()

print(x1)#因为x1的作用域在函数体中，全局调用不了函数体内局部作用域的赋值

总结：

一个函数就是一个作用域

作用域中查找数据规则：优先在自己的作用域找数据，自己没有就去 "父级" -> 全局作用域 去找，全局里没有就报错

注意：父级作用域中的值到底是什么

x = 11
def func():
x = 8
print(x) #8
def x1():
print(x) #8
x1()
x = 9
x1() #9
x = 10
print(x) #10
func()

子级作用域中重新赋值，不会影响到父级和全局的变量赋值

子级作用域中修改可变类型变量，则会影响到父级和全局的可变变量值

info = [11,22]
def func():
info.append(33)
print(info)
func() #结果为[11,22,33]
global：在局部变量中强制赋值，修改全局变量
name = "yanan"
def func():
global name
name = "alec"
func()
print(name)#输出结果为name = alec
#######################################
name = ['wo','yanan']
def func():
global name
name = "alec"
func()
print(name)#输出结果为name = alec
########嵌套内的函数中，global修改的也是全局变量
name = "yanan"
def func():
name = "centos"
def inner():
global name
name = 999
print("inner",name)#name = 999
inner()
print("func",name)#name = centos
func()
print("全局变量",name)#name = 999（被global修改过的变量）
nolocal：只能用在嵌套函数中，嵌套函数中只修改上层的赋值
name = "yanan"
def func():
name = "centos"
def inner():
nonlocal name
name = 999
print("inner",name)#name = 999
inner()
print("func",name)#name = 999（被nonlocal修改过的变量）
func()
print("全局变量",name)#name = "yanan"（全局未被修改）

全局变量由大写字母组成，函数体内部可由小写字母组成。类似于以下代码

USER_LIST = [11,22,33]
def func():
USER_LIST.append(44)
USER_LIST.append(550)
func()
print(USER_LIST)