python中各种模块教程（python模块你都用过哪些）
python中各种模块教程（python模块你都用过哪些）configparser.sections()读取配置文件，直接读取ini文件内容方法说明configparser.read(filename)
在本篇幅中主要介绍如下10个模块，若想查看前10个模块的介绍，可点击：python常用的内置模块有哪些？这20个模块算是高频使用的吗？(上)
11.1 作用
读写配置文件
11.2 导入
import configparser
1.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 yaml
12.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 itertools
13.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 re
14.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 calendar
15.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 math
16.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 Queue
18.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 logging
19.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 copy
20.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的原来值保持一致
