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