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

一、函数对象
函数是第一类对象：值的内存地址可以像变量一样去使用
def foo():#foo=函数的内存地址,可以当做一种变量值去使用
1、函数可以被引用
def foo():
　　print('hello')
f=foo
print(f)
f()
2、可以当作参数传递
def foo():
　　print('hello')
def bar(x):
　　print(x)
　　x()
bar(foo)
3.可以当做函数的返回值
def foo():
　　print('hello')
def func(x):
　　return(x)
f=func(foo)
print(f)
4.可以当做容器类的元素
def foo():
　　print('hello')
dic={'1':foo}
print(dic)
dic['1']()

def register():
　　print('注册')
def login():
　　print('登录')
def pay():
　　print('支付')
def transfer():
　　print('转账')
dic_choice={'1':register,'2':login,'3':pay,'4':transfer}
while True:
　　print('''
　　0 退出
　　1 注册
　　2 登录
　　3 支付
　　4 转账
　　''')
　　choice=input('请输入你的操作:').strip()
　　if choice == '0':break
　　if choice not in dic_choice:
　　　　print('输入有误,请重新输入')
　　　　continue
　　dic_choice[choice]()

二.函数嵌套
#函数的嵌套调用:在一个函数内部调用其他函数
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
#函数的嵌套定义:在函数内又定义了其他函数
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(10,0)
三.名称空间
存放名字与值内存地址绑定关系的空间
名称空间的分类
　　内置名称空间 存储解释器自带的一些名称与值的对应关系
　　(python解释器启动时创建 所有代码全部执行完毕 关闭解释器时 销毁)
　　print len max min

　　全局名称空间
　　　　只要你的名字的定义是顶着最左边写的就在全局空间
　　　　除了内置的函数内的 都在全局中
　　　（执行py文件创建全局名称空间 文件执行结束 销毁）

　　局部名称空间 只要是函数内的名称就是局部的
　　(调用函数时创建 函数执行完毕就销毁)

　　名称空间的加载顺序
　　　　内置的 -> 全局的 ->局部的

　　名称的查找顺序
　　　　局部 -> 全局的 -> 内置的
结论:
　　1.查找名字的位置是从当前位置往外查找
　　2.名称空间的嵌套关系是在函数定义阶段就固定死了,与调用位置无关
　　def outter():
　　　　x=1111
　　　　def inner():
　　　　print(x)
　　　　return inner

　　f=outter()

　　def foo():
　　　　x=2222
　　　　f()

　　foo()

      输出的是1111

四.作用域（作用范围）
　　域 指的是区域 范围的的意思
　　全局的名称空间和内置的名称空间 在使用上没什么区别
　　局部的 和 全局的内置的 就有区别了 局部定义的只能在局部使用

　　给三个空间划分范围:
　　全局的和内置可以划分为同一个范围
　　global 全局作用域

　　局部的单独划分为一个范围
　　local 局部作用域

　　globals（）
　　locals（）

　　查看全局作用域中的内容
　　# print(dir(globals()['__builtins__']))
　　查看局部作用域中的内容 注意:在全局中使用locals 看到的就是全局的内容与globals没有区别
　　print(globals（）)
　　print(locals（）)

　　age=18
　　def func():
　　　　age=19
　　　　print(age) #19
　　func()
　　print(age) #18

　　age=18
　　def func():
　　　　global age #明确声明要使用全局中的age
　　　　age=19
　　　　print(age) #19
　　func()
　　print(age) #19

　　a=1
　　def func():
　　　　a=10
　　　　def inner():
　　　　　　a=100
　　　　　　print(a) #100
　　　　inner()
　　　　print('这是func中a',a) #这是func中a 10
　　func()
　　print(a) #1

　　a=1
　　def func():
　　　　a=10
　　　　def inner():
　　　　　　nonlocal a #明确声明要使用上一层中的a,如果上一层没有则找上上层,但是注意不能找到全局中
　　　　　　a=100
　　　　　　print(a) #100
　　　　inner()
　　　　print('这是func中的a',a) #这是func中的a 100
　　func()
　　print(a) #1

五.闭包函数
　　闭包函数 也是一个函数
　　闭函数:该函数一定是定义在函数内的函数
　　包函数: 该内部函数包含对外层函数作用域名字的引用

　　为函数体传值的解决方案:
　　①为函数体传值的方案一:直接以参数的形式传入
　　def f(x):
　　　　print(x)
　　f(10)
　　f(11)

　　②为函数体传值的方案二:用闭包函数传值
　　def outter(x):
　　　　def f():
　　　　　　print(x)
　　　　return f
　　fff=outter(10)
　　fff()