学习10.内容# 1.函数的动态参数 # 2.函数的注释 # 3.名称空间 # 4.函数的嵌套

1.函数的动态参数

def func(a, b=1):
    print(a, b)

func(1)

*args

def func(a, b, *args):  # *args 是万能(接受任意多个)的未知参数 *在函数定义的时候叫做聚合
    print(a, b, args)

func(1, 2, 3, 4, 5, 6)

def func(a, b, *args):  # *args 是万能(接受任意多个)的未知参数 *在函数定义的时候叫做聚合
    print(a, b, *args)

func(1, 2, 3, 4, 5, 6)
未知参数 > 动态位置参数 > 默认参数

def func(*args, a=1, b=2):
    print(a, b, args)     # 元组(接受的位置参数)

func(12, 23, 43, 54, 654)

*kwargs

def func(a, b, **kwargs):
    print(a, b, kwargs)  # 字典(接受的关键字的参数)

func(12, 21, f=3)

def func(a, b, *args, c=1, d=2):
    print(a, b, *args, c, d)

func(1, 2, 3, 4)

def func(a, b, *args, c=1, d=2, **kwargs):
    print(a, b, *args, c, d, kwargs)   # *kwargs -- 获取到的字典的键

func(1, 2, 3, 4, c=8, d=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.动态位置参数,关键字参数,动态关键字参数

2.函数的注释

def func(a,b):
    """
    逻辑判断...
    :param a: str
    :param b: int
    :return: bool
    """
    print(a,b)

def func1(user,password):
    """
    密码加密
    :param user: 用户名 str
    :param password: 密码 str
    :return: 加密的密码 MD5
    """
    print(user,password)

print(func.__doc__)
print(func1.__doc__)
print(func.__name__)

3.名称空间

print(11)
a=10

def func():
    b = 20
    print(b)

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

加载顺序:
    内置空间 > 全局空间 > 局部空间

取值顺序:
    局部空间 > 全局空间 > 内置空间(找不到就报错了!)

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

4.函数的嵌套

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

不管在什么位置,只要是函数名+() 就是在跳用此函数

函数调用执行后,函数重新开辟的空间就自动销毁

def func():
    a = 1
    def foo():
        b = 2
        print(b)  # 2
        print(a)  # 1
        def f1():
            print(b) # 2
        return f1()
    return foo()
print(func())

函数的调用

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

def foo():
    b = 2
    print(b)
func()

def a():
    a1 = 1
    c()
    print(c)
def b():
    b1 = 2
    print(b1)
def c():
    c1 = 3
    print(a)
def run():
    a()
run()

def func():
    a = 1
    def b():
        print(a)

def foo():
    b = 1
    def z():
        print(func)
        print(b)
    ret = z()
    func()
    return ret

def run():
    foo()
print(run())

def func(a):
    foo(a) #10

def foo(e):
    b(e) # return 10

def b(c):
    print(c)
    return 10

print(func(5))

5.gloabal,nonlocal

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

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

a = 10
def func():
    def f1():
        global a
        a += 1
        def foo():
            nonlocal a
            a += 1
            print(a)   # 31
        foo()
        print(a) # 31
    f1()
func()
print(a)   # 10

总结

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

原文地址：https://www.cnblogs.com/changxin7/p/11202383.html