版权声明：转载请联系作者 https://blog.csdn.net/weixin_41826501/article/details/89139861

1.文件IO

a.读写文件

IO编程中，Stream（流）是一个很重要的概念，可以把流想象成一个水管，数据就是水管里的水，但是只能单向流动。Input和Output是针对内存来讲的，Input Stream就是数据从外面（磁盘、网络）流进内存，Output Stream就是数据从内存流到外面去。读写文件就是请求操作系统打开一个文件对象（通常称为文件描述符），然后通过操作系统提供的接口函数从这个文件对象中读取数据（读文件），或者把数据写入这个文件对象（写文件）。（详细的文件读写使用见http://www.runoob.com/python3/python3-file-methods.html或https://docs.python.org/3/library/functions.html#open）

读文件

[code]# 读文件

#方法一
f = open('file1.txt', 'r')
f.read()#对文件对象进行操作
f.close()

#方法二
with open('file1.txt', 'r') as f:
f.read()#对文件对象进行操作

#方法三，等价于方法二，以防有的文件找不到抛出IOError后终止运行
try:
f = open('file1.txt', 'r')
f.read()#对文件对象进行操作
finally:
if f:
f.close()

写文件

[code]# 写文件

#方法一
f = open('file1.txt', 'w')
f.write()#对文件对象进行操作
f.close()

#方法二
with open('file1.txt', 'w') as f:
f.write()#对文件对象进行操作

其中需要注意以下几项：

1) open()函数的完整语法格式为：

2）open()函数的第二个参数是文件对象的打开模式mode，它有以下选择：

 其中，r/w相当于rt/wt，是针对utf-8编码的文本文件的，如果用图片视频等二进制文件(.jpg等后缀的）需要加b。

3) 要读取非utf-8编码的文本文件，需要给

open()

函数传入

encoding

参数，例如，读取GBK编码的文件：

[code]open('/Users/michael/gbk.txt', 'r', encoding='gbk')

3）遇到有些编码不规范的文件，你可能会遇到

UnicodeDecodeError

，因为在文本文件中可能夹杂了一些非法编码的字符。遇到这种情况，

open()

函数还接收一个

errors

参数，表示如果遇到编码错误后如何处理。最简单的方式是直接忽略：

[code]open('/Users/michael/gbk.txt', 'r', encoding='gbk', errors='ignore')

b.文件对象的操作方法

f.read([size]) 读取整个文件到一个string，如果有指定size，就读入指定的字节数

f.readlines() 读取整个文件到一个list，每个list元素是一个string，对应到文件中的一行

f.readline() 读取下一行到一个string

f.write(str) 将str写入到文件

f.writelines(sequence) 写入多行到文件，要自己加上换行符

f.flush() 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件

c.内存中变量的保存到文件与从文件读取（序列化）

字符串或者二进制变量可以用前面的方法直接进行文本文件（.txt）或二进制文件（.jpg）的存取，如果是非string的对象如dict、class等，需要先将对象序列化后再进行文件存取（文件名后缀任意），下面介绍两种序列化方式。

pickle

pickle是Python语言特定的序列化模块，pickle能够任意对象序列化成

bytes，但

它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。

方法一：pickle.dumps()将对象序列化成bytes（pickle.loads()将bytes反序列化），用普通的文件读写wb/rb存取bytes

[code]import pickle
d = dict(name='Bob', age=20, score=88)
# 对象序列化与存储到文件
dbytes = pickle.dumps(d) #pickle.dumps()将任意对象序列化成一个bytes
with open('file2.txt', 'wb') as f:
f.write(dbytes)
# 从文件读取与对象反序列化
with open('file2.txt', 'rb') as f:
dbytes2 = f.read()
d2 = pickle.loads(dbytes2) #pickle.loads()将一个bytes反序列化成对象
print(dbytes2)
’‘’b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x03\x00\x00\x00Bobq\x02X\x03\x00\x00\x00ageq\x03K\x14X\x05\x00\x00\x00scoreq\x04KXu.'‘’‘
print(d2)
’‘’{'name': 'Bob', 'age': 20, 'score': 88}‘’‘

方法二：直接用pickle.dump()和pickle.load 4000 ()进行序列化和文件存取，省去了普通的文件读写，比方法一更方便存取

[code]import pickle
d = dict(name='Bob', age=20, score=88)
# 对象序列化与存储到文件
with open('file2.txt', 'wb') as f:
pickle.dump(d, f) #pickle.dump()将任意对象序列化成一个bytes并存储到文件
# 从文件读取与对象反序列化
with open('file2.txt', 'rb') as f:
d2 = pickle.load(f) #pickle.load()读取文件并将一个bytes反序列化成对象
print(d2)
'''{'name': 'Bob', 'age': 20, 'score': 88}'''

json

pickle只能用于Python，如果要把序列化搞得更通用、更符合Web标准，就要使用

json

模块，所以更推荐使用json来序列化。Python内置的

json

模块提供了非常完善的Python对象到JSON格式的转换。JSON表示出来就是一个字符串（然后就可以用文本文件的存取方式来存取），可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。

对于可以直接json序列化的对象（如dict等），可以直接使用json.dumps()：

[code]import json
d = dict(name='Bob', age=20, score=88)
dstring = json.dumps(d) #json序列化成一个字符串
print(dstring) #dstring是一个字符串'{"name": "Bob", "age": 20, "score": 88}'
d2 = json.loads(dstring) #json反序列化成对象
print(d2) #反序列化得到一个dict对象：{'name': 'Bob', 'age': 20, 'score': 88}

对于不能直接json序列化的对象（如class等），需要传进去一个转换函数的参数：

[code]import json
class Student(object):
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
s = Student('Bob', 20, 88)
# print(json.dumps(s)) #直接json序列化会报错，因为json在默认情况下不知道如何将class对象序列化

# json序列化
def student2dict(std):
return {
'name': std.name,
'age': std.age,
'score': std.score
}
print(json.dumps(s, default=student2dict)) # 方法一：自定义一个转换函数，并将函数名作为参数传入json.dumps()
print(json.dumps(s, default=lambda obj: obj.__dict__)) # 方法二：直接使用class对象的__dict__属性构造匿名函数，并作为参数传入json.dumps()
djson = json.dumps(s, default=student2dict)

#json反序列化
def dict2student(dict):
return Student(dict['name'], dict['age'], dict['score'])
print(json.loads(djson,object_hook=dict2student)) #输出一个Student类的实例<__main__.Student object at 0x10ecf6a58>。loads()方法首先从string转换出一个dict对象，然后传入的object_hook函数负责把dict转换为Student实例。

d.对excel及csv文件进行读写和操作

如果是numpy矩阵，一般会涉及到excel和csv文件的存取，这两种文件的存取有很多封装好的模块和函数可以用。

excel文件IO (.xls .xlsx)：

详见https://blog.csdn.net/qq_34617032/article/details/80433939

1）用Pandas的pd.read_excel和pd.to_excel进行读写

只读写而不修改，并且处理较小的表的话，推荐使用pandas。pandas把Excel当作数据读写的容器，为其强大的数据分析服务，因此读写性能表现中规中矩，但其对Excel文件兼容性是最好的，支持读写.xls，.xlsx文件，且支持只读表中单一工作页，每个工作页最多写入256列。

[code]import pandas as pd

# 读
def test_pandas_read():
for i in range(1, 6):
sheet_name = "Sheet" + str(i)
# df = pd.read_excel('test_cases\\read_xls.xls', sheet_name)
df = pd.read_excel('test_cases\\read_xlsx.xlsx', sheet_name)

# 写
import numpy as np
d = np.zeros([2000, 255])
d += 65536
df = pd.DataFrame(d)
# writer = pd.ExcelWriter('test_cases\\write_xls.xls')
writer = pd.ExcelWriter('test_cases\\write_xlsx.xlsx')
def test_pandas_write():
df.to_excel(writer, 'Sheet1')
df.to_excel(writer, 'Sheet2')
df.to_excel(writer, 'Sheet3')
df.to_excel(writer, 'Sheet4')
df.to_excel(writer, 'Sheet5')
writer.save()

2）用xlwings的xlwings.Book进行读写

既要读写又要修改的话，并且处理较大的表的话，推荐使用xlwings。xlwings强大的转换器可以处理大部分数据类型，包括二维的numpy array和pandas DataFrame，可以轻松搞定数据分析的工作。

[code]import xlwings

#读
def test_xlwings_read():
# f = xlwings.Book('test_cases\\read_xls.xls')
f = xlwings.Book('test_cases\\read_xlsx.xlsx')

#写
import numpy as np
f = xlwings.Book('')
d = np.zeros([2000, 1200])
d += 65536
def test_xlwings_write():
for s in range(1):
sheet = f.sheets.add()
sheet.range('A1').value = d
f.save('test_cases\\write_xlsx.xlsx')

csv文件IO (.csv, 以纯文本形式存储表格数据)：

详见https://www.geek-share.com/detail/2729091009.html

1）用csv本身的csv.reader和csv.writer()进行读写

[code]import csv

# 读
birth_data = []
with open(birth_weight_file) as csvfile:
csv_reader = csv.reader(csvfile)  # 使用csv.reader读取csvfile中的文件
birth_header = next(csv_reader)  # 读取第一行每一列的标题
for row in csv_reader:  # 将csv 文件中的数据保存到birth_data中
birth_data.append(row)
birth_data = [[float(x) for x in row] for row in birth_data]  # 将数据从string形式转换为float形式
birth_data = np.array(birth_data)  # 将list数组转化成array数组便于查看数据结构
birth_header = np.array(birth_header)
print(birth_data.shape)  # 利用.shape查看结构。
print(birth_header.shape)

# 写
import os
import numpy as np
import random
import requests
birth_weight_file = 'birth_weight.csv'
# download data and create data file if file does not exist in current directory
# 如果当前文件夹下没有birth_weight.csv数据集则下载dat文件并生成csv文件
if not os.path.exists(birth_weight_file):
birthdata_url = 'https://github.com/nfmcclure/tensorflow_cookbook/raw/master/01_Introduction/07_Working_with_Data_Sources/birthweight_data/birthweight.dat'
birth_file = requests.get(birthdata_url)
birth_data = birth_file.text.split('\r\n')
# split分割函数,以一行作为分割函数，windows中换行符号为'\r\n',每一行后面都有一个'\r\n'符号。
birth_header = birth_data[0].split('\t')
# 每一列的标题，标在第一行，即是birth_data的第一个数据。并使用制表符作为划分。
birth_data = [[float(x) for x in y.split('\t') if len(x) >= 1] for y in birth_data[1:] if len(y) >= 1]
print(np.array(birth_data).shape)
# (189, 9)
# 此为list数据形式不是numpy数组不能使用np,shape函数,但是我们可以使用np.array函数将list对象转化为numpy数组后使用shape属性进行查看。
with open(birth_weight_file, "w", newline='') as f:
# with open(birth_weight_file, "w") as f:
writer = csv.writer(f)
writer.writerows([birth_header])
writer.writerows(birth_data)
f.close()

2) 用Pandas的pd.read_csv读

[code]import pandas as pd

csv_data = pd.read_csv('birth_weight.csv')  # 读取训练数据
print(csv_data.shape)  # (189, 9)
N = 5
csv_batch_data = csv_data.tail(N)  # 取后5条数据
print(csv_batch_data.shape)  # (5, 9)
train_batch_data = csv_batch_data[list(range(3, 6))]  # 取这20条数据的3到5列值(索引从0开始)
print(train_batch_data)

#      RACE  SMOKE  PTL
# 184   0.0    0.0  0.0
# 185   0.0    0.0  1.0
# 186   0.0    1.0  0.0
# 187   0.0    0.0  0.0
# 188   0.0    0.0  1.0

3）用TensorFlow的tf.decode_csv读 

[code]'''使用Tensorflow读取csv数据'''
filename = 'birth_weight.csv'
file_queue = tf.train.string_input_producer([filename])  # 设置文件名队列，这样做能够批量读取文件夹中的文件
reader = tf.TextLineReader(skip_header_lines=1)  # 使用tensorflow文本行阅读器，并且设置忽略第一行
key, value = reader.read(file_queue)
defaults = [[0.], [0.], [0.], [0.], [0.], [0.], [0.], [0.], [0.]]  # 设置列属性的数据格式
LOW, AGE, LWT, RACE, SMOKE, PTL, HT, UI, BWT = tf.decode_csv(value, defaults)
# 将读取的数据编码为我们设置的默认格式
vertor_example = tf.stack([AGE, LWT, RACE, SMOKE, PTL, HT, UI])  # 读取得到的中间7列属性为训练特征
vertor_label = tf.stack([BWT])  # 读取得到的BWT值表示训练标签

# 用于给取出的数据添加上batch_size维度，以批处理的方式读出数据。可以设置批处理数据大小，是否重复读取数据，容量大小，队列末尾大小，读取线程等属性。
example_batch, label_batch = tf.train.shuffle_batch([vertor_example, vertor_label], batch_size=10, capacity=100, min_after_dequeue=10)

# 初始化Session
with tf.Session() as sess:
coord = tf.train.Coordinator()  # 线程管理器
threads = tf.train.start_queue_runners(coord=coord)
print(sess.run(tf.shape(example_batch)))  # [10  7]
print(sess.run(tf.shape(label_batch)))  # [10  1]
print(sess.run(example_batch)[3])  # [ 19.  91.   0.   1.   1.   0.   1.]
coord.request_stop()
coord.join(threads)

'''
对于使用所有Tensorflow的I/O操作来说开启和关闭线程管理器都是必要的操作
with tf.Session() as sess:
coord = tf.train.Coordinator()  # 线程管理器
threads = tf.train.start_queue_runners(coord=coord)
#  Your code here~
coord.request_stop()
coord.join(threads)
'''

2.os模块

Python内置的

os

模块可以直接调用操作系统提供的接口函数，来实现对目录和文件的操作，函数的功能类似于在命令行对文件进行dir、cp等。

os

模块的某些函数是跟操作系统相关的，有的操作系统有有的操作系统没有，os模块的部分操作如下：

[code]import os

# 对系统的操作
print(os.name) #操作系统类型，如果是posix，说明系统是Linux、Unix或Mac OS X，如果是nt，就是Windows系统。
'''posix'''
print(os.uname()) #详细的操作系统信息，windows没有这个函数
'''posix.uname_result(sysname='Darwin', nodename='gaoxuanxuandeMacBook-Pro.local', release='17.7.0', version='Darwin Kernel Version 17.7.0: Wed Feb 27 00:43:23 PST 2019; root:xnu-4570.71.35~1/RELEASE_X86_64', machine='x86_64')'''
print(os.environ) #查看系统中定义的所有环境变量
'''environ({'PATH': '/Users/gaoxuanxuan/anaconda3/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Library/TeX/texbin:/usr/local/share/dotnet:/Library/Frameworks/Mono.framework/Versions/Current/Commands:/Applications/Xamarin Workbooks.app/Contents/SharedSupport/path-bin', 'CONDA_DEFAULT_ENV': 'base', 'CONDA_EXE': '/Users/gaoxuanxuan/anaconda3/bin/conda', 'CONDA_PYTHON_EXE': '/Users/gaoxuanxuan/anaconda3/bin/python', 'COMMAND_MODE': 'unix2003', 'CONDA_PREFIX': '/Users/gaoxuanxuan/anaconda3', 'LOGNAME': 'gaoxuanxuan', 'XPC_SERVICE_NAME': 'com.apple.xpc.launchd.oneshot.0x10000004.pycharm', 'PWD': '/Users/gaoxuanxuan/PycharmProjects/LearnPython', 'PYCHARM_HOSTED': '1', 'CONDA_SHLVL': '1', 'PYTHONPATH': '/Users/gaoxuanxuan/PycharmProjects/LearnPython', 'SHELL': '/bin/bash', 'PYTHONIOENCODING': 'UTF-8', 'SECURITYSESSIONID': '186a9', 'USER': 'gaoxuanxuan', 'TMPDIR': '/var/folders/zj/8c24hk110n9dfhlrsgnjz1bm0000gn/T/', 'SSH_AUTH_SOCK': '/private/tmp/com.apple.launchd.mKSykb7UiJ/Listeners', 'XPC_FLAGS': '0x0', 'PYTHONUNBUFFERED': '1', '__CF_USER_TEXT_ENCODING': '0x1F5:0x19:0x34', 'Apple_PubSub_Socket_Render': '/private/tmp/com.apple.launchd.sam8mHbObS/Render', 'CONDA_PROMPT_MODIFIER': '', 'LC_CTYPE': 'UTF-8', 'HOME': '/Users/gaoxuanxuan'})'''
print(os.environ.get('PATH'))#获取PATH这个环境变量的值
'''/Users/gaoxuanxuan/anaconda3/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Library/TeX/texbin:/usr/local/share/dotnet:/Library/Frameworks/Mono.framework/Versions/Current/Commands:/Applications/Xamarin Workbooks.app/Contents/SharedSupport/path-bin'''

# 对路径进行操作（是与操作系统有关的字符串操作，与该目录或文件名是否真实存在无关）
print(os.path.join('/Users/gaoxuanxuan/PycharmProjects/LearnPython', 'testdir')) #路径合成，会根据操作系统进行不同的拼接，linux下是/，windows下是\
# '''/Users/gaoxuanxuan/PycharmProjects/LearnPython/testdir'''
print(os.path.split('/Users/gaoxuanxuan/PycharmProjects/LearnPython/testdir')) #路径拆分，可以把一个路径拆分为两部分，后一部分总是最后级别的目录或文件名
'''('/Users/gaoxuanxuan/PycharmProjects/LearnPython', 'testdir')'''
print(os.path.splitext('/Users/gaoxuanxuan/PycharmProjects/LearnPython/testdir/text1.txt')) #获取文件扩展名
'''('/Users/gaoxuanxuan/PycharmProjects/LearnPython/testdir/text1', '.txt')'''

# 对目录对操作
print(os.path.abspath('.')) #查看当前目录的绝对路径
'''/Users/gaoxuanxuan/PycharmProjects/LearnPython'''
print(os.listdir('.'))#查看当前目录下的内容
'''['file2.txt', 'file1.txt', 'LiaoXuefeng.py', 'venv', '.idea']'''
os.mkdir('/Users/gaoxuanxuan/PycharmProjects/LearnPython/testdir') #目录的创建
os.rmdir('/Users/gaoxuanxuan/PycharmProjects/LearnPython/testdir') #目录的删除
print([x for x in os.listdir('.') if os.path.isdir(x)]) #目录过滤
'''['venv', '.idea']'''

# 对文件进行操作
os.rename('file1.txt', 'file1.py') #文件重命名，包括可以更改文件扩展名
if os.path.exists('file1.txt'): #判断文件是否存在
os.remove('file1.txt') #删除文件
import shutil
shutil.copyfile('file2.txt','file1.txt') #复制文件，os里没有复制文件的函数，shutil模块对文件操作做了补充
print([x for x in os.listdir('.') if os.path.isfile(x) and os.path.splitext(x)[1]=='.py']) #特定格式的文件过滤
'''['file1.py', 'LiaoXuefeng.py']'''

3.datetime模块

datetime是Python内置的处理日期和时间的标准库。datetime格式的时间是与时区有关系的，计算机内部存储时间用的时间戳timestamp是与时区没有关系的，二者可以互相转换。

datetime模块中有一个同名的datetime类，在导入和使用时，要注意区分导入的是模块还是类：

[code]import datetime #导入的是模块
print(datetime.datetime.now()) # 2019-04-10 15:45:09.194766

from datetime import datetime #导入的是类
print(datetime.now()) # 2019-04-10 15:45:09.194766

datetime类的方法：

[code]from datetime import datetime

# 显示当前日期时间
print(datetime.now()) #2019-04-10 15:55:53.447377

# 创建一个指定的日期时间
dt = datetime(2019,4,10,16,10,35)
print(dt) #2019-04-10 16:10:35

# 将指定日期时间转换成timestamp（timestamp是相对于UTC+00:00时区的1970年1月1日00:00:00（也称epoch time）度过的秒数，该时刻timestamp
#  = 0, 该时刻之前的是负数，之后的全是正数。计算机存储的当前时间是以timestamp表示的，因为timestamp不受时区影响，全球各地的计算机在任意时
# 刻的timestamp都是完全相同的。timestamp是一个浮点数。如果有小数位，小数位表示毫秒数。）
print(dt.timestamp()) # 1554883835.0
# 将timestamp转换成datetime的格式,datetime是有时区的
t = dt.timestamp()
print(datetime.fromtimestamp(t)) # 转换到当前系统设置的时区。2019-04-10 16:10:35 (UTC+8:00）
print(datetime.utcfromtimestamp(t)) # 直接转换到UTC标准时区的时间。2019-04-10 08:10:35（UTC+0:00）

# str转换成datetime
cday = datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')
print(cday) # '2015-06-01 18:19:59'
# datetime转换成str
print(dt.strftime('
1fff7
%Y-%m-%d %H:%M:%S')) # 2019-04-10 16:10:35

# datetime加减需要从datetime模块导入timedelta类，可以直接+ -
from datetime import timedelta
now = datetime.now()
future = now + timedelta(days=2,hours=2)
print(future)

# 给datetime强制设置时区属性tzinfo，需要从datetime模块导入timezone类先创建一个时区
from datetime import timezone
tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
now = datetime.now()
dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
print(dt) #输出就含有时区了： 2019-04-10 16:29:33.234812+08:00

# 将datetime进行时区转换用astimezone()
utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc) # 拿到当前UTC时间，并转换到时区UTC+0:00的时间，变成带时区的datetime
print(utc_dt) #2019-04-10 08:36:05.106337+00:00
bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8))) # 将utc_dt转换时区为北京时间
print(bj_dt) #2019-04-10 16:36:05.106337+08:00
tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9))) # 将utc_dt转换时区为东京时间
print(tokyo_dt) #2019-04-10 17:36:05.106337+09:00
tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9))) # 将bj_dt转换时区为东京时间（以datetime设置的时区为准计算timedelta）
print(tokyo_dt2) #2019-04-10 17:36:05.106337+09:00

4.类和对象

5.正则表达式与re模块

a. 正则表达式

正则表达式是一种用来匹配字符串的强有力的武器，可以用于检查一个字符串是否是邮件、电话号码或者是否符合任意一种模式等，它的设计思想是用一种描述性的语言来给字符串定义一个规则，凡是符合规则的字符串，我们就认为它“匹配”了，否则该字符串就是不合法的。正则表达式里的字符有：

正则表达式的字符	原字符
字符	精确匹配到字符（某些原字符需用转义字符来匹配）
\-	-
\\	\
\d	一个数字
\w	一个字母或数字
.	一个任意字符（字母、数字、符号等）
\s	一个空格
[0-9a-zA-Z\_]	一个数字、字母或下划线
(A|B)	A或B
^，^\d	行的开头，必须以数字开头
$，\d$	行的结束，必须以数字结束

为了实现变长表示， 在上表的字符（除了^和$，都可以）后面可以跟上相应的符号，可表示有多少个该字符：

正则表达式的字符	匹配的字符长度信息
*	任意个字符（包括0个）
+	至少一个字符
？	0个或1个字符
{n}	n个字符
{n,m}	n到m个字符

例如，‘010-12345’ 就可以用r'^\d{3}\-\d{3,8}$'这个python的字符串组成的正则表达式来表示，其中r是为了使得正则表达式的字符串本身不转义，如果没有r正则表达式本身的字符串就会是'^\d{3}-\d{3,8}$'，这样中间的-将无法与‘010-12345’ 中的-匹配。

b. re模块

Python提供

re

模块，包含所有正则表达式的功能，包括：正则表达式的预编译、字符串的正则匹配、字符串切分（变成规则的list）、字符串的分组（子串提取）、字符串的非贪婪匹配（与正则表达式是贪婪匹配相对）等。

正则表达式的预编译

 

字符串的正则匹配

 

字符串切分

 

字符串的分组

 

字符串的非贪婪匹配​​​​​​​

 

6.http请求与requests模块