函数的动态参数 及函数嵌套

1.函数的动态传参

顺序：位置参数=>*arge(接收内容)=>默认参数值（返回的是一个元组）

def chi(*food):
    print(food)
chi("包子","盖浇饭","大盘鸡","麻辣香锅")
#结果            ('包子  ', '盖浇饭', '大盘鸡', '麻辣香锅')

def chi(name,*food):
  print(name+"要吃",food)
chi("麻花藤","包子","盖浇饭","大盘鸡","麻辣香锅")
#位置参数和动态参数的使用

def chi(name,*food,didian="北京"):
  print(name+"要吃",food,didian)
chi("麻花藤","包子","盖浇饭","大盘鸡","麻辣香锅")
#位置参数，动态参数和默认参数的联合使用

2.关键字的动态传参

位置参数, *args, 默认值参数, **kwargs （返回的是一个字典）

def chi (**food):
    print(food)
chi(早餐="大麻花",午餐="西红柿鸡蛋面",晚上="牛肉罩饼")

无敌传参
def chi (*food ,**food2):
    print(food)
    print(food2)
chi("大白梨","菠萝啤",早餐="小米粥"

函数的主注释

def func(a, b):
    """

    :param a:第一个数据
    :param b:第二个数据
    :return:返回两个数据的和
    """
    return a+b
print(func.__doc__)#

2.形参的位置*,**: 聚合
实参的位置*,**: 打散

# 形参: 聚合
def func(*food): # 聚合, 位置参数
    print(food)
lst = ["鸡蛋","煎饼果子","猪蹄","滋滋冒油"]
# # 实参: 打散
func(*lst) # 打散. 把list, tuple, set, str 进行迭代打散

聚合成关键字参数
# def func(**kwargs):
#     print(kwargs)
#
# dic = {"name":'alex', 'age':'18'}
# func(**dic) # 打散成关键字参数

3.命名空间

加载顺序:
1. 内置命名空间
2. 全局命名空间
3. 局部命名空间(函数被执行的时候)
取值顺序:
1. 局部命名空间
2. 全局命名空间
3. 内置命名空间

 def outer():
#     print("哈哈")
#     def inner_1():
#         print("呵呵")
#         def inner_1_1():
#             print("嘻嘻")
#         inner_1_1()
#         print("吼吼")
#     def inner_2():
#         print("嘿嘿")
#     inner_2()
#     inner_1()
# outer()
输出结果：
哈哈
嘿嘿
呵呵
嘻嘻
吼吼

作用域

print(globals()) # 可以查看全局作用域中的内容
print(locals()) # 查看当前作用域中的内容

全局作用域: 包含内置命名空间和全局命名空间. 在整个文件的任何位置都可以使用(遵循
从上到下逐行执行).
局部作⽤用域: 在函数内部可以使用.
作用域命名空间:
1. 全局作用域: 全局命名空间 + 内置命名空间
2. 局部作用域: 局部命名空间
我们可以通过
globals()函数来查看全局用域中的内容,
locals()来查看局部作用域中的变量和函数信息

4.函数嵌套

函数是可以互相嵌套的

5.  global和nonlocal关键
global: 在局部访问全局中的内容
nonlocal: 在局部寻找外层函数中离他最近的那个变量

函数名的应用:(第一类对象)
    函数名的命名规范和变量是一样的
    函数名其实就是变量名

    可以作为列表中的元素进行存储
    def func1():
        pass
    def func2():
        pass
    list = [func1,func2]
    for el in list:
        el()

    可以作为参数传递给函数
    def func():
        pass
    def proxy(fn):
        fn()
    proxy(func)

    可以作为函数的返回值
    def func():
        def inner():
            pass
        return inner)
    func()()
2,闭包
    在内层函数中访问外层函数的局部变量
    好处:
        1,保护你的变量不受外界影响
        2,可以让变量常驻内存
    写法:
        def outer():
            a = 10
            def inner():
                print(a)
            return inner