## 复习
```python
'''
三元表达式
结果1 if 条件 else 结果2
列表推导式
[列表元素 for v in iterable]
字典推导式
{字典元素 for k, v in iterable}
递归：函数的自调用
直接自调用：自己调自己
间接自调用：自己调别人，别人再调回自己
回溯(回溯条件) => 递推(递推开始，回溯的结束点)
def get_age(num):
if num == 1:
return 18
age = get_age(num - 1) - 2
age = get_age(5)
匿名函数：
lambda 形参们: 返回值
1. 用变量接收
2. 结合内置函数使用
内置函数：
max
'''
def func():
return [lambda x: x * i for i in range(4)] # [6, 6, 6, 6]
# return [lambda x, i=i: x * i for i in range(4)] # [0, 2, 4, 6]
# def m(2):
# return 2 * 0|1|2|3
print([m(2) for m in func()])
# 1.func()执行结果为list，所以被迭代
# 2.for i in range(4)能产生4次结果，所以func()的返回值list有四个元素
# 3.最终打印的列表推导式也有四个元素
# 4.func()返回值list中存放的是四个函数地址，匿名函数体没有被执行
# 5.m(2)时，匿名函数体才被调用，但四个匿名函数都已形成，再去获得i的值，i存放的是最后一次值3
# 理解案例
y = 10
def aaa(arg=y):
print(y)
print(arg)
y = 20
y = 30
y = 40
aaa()
print('------------------------------------------------')
def fn(x):
print(x)
return x
res = max([1, 5, 3, 2, 4], key=fn)
print('>>>', res)
dic = {'a': 100, 'b': 10}
res = max(dic, key=lambda k: dic[k])
print('>>>', res)
```
## 函数的回调
```python
# 提前写出函数的调用，再去考虑函数体的实现
# 怎么样提前写出函数的调用：在另一个函数中写出函数的调用
# 再去考虑函数体的实现：根据实际的需求
def my_sleep(sec):
import time
current_time = time.time()
while time.time() - current_time < sec:
pass
def download(fn=None):
print('开始下载')
my_sleep(1)
data = '下载得到的信息'
print('下载完成')
if fn: # 如果外界提供了回调函数的实现体，再去调用，否则就只完成默认下载的功能
res = fn(data) # 下载成功的回调函数，具体完成什么事之后决定
if res:
print('操作成功')
return True
print('操作失败')
return False
return data # 没有外界具体操作下载结果的功能代码，就将下载结果直接返回
# res = download()
# print(res)
def download_action(data):
print('往文件中写')
with open('1.txt', 'w', encoding='utf-8') as f:
f.write(data)
return True
return False
res = download(download_action)
print(res)
# 下载成功后的动作可以多样化
def download_action1(data):
print(data)
return True
res = download(download_action1)
print(res)
# 补充：
# 自定义sleep
# def my_sleep(sec):
# import time
# current_time = time.time()
# while time.time() - current_time < sec:
# pass
# print(000)
```
## 模块
```python
'''
1.了解什么是模块
2.为什么要使用模块
3.import导入模块：名称空间
4.起别名：原名与别名
5.from导入方式
6.*的知识点
7.查询顺序
8.自启文件与模块的区别
难点：循环导入
'''
'''
模块的四种存在方式：
1.使用python编写的.py文件（任何一个py文件都可以作为模块）
2.包:一堆py文件的集合体
3.使用C编写并链接到python解释器的内置模块
4.已被编译为共享库或DLL的C或C++扩展
'''
# 模块：一系列功能的集合体
# 使用模块：在要使用该模块功能的文件中导入模块，通过import关键字导入模块名
import module
# 导入模块，会编译执行成一个pyc文件,该pyc文件就是该模块的执行文件
# print(module)
# 再次导入，module该模块不会被执行了
import module
import module
import module
import module
# 导入模块: import module
# 1.编译执行模块所对应的py文件，形成对应的pyc文件
# 2.产生该模块自己的全局名称空间
# 3.在使用该模块的全局名称空间中产生一个名字(导入的模块名)
import module
aaaaa = module
import module
a = 888
module.b()
module.c()
print(aaaaa.a)
print(a)
# 注：
# 1.每一个文件都会产生自己的全局名称空间，且相互不影响
# 2.多次导入，只会编译执行模块一次，将其加载到内存，之后的都是直接对名字的引用
```
## 起别名
```python
num = 20
print(num)
# 在任何地方都可以导入模块
# def fn():
# global m3
# import m3 # 就是普通的名字，只是该名字执行的是一个py文件(全局名称空间)
# print('>>>', m3.num)
# fn()
# print(m3.num)
# 通过as关键字可以给模块起别名: 模块名一旦起别名，原模块名就不能再使用
# 1.可以简化模块名字
import mmmmmmmmmmmmmmmmmm3 as my_m3
print(my_m3.num)
# 2.可以统一功能
cmd = input('数据库选择 1:mysql | 2:oracle：')
if cmd == '1':
import mysql as db
# mysql.excuse()
else:
import oracle as db
# oracle.excuse()
db.excuse()
```
## from导入模块
```python
# import m3, m4
# import m3
# import m4
# 在import后的名字才会在该文件的名称空间中产生
# from m4 import a, b, _c # 指名道姓的可以导入_开头的名字
# 通过*导入: 可以将导入模块中的(除了以_开头的)名字一并导入
from m4 import *
# 通常不建议导入*，当需要使用模块中绝大部分名字时，才考虑导入*
print(a)
a()
# 两个py文件中的名字a都合理存在，
# 但import后的名字a和a=20，在一个名称空间中，只会保留最后一次值
a = 20
# a()
b()
print(a)
# _c()
print(_c)
# print(c)
```
## from导入起别名
```python
# 一旦起别名，原名字就不能再用
from m5 import aaaaa as a, bbbbb as b, ccccc as c
print(a)
print(b)
print(c)
```