在本篇幅中主要介绍如下10个模块，若想查看前10个模块的介绍，可点击：python常用的内置模块有哪些？这20个模块算是高频使用的吗？(上)

11.configparser

11.1 作用

读写配置文件

11.2 导入

import configparser

1.3 常用方法及说明

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 常用方法及说明

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 常用方法及说明

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 常用方法及说明

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 常用方法及说明

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 常用方法及说明

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))       # 结果 ： 8

17.uuid

17.1 作用

通用唯一识别码

17.2 导入

import uuid

17.3 常用方法及说明

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-7678feb36387

18.Queue

18.1 作用

提供了同步的、线程安全的队列类

18.2 导入

from queue import Queue

18.3 常用方法及说明

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 常用方法及说明

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 常用方法及说明

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的原来值保持一致