python 10 动态参数

目录

• 1. 函数的动态参数
  • 1.1 动态位置参数（*arges）
  • 1.2 动态关键字参数 （**kwargs）
  • 1.3 万能传参：
• 2. 函数的注释
• 3. 名称空间
• 4. 函数嵌套
• 5. 函数变量修改
  • 5.1 global
  • 5.2 nonlocal

1. 函数的动态参数

1.1 动态位置参数（*arges）

def func(*args):  # *arges 是万能（接受任意多个）的位置参数
	print(args)   #以元组的形式（1，2，3，4，5）输出
func(1,2,3,4,5)  

def func(*args):    #* 在函数定义的时候叫做聚合
	print(*args)  # *args 将元组打散  1 2 3 4 5 
func(1,2,3,4,5)

def func(a,b,*args): 
	print(a,b,args)  # 1 2 (3,4,5)
func(1,2,3,4,5)

def func(a,b,*arges,c=6):
	print(a,b,arges,c)   #1 2 (3,4,5) 6
func(1,2,3,4,5)

# 优先级：位置参数 > 动态位置参数 > 默认参数

1.2 动态关键字参数 （**kwargs）

def func(a,b,**kwargs):
    print(a,b,kwags)  # 1 2 {"c":3,"d":4} 字典（接受关键字的参数）
func(1,2,c=3,d=4)	

def func(a,b,**kwargs)
	print(a,b,*kwargs)  # *kwargs 打散会取键
func(1,2,c=3,d=4)       # 1 2 c d

1.3 万能传参：

​ (动态位置参数，动态关键字参数)

def func(a,b,*args,c=1,d=2,**kwags):
    print(a,b,*args,c,d,kwags)
func(1,2,3,4,c=5,d=6,e="alex",f="wusir")
# 1 2 3 4 5 6 {"e":alex,"f":wusir}

def func(*arges,**kwargs):
    print(arges,kwargs)
func(1,2,3,4,e=3,d=4,f=5)  
#(1,2,3,4) {"e":4,"d":4,"f":5}

优先级：位置参数 > 动态位置参数 > 默认参数（关键字参数）> 动态关键字参数

lst = [1,2,3,4,5,6]
def func(*arges):	#聚合
    print(*arges)   #再打散
func(*lst)   # 先将lst打散 传入

dic = {"a":1,"b":2,"c":3}
def func(**kwargs):
    print(kwargs)
func(**dic)   #打散字典

2. 函数的注释

每写一个函数需注释  """ (回车) """
函数名.__doc__    #可查看函数的注释
函数名.__doc__    #查看函数的名字

3. 名称空间

内置空间：python中自带的文件，例如print/input
全局空间：当前py文件中需要开辟的空间存放在全局空间（顶头写）
局部空间：函数中开辟的空间就是局部空间

加载顺序：内置 > 全局 > 局部
取值顺序：内置 > 全局 > 局部

作用域：
全局作用域：内置空间 + 全局空间
局部作用域：局部空间

4. 函数嵌套

不管在什么位置，只要是 函数名+(), 就是在调用此函数。
函数执行后，函数体中开辟的空间会自动销毁。

同一级函数之间的数据不能共享。

#函数嵌套：
def func():
    a = 1
    def foo():
        b=2
        print(b)
        print(a)
        def f1():
            print(b)
        return f1()
    return foo()
print(func())   # 2 1 2 None

#函数互相引用
def func():
    a = 1
    foo()
    print(a)
def foo():
    b=2
    print(b)
func()  		# 2 1

def func():
    a = 1
    def b():
        print(a)  #没有调用
def foo():
    b = 1
    def z():
        print(func)  # 同级函数 会打印 func的地址
        print(b)
    ret = z()
    func()
    return ret  # None
def run():
    foo()
print(run())  # None

5. 函数变量修改

5.1 global

​ 声明修改全局变量的值。

a = 10
def func():
    global a  #声明修改全局变量的值
    a += 1
    print(a)   # 11
func()

5.2 nonlocal

​ 在外层的函数中,修改局部空间的变量值.完全不涉及全局变量,只修改离它最近的一层,最近的一层没有变量继续向上找,直到找到最外层函数

a = 10
def func():
    def f1():
        a = 30
        def foo():
            nonlocal a  #只修改近的 a
            a += 1
            print(a)   # 31
        foo()
        print(a) # 31
    f1()
func()
print(a)   # 10    

# 31 31 10