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、如何要用闭包函数：
闭包函数提供了一种函数体传值的解决方法
