python常用的20个内置模块包 ，看看这里面是否有你没用过的？

1.os

1.1 作用

主要是和操作系统相关的一个模块，如可以进行文件/目录的创建、删除等

1.2 导入

import os

1.3 常用方法及说明

常用方法	说明
os.getcwd()	获取当前路径
os.chdir(path)	改变当前工作目录
os.listdir(path)	列出指定路径下的所有文件和子目录，以列表形式展示
os.mkdir(‘dirname’)	创建文件夹
os.makedirs(‘dirname1/dirname2’)	可以生成多层递归目录
os.removedirs(‘dirname’)	若目录为空，则删除，并递归到上一层目录，若也为空，则删除。
os.rmdir(‘dirname’)	删除空目录，若目录不为空则报错
os.remove()	删除一个文件
os.rename(‘oldname’,‘newname’)	重命名文件/目录
os.stat(‘path/filename’')	获取文件/目录信息
os.sep	输入操作系统特定的路径分隔符，win下为’\‘,Linux为’/’
os.name	获取当前的平台，win为’nt’ ,Linux为’posix’
os.system(‘command’)	运行shell命令
os.environ	获取系统环境变量
os.path.abspath(path)	返回path的绝对路径
os.path.split(path)	将path分割成目录和文件名的元组
os.path.splittext(path)	分割路径，返回路径名和文件扩展名的元祖
os.path.dirname(path)	返回path的上一层目录
os.path.basename(path)	返回path中最后的文件名
os.path.exist(path)	若path存在返回True，否则返回False
os.path.isfile(path)	若path是一个文件则返回Ture,否则返回False
os.path.isdir(path)	若path是一个目录则返回Ture,否则返回False
os.path.isabs(path)	若path是绝对路径则返回Ture,否则返回False
os.path.join(path1[, path2[, …]])	把目录和文件名合成一个路径
os.path.getsize(path)	返回文件大小，如果文件不存在就报错
os.path.getmtime(path)	返回最近文件修改时间
os.path.getctime(path)	返回文件path创建时间
os.path.realpath(path)	返回path的真实路径
os.path.normpath(path)	返回path的真实路径

1.4 示例

import os


print(os.getcwd())                 #获取当前路径 ，输出：E:\project\demo_mod
print(os.listdir())                #列出当前目录下的所有文件和目录 ，输出：['.idea', 'abc.txt', 'demo_os.py']
os.mkdir("aaa")                     #创建文件夹aaa
os.rmdir("aaa")                     #删除空目录aaa
os.makedirs("abc/bcd")              #创建多层文件夹abc/bcd
os.removedirs("abc/bcd")            #删除多层多文件abc/bcd
print(os.stat('abc.txt'))           # 输出 ：os.stat_result(st_mode=33206, st_ino=562949953424572, st_dev


print(os.path.abspath("."))                             # 返回当前路径的绝对路径 ，输出 ：E:\project\demo_mod
os.path.exists(r"E:\project\demo01")                    # 判断path是否存在 ，输出：False
os.path.isfile("abc.txt")                               # 判断abc.txt是文件 ，输出：True
print(os.path.split(r"E:\project\demo_mod\abc.txt"))    # ('E:\\project\\demo_mod', 'abc.txt')
print(os.path.dirname(r"E:\project\demo_mod\abc.txt"))  # E:\project\demo_mod

2.sys

2.1 作用

针对python解释器相关的变量和方法

2.2 导入

import sys

2.3 常用方法及说明

属性/方法	说明
sys.argv	命令行参数，第一个参数为脚本名字
sys.modules	所有加载到内存的模块都放在modules
sys.path	返回查找模块的搜索路径，以列表返回
sys.platform	返回操作系统平台名词
sys.version	返回python解释器程序的版本信息
sys.exit()	退出程序

2.4 示例

import sys


print("获取默认第一个参数:",sys.argv)
print("获取系统路径:",sys.path)
print("获取当前平台:",sys.platform)
print("获取当前版本：",sys.version)

#返回：
获取默认第一个参数: ['E:/project/demo_mod/demo02_sys.py']
获取系统路径: ['E:\\project\\demo_mod', 'E:\\project\\demo_mod', 'C:\\python36\\python36.zip', 'C:\\python36\\DLLs', 'C:\\python36\\lib', 'C:\\python36', 'C:\\python36\\lib\\site-packages']
获取当前平台: win32
获取当前版本： 3.6.4 (v3.6.4:d48eceb, Dec 19 2017, 06:04:45) [MSC v.1900 32 bit (Intel)

3.time

3.1 作用

和时间相关的模块

3.2 导入

import time

3.3 常用方法及说明

方法	说明
time.time()	获取当前时间戳
time.sleep(n)	当前线程停止运行n秒
time.asctime()	返回当前时间，格式是西欧格式
time.ctime()	返回当前时间，格式是西欧格式
time.localtime()	返回当前时间对象
time.struct_time()	构造一个对应的事件对象
time.strftime()	将一个时间对象格式化为特定的字符串输出
time.strptime()	照格式化字符把一个格式化时间字符串转成元组。

3.4 示例

import time

print("获取当前时间戳：",time.time())
print("返回当前时间,西欧格式：",time.ctime())
print("返回当前时间对象:",time.localtime())

time.sleep(2)       #睡眠2s
print("返回格式化后的时间:",time.strftime("%Y-%m-%d %X", time.localtime()))
print("将格式化的时间转化成时间对象,元祖形式:",time.strptime('2010-8-11 7:26:16', '%Y-%m-%d %X'))

#返回：
获取当前时间戳： 1634373068.0492582
返回当前时间,西欧格式： Sat Oct 16 16:31:08 2021
返回当前时间对象: time.struct_time(tm_year=2021, tm_mon=10, tm_mday=16, tm_hour=16, tm_min=31, tm_sec=8, tm_wday=5, tm_yday=289, tm_isdst=0)
返回格式化后的时间: 2021-10-16 16:31:10
将格式化的时间转化成时间对象,元祖形式: time.struct_time(tm_year=2010, tm_mon=8, tm_mday=11, tm_hour=7, tm_min=26, tm_sec=16, tm_wday=2, tm_yday=223, tm_isdst=-1)

4.datetime

4.1 作用

关于时间和日期的模块 ，这里面有几个常用的类，包括：

• date : 日期类
• time : 时间类
• datetime : 日期和时间的类 ，相当于前面的两个类
• datedelta : 时间间隔

4.2 导入

4.3 常用方法及说明

from datetime import date
d = date(date(2020,11,20))

下面表格中的d就是上面的日期对象

属性/方法	说明
date.max	返回最大的日期对象
date.min	返回最小的日期对象
d.year	返回2020
d.month	返回11
d.day	返回20
d.replace(year,month,day)	生成并返回一个新的日期对象，原日期对象不变
d.timetuple()	返回日期对应的time.struct_time对象
d.toordinal()	返回日期自0001-01-01开始的第多少天
d.weekday()	返回日期是星期几，[0, 6]，0表示星期一
d.isoweekday()	返回日期是星期几，[1, 7], 1表示星期一
d.isocalendar()	返回一个元组，格式为：(year, weekday, isoweekday)
d.isoformat()	返回‘YYYY-MM-DD’格式的日期字符串
d.strftime(format)	返回指定格式的日期字符串，与time模块的strftime(forma t, struct_time)功能相同

from datetime import time
t = time(20,51,32)

下面表格中的t就是上面的时间对象

属性/方法	说明
t.hour	返回20,取值范围[0,23]
t.minute	返回51，取值范围在[0,59]
t.second	返32，取值范围在[0,59]
t.microsecond	微秒
t.tzinfo	返回传递给time构造方法的tzinfo对象，如果该参数未给出，则返回None
t.replace(hour[, minute[, second[, microsecond[, tzinfo]]]])	生成并返回一个新的时间对象，原时间对象不变
t.isoformat()	返回一个‘HH:MM:SS.%f’格式的时间字符串
t.strftime()	返回指定格式的时间字符串，与time模块的strftime(format, struct_time)功能相同

from datetime import datetime
dt = datetime(2020,09,22,10,35,28,322)

下面表格中的dt就是上面的日期时间对象

属性/方法	说明
dt.year	返回2020
dt.month	返回09
dt.day	返回22
dt.hour	返回10
dt.minute	返回35
dt.second	返回28
dt.microsecond	返回322
datetime.today()	返回一个表示当前本期日期时间的datetime对象
datetime.now([tz])	返回指定时区日期时间的datetime对象，如果不指定tz参数则结果同上
datetime.utcnow()	返回当前utc日期时间的datetime对象
datetime.fromtimestamp(timestamp[, tz])	根据指定的时间戳创建一个datetime对象
datetime.utcfromtimestamp(timestamp)	根据指定的时间戳创建一个datetime对象
datetime.combine(date, time)	把指定的date和time对象整合成一个datetime对象
datetime.strptime(date_str, format)	将时间字符串转换为datetime对象
datetime.timedelta()	返回一个时间间隔对象，可以直接与datetime.datetime对象做加减操作

4.4 示例

date示例

from datetime import date

now = date(2021, 10, 16)
tomorrow = now.replace(day = 17)

print('今天日期:', date.today())
print('今天日期:', now,)
print('明天日期:', tomorrow)
print("日期的元祖", now.timetuple())
print('返回星期几,0代表星期一:', now.weekday())
print('返回星期几,1代表星期一:', now.isoweekday())
print( '返回一个元祖', now.isocalendar())
print( '返回日期字符串:', now.isoformat())
print( '返回格式化的日期:', now.strftime("%Y-%m-%d"))


#输出：
今天日期: 2021-10-16
今天日期: 2021-10-16
明天日期: 2021-10-17
日期的元祖 time.struct_time(tm_year=2021, tm_mon=10, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=289, tm_isdst=-1)
返回星期几,0代表星期一: 5
返回星期几,1代表星期一: 6
返回一个元祖 (2021, 41, 6)
返回日期字符串: 2021-10-16
返回格式化的日期: 2021-10-16

time示例

from datetime import time

t1 = time(17,25,15)
print("显示小时：",t1.hour)
print("显示分钟：",t1.minute)
print("显示秒：",t1.second)
print("显示微秒：",t1.microsecond)

tm1 = t1.replace(minute=32)
print("替换后时间:",tm1)
print('返回时间字符串:', t1.isoformat())
print('返回格式化后的时间字符串', t1.strftime("%X"))


#输出：
显示小时： 17
显示分钟： 25
显示秒： 15
显示微秒： 0
替换后时间: 17:32:15
返回时间字符串: 17:25:15
返回格式化后的时间字符串 17:25:15

datetime示例

from datetime import datetime



print('最大时间:', datetime.max)
print('最小时间:', datetime.min)
print('今天时间,精确到微秒:', datetime.today())
print('现在时间,精确到微秒::', datetime.now())
print("格式化日期:",datetime.strftime(datetime.now(),"%y-%m-%d %H:%M:%S"))


#输出 ：
最大时间: 9999-12-31 23:59:59.999999
最小时间: 0001-01-01 00:00:00
今天时间,精确到微秒: 2021-10-16 17:41:08.807900
现在时间,精确到微秒:: 2021-10-16 17:41:08.807900
格式化日期: 21-10-16 17:41:08

timedelta示例

from  datetime import timedelta,datetime
dt = datetime.now()

#日期减一天
dt1 = dt + timedelta(days=-1)       #昨天
dt2 = dt - timedelta(days=1)        #昨天
dt3 = dt + timedelta(days=1)        #明天
delta_obj = dt3-dt
print("当前日期-1:",dt1)
print("当前日期-1:",dt2)
print("当前日期+1:",dt3)
print("相差几天:",delta_obj)


#输出：
当前日期-1: 2021-10-15 17:45:39.574903
当前日期-1: 2021-10-15 17:45:39.574903
当前日期+1: 2021-10-17 17:45:39.574903
相差几天: 1 day, 0:00:00

5.random

5.1 作用

用于生成随机数

5.2 导入

import random

5.3 常用方法及说明

方法	说明
random.random()	用于生成一个0~1的随机浮点数
random.uniform(a,b)	用于生成一个指定范围内的随机浮点数
random.randint(a,b)	用于生成一个指定范围内的整数
random.randrange(start,end,step)	从指定范围内，按指定基数递增的集合中 获取一个随机数。
random.choice(sequence)	从序列中获取一个随机数
random.shuffle(x[, random])	用于将一个列表中的元素打乱,即将列表内的元素随机排列。
random.sample(sequence, k)	从指定序列中随机获取指定长度的片断并随机排列。

5.4 示例

import random


print("生成一个0~1的随机数:",random.random())
print("生成一个指定范围内的随机数:",random.uniform(1,10))
print("生成一个指定范围的随机整数:",random.randint(1,100))
print("生成指定集合，然后随机生成一个数:",random.randrange(1,5,1))
print("从列表中随机拿一个数:",random.choice(['a','b','c','d']))
print("指定的长度中随机排序",random.sample(['a','b','c','d'],3))

lst = [1,3,46,33,'a','b','c','d']
random.shuffle(lst)
print("列表被打乱后随机排序",lst)


#输出：
生成一个0~1的随机数: 0.06636579979518498
生成一个指定范围内的随机数: 7.29403347010388
生成一个指定范围的随机整数: 93
生成指定集合，然后随机生成一个数: 3
从列表中随机拿一个数: c
指定的长度中随机排序 ['d', 'b', 'a']
列表被打乱后随机排序 ['a', 3, 46, 'b', 1, 'c', 33, 'd']

6.subprocess

6.1 作用

执行系统命令

6.2 导入

import subprocess

6.3 常用方法及说明

方法	说明
subprocess.call(command)	执行命令，返回状态码
subprocess.run()	执行命令，等待命令执行完成后返回一个包含执行结果的CompletedProcess类的实例。
subprocess.check_call(command)	执行命令，如果执行状态码是0，则返回0，否则抛出异常
subprocess.check_output()	执行命令，如果执行状态码是0，则返回命令执行结果，否则抛出异常
subprocess.getoutput(cmd)	接收字符串格式的命令，执行命令并返回执行结果，其功能类似于os.popen(cmd).read()和commands.getoutput(cmd)。
subprocess.getstatusoutput(cmd)	执行cmd命令，返回一个元组(命令执行状态, 命令执行结果输出)，其功能类似于commands.getstatusoutput()。
subprocess.Popen()	可以执行各种命令，以上的那些方法都是基于此类实现的。

6.4 示例

import subprocess


# 查看当前目录下的文件 ,以下三条命令必须指定shell参数 ，否则会报错
subprocess.run(["dir"],shell=True)
subprocess.run(["java","-version"])
subprocess.call("dir",shell=True)
subprocess.check_call("dir",shell=True)


# 以下两条方法专门就是执行shell命令的 。
subprocess.getoutput("dir")
subprocess.getstatusoutput("dir")

#输出 ：以上都可以返回命令执行后的结果

7.hashlib

7.1 作用

用于加密相关的操作

7.2 导入

import hashlib

7.3 常用方法及说明

方法	说明
hashlib.md5()	进行md5算法加密
hashlib.sha1()	进行SHA1算法加密
hashlib.sha224()	进行SHA224算法加密
hashlib.sha256()	进行SHA256算法加密
hashlib.sha384()	进行SHA384算法加密

7.4 示例

import hashlib

m1 = hashlib.md5('hello python'.encode(encoding='utf-8'))  # 构建MD5对象
print(m1.hexdigest())       # 结果为： e5d3024684c9be1dd3f6114ecc8bbdddc


sh224 = hashlib.sha224("hello python".encode('utf-8'))
print(sh224.hexdigest())     

sh256 = hashlib.sha256("hello python".encode('utf-8'))
print(sh256.hexdigest())    

sh384 = hashlib.sha384("hello python".encode('utf-8'))
print(sh384.hexdigest())    


#结果输出:
e53024684c9be1dd3f6114ecc8bbdddc
7f78ad20eff5afc21166e6a5e22962a2819bd28d335ba95ff414b3f5
373a23512f9531ad49ec6ad43ecdda58df01e59d9ec5812d601fd05cc53345d3
eaf44aabb38c34ff948e714b9c3c08f3fed996d74fc9f1225d7368ccb386465df272e55912041921eddf13b51aff833c

8.json

8.1 作用

编码或解码json对象

8.2 导入

import json

8.3 常用方法及说明

方法	说明
json.dumps()	将python对象转化成json字符串
json.loads()	将json字符串转化为python对象
json.dump()	将python对象转化成json字符串并存入文件
json.load()	从文件读取字符串转化成python对象

8.4 示例

import json

# 1.字符串(json) --> 字典
color = '{"1":"red","2":"green","3":"blue","4":"black"}'
color_dict = json.loads(color)
print("color_dict:",color_dict)


# 2.字典 --> json
color_json  = json.dumps(color_dict)
print("color_json:",color_json)


# 3.(json)文件 --> 字典
with open("color.json") as f:
    dt = json.load(f)
print("dt:",dt)

# 4.dict --> (json)文件
with open("color1.json","w") as f1:
    json.dump(dt,f1)                #将python字典数据写入color1.json

    
#输出 ：
color_dict: {'1': 'red', '2': 'green', '3': 'blue', '4': 'black'}
color_json: {"1": "red", "2": "green", "3": "blue", "4": "black"}
dt: {'1': 'red', '2': 'green', '3': 'blue', '4': 'black'}

9.pickle

9.1 作用

用于序列化的模块

9.2 导入

import pickle

9.3 常用方法及说明

方法	说明
pickle.dumps()	将数据通过特殊的形式转换为只有python语言认识的字符串
pickle.loads()	将pickle数据转换为python的数据结构
pickle.dump()	将数据通过特殊的形式转换为只有python语言认识的字符串，并写入文件
pickle.load()	从数据文件中读取数据，并转换为python的数据结构

9.4 示例

import pickle

# 1.序列化
color = ["red","green","blue","black"]
color_byte = pickle.dumps(color)
print("color_byte:",color_byte)


# 反序列化即字节转列表(python数据类型)
color_obj  = pickle.loads(color_byte)
print("color_obj:",color_obj)


class Person():

    def __init__(self,name,age):
        self.name = name
        self.age = age


p = Person('zhangsan',21)


# 3.持久化到文件
with open("color.txt","wb") as f:
    dt = pickle.dump(p,f)

# 4. 从文件读取数据
with open("color.txt","rb") as f:
    p_data = pickle.load(f)

print(p_data)


#输出 ：
color_byte: b'\x80\x03]q\x00(X\x03\x00\x00\x00redq\x01X\x05\x00\x00\x00greenq\x02X\x04\x00\x00\x00blueq\x03X\x05\x00\x00\x00blackq\x04e.'
color_obj: ['red', 'green', 'blue', 'black']
<__main__.Person object at 0x03A4B050>

10.shutil

10.1 作用

主要用于文件或目录的复制或归档的操作

10.2 导入

import shutil

10.3 常用方法及说明

方法	说明
shutil.copy(‘源文件’,‘目标地址’)	复制文件
shutil.copy2(‘源文件’,‘目标地址’)	复制文件，暴露元数据
shutil.copyfileobj(open(‘源文件’,‘r’),open(‘目标文件’,‘w’))	讲一个文件的内容拷贝到另外一个文件当中
shutil.copyfile(‘源文件’，‘目标文件’)	将一个文件的内容拷贝到另外一个文件中
shutil.copytree(‘源目录’,‘目标目录’)	复制整个目录
shutil.copymode()	拷贝权限
shutil.copystat()	拷贝元数据（状态）
shutil.rmtree()	移除整个目录，无论是否为空
shutil.move(‘源地址’,‘目标地址’)	移动文件或文件夹
shutil.which(‘命令字符串’)	检测命令对应的文件路径
shutil.disk_usage(‘盘符’)	检测磁盘使用信息
shutil.make_archive(‘目标文件路径’,‘归档文件后缀’,‘需要归档的目录’)	归档函数，归档操作
shutil.unpack_archive(‘归档文件路径’,‘解包目标文件夹’)	解包操作
shutil.get_archive_formats()	获取当前系统已注册的归档文件格式(后缀)
shutil.get_unpack_formats()	获取当前系统已经注册的解包文件格式(后缀)

10.4 示例

import shutil

shutil.copy('abc.txt','bcd.txt')
shutil.copy2('abc.txt','ddd.txt')

# 基于文件流的复制，目标文件必须存在
with open("abc.txt","rb") as f ,open("ddd.txt","wb") as s:
    shutil.copyfileobj(f,s)

shutil.copyfile('abc.txt','acc.txt')        # 目标文件无须存在
shutil.copymode('abc.txt','acc.txt')        # 仅拷贝权限，内容，组，用户均不变，目标文件必须存在


# 文件夹压缩，不可压缩文件
shutil.make_archive("a1","zip","E:\project\demo2801")


# 备注 ：以上都直接形成文件

11.configparser

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

17.uuid

17.1 作用

通用唯一识别码

17.2 导入

import uuid

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

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