一、args与kwargs

def index(a,b,c):
    print(a,b,c)

def wrapper(*args,**kwargs):  # args=(1,2,3)    kwargs={}
    index(*args,**kwargs)  # index(*(1,2,3) ,**{})  # index(1,2,3)

    # index(b=2,c=3,a=1)
# wrapper(1,2,3)
wrapper(b=2,c=3,a=1)

二、函数嵌套

函数的嵌套调用：在调用一个函数的过程中，又调用了其他函数

# def max2(x,y):
#     if x > y:
#         return x
#     else:
#         return y
#
# def max4(a,b,c,d):
#     res1 = max2(a,b)
#     res2 = max2(res1,c)
#     res3 = max2(res2,d)
#     print(res3)
#
# max4(1,2,3,4)

函数的嵌套定义: 在函数内又定义了一个函数
# def f1():  # 定义在函数内部的内容有一个效果：函数外无法访问，只有在函数内才可以访问到
#     x = 111
#     print(x)
#
# f1()
# # print(x)

# def f1():
#     def f2():
#         print('from f2')
#     f2()
#
# f1()
# # f2()


# from math import pi
#
# def circle(radius,mode=0):
#     def perimiter(radius):
#         return 2 * pi * radius
#
#
#     def area(radius):
#         return pi * (radius ** 2)
#
#     if mode == 0:
#         return perimiter(radius)
#     elif mode == 1:
#         return area(radius)
#
#
# circle(3,0)

三、函数对象

def foo():  # foo->函数的内存地址
    print('from foo')


# x = 10  # x->10的内存地址

# 1、可以被赋值
# y = x
# f = foo

# 2、可以当做参数传入
# def f1(func):
#     print('====>f1')
#     func()
#
# f1(foo)  # f1(函数的内存地址)

# 3、可以当做返回值
# def f1(func):
#     return func
#
# f = f1(foo)
# print(f)

# 4、可以当做容器类型的元素
# x = 10
# l = [x,foo,foo()]
# # print(l)
#
# l[1]()


def login():
    print('登录功能'.center(50, '*'))


def register():
    print("注册功能".center(50, '*'))


def transfer():
    print("转账功能".center(50, '*'))


def withdraw():
    print("提现功能".center(50, '*'))


func_dic = {
    "1": ['登录功能', login],
    "2": ['注册功能', register],
    "3": ['转账功能', transfer],
    "4": ['提现功能', withdraw],
}



while True:
    print("0 退出")
    for k in func_dic:
        print(k,func_dic[k][0])

    choice = input("请输入命令编号：").strip()
    if choice == "0":
        break

    # if choice == '1':
    #     login()
    # elif choice == '2':
    #     register()
    # elif choice == '3':
    #     transfer()
    # else:
    #     print("输入的指令错误")

    if choice in func_dic:
        func_dic[choice][1]()
    else:
        print("输入的指令错误")

四、名称空间与作用域

# 名称空间Namespace：存放名字与内存地址绑定关系的地方

# 内置名称空间：存放python解释器自带的名字
# print(len)
# print(input)

# 全局名称空间: 存放的是*的名字，如下x、z、f1、xxx都是
# x = 100
# def f1():
#     y = 200
#
# if 10 > 3:
#     z = 300
#
#     if True:
#         xxx = 400


# 局部名称空间：存放的是函数内定义的名字
# def f1():
#     x = 200
#
# f1()



# 重要结论1：局部Local-》外层函数Enclosing-》全局Global-》内置Builtin
#          L->E->G->B


# 例1：
# def f1():
#     # len = 200
#     print(len)
#
# len = 100
#
# f1()
#
# print('=====>',len)
#
# 例2：LEGB

# len = 100
#
# def f1():
#     # len = 200
#
#     def f2():
#         # len = 300
#         print(len)
#     len = 1111111111111111111111111111111111111111111
#     f2()
#
# f1()


# 重要结论2：名称空间的嵌套关系是在函数定义阶段、扫描语法时就确定好的，与调用位置无关
# # 例1：
# len = 100
#
# def f1():
#     # len = 200
#     def f2():
#         print(len)
#
#     return f2
#
# f = f1()
#
# # print(f)
#
# len = 6666666666666
# f()

# 例2：
# len = 100
#
# def f1():
#     def f2():
#         print(len)
#     # len = 200
#
#     return f2
#
# f = f1()
#
# def foo():
#     len = 77777
#     f()
#
# foo()

# 例3
# x = 100
#
# def f1():
#     print(x)
#     x = 200
#
#
# f1()

# 总结：
# 全局作用域：全局存活，全局有效
#           内置名字空间、全局名称空间

# 局部作用域：临时存活，局部有效
#           局部名称空间


# =============》 global关键字
# l = []
# x = 100
#
# def foo():
#     l.append(333)
#
#     global x
#     x = 200
#
# foo()
#
# print(l)
# print(x)

# =============》 nonlocal关键字

x = 111
def f1():
    # x = 222
    def f2():
        # global x
        nonlocal x
        x = 333

    f2()
    print('==========>f1肚子里的x： ',x)

# f1()

# print(x)

五、闭包函数

# 闭函数：定义在函数内部的函数
# def outter():
#     def wrapper():
#         print('====>wrapper')

# 包函数: 内部函数引用了一个来自于外层函数的变量
# def outter():
#     x = 111
#     def wrapper():
#         print('====>wrapper',x)



# 为函数体传参的两种方案
# 方案一：直接通过参数传入即可
# def wrapper(x):
#     print('====>wrapper',x)
#
# wrapper(111)
# wrapper(222)

# 方案二：闭包函数
def outter(x):
    def wrapper():
        print('====>wrapper',x)
    return wrapper  # 不要加括号

# new_wrapper1 = outter(111)
# new_wrapper1()
#
# new_wrapper2 = outter(222)
# new_wrapper2()


xxx = outter(111)

xxx()