day10

今日内容：

1、函数对象

2、函数嵌套

3、名称空间与作用域

4、闭包函数

1、函数对象：

　　函数是第一类对象：指的是函数名指向的值（内存地址）可以被当成数据去使用。

　　1、可以被引用

# x=age
# print(x,age)

# f=func
# print(f)
# f()

　　2、可以被当作一个参数传给另一个函数

# def bar(x):
#     print(x)

# bar(age)
# bar(func)

　　3、可以当作一个函数的返回值

# def bar(x):
    # return x

# res=bar(age)
# print(res)

# res=bar(func)
# print(res)

　　4、可以当作容器类型的元素

# l=[age,func,func()]
# print(l)

实际应用：

def login():
    print('login')

def register():
    print('register')

def shopping():
    print('shopping')

def pay():
    print('pay')


def transfer():
    print('transfer')

func_dic={
    '1':login,
    '2':register,
    '3':shopping,
    '4':pay,
    '5':transfer
}
# print(func_dic)

msg="""
0 退出
1 登陆
2 注册
3 购物
4 支付
5 转账
"""

while True:
    print(msg)
    choice=input('请输入您的操作: ').strip()
    if choice == '0':break
    # if choice == '1':
    #     login()
    # elif choice == '2':
    #     register()
    # elif choice == '3':
    #     shopping()
    # elif choice == '4':
    #     pay()
    # else:
    #     print('输入错误指令,请重新输入')
    if choice in func_dic:
        func_dic[choice]()
    else:
        print('输入错误指令,请重新输入')

2、函数嵌套

　　1、函数嵌套调用：在调用一个函数过程中，其内部代码调用了其他函数。

# 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)
#     return res3
#
# print(max4(1,2,3,4))

　　2、函数嵌套定义：一个函数内又定义了另外一个函数

# def outter():
#     x=1
#     print('from outter')
#     def inner():
#         print('from inner')
#     # print(x)
#     # print(inner)
#     inner()
#
# # outter()
# # inner
#
# outter()

3、名称空间

　　1、什么是名称空间？

　　　　存放名称与值内存地址绑定关系的一个地方（内存空间）

　　　　但凡查找值，一定要通过名字，访问名字必先取名称空间查找。

　　2、分为三大类：

　　　　内置名称空间：

　　　　　　内置名称空间存放python解释器自带的名字

　　　　　　内置名称空间的生命周期：在解释器启动时则生效，关闭则失效。

　　　　全局名称空间

　　　　　　全局名称空间存放文件级别的名字

　　　　　　全局名称空间的生命周期：在python解释器执行文件的时候生效，执行完后失效

　　　　局部名称空间

　　　　　　局部名称空间存放函数内的名字

　　　　　　局部名称空间的生命周期：在调用函数临时产生改函数的局部名称空间，该函数调用完毕失效

　　　　内置==》全局==》局部

　　　　查找名字：基于当前所在的位置往外层找

　　　　名字查找顺序：在函数定义阶段，就已经固定死了，与函数的调用位置无关，也就是说无论在任何地方调用函数，都必　　　　　　　　　　　　　　　　         须回到当初定义函数的位置去确定名字的查找关系。

作用域：

域：指的是范围，作用域指作用的范围

全局作用域：包含内置名称空间和全局名称空间中的名字

　　特点：全局有效，全局存活

局部作用域：包含的是局部名称空间中的名字

　　特点：局部有效，临时存活

global：在局部声明一个名字是来自于全局作用域的，可以用来在局部修改全局的不可变类型。

nonlocal：声明一个名字是来自于当前层外一层的作用域，可以用来在局部修改外层函数的不可变类型

# 案列一:
# # len=111
#
# def foo():
#     len=222
#     print(len)
#
# foo()
# print('站在全局找len: ',len)


# x=111
#
# def f1():
#     x=222
#     def f2():
#         def f3():
#             # x=444
#             print(x)
#         x=333
#         f3()
#     f2()
# f1()

# (******)名字的查找顺序,在函数定义阶段就已经固定死了(即在检测语法时就已经确定了名字的查找顺序),与函数的调用位置无关,也就是说无论在任何地方调用函数,都必须回到
# 当初定义函数的位置去确定名字的查找关系

# 案列二:
# x=111
# def outer():
#     def inner():
#         print('from inner',x) # x访问的时全局名称空间中x
#     return inner
#
# f=outer()
# # print(f)
#
# x=222
# f()


# 案列三:
x=111
def outer():
    def inner():
        print('from inner',x) # x访问的时全局名称空间中x
    return inner

f=outer()

# x=222
def func():
    x=333
    f()

x=444

func()


# 案列四:
# x=111
# def outer():
#     def inner():
#         print('from inner',x) # x是来自于当前层的名字
#         x=2222222222
#     return inner
#
# f=outer()
#
# f()

5、闭包函数

　　1、什么是闭包函数？

　　　　闭：指的是闭包函数定义在一个函数内部的函数

　　　　包：该内部函数包含一个对外层函数的引用域

　　　　闭包函数需要结合函数对象的概念回到全局作用域

def outter():
    x=111
    def inner():
        print(x)
    return inner

f=outter() #f=outter内的inner

# x=22222
# f()
def func():
    x=3333
    f()

func()

　　2、如何要用闭包函数：

　　　　闭包函数提供了一种函数体传值的解决方法