day10——动态参数、函数注释、名称空间、函数的嵌套、global及nonlocal

day10

三元运算符：

变量 = 条件成立的结果 条件判断 条件不成立的结果

补充：

# lst = [12,23,3,4,5,6]
# def func(*args):
#     print(*args)
# func(lst[0],lst[1]) # 笨的办法
# func(*lst)

# dic = {"key":1,"key1":34}
# def func(**kwargs):
#     print(kwargs)
# func(**dic)

动态参数

*args ：能接收（接受任意多个）的位置参数，元组，*****在函数定义的时候叫聚合

输出的时候*args就是打散，把元组里面的东西一个个打印出来

位置参数 > 动态位置参数 > 默认参数

**kwargs ：接收的是关键字参数，字典

输出的时候*kwargs，打印出键

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

​ 1、万能传参：动态位置参数 ， 动态关键字参数（最常用************）

​ 2、位置参数，动态位置参数

​ 3、动态位置参数，关键字参数，动态关键字参数

def func(a,b=1):
    print(a,b)
func(1)
--------------------------
def func(a,b,*args): # *args是万能（接受任意多个）的位置参数，*在函数定义的时候叫聚合
    print(a,b,args)
func(1,2,3,4,5,6,7,8,9)
---------------------------
def func(a,b,*args):
    print(a,b,*args)  # 打散
func(1,2,3,4,5,6,7,8,9)
# 位置参数 > 动态位置参数 > 默认参数
-------------------------
def func(*args , a=1, b=2):
    print(a,b,args)  # 元组（接收的位置参数）
func(12,15,21,11,17)
---------------------------
def func(a,b,**kwargs):
    print(a,b,kwargs) # 字典（接收的关键字的参数）
func(1,2,c=1,d=2)
----------------------------
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(*args,**kwargs):  # 万能传参
    print(args,kwargs)
func(1,2,3,4,5,6,7,a=1,b=2,c=3)

函数释

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(funcc.__name__)

名称空间

• 内置空间：print，input，len
• 全局空间：当前py文件中定义的内容需要开辟空间存放在全局空间
• 局部空间：函数中开辟的空间就是局部空间
• 加载顺序：

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

• 取值顺序：

局部空间 > 全局空间 > 内置空间（找不到就报错）

• 作用域：

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

局部作用域：局部空间

print(11)
a = 10
def func():
    b = 20
    print(b)

函数的嵌套

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

函数调用执行后，函数体中开辟的空间就自动销毁了

函数中套函数

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

函数嵌套调用

def func():
    a = 1
    def foo():
        b = 2
        print(b)
        print(a)
        def f1():
            print(b)
        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)
def foo(e):
    b(e)
def b(c):
    print(c)
    return 10
print(func(5))

global及nonlocal

global：把全局空间的变量强制放在局部空间，使局部变量可以修改全局空间里的变量

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)
        print(a)
        f3()
    print(a)
    f2()
f1()
----------------------
a = 10
def func():
    global a
    a += 1
    def f1():
        a = 10
        def foo():
            nonlocal a # 11 11 11 11
            a += 1
            print(a)
        foo()
        print(a)
    print(a)
    f1()
func()
print(a)