函数之名称空间、作用域

一、函数对象

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

　　　　　　# 函数对象的应用
　　　　　　   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,
　　　　　　　　　　　　　　'quyu': quyu,
　　　　　　　　　　　　　　}
　　　　　　　　　　# 根据指令获取计算方法
　　　　　　　　　　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)

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

四、函数的嵌套定义

　　　　将函数直接定义到另一个函数内部，就可以使用外部函数的中的名字
　　　　　　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)      # 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

六、闭包

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