函数对象、函数嵌套、名称空间与作用域、装饰器

一 函数对象

一 函数是第一类对象，指的是函数可以当作数据传递  

 #1 可以被引用 x=1,y=x 
 #2 可以当作参数传递
 #3 返回值可以是函数
 #3 可以当作容器类型的元素

#函数是第一类对象，指的是函数可以当作数据传递  
问题：1.什么是数据？
     x=1   #1就是数据 函数可以当做数据传递，这里的1可以怎么样玩，我们的函数就可以怎么样玩

 

 实例：

#1、可以被引用 x=1,y =x
#函数可以被引用，意味着funciton函数就可以被赋值 #f=function
#function() 这个是函数的结果
def function(x,y):
print(x,y)
f=function #function 函数被赋值 
f(1,2) #进行调用

#2 可以当作参数传递
def foo():
print('from foo')
def bar(func):
print(func) 
bar(foo) #bar 得到的就是foo 的内存地址，既然你在bar函数拿到foo内存地址就可以进行调用
#######################
def foo():
print('from foo')
def bar(func):
#print(func) 
func()
bar(foo)


#3 重要-返回值可以是函数
def foo():
print('from foo')
def bar():
retrun foo
f=bar() #这个时候拿到foo 的内存地址 
f() #进行调用


#3 可以当作容器类型的元素
1.什么叫做容器类型，可以存放多个值的都叫容器类型 字典 元组 列表 
def foo():
print('from foo')
def bar():
print('from bar')

l=[foo,bar]

#调用第一个函数通过索引方式取值进行调用
l[0]()
l[1]()

#这个有什么功能？比如：

def put():

    print('put')

def ls():

    print('ls')

 

cmd = input(">>:").strip

if cmd == 'put'

   put()

#这样的方式太low 我们可以优雅的试验

#需要保证的前提，用户输入的key 只要在我们的字典里面就可以这样使用

def put():
    print('put')
def ls():
    print('ls')
func_dic={
    'put':put,
    'ls':ls
}
cmd=input('>>:').strip()
if cmd in func_dic:
    func_dic[cmd]()
#必须说我们现在有增加了其他的功能，直接在我们字典里面添加

def put():
    print('put')
def ls():
    print('ls')
def auth():
    print('auth')

func_dic={
    'put':put,
    'ls':ls,
    'auth':auth  #我们增加一个auth 认证功能
}
cmd=input('>>:')
if cmd in func_dic:
    func_dic[cmd]()

 

  

练习2 利用该特性，优雅的取代多分支的if

def foo():
    print('foo')

def bar():
    print('bar')

dic={
    'foo':foo,
    'bar':bar,
}
while True:
    choice=input('>>: ').strip()
    if choice in dic:
        dic[choice]()

二 函数嵌套

一 函数的嵌套调用

def max(x,y):
    return x if x > y else y
#求四个数的最大值  
#以下就是函数的嵌套的调用
#好处就是：节省代码，组织结构更清晰

def my_max2(a,b,c,d):
    res1=my_max(a,b)
    res2=my_max(res1,c)
    res3=my_max(res2,d)
    return  res3
print(my_max2(1,2,3,4))
#返回结果是4  

二 函数的嵌套定义

#在一个函数内部，有定义一个函数 嵌套定义

def f1():
    def f2():
        def f3():
            print('from f3')
        f3()
    f2()

f1()
f3() #报错，为何？请看下一小节

三 名称空间与作用域

一 什么是名称空间？

#名称空间：存放名字的地方，三种名称空间，（之前遗留的问题x=1，1存放于内存中，那名字x存放在哪里呢？名称空间正是存放名字x与1绑定关系的地方）
#名称空间又可以叫做命名空间： 存放的名字与值绑定关系的地方,名称空间存放一系列的名字可以存放x  也可以存放 y 
#名称空间分为三种： 内置名称空间 全局名称空间 局部名称空间
#内置名称空间：python解释器内置的一些名字len  max  print
#全局名称空间：  x = 1 文件级别定义的名字
#局部名称空间： 函数内部定义的就是局部空间，在什么情况下，才会产生局部名称空间放进去，在调用函数，才会运行函数体的代码，局部名称空间调用时生效，调用结束失效.不同的函数调用，是不同的局部空间

 

二 名称空间的加载顺序

python test.py
#1、python解释器先启动，因而首先加载的是：内置名称空间
#2、执行test.py文件，然后以文件为基础，加载全局名称空间
#3、在执行文件的过程中如果调用函数，则临时产生局部名称空间
#4、名称空间遵循的是LEGB原则
#加载顺序：内置（bulit in） ----->>全局（global）----->>局部（local）
#访问名字的顺序：局部空间--->>全局空间---->>内置空间

问题：函数的层级限制，给你带来的困扰?
是你用名字，不能随心所以去用，你访问名字是受限于三个名词空间的,只要涉及到名字，放在名称空间

三 名字的查找顺序

访问名字的顺序:局部名称空间--->全局名称空间--->内置名称空间

#需要注意的是：在全局无法查看局部的，在局部可以查看全局的，如下示例

# max=1
def f1():
    # max=2
    def f2():
        # max=3
        print(max)
    f2()
f1()
print(max) 


#如果你再全局需要找一个名字顺序:全局--->>内置         #名字没有找到就报错
#如果你是局部需要找一个名字顺序：局部-->>全局-->>内置  #名字没有找到就报错

#证明一件事：全局名称空间
# print (x)  #这个是在全局角度找一个名字,右键运行我们的程序，先把python解释器启动起来,内置名称空间起来以后，接下来就是执行python的文件,还没有开始的时候开始产生一个 X 它的名称空间
#首先取全局找，然后去内置找，没有找到就报错 NameError: name 'x' is not defined

#内置名称空间 
#print(max)   #<built-in function max> 返回结果告诉你是一个内置函数，首先在全局名称空间找max名字，没有就去内置名称空间去找