基石为勤能补拙的迷宫之旅——第十一天（Python函数对象、名称空间、函数嵌套、作用域和闭包）

一、函数对象

    函数名就是存放了函数的内存地址，存放了内存地址的变量都是对象，即 函数名 就是 函数对象。

函数对象的应用

1 .可以直接被引用——fn = cp_fn
2 .可以当作函数参数传递——computed(cp_fn, 100, 20)
3 .可以作为函数的返回值——get_cp_fn(cmd): return add
4 .可以作为容器类型的元素——method_map: 对应关系中的值

def add(a, b):
    return a + b
def low(a, b):
    return a - b
def jump(a, b):
    return a * b
def full(a, b):
    return a / b
def quyu(a, b):
    return a % b
def computed(fn, n1, n2):
    res = fn(n1, n2)
    return res
method_map = {
    'add': add,
    'low': low,
    'jump': jump,
    'full': full,
    'mod': mod,
}
# 根据指令获取计算方法
def get_cp_fn(cmd):
    if cmd in method_map:
        return method_map[cmd]
    return add  # 输入有误用默认方法处理


while True:
    cmd = input('cmd: ')
    if cmd == 'quit':
        break
    cp_fn = get_cp_fn(cmd)
    result = computed(cp_fn, 100, 20)
    print(result)

二、名称空间

    名称空间：存放名字与内存空间地址对应关系的容器
    作用：解决由于名字有限，导致名字重复发送冲突的问题

三种名称空间

• Built-in：内置名称空间；系统级，一个；随解释器执行而产生，解释器停止而销毁
• Global：全局名称空间；文件级，多个；随所属文件加载而产生，文件运行完毕而销
• Local：局部名称空间；函数级，多个；随所属函数执行而产生，函数执行完毕而销毁

注：
    del 名字：可以移除查找最近的名字与内存空间地址的对应关系
    加载顺序：Built-in > Global > Local

global 关键词

def fn()
	global num
    num = 20
    print(num)
    
fn()  
print(num)

    global关键词可以将Local的名字提升为Global的名字
    一个文件中的Global名字就是一个，所以函数内部外部使用的名字都是一个
    一定要调用函数，才能产生名字，并提升

三、函数的嵌套

定义

将函数直接定义到另一个函数内部，就可以使用外部函数的中的名字

def outer():
    num = 20
    def inner():
        print(num)  # inner就可以直接使用outer中的名字
    inner()
outer()

四、作用域

作用域：名字起作用的范围
作用：解决同名字可以共存问题

四种作用域

• Built-in：内置作用域，所有文件所有函数
• Global：全局作用域，当前文件所有函数
• Enclosing：嵌套作用域，当前函数与当前函数的内部函数
• Local：局部作用域，当前函数

    不同作用域之间名字不冲突，以达到名字的重用
    查找顺序：Local > Enclosing > Global > Built-in

len = 10
def outer():
    len = 20  # 外层函数的局部变量：Enclosing - 嵌套作用域
    def inner():
        len = 30
        print('1:', len)  # inner -> outer -> global -> built-in
    inner()
    print('2:', len)  # outer -> global -> built-in
outer()
print('3:', len)  # global -> built-in

del len
print('4:', len)  # built-in

五、闭包

    闭包就是函数嵌套(格式稍作改良)。
    inner可以使用outer的局部变量：可以将inner定义在outer中
    inner的调用还是在外部：inner函数对象能被outer返回

    将内部函数对象作为外部函数的返回值：1.可以使用局部变量; 2.不改变函数的调用位置

def outer():
    num = 10
    def inner():  # 闭包：定义在函数内部的函数称之为闭包
        print(num)
    return inner
fn = outer()  # fn = inner
fn()

closure：被包裹的函数，称之为闭包
完整的闭包结构：1.将函数进行闭包处理；2.提升函数名的作用域，将内部函数对象作为外部函数的返回值

def outer(url):
    def get_html():
        html = requests.get(url)
        print(html.text)
    return get_html
# 先预定义多个爬虫方法，爬页面操作并未执行
baidu = outer('https://www.baidu.com')
python = outer('https://www.python.org')
sina = outer('https://www.sina.com.cn')
# 什么时候想爬什么页面就调用指定页面的爬虫方法
baidu()
sina()
baidu()