函数的动态参数 函数的注释 名称空间 函数的嵌套

1.函数的动态参数

动态参数

*args,**kwargs (能够接受动态的位置参数和动态的关键字参数)

定义阶段(*args,**kwargs) 聚合

*args - tuple

**kwargs -- dict

使用阶段*args,*kwargs 打散

*args - 源数据类型

*kwargs - 打散是字典的键

*args

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

def func(a,b,*args):  # *args 是万能(接受任意多个)的位置参数 
                      # *在函数定义的时候叫做聚合
    print(a,b,*args)  # * 打散     1 2 3 4 5 6 7 8 9

**kwargs

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

def func(a,b,*args,c=1,d=2,**kwargs):
    print(a,b,*args,c,d,kwargs)
func(1,2,3,4,c=8,d=10,e="alex",f="wusir") 
 #1 2 3 4 8 10 {'e': 'alex', 'f': 'wusir'}

万能传参

def func(*agrs,**kwargs):
    print(agrs,kwargs)
func(1,2,3,4,5,6,7,8,a=1,b=2,c=3)
# (1, 2, 3, 4, 5, 6, 7, 8) {'a': 1, 'b': 2, 'c': 3}

重点总结:

1.参数的优先级:位置参数 > 动态位置参数 > 默认参数(关键字参数) > 动态关键字参数
2.万能传参:动态位置参数,动态关键字参数(常用)
3.动态位置参数,关键字参数,动态关键字参数

2.函数的注释

def func(a,b):
    """
    注释:敲六个' " ',回车
    :param a: 
    :param b: 
    :return: 
    """
    print(a,b)
    
def func1(user,password):
    """
    密码加密
    :param user: 用户名 str
    :param password: 密码 str
    :return: 加密的密码 MD5
    """
    print(user,password)
    
print(func.__doc__)         # 查看函数注释
print(func.__name__)        # 查看函数命名

3.名称空间

def fun():   
    a = 10   
    print(a)
fun()
print(a)    # a不存在了已经..

命名空间分类:

内置空间 : print input len
全局空间 : 当前py文件需要开辟的空间存放在全局空间
局部空间 : 函数中开辟的空间就是局部空间

加载顺序:

内置空间 > 全局空间 > 局部空间

取值顺序:

局部空间 > 全局空间 > 内置空间(找不到就报错了!)

作用域:

全局作用域: 内置空间 + 全局空间

局部作用域: 局部空间

4.函数的嵌套

def func():    
    print(1)    
    def f1():        
        print(2)    
    return f1()
func()                        # 1 2

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

示例

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

函数互相引用

1.
def func():
    a = 1
    foo()
    print(a)

def foo():
    b = 2
    print(b)
func()                      # 2 1
2.
def a():
    a = 1
    c()
    print(c)
def b():
    b1 = 2
    print(b1)
def c():
    c = 3
    print(a)
def run():
    a()
run()                      #<function a at 0x000001DCFC439B70>
                           #<function c at 0x000001DCFC439C80>

    
def func():
    a = 1
    def b():
        print(a)
def foo():
    b = 1
    def z():
        print(func)     #内存地址
        print(b)        # 1
    ret = z()
    func()
    return ret
def run():
    foo()
print(run())
# 内存地址 1 None

函数中套函数
函数嵌套调用
函数嵌套参数的传递
函数嵌套返回值的传递

5.globle 与 nonlocal

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


a = 10
def f1():
    a = 10
    def f2():
        a = 15
        def f3():
            global a
            a += 1
            print(a)
        print(a)
        f3()
    print(a)
    f2()
f1()                      # 10 15 11

a = 10
def func():
    def f1():
        global a
        a += 1
        def foo():
            nonlocal a       
            a += 1
            print(a)   
        foo()
        print(a) 
    f1()
func()
print(a)   
# 报错
局部空间内没有a的值

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