day11

## 函数总结

```python
# 函数的定义：
def func(a, b):
print(a, b)
return a + b

# 函数四个组成部分
# 函数名：调用函数的依据，必须的
# 函数体：执行函数逻辑的，必须的
# 参数列表：为函数内部提供资源，非必须的
# 返回值：将函数执行结果返回给外界，（非必须的）

# 返回值：空返回（没有return|空return） | 一值返回 | 多值返回：装有多个值的元组

# 参数列表：
# 实参：外界调用函数传入的参数，拥有实际值
# 形参：函数定义时，()中定义用来接受实参的值

# 参数重点一：形参是对实参的值拷贝 *****
ls = [1, 2, 3, 4, 5]
num = 10

def fn(arg, n):
arg[2] = 300
print('1:', arg[2])
print(id(n))
n = 100
print(id(n))

fn(ls, num)
# arg是对ls的值拷贝
print('2:', ls[2])
print(id(num))

# 实参的分类
# 位置实参：按位置对应传递参数，必须出现在关键字实参之前
# 关键字实参：不需要按位置对应传参，用参数名标注为谁传参，必须出现在位置实参之后

# 参数重点二：先位置实参后关键字实参传参

# 参数重点三：
# 位置实参：只能给位置形参传参（位置形参|默认形参|可变长位置形参）
# 关键字实参：可以给任意形参传参

# 出现顺序
# 参数重点四：
# 位置形参 > 默认形参 > 可变长位置形参 > 关键字形参 > 可变长关键字形参

def fn1(a, b, c=10, *args, d, e=20, f, **kwargs):
pass

```

## 函数对象

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

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

```python
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)

```

## 名称空间

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

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

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

## global关键词

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

```

## 函数的嵌套定义

```python
# 将函数直接定义到另一个函数内部，就可以使用外部函数的中的名字
def outer():
num = 20
def inner():
print(num) # inner就可以直接使用outer中的名字
inner()
outer()
# 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 fn4():
num = 20
def fn5():
print(num)
fn5()
fn4()

```

## 作用域

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

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

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

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

```

```python
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
```

## 闭包

```python
# 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()

# 闭包就是函数嵌套(格式稍作改良)

# inner可以使用outer的局部变量：可以将inner定义在outer中
# inner的调用还是在外部：inner函数对象能被outer返回

# 将内部函数对象作为外部函数的返回值：1.可以使用局部变量; 2.不改变函数的调用位置
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')
'''