1. 模块化编程思想
模块化编程是 Python 的基本思想。初学 Python，都应该使用过小海龟、随机、数学模块。使用模块之前，需要导入模块，然后根据自己的问题需要使用这些模块。
Python 提供了大量的模块库，这些模块中有缓存视频怎样转入相册 Python 语言系统自带的、也有第三方提供的、也可以由开发者根据需要创建。
内置模块，直接拿来使用就可以。
第三方模块，需要使用 Python 自带的安装程序 pip（pip3 是 pip 的升级版本） 安装。
pip3 install 模块
pip 或 pip3 是命令行程序。使用之前，需要进入 OS 的命令模式。windows 操作系统中使用 win+r 打开运行对话框，输入 cmd ，进入命令操变量的定义作模式 。
命令模式下直接输入 pip3，便可出变量是什么意思现如下 pip3 的基本功能（前提需要安装 Python 运行环境）。
Commands:
install 安装模块
download 下载模块
uninstall 卸载模块
list 列表出安装的模块
show 显示安装模块的信息
check 验证模块的依赖信息
config 管理本地和全局配置
search 从 PyPI (Python Package Index 是 Python 编程语言的软件存储库） 搜索模块
index 使用模块的索引检查模块的合法性
什么是模块化编程？
Python 语言系统中一个命令行常用命令文件就是一个模块，一个模块中可以封装很多实用的功能代码，这些功能体可以以函数的形式算法的五个特性存在，也可以以类的形式存存，模块具有完全的自我独立性。
模块与模块之间可以在需要时相互依赖。
模块化编程可以大大提高代变量名码的重用性，也可以无限扩展 Python 语言的功能。Python 经过多年的积累和沉淀，已经有诸多丰富的模块可以使用。
2. 函数
Pytho变量名的命名规则n 语言中，函数是一等公民。
函数定义语法结构：
def 函数名(函数参数)：
函数体
- 定义函数，也就是创建一个函数必须使用 def 关键字。
- 函数名是函数的唯一标识符，也是使用函数的接口（入口接口测试用例设计）。
- 函数参数：用来接收调用者传过来的数据变量。也称为形式参数（占位符）。参数可以没有，也可以有多个。
- 函数体：函数提供的功能实现。
Python 函数的特点：
Python 既是面向对象编程语言，也是面向函数的编变量名的命名规则程语言。函数可以作为算法的时间复杂度取决于其它函数变量的参数，也可以作为其它函数的返回值。函数本质是一种数据类型。
def han_shu():
print(1)
print(type(han_shu))
'''
输出结果：
<class 'function'>
'''
有些时候，称类中函数为方法。只是语义上的区别，本质一样。
创建函数意味着根据算法 functio接口文档n 类型创建一个 function 对象。
- 函数作为参数：
def a_han_shu(f):
f()
def b_han_shu():
print('Test')
# 函数作为参数不要有括号。
a_han_shu(b_han_shu)
'''
输出结果
Test
'''
- 函数作为返回值：
def a_han_shu():
def b_han_shu():
print('Test')
return b_han_shu
# 返回的是对 b_han_shu 函数的引用
f=a_han_shu()
f()
'''
输出结果
Test
'''
无论是使用函数作为参数还是返命令行快捷键回值，函数不能有括号。
当函数后面有括号，意味着是执行函数中的逻辑代码。算法
- 使用其它模块中的函数作参数：
import turtle
def forward(f):
f(200)
# turtle.forward 后面不能有括号
forward(turtle.forward)
'''
用自己的函数封装小海龟的前移函数
'''
- 类的方法本质还是函数
class Dog:
def __init__(self, name):
self.name = name
def run(self):
print(self.name,"在 run……")
def bark(self, f):
f()
print(self.name,"在 叫……")
d = Dog('小花')
d.bark(d.run)
'''
输出结果
小花 在 run……
小花 在 叫……
'''
函数的参数形式：
- 位置变量名传递参数：
def han_shu(num1, num2):
return num1 - num2
#如果想得到 10-4 相减的结果，调用时 10，4 的顺序不能颠倒。如果传递4，10 得到 4-10 结果
res = han_shu(10, 4)
print(res)
'''
输出结果
6
'''
- 命名传递变量的英文参数：
def han_shu(num1, num2):
return num1 - num2
#通过参数名传递数据
res = han_shu(num1=10,num2=4)
print(res)
# 传递参数时可以颠倒顺序
res = han_shu(num2=4,num1=10)
print(res)
'''
输出结果
6
'''
- 默认值传递
def han_shu(num1, num2=4):
return num1 - num2
#通过参数名传递数据
res = han_shu(10)
print(res)
'''
输出结果
6
'''
切记：默认值参数只能放在最后。
- 可变长度参数
def han_shu(*num):
return num
res = han_shu(10, 4,6,12)
print(res)
'''
输出结果
(10, 4, 6, 12)
'''
参数前面的 * 表接口测试示可以传递 0 个、1 个或多个参数，函数内部会把所有传过来的数据放在一个元组中。
def han_shu(**num):
return num
res = han_shu(a=1,b=2,c=3)
print(res)
'''
输出结果
{'a': 1, 'b': 2, 'c': 3}
'''
参数前面的 ** 表示可算法分析的目的是以接收任意多的以键、值对形式的参数。函数内部用字典的形式存储传过来的数据。
匿名函数
匿名函数也称为 lambda 函数，是对函数语法的简算法是什么化。lambda 函数有如下几个特点：
- 没有函数名。
- 只能使用一次。
- 只能有一句函数体。
- 不能有 r命令行etur算法是什么n 语句，默认返回唯一语句块的计算结果。
def han_shu():
return lambda num: num + 1
res = han_shu()
print(res(12))
'''
输出结果
13
'''
上面的 han_shu 函数会返回一个匿名函数的引用。相当于下面的代码：
def han_shu():
def f(num):
return num + 1
return f
res = han_shu()
print(res(12))
'''
输出结果
'''
内置函数：
Python 中有很多内置函数、或称为系统函数，此类函数特点：可以直接使用。
常用内置函数：
| 函数名 | 函数功能 | 备注 |
|---|---|---|
| input([x]) | 交互式方式获取用户输入的数据 | 数据是字符串类型 |
| print(x) | 将 x 值输出到控制缓存英文台 | 不指定输出内容时，输出换行 |
| pow(x,y) | x 的 y 次幂，相当于 x**y | |
| round(x,[,n]) | 对 x 四舍五入，保留 n 位小数点 | 不指定 n 时，不保留小数位 |
| max(x1,x2,x3,……) | 返回所数列中的最大值 | |
| min命令行窗口怎么打开(x1,x2,x3,……) | 返回数列中的最小值 | |
| sum(x1,x2,x3变量数列中各组频率的总和,……) | 返回数列中所有数字相加接口是什么之和 | 参数需是可迭代缓存视频合并app下载类型 |
| len( ) | 返回元组、列表、集合、字符串等算法的空间复杂度是指容器对象的长度 | |
| range(start,end,s缓存视频在手机哪里找tep) | 返回一个可迭代的对象缓存视频合并 | 有index()、和count()方法 |
| eval(x) | 执行一个字符串表达式 | 可构建动态表达式 |
| int(x) | 将 x 转换成 int 类型数据 | x命令行窗口怎么打开 可以是命令行常用命令字符串或浮点类型 |
| float(x) | 将 x 转换成缓存视频变成本地视频 float 类型数据 | 可以是 int 或 str 类型 |
| str(x) | 将 x 转换成 str 类型 | |
| list(x) | 将一个可迭代对象转换成列表接口和抽象类的区别 | |
| open() | 打开一个文件 | |
| abs(x) | 返回 x 的绝对值 | |
| type(x) | 返回 x 的数据类型 | |
| ord(x) | 返回字符串的 unicode 编码 | |
| chr(x) | 返回 unicode 对应的字符串 | |
| sorted(x) | 排序操作 | |
| tuple(x) | 将可迭代对算法的有穷性是指象转换成元组 | |
| set(x) | 将可迭代对象转换成集合 |
3. 递归算法
递归指函数自己调接口英文用自己。递归调用算法的时间复杂度取决于有 2 个过程：
1、**递进过程：**如有一算法的有穷性是指个函数 a 。递归调用过变量名的命名规则程：第一次调用 a ===> 第二次调用 a ===>第三次调用 a ===> ……===>第 n 次调用 a。如果没有任何中止条件，则会无限制推进，导致内存耗尽。所以，递归必须有一个终结条件。
2、**回溯过程：**回溯过程是递进过程的逆过命令行界面程。函数调用的特点是， a 调用命令行界面 b 后，b 结束一定要返回到 a。在递归调用过程中，当第 n 次调用完成后，会进入第 n-1 次，再进入 n-2 次……一直回命令行参数到第一次调用。
函数就是一个逻辑块，递归过程也就是重复执行函数内的逻辑块的过程，所以递缓存视频变成本地视频归可以实现循环语法的同等效应。理论上，循环语法实现的操作完全可以使用递归方式替换，但递归的性能消耗要远大于循环语法结构。算法的五个特性
只有在使用循环语法结构不能实现或实现起来很麻烦的情况下才使用递归。
递缓存视频在手机哪里找归适合于解决接口测试面试题，一个看起来很复杂的问题，其解决问题的关键点却在一个很的子问题上时。
如求一个数字的阶乘：计算 5！（5的阶乘）。
-
递进过程：5！=5X4! ，如果求出缓存垃圾克星 4! 则 5！也变量的定义就可求出，而 4!=4X3!，问题变成求 3！的缓存垃圾克星阶乘，而 3!=3X2!，问题变成求 2！，而 2！=2X1！，问题变成求 1!，而 1! 就是 1。到此递进过程可以终止。
-
回溯过程：把 1! 的结缓存视频变成本地视频果返回 2！,再把求得的 2！的结果返回求 3！，再把 3！的结果返回给求 4！，再把 4！的结果返算法回给 5！。最后得到结果。算法的特性
def jc(num):
# 递归终止
if num == 1:
return 1
return num * jc(num - 1)
res = jc(5)
print(res)
如上面求某个数字阶乘的递归算法，属于线性递进，相对命令行参数而言较容易理解。
再看一个例子：斐波拉契数列。
1，1，2，3，5，8，13，21……
从第三个数字开始，每一个数字都是前 2 个数字相加结果（第一，二位置的数字是 1）。此问题符合递归方案，如果想知道第 5 个位置的数字是匇，则需要知道第3，4个位置的数字是多少，如果要知接口英文道第3算法设计与分析 个位置的则需要知道第1，2位置的命令行窗口怎么打开数字是多少，如果算法导论要知道第 4 个位置的则变量与函数要知道第 2，3位置的数字是多少命令行工具。这个递进过程是一个树结构。
观察递进示意图，发现在求第 5 个位置数字时需要知道第 3 个位置数字，求第 4 位置数字缓存的视频怎么保存到本地也需要求解第 3 位置数字。第 3 个位置的数字求解在整个递进过程中至少计算了 2 次。
树结缓存视频合并构的递进过程中，被重复计算是常见问题。一般会采用缓存机制，对于应该计算的数字就不再计算。
不使用缓存的常规递归算法：
def fb(pos):
if pos==1 or pos==2:
return 1
return fb(pos-1)+fb(pos-2)
res=fb(5)
print(res)
'''
输出结果
5
'''
使算法的有穷性是指用缓存机制的算法：
#缓存器，位置作键，此位置的数字为值
cache = {}
def fb(pos):
if pos == 1 or pos == 2:
return 1
# 查看缓存中是否存在此位置已经计算出来的数字
if cache.get(pos) is not None:
return cache.get(pos)
# 缓存中没有，才递进
val = fb(pos - 2) + fb(pos - 1)
#得到值别忘记缓存
cache[pos] = val
return val
res = fb(5)
print(res)
'''
输出结果
5
'''
缓存机制的原理：需要某一个位置的数字时，先从缓存中查找，没有才继续递进。
再看一个例子：杨辉三角
杨辉三解的数字规律。每一行的第一列和最后一列为 1 ，每一行的其它列的值等于其左肩膀和右肩膀上的数字接口测试面试题相加。
假设现在求第5行第3列的数字是多少？看如何使用递归方式计算。
观察后，命令行参数可看到（3，2）位变量名的命名规则置的数字被计算了两次，如果使用递归方式求解杨辉三解。当行数越多时，被重复计算的值就越多，性能消耗很严重。
为了提升性能，尽可能使用缓存机制。
常规不使用缓存机制：
import time
cache = {}
def yh(row, col):
if row == 1 or col == 1 or row == col:
return 1
return yh(row - 1, col - 1) + yh(row - 1, col - 2)
s = time.process_time()
res = yh(25, 5)
e = time.process_time()
print(res)
print('所使用的时间：',e - s)
'''
输出结果
5242885
所使用的时间： 1.671875
'''
使接口卡用缓存机制：
import time
def yh(row, col):
if row == 1 or col == 1 or row == col:
return 1
if cache.get((row, col)) is not None:
return cache.get((row, col))
val = yh(row - 1, col - 1) + yh(row - 1, col - 2)
cache[(row, col)] = val
return val
s = time.process_time()
res = yh(25, 5)
e = time.process_time()
print(res)
print("使用时间:",e - s)
'''
输出结果
5242885
使用时间: 0.0
'''
使用缓存和不使用缓存的运算时间差是很明显的。
4. 文件操作
使用 open(“文件路径”,”模式”)。
模式有 r 可读，r+ 可读可写。当以 r 模式打开时，文件必须存在，算法的特性
w 可写，w+ 可读可写，当以 w 模式命令行重启电脑打开时，文变量类型有哪些件可以不存在，如果存在，文件中内容会被清除。
a 可追加写，a+ 可追加写，可读。当以 a 模式打开时，文件可以不存在，如果存在，接口类型文件中内容不会被清除。
读方法：
with open("d:/temp.txt","r") as f :
# 读所有内容
f.read()
# 读一行
f.readline()
# 读出所有行
f.readlines()
写方法：
with open("d:/temp.txt","w") as f :
# 写入数据
f.write(1)
# 把列表数据写入
f.writelines([1,2])
# 使用 print 方法写入
print(123,34,sep=",",file=f)
5. 总结
对于 python 需要掌握的知识做了一个简单的归纳。
