函数嵌套 动态运算符 名称空间

三元运算符:

# 变量 = 条件成立的结果  条件判断  条件不成立的结果
a = 30
b = 20
c = a if a > b else b
print(c)

1.函数的动态参数

*args,**kwargs (能够接受动态的位置参数和动态的关键字参数)
定义阶段(*args,**kwargs) 聚合
    *args -  tuple
    **kwargs -- dict
使用阶段*args,*kwargs 打散
    *args - 源数据类型
    *kwargs - 打散是字典的键
优先级: 位置 > 动态位置> 默认 > 动态关键字
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)

2.函数的注释

"""
每次写函数的时候需要写注释
函数名.__doc__
"""

3.名称空间

内置空间: Python解释器自带的
全局空间: 当前文件(.py文件)
局部空间: 函数体开辟的空间
    
    加载顺序: 内置 > 全局 > 局部
    取值顺序: 局部 > 全局 > 内置
        
作用域:
    全局作用域: 内置 + 全局
    局部作用域: 局部

4.函数嵌套

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

5.global nonlocal

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

6.三元运算符

a = 10
b = 20
c = a if a > b else b

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 :在外层的函数中,修改局部空间的变量值.完全不涉及全局变量,
只修改离它最近的一层,最近的一层没有变量继续向上找,直到找到最外层函数