第一章：基础知识
1. 标识符
标识符是编程时使用的名字，用于给变量、函数、语句块等命名，Python 中标识符由字母、数字、下划线组成，不能以数字开头，区分大小写。
以下划线开头的标识符有特殊含义，单下划线开头的标识符，如：_xxx ，表示不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 导入；双下划线开头的标识符，如：__xx，表示私有成员；双下划线开头和结尾的标识符，如：xx，表示 Python 中内置标识，如：init() 表示类的构造函数。
2 .关键字
| and | exec | not | assert | finally | or |
|---|---|---|---|---|---|
| break | for | pass | class | from | |
| continue | global | raise | def | if | return |
| del | import | try | elif | in | while |
| else | is | with | except | lambda | yield |
上面表中是 Python 中的关键字（保留字），我们在自定义标识符时不能使用关键字。
3 .引号
Python 可以使用引号（'）、双引号（"）、三引号（''' 或 """）来表示字符串，引号的开始与结束须类型相同，三引号可以由多行组成。
id = '001'
name = "张三"
skill = '''
唱歌
跳舞'''
skill = """
唱歌
跳舞"""
4 .编码
Python2 中默认编码为 ASCII，假如内容为汉字，不指定编码便不能正确的输出及读取，比如我们想要指定编码为 UTF-8，Python 中通过在开头加入 # -- coding: UTF-8 -- 进行指定。
Python3 中默认编码为 UTF-8，因此在使用 Python3 时，我们通常不需指定编码。
5 .输入输出
Python 输出使用 print()，内容加在括号中即可。如下所示：
print('Hello Python')
Python 提供了一个 input()，可以让用户输入字符串，并存放到一个变量里。如下所示：
name = input()
6. 缩进
Python 不使用 {} 来控制类、函数、逻辑判断等，而是使用缩进，缩进的空格可变。
if True:
print(True)
else:
print(False)
7. 多行
Python 中一般以新行作为语句的结束标识，可以使用 \ 将一行语句分为多行显示。如下所示：
a = 128
b = 1024
c = 512
d = a + \
b - \
c
如果包含在 []、{}、() 括号中，则不需要使用 \。如下所示：
arr = {
a,
b,
c
}
8. 注释
Python 中单行注释使用 #，多行注释使用三个单引号（'''）或三个双引号（"""）。如下所示：
# 我是单行注释
'''
我是多行注释
我是多行注释
'''
"""
我是多行注释
我是多行注释
"""
9 .数据类型
整数：可以为任意大小、包含负数
浮点数：就是小数
字符串：以单引号 '、双引号"、三引号 ''' 或 """括起来的文本
布尔：只有 True、False 两种值
空值：用 None 表示
变量：是可变的
常量：不可变
10. 运算符
10.1 常用运算符
| 运算符 | 描述 | 示例 | ||
|---|---|---|---|---|
| + | 相加 | a + b | ||
| - | 相减 | a - b | ||
| * | 相乘 | a * b | ||
| / | 相除 | a / b | ||
| % | 取模 | a % b | ||
| ** | 幂 | a**b 表示 a 的 b 次幂 | ||
| // | 取整除 | 9 // 4 结果为 2 | ||
| == | 是否相等 | a == b | ||
| != | 是否不等于 | a != b | ||
| 是否大于 | a > b | |||
| >= | 是否大于等于 | a >= b | ||
| <= | 是否小于等于 | a <= b | ||
| = | 简单的赋值运算符 | a = b + c | ||
| += | 加法赋值运算符 | a += b 等效于 a = a + b | ||
| -= | 减法赋值运算符 | a -= b 等效于 a = a - b | ||
| *= | 乘法赋值运算符 | a *= b 等效于 a = a * b | ||
| /= | 除法赋值运算符 | a /= b 等效于 a = a / b | ||
| %= | 取模赋值运算符 | a %= b 等效于 a = a % b | ||
| **= | 幂赋值运算符 | a **= b 等效于 a = a ** b | ||
| //= | 取整除赋值运算符 | a //= b 等效于 a = a // b | ||
| & | 与 | a & b | ||
| 或 | a | b | ||
| 异或 | a ^ b | |||
| ~ | 取反 | ~a | ||
| << | 左移动 | a << 3 | ||
| >> | 右移动 | a >> 3 | ||
| and | 布尔类型与 | a and b | ||
| or | 布尔类型或 | a or b | ||
| not | 布尔类型非 | not a | ||
| is | 判断两个标识符是否引用同一个对象 | a is b | ||
| is not | 判断两个标识符是否引用不同对象 | a is not b | ||
10.2 运算符优先级
| 运算符 | 描述（由上至下对应优先级由高到低） |
|---|---|
| ** | 幂运算 |
| ~ + - | 取反、正号、负号 |
| * / % // | 乘、除、取模、取整除 |
| + - | 加法、减法 |
| >> << | 右移、左移 |
| & | 与 |
| 异或、或 | |
| <= < > >= | 比较运算符 |
| == != | 是否等于、是否不等于 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not and or | 逻辑运算符 |
第二章python序列
1.列表
创建： 列表中所有元素都放在一个中括号 [] 中，相邻元素之间用逗号 , 分隔
访问count： 通过索引访问列表中的值，还可以使用 : 截取范围内的元素
更新append： 除了对列表中现有元素进行修改外，还可以使用 append() 向列表中添加新元素
删除del： 使用 del 删除列表中元素
l = [1024, 0.5, 'Python']
# 删除列表中第二个元素
del l[1]
print('l -->', l)
输出结果：
l --> [1024, 'Python']
常用方法
① count()
统计列表中某个元素出现的次数
l = ['d', 'b', 'a', 'f', 'd']
print("l.count('d') -->", l.count('d'))
输出结果：
l.count('d') --> 2
② index()
查找某个元素在列表中首次出现的位置（即索引)
③ remove()
移除列表中某个值的首次匹配项
④ sort()
对列表中元素进行排序
⑤ copy()
复制列表
2.元组
元组（tuple）与列表类似，但元组是不可变的，可简单将其看作是不可变的列表，元组常用于保存不可修改的内容。
创建
元组中所有元素都放在一个小括号 () 中，相邻元素之间用逗号 , 分隔
访问
与访问列表中元素类似
修改
元组中元素不能被修改，我们要用重新赋值的方式操作，
删除
元组中的元素不能被删除，我们只能删除整个元组
常用方法
① len()
计算元组中元素个数，使用如下所示：
t = (1024, 0.5, 'Python')
print('len(t) -->', len(t))
输出结果：
len(t) --> 3
② max() 和 min()
返回元组中元素最大、最小值
③ tuple()
将列表转换为元组
3.字典
字典（dict）是 Python 的数据结构，它们的内容都是以键-值（key-value）的方式存在的。
dict 拥有良好的查询速度，dict 中的值可以是任意 Python 对象，多次对一个 key 赋 value，后面的 value 会把前面的 value 覆盖。
字典的内容在花括号 {} 内，键-值（key-value）之间用冒号 : 分隔，键值对之间用逗号 , 分隔，比如创建字典 d，如下所示：
d = {'name':'小明', 'age':'18'}
# 使用 dict 函数
# 方式一
l = [('name', '小明'), ('age', 18)]
d = dict(l)
# 方式二
d = dict(name='小明', age='18')
# 空字典
d = dict()
d = {}
字典中的值通过 key 进行访问，如下所示：
>>> d = dict(name='小明', age='18')
>>> d['name']
'小明'
# 使用 get 方法
>>> d.get('name')
'小明'
修改操作，以修改 age 为例，如下所示：
>>> d = dict(name='小明', age='18')
>>> d['age'] = '20'
>>> d['age']
'20'
清空集合，如下所示：
>>> d = dict(name='小明', age='18')
>>> d.clear()
>>> d
{}
获取字典的长度，如下所示：
>>> d = dict(name='小明', age='18')
>>> len(d)
2
4.集合
集合（set）与字典相同均存储 key，但也只存储 key，因 key 不可重复，所以 set 的中的值不可重复，也是无序的。
集合使用花括号 {} 或者 set() 函数创建，如果创建空集合只能使用 set() 函数，以创建集合 s 为例，如下所示：
s = {'a', 'b', 'c'}
# 使用 set 函数
s = set(['a', 'b', 'c'])
# 空集合
s = set()
集合中重复的元素会被自动过滤掉，如下所示：
>>> s = {'a', 'a', 'b', 'c', 'c'}
>>> s
{'a', 'c', 'b'}
# 添加元素可以使用 add 或 update 方法，如果元素已经存在，则不进行操作，如下所示：
>>> s = {'a', 'b', 'c'}
>>> s.add('d')
>>> s
{'a', 'd', 'c', 'b'}
>>> s.update('e')
>>> s
{'a', 'b', 'e', 'd', 'c'}
# 添加已经存在的元素 a
>>> s.add('a')
>>> s
{'a', 'b', 'e', 'd', 'c'}
删除元素使用 remove 方法
>>> s = {'a', 'b', 'c'}
>>> s.remove('c')
>>> s
{'a', 'b'}
清空集合使用 clear 方法，如下所示：
>>> s = {'a', 'b', 'c'}
>>> s.clear()
>>> s
set()
获取集合的长度，同样使用 len 方法，如下所示：
>>> s = {'a', 'b', 'c'}
>>> len(s)
3
第三章：选择与循环
条件表达式
-
- 算术运算符：+ 、 − 、 ∗ 、 / 、 / / 、 +、-、*、/、//、%、**+、−、∗、/、//、
- 关系运算符：> 、 < 、 = = 、 < = 、 > = 、 ! = ， >、<、==、<=、>=、!=，>、<、==、<=、>=、!=，可以连续使用
>>> 1<2<3
True
>>> 1<2>3
False
>>> 1<3>2
True
- 测试运算符: in、not in、is、is not
- 逻辑运算符：and、or、not，注意短路求值
- 位运算符：~、&、|、 ^、 <<、>>
- 在选择和循环结构中，条件表达式的值只要不是False、0（或0.0、0j等）、空值None、空列表、空元组、空集合、空字典、空字符串、空range对象或其他空迭代对象，Python解释器均认为与True等价
- 逻辑运算符and和or以及关系运算符具有惰性求值特点，只计算必须计算的表达式
- 以“and”为例，对于表达式“表达式1 and 表达式2”而言，如果“表达式1”的值为“False”或其他等价值时，不论“表达式2”的值是什么，整个表达式的值都是“False”，此时“表达式2”的值无论是什么都不影响整个表达式的值，因此将不会被计算，从而减少不必要的计算和判断
- 在设计条件表达式时，如果能够大概预测不同条件失败的概率，并将多个条件根据“and”和“or”运算的短路求值特性来组织先后顺序，可以大幅度提高程序运行效率
- 在Python中，条件表达式中不允许使用赋值运算符“=”
>>> if a=3:
SyntaxError: invalid syntax
>>> if (a=3) and (b=4):
SyntaxError: invalid syntax
if语句
if 判断条件：
要执行的代码
#注意语句结尾有冒号:下一行有缩进；如果满足条件，则执行代码；如果不满足，则跳过
双分支结构
value1 if condition else value2
当条件表达式condition的值与True等价时，表达式的值为value1，否则表达式的值为value2。在value1和value2中还可以使用复杂表达式，包括函数调用和基本输出语句。这个结构的表达式也具有惰性求值的特点
for循环与while循环
- Python提供了两种基本的循环结构语句——while和for
- while循环一般用于循环次数难以提前确定的情况，也可以用于循环次数确定的情况
- for循环一般用于循环次数可以提前确定的情况，尤其是用于枚举序列或迭代对象中的元素
- 一般优先考虑使用for循环
- 相同或不同的循环结构之间都可以互相嵌套，实现更为复杂的逻辑
- for循环和while循环都可以带else
while 条件表达式:
循环体
[else: # 如果循环是因为break结束的，就不执行else中的代码
else子句代码块]
for 取值 in 序列或迭代对象:
循环体
[else:
else子句代码块]
if-elif语句
当条件判断的分支超过两个，使用if-elif语句
if 判断条件：
要执行的代码
elif 判断条件：
要执行的代码
elif 判断条件：
要执行的代码
……
else:
要执行的代码
break和continue
break语句在while循环和for循环中都可以使用，一般放在if选择结构中，一旦break语句被执行，将使得整个循环提前结束
continue语句的作用是终止当前循环，并忽略continue之后的语句，然后回到循环的顶端，提前进入下一次循环
第四章：字符串与正则表达式
字符串
Python 使用了 ord() 函数返回单个字符的编码，chr() 函数把编码转成相应字符。
输入：
s = 'A'
print(ord(s))
print(chr(65))
输出结果：65 A
转义符：可以通过反斜杠 \ 将一行语句分多行显示，其实就是 \ 来转义字符
常见的转义字符：
| \ | 在行尾使用时，用作续行符 |
|---|---|
| \b | 退格（Backspace） |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
格式化:当我们需要输出的内容中含有变量时，比如：Hello xxx，xxx 为变量，此时便需要一种格式化字符串的方式，Python 使用 % 格式化字符串，常用占位符如下表所示：
| 占位符 | 描述 |
|---|---|
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %f | 格式化浮点数 |
输入：print('Hello %s' % 'Python')
输出结果：Hello Python
我们也可以使用字符串的 format() 方法进行格式化
如：print('{0} {1}'.format('Hello', 'Python'))
这种方式是用传入的参数依次替换字符串内的占位符{0}、{1} ...
常用的字符串方法：
* encode() # 编码成bytes类型
* find() # 查找子串
* index() # 获取下标
* replace() # 替换子串
* len(string) # 返回字符串长度，Python内置方法，非字符串方法。
* lower() # 小写字符
* upper() # 大写字符
* split() # 分割字符串
* strip() # 去除两端的指定符号
* startswith() # 字符串是否以xxx开头
* endswith() # 字符串是否以xxx结尾
正则表达式
正则表达式（regular expression）是一种工具，一种广泛用于匹配字符串的工具。它用一个“字符串”来描述一个特征，然后去验证另一个“字符串”是否符合这个特征。比如 表达式“ab+”描述的特征是“一个'a'和任意个'b'”，那么'ab','abb','abbbbbbbbbb'都符合这个特征。
一、普通字符
字母、数字、汉字、下划线、以及没有特殊定义的符号，都是"普通字符"。正则表达式中的普通字符，在匹配的时候，只匹配与自身相同的一个字符。
二、元字符
正则表达式中使用了很多元字符，用来表示一些特殊的含义或功能。
| 表达式 | 匹配 | |
|---|---|---|
| . | 小数点可以匹配除了换行符\n以外的任意一个字符 | |
| 逻辑或操作符 | ||
| [] | 匹配字符集中的一个字符 | |
| [^] | 对字符集求反，也就是上面的反操作。尖号必须在方括号里的最前面 | |
| - | 定义[]里的一个字符区间，例如[a-z] | |
| \ | 对紧跟其后的一个字符进行转义 | |
| () | 对表达式进行分组，将圆括号内的内容当做一个整体，并获得匹配的值 |
三、转义字符
一些无法书写或者具有特殊功能的字符，采用在前面加斜杠""进行转义的方法。
| 表达式 | 匹配 |
|---|---|
| \r, \n | 匹配回车和换行符 |
| \t | 匹配制表符 |
| \ | 匹配斜杠\ |
| ^ | 匹配^符号 |
| $ | 匹配$符号 |
| . | 匹配小数点. |
四、预定义匹配字符集
正则表达式中的一些表示方法，可以同时匹配某个预定义字符集中的任意一个字符。比如，表达式\d可以匹配任意一个数字。虽然可以匹配其中任意字符，但是只能是一个，不是多个。如下表所示
| 表达式 | 匹配 |
|---|---|
| \d | 任意一个数字，0~9 中的任意一个 |
| \w | 任意一个字母或数字或下划线，也就是 A |
| \s | 空格、制表符、换页符等空白字符的其中任意一个 |
| \D | \d的反集，也就是非数字的任意一个字符，等同于[^\d] |
| \W | \w的反集，也就是[^\w] |
| \S | \s的反集，也就是[^\s] |
五、重复匹配
前面的表达式，无论是只能匹配一种字符的表达式，还是可以匹配多种字符其中任意一个的表达式，都只能匹配一次。但是有时候我们需要对某个片段进行重复匹配，这种情况可以使用表达式再加上修饰匹配次数的特殊符号{}，不用重复书写表达式就可以重复匹配。
| 表达式 | 匹配 |
|---|---|
| {n} | 表达式重复n次，比如\d{2}相当于\d\d,a{3}相当于aaa |
| {m,n} | 表达式至少重复m次，最多重复n次。比如ab{1,3}可以匹配ab或abb或abbb |
| {m,} | 表达式至少重复m次，比如\w\d{2,}可以匹配a12,_1111,M123等等 |
| ? | 匹配表达式0次或者1次，相当于{0,1}，比如a[cd]?可以匹配a,ac,ad |
| + | 表达式至少出现1次，相当于{1,}，比如a+b可以匹配ab,aab,aaab等等 |
| * | 表达式出现0次到任意次，相当于{0,}，比如^*b可以匹配b,^^^b等等 |
六、位置匹配
| 表达式 | 匹配 |
|---|---|
| ^ | 在字符串开始的地方匹配，符号本身不匹配任何字符 |
| $ | 在字符串结束的地方匹配，符号本身不匹配任何字符 |
| \b | 匹配一个单词边界，也就是单词和空格之间的位置，符号本身不匹配任何字符 |
| \B | 匹配非单词边界，即左右两边都是\w范围或者左右两边都不是\w范围时的字符缝隙 |
七、常用正则表达式
校验数字
| 功能 | 表达式 | |
|---|---|---|
| 数字 | ^[0-9]*$ | |
| n位的数字 | ^\d{n}$ | |
| 至少n位的数字 | ^\d{n,}$ | |
| m-n位的数字 | ^\d{m,n}$ | |
| 零和非零开头的数字 | ^(0 | [1-9][0-9]*)$ |
| 非零开头的最多带两位小数的数字 | ^([1-9][0-9]*)+(.[0-9]{1,2})?$ | |
| 带1-2位小数的正数或负数 | ^(-)?\d+(.\d{1,2})?$ | |
| 正数、负数、和小数 | ^(- | +)?\d+(.\d+)?$ |
| 有两位小数的正实数 | ^[0-9]+(.[0-9]{2})?$ | |
| 有1~3位小数的正实数 | ^[0-9]+(.[0-9]{1,3})?$ | |
| 非零的正整数 | ^[1-9]\d*$ | |
| 非零的负整数 | ^-[1-9]\d*$ | |
| 非负整数 | ^\d+$ | |
| 非正整数 | ^-[1-9]\d* | 0$ |
| 非负浮点数 | ^\d+(.\d+)?$ | |
| 非正浮点数 | ^((-\d+(.\d+)?) | (0+(.0+)?))$ |
| 正浮点数 | ^[1-9]\d*.\d* | 0.\d*[1-9]\d*$ |
| 负浮点数 | ^-([1-9]\d*.\d* | 0.\d*[1-9]\d*)$ |
| 浮点数 | ^(-?\d+)(.\d+)?$ |
校验字符的相关表达式：
| 功能 | 表达式 |
|---|---|
| 汉字 | ^[\u4e00-\u9fa5]{0,}$ |
| 英文和数字 | ^[A-Za-z0-9]+$ |
| 长度为3-20的所有字符 | ^.{3,20}$ |
| 由26个英文字母组成的字符串 | ^[A-Za-z]+$ |
| 由26个大写英文字母组成的字符串 | ^[A-Z]+$ |
| 由26个小写英文字母组成的字符串 | ^[a-z]+$ |
| 由数字和26个英文字母组成的字符串 | ^[A-Za-z0-9]+$ |
| 由数字、26个英文字母或者下划线组成的字符串 | ^\w+$ |
| 中文、英文、数字包括下划线 | ^[\u4E00-\u9FA5A-Za-z0-9_]+$ |
| 中文、英文、数字但不包括下划线等符号 | ^[\u4E00-\u9FA5A-Za-z0-9]+$ |
| 可以输入含有^%&’,;=?$\”等字符 | [^%&’,;=?$\x22]+ |
| 禁止输入含有~的字符 | [^~\x22]+ |
特殊场景的表达式:
| 功能 | 表达式 | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Email地址 | ^\w+([-+.]\w+)@\w+([-.]\w+).\w+([-.]\w+)*$ | ||||||||||||||||||||
| 域名 | [a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.? | ||||||||||||||||||||
| InternetURL | [a-zA-z]+://[^\s]* 或 ^http://([\w-]+.)+[\w-]+(/[\w-./?%&=]*)?$ | ||||||||||||||||||||
| 手机号码 | ^(13[0-9] | 14[5 | 7] | 15[0 | 1 | 2 | 3 | 5 | 6 | 7 | 8 | 9] | 18[0 | 1 | 2 | 3 | 5 | 6 | 7 | 8 | 9])\d{8}$ |
| 国内电话号码 | \d{3}-\d{8} | \d{4}-\d{7}(0511-4405222、021-87888822) | |||||||||||||||||||
| 身份证号 | ^\d{15} | \d{18}$(15位、18位数字) | |||||||||||||||||||
| 短身份证号码 | ^([0-9]){7,18}(x | X)?$ 或 ^\d{8,18} | [0-9x]{8,18} | [0-9X]{8,18}?$(数字、字母x结尾) | |||||||||||||||||
| 帐号是否合法 | ^[a-zA-Z][a-zA-Z0-9_]{4,15}$(字母开头，允许5-16字节，允许字母数字下划线) | ||||||||||||||||||||
| 密码 | ^[a-zA-Z]\w{5,17}$(以字母开头，长度在6~18之间，只能包含字母、数字和下划线) | ||||||||||||||||||||
| 强密码 | ^(?=.\d)(?=.[a-z])(?=.*[A-Z]).{8,10}$(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在8-10之间) | ||||||||||||||||||||
| 日期格式 | ^\d{4}-\d{1,2}-\d{1,2} | ||||||||||||||||||||
| 一年的12个月(01～09和1～12) | ^(0?[1-9] | 1[0-2])$ | |||||||||||||||||||
| 一个月的31天(01～09和1～31) | ^((0?[1-9]) | ((1 | 2)[0-9]) | 30 | 31)$ | ||||||||||||||||
| xml文件 | ^([a-zA-Z]+-?)+[a-zA-Z0-9]+\.[x | X][m | M][l | L]$ | |||||||||||||||||
| 双字节字符 | [^\x00-\xff](包括汉字在内，可以用来计算字符串的长度(一个双字节字符长度计2，ASCII字符计1)) | ||||||||||||||||||||
| 空白行的正则表达式 | \n\s*\r (可以用来删除空白行) | ||||||||||||||||||||
| HTML标记的正则表达式 | <(\S*?)[^>]>.?</\1> | <.*? />(对于复杂的嵌套标记依旧无能为力) | |||||||||||||||||||
| 首尾空白字符的正则表达式 | ^\s* | \s*$或(^\s*) | (\s*$)(可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)) | ||||||||||||||||||
| 腾讯QQ号 | [1-9][0-9]{4,} (腾讯QQ号从10000开始) | ||||||||||||||||||||
| 中国邮政编码 | [1-9]\d{5}(?!\d) (中国邮政编码为6位数字) | ||||||||||||||||||||
| IP地址提取 | \d+.\d+.\d+.\d+ (提取IP地址时有用) | ||||||||||||||||||||
| IP地址合法性判断 | ((?:(?:25[0-5] | 2[0-4]\d | [01]?\d?\d)\.){3}(?:25[0-5] | 2[0-4]\d | [01]?\d?\d)) |
re模块
在Python中，通过内置的re模块提供对正则表达式的支持。
提供了下面的方法进行字符串的查找、替换和分割等各种处理操作。
| 方法 | 描述 | 返回值 |
|---|---|---|
| compile(pattern[, flags]) | 根据包含正则表达式的字符串创建模式对象 | re对象 |
| search(pattern, string[, flags]) | 在字符串中查找 | 第一个匹配到的对象或者None |
| match(pattern, string[, flags]) | 在字符串的开始处匹配模式 | 在字符串开头匹配到的对象或者None |
| split(pattern, string[, maxsplit=0,flags]) | 根据模式的匹配项来分割字符串 | 分割后的字符串列表 |
| findall(pattern, string,flags) | 列出字符串中模式的所有匹配项 | 所有匹配到的字符串列表 |
| sub(pat,repl, string[,count=0,flags]) | 将字符串中所有的pat的匹配项用repl替换 | 完成替换后的新字符串 |
| finditer(pattern, string,flags) | 将所有匹配到的项生成一个迭代器 | 所有匹配到的字符串组合成的迭代器 |
| subn(pat,repl, string[,count=0,flags]) | 在替换字符串后，同时报告替换的次数 | 完成替换后的新字符串及替换次数 |
| escape（string） | 将字符串中所有特殊正则表达式字符串转义 | 转义后的字符串 |
| purge(pattern) | 清空正则表达式 | |
| template(pattern[,flags]) | 编译一个匹配模板 | 模式对象 |
| fullmatch(pattern, string[, flags]) | match方法的全字符串匹配版本 | 类似match的返回值 |
第五章：函数
Python 使用 def 关键字来声明函数，格式如下所示：
def 函数名(参数):
函数体
return 返回值
如果要定义一个无任何功能的空函数，函数体只写 pass 即可。格式如下所示：
def 函数名():
pass
当我们不确定参数的个数时，可以使用不定长参数，在参数名前加 * 进行声明，格式如下所示：
def 函数名(*参数名):
函数体
我们还可以使用 lambda 定义匿名函数，
- lambda表达式可以用来声明匿名函数（也可以定义具名函数），也就是没有函数名字的临时使用的小函数，尤其适合需要一个函数作为另一个函数参数的场合
- lambda表达式只可以包含一个表达式，该表达式可以任意复杂，其计算结果可以看作是函数的返回值
格式如下所示：
lambda 参数 : 表达式
例子：
# 空函数
def my_empty():
pass
# 无返回值
def my_print(name):
print('Hello', name)
# 有返回值
def my_sum(x, y):
s = x + y
print('s-->', s)
return s
# 不定长参数
def my_variable(*params):
for p in params:
print(p)
# 匿名函数
my_sub = lambda x, y: x - y
函数调用：
调用一个函数只需要知道函数名和参数即可。
例：
my_empty()
my_print('Jhon')
result = my_sum(1, 2)
my_variable(1, 2, 3, 4, 5, 6)
print(my_sub(2, 1))
return语句
- return语句用来从一个函数中返回一个值，同时结束函数
- 对于以下情况，Python将认为该函数以return None结束，返回空值
- 函数没有return语句
- 函数有return语句但是没有执行到
- 函数有return也执行到了，但是没有返回任何值
- 在调用函数或对象方法时，一定要注意有没有返回值
变量作用域
- 变量起作用的代码范围称为变量的作用域，不同作用域内变量名可以相同，互不影响
- 在函数内部定义的普通变量只在函数内部起作用，称为局部变量。当函数执行结束后，局部变量自动删除，不再可以使用
- 局部变量的引用比全局变量速度快
- 全局变量会增加函数之间的隐式耦合
全局变量可以通过关键字global来定义。这分为两种情况
- 一个变量已在函数外定义，如果在函数内需要为这个变量赋值，并要将这个赋值结果反映到函数外，可以在函数内使用global声明其为全局变量
- 一个变量已在函数外定义，如果在函数内需要为这个变量赋值，并要将这个赋值结果反映到函数外，可以在函数内使用global声明其为全局变量
在某个作用域内任意位置只要有为变量赋值的操作，该变量在这个作用域内就是局部变量，除非使用global进行了声明
map（）函数
- 内置函数map()可以将一个函数作用到一个或多个序列或迭代器对象上，返回可迭代的map对象
recude（）函数
- 标准库functools中的reduce()函数可以将一个接受2个参数的函数以迭代的方式从左到右依次作用到一个序列或迭代器对象的所有元素上
filter（）
- 内置函数filter将一个函数作用到一个序列上，返回该序列中使得该函数返回值为True的那些元素组成的filter对象
第六章：文件的操作
创建文件
Python 使用 open() 函数创建或打开文件，语法格式如下所示
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
- file：表示将要打开的文件的路径，也可以是要被封装的整数类型文件描述符。
- mode：是一个可选字符串，用于指定打开文件的模式，默认值是 'r'（以文本模式打开并读取）。可选模式如下：
| 模式 | 描述 |
|---|---|
| r | 读取（默认） |
| w | 写入，并先截断文件 |
| x | 排它性创建，如果文件已存在则失败 |
| a | 写入，如果文件存在则在末尾追加 |
| b | 二进制模式 |
| t | 文本模式（默认） |
| + | 更新磁盘文件（读取并写入） |
- buffering：是一个可选的整数，用于设置缓冲策略。
- encoding：用于解码或编码文件的编码的名称。
- errors：是一个可选的字符串，用于指定如何处理编码和解码错误（不能在二进制模式下使用）。
- newline：区分换行符。
- closefd：如果 closefd 为 False 并且给出了文件描述符而不是文件名，那么当文件关闭时，底层文件描述符将保持打开状态；如果给出文件名，closefd 为 True （默认值），否则将引发错误。
- opener：可以通过传递可调用的 opener 来使用自定义开启器。
以 txt 格式文件为例，我们不手动创建文件，通过代码方式来创建，如下所示：
open('test.txt', mode='w',encoding='utf-8')
写入文件
| 函数 | 描述 |
|---|---|
| write(str) | 将字符串写入文件，返回写入字符长度 |
| writelines(s) | 向文件写入一个字符串列表 |
读文件
| 函数 | 描述 |
|---|---|
| read(size) | 读取指定的字节数，参数可选，无参或参数为负时读取所有 |
| readline() | 读取一行 |
| readlines() | 读取所有行并返回列表 |
