在本篇幅中主要介绍如下10个模块，若想查看前10个模块的介绍，可点击：python常用的内置模块有哪些？这20个模块算是高频使用的吗？(上)
11.configparser
11.1 作用
读写配置文件11.2 导入
import configparser1.3 常用方法及说明
方法 | 说明 |
configparser.read(filename) | 读取配置文件，直接读取ini文件内容 |
configparser.sections() | 获取ini文件内所有的section，以列表形式返回 |
configparser.options(sections) | 获取指定sections下所有options ，以列表形式返回 |
configparser.items(sections) | 获取指定section下所有的键值对 |
configparser.get(section, option) | 获取section中option的值，返回为string类型 |
configparser.getint(section,option) | 得到section中option的值，返回int类型的结果 |
configparser.write(filename) | 将configparser对象写入.ini类型的文件 |
configparser.add_section() | 添加一个新的section |
configparser.add_set(section,option,value) | 对section中的option信息进行写入 |
configparser.remove_section(section) | 删除文件中的某个section的数值 |
configparser.remove_option(section,option) | 删除文件中某个section下的option的数值 |
11.4 示例
配置项生成和读取
import configparser
conf = configparser.ConfigParser()
# === 1.创建配置项====
def write_conf():
conf['mysql'] = {
"host" : "192.169.10.68",
"port" : "3306",
"user" : "root",
"password" : "123456"
}
with open('config.ini','w',encoding='utf-8') as f:
conf.write(f)
"""
调用write_conf()将生成config.ini文件，文件内容如下：
[mysql]
host = 192.169.10.68
port = 3306
user = root
password = 123456
"""
# ====2.读取配置项======
# 通过read读取到config.ini中的数据
conf.read('config.ini',encoding='utf-8')
print("ini内所有的section,以列表形式返回:",conf.sections())
for k,v in conf.items('mysql'):
print(k,v)
"""
通过conf.items()循环后返回如下：
host 192.169.10.68
port 3306
user root
password 123456
"""
# 使用options获取某个section中所有的键
print(conf.options('mysql')) #返回：['host', 'port', 'user', 'password']
# 使用get获取某个键对应的值
print("获取port的值:",conf.get("mysql","port")) #返回：3306
配置项的新增、修改、删除
import configparser
conf = configparser.ConfigParser()
conf.read('config.ini')
# 添加新配置项
def add_config():
'''
要新增的内容
[api]
name = /user/login
method = 'get'
body = {'username':'admin','password':'123456'}
'''
conf.add_section('api')
conf.set('api','name','/user/login')
conf.set('api','method','get')
conf.set('api','body',"{'username':'admin','password':'123456'}")
with open('config.ini','w') as f:
conf.write(f)
# add_config() #只需运行一次
# 修改配置项
conf.set('api','method','post')
with open('config.ini', 'w') as f:
conf.write(f)
# 删除配置项
conf.remove_option('api','body')
conf.remove_section('api')
with open('config.ini', 'w') as f:
conf.write(f)12.yaml
12.1 作用
进行yaml格式的读取和转化12.2 导入
import yaml12.3 常用方法及说明
方法 | 说明 |
yaml.load() | 读取yaml文件 |
yaml.dump() | 将一个python对象生成yaml文档 |
yaml.load_all() | 如果string或文件包含几块yaml文档，可以使用yaml.load_all来解析全部的文档。 |
yaml.dump_all() | 将多个段输出到一个文件中 |
12.4 示例
import yaml
"""
文件名：sutdent.yaml
文件内容:
name: zhangsan
age: 37
lower student:
name: lisi
age: 25
higher student:
- name: wangwu
age: 35
- name1: zhaoliu
age1: 42
"""
# 1.load方法,读取yaml文件，
with open('sutdent.yaml') as f:
res = yaml.load(f,Loader=yaml.FullLoader)
print("读取结果:",res)
# 2.dump ,将一个python对象生成yaml格式
dct = {'a':'python','b':'java'}
res1 = yaml.dump(dct)
print(res1)
# 3.load_all ,将文件包含的几块Yaml读取出来
fl = '''
---
name: tony
age: 20
---
name: lisy
age: 29
'''
res2 = yaml.load_all(fl,Loader=yaml.FullLoader)
for data in res2:
print(data)
# 4.将多段输出到yaml文件
obj1 = {"name": "James", "age": 20}
obj2 = ["Lily", 19]
with open(r'a.yaml', 'w') as f:
yaml.dump_all([obj1, obj2], f)
"""
输出到文件如下：
age: 20
name: James
---
- Lily
- 19
"""
# 输出：
读取结果: {'name': 'zhangsan', 'age': 37, 'lower student': {'name': 'lisi', 'age': 25}, 'higher student': [{'name': 'wangwu', 'age': 35}, {'name1': 'zhaoliu', 'age1': 42}]}
a: python
b: java
{'name': 'tony', 'age': 20}
{'name': 'lisy', 'age': 29}13.itertools
13.1 作用
用来产生不同类型迭代器13.2 导入
import itertools13.3 常用方法及说明
方法 | 说明 |
count( start [,step]) | 创建一个从 start 开始，步长为 step 的迭代器，默认为1。 |
cycle( iterable ) | 创建一个从 iterable 中 循环 取出元素的迭代器。 |
repeat( elem [,n] ) | 重复 elem元素 n次。 n为空时，重复无穷次。 |
accumulate( p [,func] ) | 创建一个迭代器，返回累加和或其他二元函数的累加结果。 |
chain( p, q, … ) | 把可迭代对象p, q 中的元素连接起来。 |
chain.from_iterable( iterable ) | 要求iterable对象中的元素也是可迭代的，然后把元素中元素创建一个迭代器 |
compress(data, selectors) | 创建一个迭代器，它返回data 中经selectors 真值测试为True 的元素。 |
dropwhile(predicate, iterable) | 创建一个迭代器，如果predicate 为true，迭代器丢弃这些元素，然后返回其他元素。 |
filterfalse(predicate, iterable) | 创建一个迭代器，只返回iterable 中predicate 为False 的元素。 |
groupby(iterable, key=None) | 创建一个迭代器，对里面的元素 按 key 进行分组。 |
islice(iterable, start, stop[, step ]) | 创建一个迭代器，返回从iterable 里选中的元素。如果start 不是0，跳过iterable 中的元素，直到到达start 这个位置。之后迭代器连续返回元素，除非step 设置的值很高导致被跳过。 |
starmap(function, iterable) | 类似 map()，function函数历遍 iterable中的元素。 |
takewhile(predicate, iterable) | 创建一个迭代器，只要predicate 为真就从可迭代对象中返回元素。 |
tee(iterable, n=2) | 从一个可迭代对象中返回n 个独立的迭代器。 |
zip_longest(*iterables, fillvalue=None) | 创建一个迭代器，从每个可迭代对象中收集元素。如果可迭代对象的长度未对齐，将根据fillvalue 填充缺失值。 |
13.4 示例
无限迭代器
import itertools
# 无限迭代器
# 1. count(start,step)
"""
start : 开始索引
step : 步长
"""
for i in itertools.count(1,2):
if i > 8:
break
print("i =", i)
"""
i = 1
i = 3
i = 5
i = 7
"""
# 2. cycle("abc") # 无限重复abc
sum = 0
for i in itertools.cycle("123"):
print(i,end=" ")
if sum > 10:
break
sum += int(i)
print()
# 输出 ：1 2 3 1 2 3 1
# 3.repeat(obj,times)
"""
obj : 循环的对象
times : 循环的次数
"""
for x in itertools.repeat("hello",2):
print(x,end=" ")
print()
#输出 ：hello hello合并与筛选迭代器
import itertools
# 迭代器合并
# 1. chain(p,q) : 将多个可迭代对象分别处理，可将多个序列处理为单个序列
"""
p , q 都是可迭代对象
"""
for i in itertools.chain("hello","python"):
print(i,end=" ")
print()
"""
输出 ：h e l l o p y t h o n
"""
# 2. chain.from_iterable(iterable) # 这里相当于将一个迭代器的元素都拿来进行返回
for i in itertools.chain.from_iterable(["hello","python"]):
print(i,end=" ")
print()
# 输出 ：h e l l o p y t h o n
# 筛选序列 ：
# 1.compress(data,selector)
"""
data：一个可以用来迭代的数据。
selector：选择器，用来对data进行筛选。
生成一个筛选之后的迭代器，筛选规则为，当selector的第i个值为真，则保留data的第i个值，否则去除data的第i个值
"""
for x in itertools.compress('ABCDEF', [1, 0, 1, 0, 1, 1]):
print(x,end=" ")
print()
# 2.dropwhile(predicate, iterable)
"""
predicate：一个判断函数，该函数返回值类型为bool。
iterable：可迭代对象。
"""
#去除小于3的数
for i in itertools.dropwhile(lambda x:x<3,[1,2,3,4,5]):
print(i,end=" ")
print()
#输出 ： 3 4 5
# 3. takewhile(predicate, iterable)
"""
创建一个迭代器，只要 predicate 为真就从可迭代对象中返回元素。
"""
for i in itertools.takewhile(lambda x: x > 5, [7, 6, 32, 3, 6, 5]):
print(i,end=" ")
print()
# 输出 ：[7, 6, 32]14.re
14.1 作用
正则匹配 ，需要说明的是，使用这个模块需要懂得一些正则表达式相关的知识 。14.2 导入
import re14.3 常用方法及说明
方法 | 说明 |
re.match(pattern, string, flags=0) | 若匹配成功，则返回一个匹配的对象，否则返回None |
re.compile(pattern) | 编译正则表达式，生成一个正则表达式对象 |
re.search() | 搜索整个字符串并返回第一个成功的匹配，如果没有匹配则返回None |
re.findall() | 在字符串中找到正则表达式所匹配的所有子串并返回一个列表，若没有匹配则返回空列表 |
re.finditer() | 在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。 |
re.sub(pattern, repl, string, count=0, flags=0) | 将匹配到的数据进行替换 |
re.subn(pattern, repl, string[, count]) | 行为与sub()相同，但是返回一个元组 (字符串, 替换次数) |
re.split(pattern, string, maxsplit=0, flags=0) | 根据匹配进?切割字符串，并返回?个列表。 |
14.4 示例
import re
# 1.match(pattern,string,flags=0)
"""
从字符串的开头进行匹配， 匹配成功就返回一个匹配对象，匹配失败就返回None
若匹配到，通过调用group()方法得到匹配的字符串并返回
"""
print("匹配到的字符串为:",re.match("ac","acd").group())
# 输出 ：匹配到的字符串为: ac
# 2.search(pattern,string,flags=0)
"""
搜索整个字符串去匹配第一个并返回，未匹配成功返回None
若匹配到，通过调用group()方法得到匹配的字符串并返回
"""
print("匹配到的字符串为:",re.search("ac","ddacd").group())
# 输出 ：匹配到的字符串为: ac
# 3. findall(pattern, string, flags=0)
"""
match和search均用于匹配单值，即：只能匹配字符串中的一个，如果想要匹配到字符串中所有符合条件的元素，则需要使用 findall。
"""
print("匹配到的字符串为:",re.findall("ac","dacdacd"))
#输出：匹配到的字符串为: ['ac', 'ac']
# 4. sub(pattern,repl,string,count=0,flags=0)
"""
替换匹配成功的指定位置字符串
"""
res = re.sub('\d','py','doc.2.exe.3.xls')
print("替换数字为py:",res)
#输出 ：替换数字为py: doc.py.exe.py.xls
# 5.split(pattern,string,maxsplit=0,flags=0)
"""
根据正则匹配分割字符串
"""
res1=re.split('a','a1bcd')
print("分割字符得到:",res1)
#输出 ：['', '1bcd']
# 6.compile()
"""
python代码最终会被编译为字节码，之后才被解释器执行。
在模式匹配之前，正在表达式模式必须先被编译成regex对象，
预先编译可以提高性能，re.compile()就是用于提供此功能
"""
obj=re.compile('\d{3}')
ret=obj.search('abcd123edee')
print(ret.group())
#输出 ：123
# 7.group()与groups()
"""
匹配对象的两个主要方法：
group() 返回所有匹配对象，或返回某个特定子组，如果没有子组，返回全部匹配对象
groups() 返回一个包含唯一或所有子组的的元组，如果没有子组，返回空元组
"""
15.calendar
15.1 作用
提供了和日历相关的方法15.2 导入
import calendar15.3 常用方法及说明
方法 | 说明 |
calendar.calendar(year) | 返回某一年的年历 |
calendar.month(year，month) | 返回月历 |
calendar.weekday(year,month,day) | 返回传入的日期是星期几。 |
calendar.isleap(year) | 返回传入的年是不是闰年，是返回True，否则为false。如2020年是闰年。 |
calendar.leapdays(start, end) | 返回start,end之间有多少个闰年，左闭右开区间。 |
calendar.timegm(tupletime) | 接受一个时间元组，返回时间戳，时间元组的值依次表示年、月、日、时、分、秒。 |
15.4 示例
import calendar
print("calendar(years)返回某一年的日历：") # calendar.prcal(2021)同样也可以实现此功能
print(calendar.calendar(2021))
""" 输出 ：
2021
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 1 2 3 4 5 6 7 1 2 3 4 5 6 7
4 5 6 7 8 9 10 8 9 10 11 12 13 14 8 9 10 11 12 13 14
11 12 13 14 15 16 17 15 16 17 18 19 20 21 15 16 17 18 19 20 21
18 19 20 21 22 23 24 22 23 24 25 26 27 28 22 23 24 25 26 27 28
25 26 27 28 29 30 31 29 30 31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 1 2 1 2 3 4 5 6
5 6 7 8 9 10 11 3 4 5 6 7 8 9 7 8 9 10 11 12 13
12 13 14 15 16 17 18 10 11 12 13 14 15 16 14 15 16 17 18 19 20
19 20 21 22 23 24 25 17 18 19 20 21 22 23 21 22 23 24 25 26 27
26 27 28 29 30 24 25 26 27 28 29 30 28 29 30
31
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 1 1 2 3 4 5
5 6 7 8 9 10 11 2 3 4 5 6 7 8 6 7 8 9 10 11 12
12 13 14 15 16 17 18 9 10 11 12 13 14 15 13 14 15 16 17 18 19
19 20 21 22 23 24 25 16 17 18 19 20 21 22 20 21 22 23 24 25 26
26 27 28 29 30 31 23 24 25 26 27 28 29 27 28 29 30
30 31
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 1 2 3 4 5 6 7 1 2 3 4 5
4 5 6 7 8 9 10 8 9 10 11 12 13 14 6 7 8 9 10 11 12
11 12 13 14 15 16 17 15 16 17 18 19 20 21 13 14 15 16 17 18 19
18 19 20 21 22 23 24 22 23 24 25 26 27 28 20 21 22 23 24 25 26
25 26 27 28 29 30 31 29 30 27 28 29 30 31
"""
print("firstweekday()返回每周的起始日：",calendar.firstweekday()) # 输出 ：0
print("isleap()返回是否是闰年：",calendar.isleap(2016), calendar.isleap(2017)) # True ,False
print("leapdays()返回两年之间的闰年总数：",calendar.leapdays(2000, 2013)) # 2000, 2004, 2008
print("month()返回某年某月的日历：",calendar.month(2021, 10)) # calendar.prmonth(2021, 10) 同样的效果
"""October 2021
Mo Tu We Th Fr Sa Su
1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31
"""
print("calendar.monthcalendar()返回装着某年某月日历的二维列表：")
print(calendar.monthcalendar(2021, 1))
print("calendar.monthrange()返回包含了两个整数的元组，分别是某年某月第一天是周几，该月有多少天：")
print(calendar.monthrange(2021, 1)) # 返回(4, 31)，4表示该月第一天为周五，31表示该月有31天
print("setfirstweekday()设置一周的起始日期码，默认一周第一天为0，即周一：")
calendar.setfirstweekday(1)
print(calendar.firstweekday()) # 返回1
print("weekday()返回某年某月某日是周几：",calendar.weekday(2021, 1, 25)) # 返回 ：0
16.math
16.1 作用
可以对数值进行数学运算16.2 导入
import math16.3 常用方法及说明
方法 | 说明 |
math.cos() | 求一个数值的余弦值 |
math.ceil() | 向上取整 |
math.floor() | 向下取整 |
math.fabs() | 取绝对值，并用浮点数形式保存 |
math.factorial() | 取阶乘 |
math.fmod() | 取余运算 |
math.fsum() | 求和 |
math.isnan() | 判断是否是非数值 |
math.sqrt() | 开根号 |
16.4 示例
import math
# 1.常量
print("返回PI的值：",math.pi)
print("返回e的值：",math.e)
# 2. 基本运算
print("次方运算:",math.pow(5, 2)) # 结果 ： 25
print("开方运算:",math.sqrt(64)) # 结果 ：8.0
print("对数运算:",math.log(100, 10)) # 结果 ：2.0
print("返回已2为底x的对数:",math.log2(3)) # 结果 ：1.584962500721156
print("返回以10为底x的对数:",math.log10(1000)) # 结果 ：3.0
print("求和:",math.fsum([3,4,5])) # 结果 ： 12
print("取余运算:",math.fmod(8, 3)) # 结果 ： 2.0
print("向上取整:",math.ceil(8.3)) # 结果 ： 9
print("向下取整:",math.floor(8.3)) # 结果 ： 817.uuid
17.1 作用
通用唯一识别码17.2 导入
import uuid17.3 常用方法及说明
方法 | 说明 |
uuid.uuid1() | 从MAC地址，序列号和当前时间生成UUID |
uuid.uuid3() | 里面的namespace和具体的字符串都是我们指定的，使用MD5生成UUID |
uuid.uuid4() | 生成一个随机UUID |
uuid.uuid5() | 此方法和uuid3写法是一样的，只不过是使用sha1生成UUID |
17.4 示例
import uuid
name = "python"
print(uuid.uuid1())
print(uuid.uuid5(uuid.NAMESPACE_URL,name))
print(uuid.uuid3(uuid.NAMESPACE_DNS,name))
print(uuid.uuid4())
#输出：
fd582a14-31a7-11ec-ace4-84c5a65bdcfd
344979f2-3e10-505c-89bf-2d5c0fefed8d
c9f8b609-b81e-3c95-8188-914324e741c8
c7e3d006-16ff-4110-8b70-7678feb3638718.Queue
18.1 作用
提供了同步的、线程安全的队列类18.2 导入
from queue import Queue18.3 常用方法及说明
方法 | 说明 |
Queue.qsize() | 返回队列的大小 |
Queue.empty() | 如果队列为空，返回True,反之False |
Queue.full() | 如果队列满了，返回True,反之False，Queue.full 与 maxsize 大小对应 |
Queue.get([block[, timeout]]) | 获取队列，timeout等待时间 |
Queue.get_nowait() | 相当于Queue.get(False)，非阻塞方法 |
Queue.put(item) | 写入队列，timeout等待时间 |
Queue.task_done() | 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号。每个get()调用得到一个任务，接下来task_done()调用告诉队列该任务已经处理完毕。 |
Queue.join() | 实际上意味着等到队列为空，再执行别的操作 |
18.4 示例
from queue import Queue
q = Queue(maxsize=5)
# 向队列写入元素
q.put('a')
q.put('b')
q.put('c')
q.put('d')
q.put('e')
print("返回队列的大小:",q.qsize())
if q.full(): # 判断队列是否满了
for x in range(5):
print(q.get()) # 获取元素
else:
print("为空判断:",q.empty())19.logging
19.1 作用
提供日志的包19.2 导入
import logging19.3 常用方法及说明
方法 | 说明 |
logging.debug() | 输出debug日志 |
logging.info() | 输出info日志 |
logging.warning() | 输出warning日志 |
logging.error() | 输出error日志 |
logging.critical() | 输出critical日志 |
logging.Logger.setLevel() | 设置日志级别 |
logging.Logger.addHandler() | 添加一个handler |
logging.Logger.removeHandler() | 删除一个handler |
logging.Logger.addFilter() | 添加过滤 |
logging.Handler.setLevel() | 设置日志级别 |
logging.Handler.setFormatter() | 设置日志格式化 |
19.4 示例
import logging
# 创建日志对象，日志器
logger = logging.getLogger(__name__)
# 设置日志级别
logger.setLevel(level=logging.DEBUG)
# 设置日志输出文件
handler = logging.FileHandler('my.log')
# 设置日志格式,创建格式化器
formatter = logging.Formatter(
fmt='%(asctime)s | %(levelname)s | %(name)s | %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'
)
# 给文件对象设置格式化器
handler.setFormatter(formatter)
# 文件对象加入日志器
logger.addHandler(handler)
# 记录日志信息
logger.debug("debug日志")
logger.info("info日志")
logger.warning("warning日志")
logger.error("error日志")
logger.critical("critical日志")
#输出到文件的格式：
2021-10-20 22:47:39 | DEBUG | __main__ | debug日志
2021-10-20 22:47:39 | INFO | __main__ | info日志
2021-10-20 22:47:39 | WARNING | __main__ | warning日志
2021-10-20 22:47:39 | ERROR | __main__ | error日志
2021-10-20 22:47:39 | CRITICAL | __main__ | critical日志20.copy
20.1 作用
拷贝数据类型20.2 导入
import copy20.3 常用方法及说明
方法 | 说明 |
copy.copy() | 浅拷贝 |
copy.deepcopy() | 深拷贝 |
20.4 示例
import copy
lst1 = ["a",1,["b",2]]
# 1.使用copy()进行浅拷贝。
lst2 = copy.copy(lst1)
lst3 = copy.deepcopy(lst1)
print("两个列表的值是否相等:",lst2 == lst3) # 返回 ：True
print("是否是同一对象:",lst2 is lst3) # 返回 ：False
lst1[2][0] = "c"
print(lst2) # 返回: ['a', 1, ['c', 2]] ,和lst1的最新值保持一致
print(lst3) # 返回: ['a', 1, ['b', 2]] ,和lst1的原来值保持一致
