函数对象+函数嵌套+名称空间与作用域+闭包函数

# 函数对象
# 一切皆对象
# 函数是第一类对象，指的是函数的内存地址可以像变量一样去使用(函数可以被当做数据处理)
# x=10
#
def func():  #func = <function func at 0x0000028E571689D8>
    print('from func')
# print(func)

x='hello'
# 1,引用
# y=x
# f=func
# print(f)
# f()

# 2，当做参数传给另个函数

# def foo(func):
#     print(func)
#     func()
# foo(func)

# 3，可以当做函数的返回值
# def foo(x):
#     return x
# res = foo(func)
# print(res)
# res()

# 4,可以当做个容器类型的元素
# l = [x,]
# l = [func,]


# 函数对象的应用
# def register():
#     print('正在注册')
#
# def login():
#     print('正在登陆')
#
# def shopping():
#     print('正在购物')
#
# def pay():
#     print('正在支付')
#
# def transfer():
#     print('正在转账')
#
# func_dic = {
#     '1':register,
#     '2':login,
#     '3':shopping,
#     '4':pay,
#     '5':transfer
# }
#
# while True:
#     msg = ("""
#     0 退出
#     1 注册
#     2 登录
#     3 购物
#     4 支付
#     5 转账
#     """
#     )
#     print(msg)
#     choice = input('请输入要操作的指令>>: ').strip()
#     if choice == '0':break
#     if choice not in func_dic:
#         print('输入的有误')
#         continue
#     func_dic[choice]()

# 函数的嵌套定义
# 在定义一个函数的时候，在函数内部又定义了一个函数
# def f1():
#     def f2():
#         print('from f2')

# 函数的嵌套调用
# 在调用一个函数的过程当中，在其内部又调用了其他的函数
# 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)  #max2((a,b),c)
#     res3=max2(res2,d)
#     return res3
# res = max4(2,5,8,9)
# print(res)

# from math import pi

# def zhouzhang(r):
#     return 2*pi*r
# def mianji(r):
#     return 2*pi* (r ** 2)
# res = zhouzhang(20)
# print(res)

# def ciecle(r,caozuo):
#
#     def zhouzhang():
#         return 2*pi*r
#
#     def mianji():
#         return 2*pi* (r ** 2)
#
#     if caozuo == 1:
#         res = zhouzhang()
#     elif caozuo == 2:
#         res = mianji()
#     return res
#
# res = ciecle(10,1)
# print(res)

名称空间与作用域
一，名称空间 namespace
指的是存放名字与值内存地址绑定过关系的地方（内存空间）

名称分为三大类
内置名称空间：存放的是python解释器自带的名字
产生：python解释器的启动则产生
销毁：python解释器关闭则销毁

全局名称空间：在顶级定义的名字
产生：执行python程序时产生
销毁：python程序执行完毕后则销毁

局部名称空间：在函数定义的名字
产生：在函数调用时临时产生
销毁：在函数调用结束后销毁

三种名称空间产生的先后顺序：
内置----->全局----->局部
销毁
局部---->全局----->内置


查找顺序：从当前位置向外一层层查找
如果当前是局部---->全局---->内置
如果当前是全局---->内置


作用域：指的是作用范围
全局作用域：包含内置名称空间与全局名称空间的名字
特点：全局存活，全局有效

局部作用域：包含
特点：临时存活，局部有效

全局变量：
局部变量：

作用域关系是在函数定义阶段就已经固定死了，与调用位置无关！！！！！！！！！



闭包函数
闭：封闭，指的是该函数是定义在一个函数内部的函数
包：该内部函数包含了对外层函数名字的引用

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

f=outter()
f()