一 首先我们学到函数的嵌套调用与定义：
1 函数嵌套
# def f1():
# print(f1)#我们这里如果输入f1那么输出的则是f1这个变量（函数）所在的地址。如果输入一个字符的话那么就直接输出该字符
# def f2():
# print(f2)
# def f3():
# print(f3)
# f3()
# # f2()
# f1()
那么我们在调用时，必须由外到内，也就是说我们如果想调用f3那么我们必须先通过f1才可以
2 函数的嵌套调用：
在函数内又调用了其他函数。
def max2(x,y):
if x>y:
return x
else:
return y
print(max2(2,3))
def max3(x,y,z):
res1=max2(x,y)
res2=max2(res1,z)
return res2
res2=max3(1,2,6)
print(res
二 名称空间 namespace
1. 名称空间顾名思义就是存放名字与值绑定关系的地方。
2. 名称空间分为三类：
（1）内置名称空间
存放python解释器自带的名字，如print（），len（）等。
当解释器一启动就会生效，也就是说就可以对其进行调用
（2）全局名称空间
用来存放文件级别的名字，只要不在函数里面都叫全局变量。
只在文件执行的时候生效，在文件结束或者文件执行期间被删除则失效。
假如我们定义一个：
x=1
def func():
name='egon'
del func#将func删除，
print('====')
x=1
def f1():
def f2():
print(x)
f2()
f1()
输出结果为1
（3）局部名称空间
用来存放函数内定义的名字，（函数的参数以及函数内的名字都存放于局部名称空间）。
只在函数调用时执行时短暂生效，函数调用结束则失效。
那么对于这三种名称空间，他们加载的顺序就是也就是他们在程序运行的一个加载先后顺序：
内置名称空间---〉全局名称空间---〉局部名称空间
那么查找在程序运行过程中查找的顺序是跟加载顺序相反的：
也就是：局部名称空间--〉全局名称空间---〉内置名称空间
作用域：作用域顾名思义就是作用的范围。
也就是函数所能访问到的范围：
全局作用域：
那么对于内置名称空间和全局名称空间来说，他们具有全局作用域，该范围内的名字会伴随程序整个运行周期，
也就是说程序不结束，那么在任何地方都能调用。
局部作用域：
只是包含局部的名称空间的名字，所以局部作用域只能在函数内部使用，调用函数时生效，调用结束后失效。
三 函数在python中是第一类对象（相当于变量）
1 可以被引用，像变量一样被引用:
变量
x=1
y=x
函数
print('from')
def bar():
f=bar#这个时候bar作为一个变量赋给f，那么f（）就相当于bar（）。
f()
'''
def foo():# foo=<function .... x1238102391203>
print('from foo')
print(foo)
x=foo
print(x)
l=[foo,]
print(l)
def print_msg(x):
# print(x)
return x
a='sdfasdfasdfasdfadsf'
res=print_msg(foo)
print(res)
'''
2 可以当作参数传入：
def func(a):#我们定义func为有参函数。
a+=1
print(a)
func(x)
def bar():
print('from bar，1')
def wrapper(func):#这一步相当于fun=bar
func()#那么相当于bar（）
wrapper(bar)#在这个过程就相当于调用函数wrapper（），我们把函数名bar传入，那么就相当于我们运行bar函数
3可以当作函数的返回值：
1#
x=1
def foo():
return x#直接将返回值传给foo
res=foo()
print(res)
2#
x=1
def foo()： 那么我们可以看出13与2#输出的结果是相同的。返回值会返回给函数本身。
print(x）
foo()
作为变量将x赋给foo() def bar(): print('from bar') def foo(func): return func print(bar) f=foo(bar) print(f) f() print(foo)#直接输出变量名，那么我们输出的是变量名所在的地址 x=1 print(x,id(x))
4 可以当作容器类型的元素。
x=1
l=[x]
print(l)
def get():
print('from get')
def put():
print('from put')
l=[get,put]
print(l)
l[0]()
程序实例
def auth():
print('登录。。。。')
def register():
print('注册')
def search():
print('查看。。')
def pay():
print('支付。。')
dic={
'1':auth,
'2':register,
'3':search,
'4':pay,
}
print(dic)
def interactive():
while True:
print('''
1 登陆
2 注册
3 查看
4 支付''')
choice=input('请输入编号：').strip()
if choice in dic:
dic[choice]()
else:
print('非法输入!')
interactive()
l=[auth,register,search,]
print(l)
View Code
四 闭包函数
闭：指的是定义在函数内部的函数。
作用域：在函数定义阶段就规定死了，与调用位置无关，不管在哪使用都要到原函数定义位置去找。
def outter():
x=2
def inner():
x=1
print('from inner',x)
return inner#在这里我们返回inner就是为了得到inner这个函数，而outter只是起到一个包裹作用。
f=outter()#在调用函数outter时，将inner返回给outter这个函数名，也就是f=inner。
print(f)#输出的为变量inner，也就是inner所对应的地址。
f()#当我们把x=1注释掉之后，会变成x=2。
def foo():
x=122323
f()
foo()
闭包函数：
1、定义在函数内的函数
2、并且该函数包含对外部函数作用域中名字的引用，该函数成为闭包函数。比如上述函数中inner引用了outer中的变量x。
闭包函数说白了就是将一个函数包进另一个函数里面，而且外层函数会给内层被包含函数定义好值，所以内部函数需要值时候先去自己所在层找。
找不到就去外层函数找，但是一般不会到全局找，因为全局变量大家都可以引用，所以闭包函数外层函数专门给闭包函数传值。
传值目的就是为了得到闭包函数的执行结果，所以return。
闭包函数包含对外部作用域的引用而非全局作用域的引用
在被包函数的头上，定义一个变量。
