python笔记(9)--函数（参数，作用域，函数嵌套）

今日内容

参数
作用域
函数嵌套

内容：

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)