函数对象

函数对象：

函数名存放的就是函数的地址，所以函数名也是对象，称之为函数对象

a = 10
print(a)

def fn():
    num = 10
    print('fn function run')

print(fn)

1 可以直接被引用

func = fn
print(func)
fn()
func()

2 可以当作函数参数传递

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 computed(fn, n1, n2):
    # fn代表四则运算中的一种
    # res为运算结果
    res = fn(n1, n2)
    return res

# 完成两个数的某一运算，拿到结果

while True:
    cmd = input('cmd：')
    if cmd == 'add':
        result = computed(add, 100, 20)
    elif cmd == 'low':
        result = computed(low, 100, 20)
    else:
        print('输入有误')
        break
    print(result)

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,
}

while True:
    cmd = input('cmd: ')
    # 用户输入的指令只要有对应关系，就会自动去走对应的计算方法
    # 这样外界就不能去关系到底有哪些计算方法
    if cmd in method_map:
        cp_fn = method_map[cmd]  # 拿到计算方法
        result = computed(cp_fn, 100, 20)  # 通过计算方法得到计算结果
        print(result)
    else:
        print('输入有误，退出')
        break

4 可以作为函数的返回值

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  # 输入有误用默认方法处理

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

名称空间的加载顺序

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

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

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

名字的查找程序：局部名称空间--->全局名称空间--->内置名称空间 

需要注意的是：在全局无法查看局部的，在局部可以查看全局的

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

    len = len('abcdef')
    print(len)

    del len

    # del len

    print(len('000111222'))
    '''
    [
        # ['len': 100001]  # 保存长度的变量
        ['len': 200001]  # 计算长度的函数
    ]
    '''


    def fn1():
        len = 10
        print(len)


    def fn2():
        len = 20
        print(len)


    fn1()
    fn2()

global关键词

part1
print(len)

len = 10

def fn():
    len = 20
    print(len)

fn()
print(len)
 part2
ls = []
def fn1():
    ls = []
    ls.append(100)
    print(ls)
fn1()
print(ls)

# 定义一个函数，函数中有一个变量

def fn2():
    num = 20
    return num

# 再定义一个函数，该函数要使用上一个函数中的变量
def fn3():
    print(num)
num = fn2()
fn3()

 part3
num = 10
def fn2():
    global num  # 将Local:num => Global: num
    num = 20
    num = 30

# Local的名字一旦global，就办成Global的名字，一个文件中的Global名字就是一个
def fn3():
    global num  
    num = 40
    print(num)
fn2()
print(num)
fn3()
print(num)

函数的嵌套

将函数直接定义到另一个函数内部，就可以使用外部函数的中的名字
def outer():
    num = 20
    def inner():
        print(num)  # inner就可以直接使用outer中的名字
    inner()
outer()

作用域：名字起作用的范围
作用：解决同名字可以共存问题
四种作用域
Built-in：内置作用域，所有文件所有函数
Global：全局作用域，当前文件所有函数
Enclosing：嵌套作用域，当前函数与当前函数的内部函数
Local：局部作用域，当前函数

1、作用域即范围 

全局范围（内置名称空间与全局名称空间属于该范围）：全局存活，全局有效 　

局部范围（局部名称空间属于该范围）：临时存活，局部有效

2、作用域关系是在函数定义阶段就已经固定的，与函数的调用位置无关

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

LEGB
不同作用域之间名字不冲突，以达到名字的重用
查找顺序：Local -> Enclosing -> Global -> Built-in -> 抛异常
闭包就是函数嵌套(格式稍作改良)

closure：被包裹的函数，称之为闭包
完整的闭包结构：1.将函数进行闭包处理；2.提升函数名的作用域，将内部函数对象作为外部函数的返回值：1.可以使用局部变量; 2.不改变函数的调用位置

inner可以使用outer的局部变量：可以将inner定义在outer中
inner的调用还是在外部：inner函数对象能被outer返回
def outer():
    num = 10
    def inner():  # 闭包：定义在函数内部的函数称之为闭包
        print(num)
    return inner
fn = outer()  # fn = inner
fn()

案例一：外部函数可以为闭包传递参数 (了解)

import time
def download():
    print('开始下载')
    time.sleep(2)
    print('下载完成')
    data = "下载得到的数据"
    outer(data)
# 为闭包传参
def outer(data):
    def inner():
        # 保存，播放，删除等操作
        print("闭包打印：", data)
    inner()
download()

案例二：延迟执行

import requests

# get_html一执行就获取页面
def get_html(url):
    html = requests.get(url)
    print(html.text)
get_html('https://www.baidu.com')
get_html('https://www.python.org')
get_html('https://www.sina.com.cn')
get_html('https://www.baidu.com')


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