python之路之函数03

 一  首先我们学到函数的嵌套调用与定义：

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(,))

 def max3(x,y,z):
     res1=max2(x,y)
     res2=max2(res1,z)
     return res2
 res2=max3(,,)
 print(res

二  名称空间    namespace
 1. 名称空间顾名思义就是存放名字与值绑定关系的地方。
 2. 名称空间分为三类：
 （1）内置名称空间
 存放python解释器自带的名字，如print（），len（）等。
当解释器一启动就会生效，也就是说就可以对其进行调用

 （2）全局名称空间
 用来存放文件级别的名字，只要不在函数里面都叫全局变量。
 只在文件执行的时候生效，在文件结束或者文件执行期间被删除则失效。
 假如我们定义一个：

x=
 def func():
     name='egon'
 del func#将func删除，
 print('====')

 x=
 def f1():
     def f2():
         print(x)
     f2()
 f1()
 输出结果为1

 （3）局部名称空间

 用来存放函数内定义的名字，（函数的参数以及函数内的名字都存放于局部名称空间）。
 只在函数调用时执行时短暂生效，函数调用结束则失效。

 那么对于这三种名称空间，他们加载的顺序就是也就是他们在程序运行的一个加载先后顺序：
 内置名称空间---〉全局名称空间---〉局部名称空间
那么查找在程序运行过程中查找的顺序是跟加载顺序相反的：
 也就是：局部名称空间--〉全局名称空间---〉内置名称空间

 作用域：作用域顾名思义就是作用的范围。
 也就是函数所能访问到的范围：

全局作用域：
  那么对于内置名称空间和全局名称空间来说，他们具有全局作用域，该范围内的名字会伴随程序整个运行周期，
 也就是说程序不结束，那么在任何地方都能调用。

 局部作用域：
只是包含局部的名称空间的名字，所以局部作用域只能在函数内部使用，调用函数时生效，调用结束后失效。

 三   函数在python中是第一类对象（相当于变量）

1  可以被引用，像变量一样被引用:

变量
 x=
 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+=
     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=
 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= print(x,id(x))

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

x=
 l=[x]
 print(l)

 def get():
     print('from get')
 def put():
     print('from put')
 l=[get,put]
 print(l)
 l[]()

 程序实例

def auth():
     print('登录。。。。')
 def register():
     print('注册')
 def search():
     print('查看。。')
 def pay():
     print('支付。。')

 dic={
     '':auth,
     '':register,
     '':search,
     '':pay,
 }
 print(dic)
 def interactive():
     while True:
         print('''
          登陆
          注册
          查看
         支付''')
         choice=input('请输入编号：').strip()
         if choice in dic:
             dic[choice]()
         else:
             print('非法输入!')

 interactive()
 l=[auth,register,search,]
 print(l)

 四  闭包函数

 闭：指的是定义在函数内部的函数。
 作用域：在函数定义阶段就规定死了，与调用位置无关，不管在哪使用都要到原函数定义位置去找。

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

    return inner#在这里我们返回inner就是为了得到inner这个函数，而outter只是起到一个包裹作用。

f=outter()#在调用函数outter时，将inner返回给outter这个函数名，也就是f=inner。
print(f)#输出的为变量inner，也就是inner所对应的地址。
f()#当我们把x=1注释掉之后，会变成x=。
def foo():
    x=
    f()
foo()

闭包函数：
 1、定义在函数内的函数
 2、并且该函数包含对外部函数作用域中名字的引用，该函数成为闭包函数。比如上述函数中inner引用了outer中的变量x。

闭包函数说白了就是将一个函数包进另一个函数里面，而且外层函数会给内层被包含函数定义好值，所以内部函数需要值时候先去自己所在层找。
找不到就去外层函数找，但是一般不会到全局找，因为全局变量大家都可以引用，所以闭包函数外层函数专门给闭包函数传值。
传值目的就是为了得到闭包函数的执行结果，所以return。
 闭包函数包含对外部作用域的引用而非全局作用域的引用
在被包函数的头上，定义一个变量。