函数对象，名称空间，闭包函数

函数对象

函数是第一类对象，函数是第一等公民

1、函数可以被赋值
# def foo():  # foo->函数的内存地址
#     print('from foo')
#
# f=foo
# # print(f)
# f()

2、函数可以当作参数传给另外一个函数
# def foo():  # foo->函数的内存地址
#     print('from foo')
#
# def func(f):
#     # print(f)
#     f()
#
# func(foo)

3、函数可以当作函数的返回值
# def foo():  # foo->函数的内存地址
#     print('from foo')
#
# def func(f):
#     return f
#
# res=func(foo)
# print(res)

4、函数可以当作容器类型的元素
# def foo():  # foo->函数的内存地址
#     print('from foo')

# l = [foo]

# print(l)
# l[0]()

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


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


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


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


func_dic = {
    "1": ["登录", login],
    "2": ["注册", register],
    "3": ["提现", withdraw],
    "4": ["转账", transfer],
}
while True:
    print("0    退出")
    for i in func_dic:
        print("%s    %s" % (i, func_dic[i][0]))

    choice = input("请输入命令编号：").strip()
    if choice == "0":
        break
    if choice in func_dic:
        func_dic[choice][1]()
    else:
        print("命令编号错误，重新输入")

函数嵌套

函数嵌套调用

在调用一个函数的过程中，该函数内部又调用了其他函数

# def bar():
#     print('from bar')
#
# def foo():
#     print('from foo')
#     bar()
#
# foo()


 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(113,133,122,312)

函数的嵌套定义:在函数内又定义了其他函数-------->封闭
# def foo():
#     def bar():
#         print('from bar')
#
#     # bar()
#     x = 111
# foo()
#
# # bar()
# print(x)

园的周长与面积
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)

res = circle(30,1)
print(res)

名称空间Namespace

存放名字与内存地址绑定关系的地方

内置名称空间：放的是python自带的名字，print\len\input
#            生命周期：解释器启动则产生，解释器关闭则销毁

# 全局名称空间：放的是顶级的名字,如下x\y\foo
#            生命周期：运行python文件则立即产生，python文件运行完毕则结束

# x = 111
#
# if 10 > 3:
#     y = 666
#
# def foo():
#     z = 222

# 局部名称空间：放的是函数内的名字，如上z
#            生命周期：调用函数则产生，函数调用完毕则销毁

# 重要结论1: 名字的查找优先级
#           局部-》全局-》内置
#           基于自己当前所在的位置向外查找，LEGB

# len = 100
#
# def foo():
#     len = 200
#
# foo()
#
# print(len)

# 重要结论2: 名称空间的嵌套关系是以函数定义为准生成的，与调用位置无关
# 例1
# def foo():
#     print(len)
#
#
# def bar():
#     len = 666
#     foo()
#
# len = 100
#
# bar()


# # 例2；
# x = 111
#
#
# def f1():
#     print(x)
#     x = 222
#
#
# f1()


# # 例3
#
# x = 1
#
# def f1():
#      x = 2
#     def f2():
#          x = 3
#         print(x)
#     f2()
#
# f1()

global关键字

在函数内，无论嵌套多少层，都可以查看到全局作用域的名字

# # 例1：
# x = 1
# def foo():
#     global x
#     x = 2
#
# foo()
# print(x)

# 例2：
# x = [111,222,333]
# def foo():
#     x.append(4444)
# foo()
# print(x)

nonlocal关键字

声明一个名字是来自于外层函数，如果外层没有不会找到全局，会报错

# x = 1
# def f1():
#     x = 2
#     def f2():
#         # global x
#         nonlocal x
#         x = 3
#     f2()
#     print(x)
#
# f1()

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

闭包函数

闭包函数=函数对象+函数嵌套定义+名称空间与作用域
闭函数：定义在函数内部的函数
# 包函数: 内部函数引用了一个外层函数的名字

# def foo():
#     x = 111
#     def wrapper():
#         print(x)
#
#     return wrapper  # 千万不要加括号
#
#
# f = foo()
#
#
# # print(f)
#
# def xxx():
#     x = 222
#     f()
#
# xxx()

闭包的函数的作用：闭包函数是一种为函数体传参的方案

# 为函数体传参方案一：直接使用形参
# def wrapper(x):
#     print(x)
#
# wrapper(111)
# wrapper(222)
# wrapper(333)

# 为函数体传参方案二：闭包函数

# def outter(x):
#     # x = 111

#     def wrapper():   （先从这开始推）
#         print(x)

#     return wrapper
#
#（全局变量，不同于局部） wrapper = outter(111)
# wrapper()
#
# # wrapper = outter(222)
# # wrapper()

---