Day 10 函数的进阶

1. 函数的动态参数
　　  1. *args 位置参数动态传参
　　2. **kwargs 关键字参数动态传参
　　顺序:位置参数, *args, 默认值, **kwargs

# by luffycity.com
# def chi(good_food, no_good_food, drink, xx, xxx,ice_cream):
#     print(good_food, no_good_food, no_good_food, drink, ice_cream)
#
# chi("盖浇饭","馒头","腊肠", "橙汁","哈根达斯")
#  顺序: 位置参数=>*args(arguments) => 默认值参数
# * 在这里表示接收位置参数的动态传参, 接收到的是元组
# def chi(name,*food, location="北京"): # 参数名是food  *表示动态传参
#     print(location)
#     print(name+"要吃", food)
#
# chi("刘旺鑫","狗不理","大麻花","天津")
# # chi("刘旺鑫","大米饭","小米饭")
# # chi("刘旺鑫","馒头")

def func(*args, **kwargs):
　　pass

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

顺序
　　位置参数, *args, 默认值参数, **kwargs
　　随以上参数可以意搭配使用

 1. 实参:
 　　位置参数
 　　关键字参数
 　　混合参数(位置, 关键字)
 2. 形参:
 　　位置参数
 　　默认值参数
 动态传参:
　　*args: 位置参数动态传参
　　**kwargs: 关键字参数动态传参
顺序: 位置, *args, 默认值, **kwargs
　　def fun(a, *args, c="哈哈", **kwargs):
　　　　print(a, args, c, kwargs)

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

# 单行注释
　　'''多行注释'''
　　函数注释
def func(a, b):
　　"""
x这个函数是用来计算a和b的和
　　:param a: 第一个数据
　　:param b: 第二个数据
　　:return: 返回的是两个数的和
　　"""
　　return a + b

 　　print(func.__doc__) # document文档x

# 接收所有参数
# def func(*args, **kwargs):# 无敌 *args相当于一个聚合的作用
print(args, kwargs)
#
# func(1,2,3,4,5,a=6,b=7,c=9)

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

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

# a = 10 # 全局名称空间中的内容
#
# def fn(): # fn也在全局名称空间
#     b = 20 # 局部名称空间
#     print(a)
# def gn():
#     print(a)
# fn()
# gn()

# 1. 内置, 2. 全局 , 3. 局部(函数调用)
# a = 110 # 全局
# def fn(): #
#     b = 20 # 局部
#     def gn(): # 局部
#         print(globals())  # 可以查看全局作用域中的内容
#         print(locals())  # 查看当前作用域中的内容
#     gn()
# fn()

# 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()

----------------------------------------------------------------------------------------------------------------------------------------------------

2. 命名空间
　　1. 内置名称空间
　　2. 全局名称空间
　　3. 局部名称空间

# a = 10 # 全局变量本身就是不安全的, 不能随意修改, 闭包
# def func():
#     global a  # 1. 可以把全局中的内容引入到函数内部 , 2. 在全局创建一个变量
#     # a = 20
#     a += 10 # a = a+10
#     print(a)

作用域:
 1. 全局作用域: 内置+全局
 2. 局部作用域: 局部(函数被调用)
　　globals() 查看全局中的内容
　　locals() 查看当前作用域中的内容
3. 函数嵌套
　　函数可以互相的嵌套
4. global和nonlocal关键
　　global: 在局部访问全局中的内容
　　nonlocal: 在局部寻找外层函数中离他最近的那个变量

# func()
# print(a)
# a = 10
# def outer():
#
#     def inner(): # 在inner中改变a的值
#         nonlocal a # 寻找外层函数中离他最近的那个变量
#         a = 20
#     inner()
#
# outer()

a = 1
def fun_1():
    a = 2
    def fun_2():
        global a
        a = 3
        def fun_3():
            a = 4
            print(a)
        print(a)
        fun_3()
        print(a)
    print(a)
    fun_2()
    print(a)
print(a)
fun_1()
print(a)