python全栈开发-Day9 函数对象、函数嵌套、名称空间与作用域(装饰器基础)详解编程语言

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

 1 def foo():                   
 2     print('foo')  
 3  
 4 def bar(): 
 5     print('bar') 
 6  
 7 dic={   
 8     'foo':foo,                   #foo是内存地址 
 9     'bar':bar,                   #bar是内存地址 
10 } 
11 while True: 
12     choice=input('>>: ').strip() 
13     if choice in dic: 
14         dic[choice]()      

1 def max(x,y): 
2     return x if x > y else y 
3  
4 def max4(a,b,c,d): 
5     res1=max(a,b) 
6     res2=max(res1,c) 
7     res3=max(res2,d) 
8     return res3 
9 print(max4(1,2,3,4))

1 def f1(): 
2     def f2(): 
3         def f3(): 
4             print('from f3') 
5         f3() 
6     f2() 
7  
8 f1() 
9 f3() #报错，外部无法调用，可以考虑如何在外面使用函数里面的功能

名称空间：存放名字的地方，三种名称空间，（之前遗留的问题x=1，1存放于内存中，那名字x存放在哪里呢？名称空间正是存放名字x与1绑定关系的地方）

#1、内置名称空间： 
#存放python解释器自带的名字,在解释器启动时就生效,解释器关闭就失效. 
 
#2、全局名称空间: 
#文件级别的名字,在执行文件的时候生效,在文件结束或者文件执行期间被删除则失效 
 
#3、局部名称空间： 
#在函数内定义的名字,(函数的参数以及函数内的名字都存放与局部名称空间),在函数调用时临时生效，函数结束则失效

python test.py 
#1、python解释器先启动，因而首先加载的是：内置名称空间 
#2、执行test.py文件，然后以文件为基础，加载全局名称空间 
#3、在执行文件的过程中如果调用函数，则临时产生局部名称空间

#局部名称空间--->全局名称空间--->内置名称空间 
 
#需要注意的是：在全局无法查看局部的，在局部可以查看全局的，如下示例 
 
# max=1 
def f1(): 
    # max=2 
    def f2(): 
        # max=3 
        print(max) 
    f2() 
f1() 
print(max) 

#1、作用域 
        #全局作用域（包含的是内置名称空间与全局名称空间的名字）： 
        #特点： 
                 #1、在任何位置都能够访问的到 
                 #2、该范围内的名字会伴随程序整个生命周期                 
                 #（全局存活，全局有效） 
　     # 局部作用域（局部名称空间的名字）： 
        #特点： 
                 #1、只能在函数内使用 
                 #2、调用函数时生效，调用结束失效                 
                 #（临时存活，局部有效） 
 
#2、作用域关系是在函数定义阶段就已经固定的，与函数的调用位置无关，如下 
x=1 
def f1(): 
    def f2(): 
        print(x) 
    return f2 
x=100 
def f3(func): 
    x=2 
    func() 
x=10000 
f3(f1()) 
 
#3、查看作用域：globals(),locals() 
 
 
LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__ 
locals 是函数内的名字空间，包括局部变量和形参 
enclosing 外部嵌套函数的名字空间（闭包中常见） 
globals 全局变量，函数定义所在模块的名字空间 
builtins 内置模块的名字空间                                

#定义在函数内部的函数,并且该函数包含对外部函数作用域中名字的引用 
该函数就是闭包函数 
 
#提示：之前我们都是通过参数将外部的值传给函数，闭包提供了另外一种思路，包起来喽，包起呦，包起来哇 
 
def outter(): 
    x=2 
    def inner(): 
        # x=1 
        print("from inner",x) 
 
    return inner 
 
f =outter() 
f()           #x值为2

#闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域 
#应用领域：“爬虫“（原来我们是传参，现在我们是包起来） 
 
import requests                   
 
 
def outter(url): #url='https://www.baidu.com' 
    def get(): 
        response=requests.get(url) 
        if response.status_code == 200: 
            print(response.text) 
 
    return get 
 
 
 
baidu=outter('https://www.baidu.com') 
python=outter('https://www.python.org') 
baidu()               
python()