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

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: 在局部寻找外层函数中离他最近的那个变量

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

函数名的应用:(第一类对象)     函数名的命名规范和变量是一样的     函数名其实就是变量名       可以作为列表中的元素进行存储     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