os库

os.path.join()函数 如果将单个文件和路径上的文件夹名称的字符串传递给它，os.path.join()就会返回一个文件路径的字符串，包含正确的路径分隔符。
利用os.getcwd()函数，可以取得当前工作路径的字符串。
os.chdir()函数，改变当前工作目录。
点（.）和点点（…）文件夹。它们不是真正的文件夹，而是可以在路径中使用的特殊名称。单个的句点（“点”）用作文件夹目名称时，是“这个目录”的缩写。两个句点（“点点”）意思是父文件夹。
os.makedirs()函数 创建新文件夹
os.path模块包含了许多与文件名和文件路径相关的有用函数。
调用os.path.abspath(path)将返回参数的绝对路径的字符串。这是将相对路径转换为绝对路径的简便方法。
调用os.path.isabs(path)，如果参数是一个绝对路径，就返回True，如果参数是一个相对路径，就返回False。
调用os.path.relpath(path, start)将返回从start路径到path的相对路径的字符串。如果没有提供start，就使用当前工作目录作为开始路径。
调用os.path.dirname(path)将返回一个字符串，它包含path参数中最后一个斜杠之前的所有内容。调用os.path.basename(path)将返回一个字符串，它包含path 参数中最后一个斜杠之后的所有内容。如果同时需要一个路径的目录名称和基本名称，就可以调用os.path.split()，获得这两个字符串的元组。
调用os.path.getsize(path)将返回path参数中文件的字节数。
调用os.listdir(path)将返回文件名字符串的列表，包含path参数中的每个文件（请注意，这个函数在os模块中，而不是os.path）。
如果path参数所指的文件或文件夹存在，调用os.path.exists(path)将返回True，否则返回False。
如果path参数存在，并且是一个文件，调用os.path.isfile(path)将返回True，否则返回False。
如果path参数存在，并且是一个文件夹，调用os.path.isdir(path)将返回True，否则返回False。

shelve库

利用shelve模块，可以将Python程序中的变量保存到二进制的shelf文件中。这样，程序就可以从硬盘中恢复变量的数据。shelve模块让你在程序中添加“保存”和“打开”功能。例如，如果运行一个程序，并输入了一些配置设置，就可以将这些设置保存到一个shelf文件，然后让程序下一次运行时加载它们。
要利用shelve模块读写数据，首先要导入它。调用函数shelve.open()并传入一个文件名，然后将返回的值保存在一个变量中。可以对这个变量的shelf值进行修改，就像它是一个字典一样。当你完成时，在这个值上调用close()。这里，我们的shelf值保存在shelfFile中。我们创建了一个列表cats，并写下shelfFile[‘cats’] =cats，将该列表保存在shelfFile中，作为键’cats’关联的值（就像在字典中一样）。然后我们在shelfFile上调用close()。
在Windows上运行前面的代码，你会看到在当前工作目录下有3个新文件：mydata.bak、mydata.dat和mydata.dir。在OS X上，只会创建一个mydata.db文件。你的程序稍后可以使用shelve模块，重新打开这些文件并取出数据。shelf值不必用读模式或写模式打开，因为它们在打开后，既能读又能写。
这里，我们打开了shelf文件，检查我们的数据是否正确存储。输入shelfFile[‘cats’]将返回我们前面保存的同一个列表，所以我们就知道该列表得到了正确存储，然后我们调用close()。
就像字典一样，shelf值有keys()和values()方法，返回shelf中键和值的类似列表的值。因为这些方法返回类似列表的值，而不是真正的列表，所以应该将它们传递给list()函数，取得列表的形式。
创建文件时，如果你需要在Notepad或TextEdit这样的文本编辑器中读取它们，纯文本就非常有用。但是，如果想要保存Python程序中的数据，那就使用shelve模块。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import shelve

shelfFile = shelve.open('mydata')
cats = ['Zophie', 'Pooka', 'Simon']
shelfFile['cats'] = cats
shelfFile.close()

shelfFile = shelve.open('mydata')
print(type(shelfFile)) # <class 'shelve.DbfilenameShelf'>
print(shelfFile['cats']) # ['Zophie', 'Pooka', 'Simon']
shelfFile.close()

shelfFile = shelve.open('mydata')
print(list(shelfFile.keys())) # ['cats']
print(list(shelfFile.values())) # [['Zophie', 'Pooka', 'Simon']]
shelfFile.close()

json库

json.dumps() 存储数据，json.loads() 读取数据

webbrowser库

webbrowser.open(url) 打开网页

time库

round(数字，小数位数)将数字四舍五入到最接近的整数，常用来处理time模块中的小数点

time.time()函数

Unix纪元是编程中经常参考的时间：1970年1月1日0点，即协调世界时（UTC）。time.time()函数返回自那一刻以来的秒数，是一个浮点值。这个数字称为UNIX纪元时间戳。

1
2
3
>>> import time
>>> time.time()
1736686789.1249623

time.sleep()函数

如果需要让程序暂停一下，就调用time.sleep()函数，并传入希望程序暂停的秒数。

datetime库

time模块用于取得Unix纪元时间戳，并加以处理。但是，如果以更方便的格式显示日期，或对日期进行算术运算（例如，搞清楚205天前是什么日期，或123天后是什么日期），就应该使用datetime模块。

1
2
3
4
5
6
7
from datetime import datetime
import time
print(datetime.now()) # 2025-01-13 14:52:02.397002
dt = datetime(2015, 10, 21, 16, 29, 0)
print(dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second) # 2015 10 21 16 29 0
print(datetime.fromtimestamp(1000000)) # 1970-01-12 21:46:40
print(datetime.fromtimestamp(time.time())) # 2025-01-13 14:52:02.397003

调用datetime.datetime.now()返回一个datetime对象，表示当前的日期和时间，根据你的计算机的时钟。这个对象包含当前时刻的年、月、日、时、分、秒和微秒。也可以利用datetime.datetime()函数，向它传入代表年、月、日、时、f分、秒的整数，得到特定时刻的datetime对象。这些整数将保存在datetime对象的year、month、day❹、hour、minute和second属性中。Unix纪元时间戳可以通过datetime.datetime.fromtimestamp()，转换为datetime对象。datetime 对象的日期和时间将根据本地时区转换。
datetime模块还提供了timedelta数据类型，它表示一段时间，而不是一个时刻。
要创建timedelta对象，就用datetime.timedelta()函数。
datetime.timedelta()函数接受关键字参数weeks、days、hours、minutes、seconds、milliseconds和microseconds。没有month和year关键字参数，因为“月”和“年”是可变的时间，依赖于特定月份或年份。timedelta对象拥有的总时间以天、秒、微秒来表示。这些数字分别保存在days、seconds和microseconds属性中。total_seconds()方法返回只以秒表示的时间。将一个timedelta对象传入str()，将返回格式良好的、人类可读的字符串表示。

1
2
3
4
5
6
7
8
from datetime import datetime, timedelta
delta = timedelta(days=11, hours=10, minutes=9, seconds=8)
print(delta.days, delta.seconds, delta.microseconds) # 11 36548 0
delta.total_seconds()
print(str(delta)) # 11 days, 10:09:08
dt = datetime(2015, 2, 27, 18, 38, 50, 636181)
thousand_days = timedelta(days=1000)
print(dt + thousand_days) # 2017-11-23 18:38:50.636181

Unix纪元时间戳和datetime对象对人类来说都不是很友好可读。利用strftime()方法，可以将datetime对象显示为字符串。（strftime()函数名中的f表示格式，format）。该的strftime()方法使用的指令类似于Python的字符串格式化。

strftime指令 含义
%Y 带世纪的年份，例如’2014’
%y 不带世纪的年份，‘00’至’99’（1970至2069）
%m 数字表示的月份, ‘01’至’12’
%B 完整的月份，例如’November’
%b 简写的月份，例如’Nov’
%d 一月中的第几天，‘01’至’31’
%j 一年中的第几天，‘001’至’366’
%w 一周中的第几天，‘0’（周日）至’6’（周六）
%A 完整的周几，例如’Monday’
%a 简写的周几，例如’Mon’
%H 小时（24小时时钟），‘00’至’23’
%I 小时（12小时时钟），‘01’至’12’
%M 分，‘00’至’59’
%S 秒，‘00’至’59’
%p ‘AM’或’PM’
%% 就是’%'字符

向strftime()传入一个定制的格式字符串，其中包含格式化指定（以及任何需要的斜线、冒号等），strftime()将返回一个格式化的字符串，表示datetime对象的信息。

1
2
3
4
5
from datetime import datetime
oct21st = datetime(2015, 10, 21, 16, 29, 0) 
print(oct21st.strftime('%Y/%m/%d %H:%M:%S')) # 2015/10/21 16:29:00
print(oct21st.strftime('%I:%M %p')) # 04:29 PM
print(oct21st.strftime("%B of '%y")) # October of '15

如果有一个字符串的日期信息，如’2015/10/21 16:29:00’或’October 21, 2015’，需要将它转换为datetime对象，就用datetime.datetime.strftime()函数。strptime()函数与strftime()方法相反。定制的格式字符串使用相同的指令，像strftime()一样。必须将格式字符串传入strptime()，这样它就知道如何解析和理解日期字符串（strptime()函
数名中p表示解析，parse）。

1
2
3
4
5
from datetime import datetime
print(datetime.strptime('October 21, 2015', '%B %d, %Y')) # 2015-10-21 00:00:00
print(datetime.strptime('2015/10/21 16:29:00', '%Y/%m/%d %H:%M:%S')) # 2015-10-21 16:29:00
print(datetime.strptime("October of '15", "%B of '%y")) # 2015-10-01 00:00:00
print(datetime.strptime("November of '63", "%B of '%y")) # 2063-11-01 00:00:00

Unix纪元时间戳（time模块中使用）是一个浮点值或整型值，表示自1970年1月1日午夜0点（UTC）以来的秒数。
datetime对象（属于datetime模块）包含一些整型值，保存在year、month、day、hour、minute和second等属性中。
timedelta对象（属于datetime模块）表示的一段时间，而不是一个特定的时刻。
下面回顾了时间函数及其参数和返回值：
time.time()函数返回一个浮点值，表示当前时刻的Unix纪元时间戳。
time.sleep(seconds)函数让程序暂停seconds参数指定的秒数。
datetime.datetime(year, month, day, hour, minute, second)函数返回参数指定的时刻的datetime对象。如果没有提供hour、minute或second参数，它们默认为0。
datetime.datetime.now()函数返回当前时刻的datetime对象。
datetime.datetime.fromtimestamp(epoch)函数返回epoch时间戳参数表示的时刻的datetime对象。
datetime.timedelta(weeks, days, hours, minutes, seconds, milliseconds,microseconds)函数返回一个表示一段时间的timedelta对象。该函数的关键字参数都是可选的，不包括month或year。
total_seconds()方法用于timedelta对象，返回timedelta对象表示的秒数。
strftime(format)方法返回一个字符串，用format字符串中的定制格式来表示datetime对象表示的时间。
datetime.datetime.strptime(time_string, format)函数返回一个datetime对象，它的时刻由time_string指定，利用format字符串参数来解析。

subprocess库

如果想在Python脚本中启动一个外部程序，就将该程序的文件名传递给subprocess.Popen()（在Windows中，右键点击该应用程序的开始菜单项，然后选择“属性”，查看应用程序的文件名。）

1
2
3
4
5
6
from subprocess import Popen
# Popen('C:/Windows/System32/calc.exe')# 打开计算器
# Popen("D:/Downloads/WPS Office/ksolaunch.exe") # 打开wps
# Popen("C:/Program Files (x86)/KuGou/KGMusic/KuGou.exe") # 打开酷狗音乐
# Popen(['C:/Windows/notepad.exe', 'C:/desktop/hello.txt']) # 使用记事本打开hello.txt
Popen(['start', 'C:/desktop/hello.txt'], shell=True) # 使用默认应用打开文件

返回值是一个Popen对象，它有两个有用的方法：poll()和wait()。可以认为poll()方法是问你的朋友，她是否执行完毕你给她的代码。如果这个进程在poll()调用时仍在运行，poll()方法就返回None。如果该程序已经终止，它会返回该进程的整数退出代码。退出代码用于说明进程是无错终止（退出代码为0），还是一个错误导致进程终止（退出代码非零，通常为1，但可能根据程序而不同）。wait()方法就像是等着你的朋友执行完她的代码，然后你继续执行你的代码。wait()方法将阻塞，直到启动的进程终止。如果你希望你的程序暂停，直到用户完成与其他程序，这非常有用。wait()的返回值是进程的整数退出代码。

smtplib库

发送文字邮件

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
32
33
import smtplib
# email：构建邮件，MIMEText：文本对象
from email.mime.text import MIMEText


# 1.准备工作：登录邮箱
# smtp服务器地址
mail_host = "smtp.qq.com"
# 发送方的邮箱账号
mail_sender = "sender@qq.com"
# 发送方的授权码，注意不是邮箱的登录密码，而是开启smtp协议时的授权码
mail_pwd = "asdfghjkl"
# 连接邮箱对象
smtp = smtplib.SMTP_SSL(mail_host, 465)
# 登录邮箱
smtp.login(mail_sender, mail_pwd)

# 2.准备数据：构建邮件内容
# 正文内容
data = MIMEText("这是一个测试")
# 邮件主题/标题
data["Subject"] = "Python发送邮件测试"
# 发送方
data["From"] = mail_sender
# 接收方
receivers = ["receiver@163.com", ]
data["To"] = ";".join(receivers)

# 3.发送邮件
# 发送
smtp.sendmail(mail_sender, receivers, data.as_string())
# 退出
smtp.quit()

发送HTML邮件

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# 导入包
# 发送邮件
import smtplib
# email：构建邮件，MIMEText：文本对象
from email.mime.text import MIMEText
# 构建多个内容
from email.mime.multipart import MIMEMultipart


# 1.准备工作：登录邮箱
# smtp服务器地址
mail_host = "smtp.qq.com"
# 发送方的邮箱账号
mail_sender = "sender@qq.com"
# 发送方的授权码，注意不是邮箱的登录密码，而是开启smtp协议时的授权码
mail_pwd = "asdfghjkl"
# 连接邮箱对象
smtp = smtplib.SMTP_SSL(mail_host, 465)
# 登录邮箱
smtp.login(mail_sender, mail_pwd)

# 2.准备数据：构建邮件内容
# 正文内容
# 创建内容对象
data = MIMEMultipart()
# 内容
html_str = """<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>标题</title>
</head>
<body>
<h1>邮件正文部分</h1>
<p>这是一个测试</p>
</body>
</html>"""
# 将内容绑定到内容对象中
data.attach(MIMEText(html_str, "html", "utf-8"))
# 邮件主题/标题
data["Subject"] = "Python发送html内容邮件测试"
# 发送方
data["From"] = mail_sender
# 接收方
receivers = ["receiver@163.com", ]
data["To"] = ";".join(receivers)

# 3.发送邮件
# 发送
smtp.sendmail(mail_sender, receivers, data.as_string())
# 退出
smtp.quit()

发送带有图片的邮件

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
# 构建图片
from email.mime.image import MIMEImage
# 导入包
# 发送邮件
import smtplib
# email：构建邮件，MIMEText：文本对象
from email.mime.text import MIMEText
# 构建多个内容
from email.mime.multipart import MIMEMultipart


# 1.准备工作：登录邮箱
# smtp服务器地址
mail_host = "smtp.qq.com"
# 发送方的邮箱账号
mail_sender = "sender@qq.com"
# 发送方的授权码，注意不是邮箱的登录密码，而是开启smtp协议时的授权码
mail_pwd = "asdfghjkl"
# 连接邮箱对象
smtp = smtplib.SMTP_SSL(mail_host, 465)
# 登录邮箱
smtp.login(mail_sender, mail_pwd)

# 2.准备数据：构建邮件内容
# 正文内容
# 创建内容对象
data = MIMEMultipart()
# 将图片构建成html
# 读取文件内容
with open("F:/Pictures/3with4/screensaver2.jpg", "rb") as f:
    img_data = f.read()
# 构建图片对象
img = MIMEImage(img_data)
img.add_header("Content-ID", "testimg")  # testimg用来在html中识别图片的ID
html_str = """
<body>
    <h2>这是一个带有图片的邮件</h2>
    <p>
        <img src="cid:testimg">
    </p>
</body>
    """
# 将内容绑定到内容对象中
data.attach(MIMEText(html_str, "html", "utf-8"))
data.attach(img)

# 邮件主题/标题
data["Subject"] = "Python发送图片内容邮件测试"
# 发送方
data["From"] = mail_sender
# 接收方
receivers = ["receiver@163.com", ]
data["To"] = ";".join(receivers)

# 3.发送邮件
# 发送
smtp.sendmail(mail_sender, receivers, data.as_string())
# 退出
smtp.quit()

发送带有附件的邮件

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# 发送邮件
import smtplib
# email：构建邮件，MIMEText：文本对象
from email.mime.text import MIMEText
# 构建多个内容
from email.mime.multipart import MIMEMultipart

# 1.准备工作：登录邮箱
# smtp服务器地址
mail_host = "smtp.qq.com"
# 发送方的邮箱账号
mail_sender = "sender@qq.com"
# 发送方的授权码，注意不是邮箱的登录密码，而是开启smtp协议时的授权码
mail_pwd = "asdfghjkl"
# 连接邮箱对象
smtp = smtplib.SMTP_SSL(mail_host, 465)
# 登录邮箱
smtp.login(mail_sender, mail_pwd)

# 2.准备数据：构建邮件内容
# 正文内容
# 创建内容对象
data = MIMEMultipart()
# 邮件主题/标题
data["Subject"] = "Python发送附件邮件测试"
# 发送方
data["From"] = mail_sender
# 接收方
receivers = ["receiver@163.com", ]
data["To"] = ";".join(receivers)

# 构建内容
with open("E:/ebook/孙子兵法.txt", 'r', encoding='utf-8') as f:
    content = f.read()
part = MIMEText(content, 'base64', 'utf-8')
# 添加到右键附件
part['Content-Disposition'] = 'attachment;filename="1.txt"'# 此处filename不支持中文
# 将内容绑定到内容对象中
data.attach(part)


# 3.发送邮件
# 发送
smtp.sendmail(mail_sender, receivers, data.as_string())
# 退出
smtp.quit()

pillow库（PIL）

计算机程序通常将图像中的颜色表示为RGBA值。RGBA值是一组数字，指定顔色中的红、绿、蓝和alpha（透明度）的值。这些值是从0（根本没有）到255（最高）的整数。这些RGBA值分配给单个像素，像素是计算机屏幕上能显示一种顔色的最小点（你可以想到，屏幕上有几百万像素）。像素的RGB设置准确地告诉它应该显示哪种颜色的色彩。图像也有一个alpha值，用于生成RGBA值。如果图像显示在屏幕上，遮住了背景图像或桌面墙纸，alpha值决定了“透过”这个图像的象素，你可以看到多少背景。在Pillow中，RGBA值表示为四个整数值的元组。例如，红色表示为（255，0，0，255）。这种颜色中红的值为最大，没有绿和蓝，并且alpha值最大，这意味着它完全不透明。
图像像素用x和y坐标指定，分别指定像素在图像中的水平和垂直位置。原点是位于图像左上角的像素，用符号（0，0）指定。第一个0表示x坐标，它以原点处为0，从左至右增加。第二个0表示y坐标，它以原点处为0，从上至下增加。
Box元组，矩形左上角坐标和右下角坐标的四个坐标值组成的元组

1
2
3
4
5
6
7
8
9
10
11
12
from PIL import Image
img_obj = Image.open('screensaver1.jpg')# 返回一个Image对象，写作img_obj
print(img_obj.size) # (488, 650)
width, height = img_obj.size
print(width) # 488
print(height) # 650
print(img_obj.filename) # C:\Desktop\test\screensaver1.jpg
print(img_obj.format) # JPEG
print(img_obj.format_description) # JPEG (ISO 10918)
# img_obj.save('screensaver1.png') # 另存为png
cropped_img = img_obj.crop((335, 345, 565, 560))# 裁剪图像
cropped_img.save('screensaver1.jpg')# 保存裁剪后的图像

新建图像

1
2
3
4
5
from PIL import Image
im = Image.new('RGBA', (100, 200), 'purple') # 新建图像，三个参数为：使用RGBA表示颜色，尺寸，颜色
im.save('purpleImage.png')
im2 = Image.new('RGBA', (200, 200)) # 新建图像，默认颜色
im2.save('transparentImage.png')

image对象的copy()方法，复制图像
image对象的paste()方法，粘贴图像
resize()方法在Image对象上调用，返回指定宽度和高度的一个新Image对象。它接受两个整数的元组作为参数，表示返回图像的新高度和宽度。请注意，resize()方法不会在原图上修改Image对象，而是返回一个新的Image对象。
图像可以用rotate()方法旋转，该方法返回旋转后的新Image对象，并保持原始Image对象不变。rotate()的参数是一个整数或浮点数，表示图像逆时针旋转的度数。注意，当图像旋转90度或270度时，宽度和高度会变化。如果旋转其他角度，图像的原始尺寸会保持。在Windows上，使用黑色的背景来填补旋转造成的缝隙，如图17-8所示。在OS X上，使用透明的像素来填补缝隙。rotate()方法有一个可选的expand关键字参数，如果设置为True，就会放大图像的尺寸，以适应整个旋转后的新图像。
利用transpose()方法，还可以得到图像的“镜像翻转”。必须向transpose()方法传入Image.FLIP_LEFT_RIGHT（水平翻转）或Image.FLIP_TOP_BOTTOM（垂直翻转）。
单个像素的颜色可以通过getpixel()和putpixel()方法取得和设置。它们都接受一个元组，表示像素的x和y坐标。putpixel()方法还接受一个元组，作为该像素的颜色。这个顔色参数是四整数RGBA元组或三整数RGB元组。