一、函数对象：

1. 　定义：函数对象就是函数名，函数名就是存放了函数的内存地址，存放了内存地址的变量就是对象
2. 　函数对象的应用：
   1. 　　可以直接被引用：（fn = cp_fn）
   2. 　　可以当做参数传递传递：　computed（cp_fn,a,b）
   3. 　　可以当做函数的返回值 ：   return add
   4. 　　可以作为容器类型的元素 ：method_map 字典里的对应关系
3. 　　综合案例：

   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,
   
       'quyu': quyu,
   
   }  # 作为容器的元素
   
   # 根据指令获取计算方法
   
   def get_cp_fn(cmd):
   
       if cmd in method_map:
   
           return method_map[cmd]
   
       return add  # 输入有误用默认方法处理    # 作为return 的返回值
   
   while True:
   
       cmd = input('cmd: ')
   
       if cmd == 'quit':
   
           break
   
       cp_fn = get_cp_fn(cmd)  # 直接被应用
   
       result = computed(cp_fn, 100, 20)
   
       print(result)

二、名称空间：

1. 　　定义：名称空间是存放名字与内存空间地址的对应关系的容器
2. 　　作用：解决由于名字有限，导致名字重复发生的冲突问题
3. 　　分类： 
   1. 1. 内置名称空间（Built in）：系统级，随着解释器执行而产生，解释器执行完毕而销毁。
      2. 全局名称空间（Global）：文件级，随着文件的加载而产生，文件运行完毕而销毁。
      3. 局部名称空间（Local）：函数级，随着函数的执行而产生，函数执行完毕而销毁。

　　　　　　　　注：

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

　　　　　Global 关键字　：

1. 1. 1. global 关键字可以将Local的名字提升为Global的名字
      2. 一个函数中 同一个名字 Global后只有一个，所有函数内部或是外部使用的名字都只有一个

def fn()

    global num

    num = 20

    print(num)

# global关键词可以将Local的名字提升为Global的名字

# 一个文件中的Global名字就是一个，所以函数内部外部使用的名字都是一个

fn()

print(num)

四、作用域：

1. 1. 定义：就是名字起作用的范围。
   2. 作用：解决同名字共存的问题。　
   3. 分类：
      1. Built-in：内置作用域，对所有文件所有函数有效（在全局和嵌套以及局部未做操作的时候）
      2. Global：全局作用域，对当前文件所有函数有效（在嵌套以及局部未做操作的时候）
      3. Eclosing：嵌套作用域，当前函数与当前函数的内部函数有效（内部函数未做操作的时候）
      4. Local：局部作用域，对当前函数有效

　　　　　　　　注：不同作用域名字之前不起冲突，从而达到名字的重复使用。查找顺序  ： Local--->Enclosing--->Global--->Built-in

len = 10

def outer():

    len = 20  # 外层函数的局部变量：Enclosing - 嵌套作用域

    def inner():

        len = 30

        print('1:', len)  # 30， inner -> outer -> global -> built-in

    inner()

    print('2:', len)  # 20， outer -> global -> built-in

outer()

print('3:', len)  # 10， global -> built-in

del len

print('4:', len)  # len地址， built-in

五、闭包函数：

1. 1. 1. 定义：闭：被包其他函数包裹的函数 ；包：包含被包裹函数中的参数
      2. 完整的闭包结构：
         1. 将函数进行闭包处理
         2. 提升函数名的作用域，将内部函数对象作为外部函数的返回值

import requests

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