python用到过的库及方法

豪豪学习8848

已于 2024-04-19 09:27:56 修改

阅读量783

点赞数 9

文章标签： python 开发语言

于 2024-04-11 21:29:28 首次发布

本文链接：https://blog.csdn.net/weixin_45365818/article/details/137636532

版权

import os

提供了许多与操作系统交互的函数，例如创建、移动和删除文件和目录，以及访问环境变量等

1.os.listdir（）

用于返回指定的文件夹包含的文件或文件夹的名字的列表。这个列表以字母顺序。

os.listdir(path)

参数
path -- 需要列出的目录路径

返回值
返回指定路径下的文件和文件夹列表

`2.os.path.isdir()`

是 Python 标准库中 os.path 模块提供的一个函数，用于判断指定路径是否为一个目录。这个函数接受一个参数，即要检查的文件路径，如果该路径是一个存在的目录，则返回 True；如果路径不存在或者是一个文件而不是目录，则返回 False。

os.path.isfile（）差不多判断是否为文件。

3.os.path.exists（）

用于判断指定的路径是否存在。这个函数接受一个参数，即要检查的文件路径。如果该路径存在，则返回 True；如果路径不存在，则返回 False。函数不关心路径是一个文件还是目录，它仅仅检查路径是否存在于文件系统中。这使得 os.path.exists() 成为在执行文件读写操作、目录创建或删除等操作之前进行安全检查的理想工具。

import shutil

针对日常的文件和目录管理任务

1.shutil.move（）

用于将文件或目录从一个位置移动到另一个位置。如果目标位置已存在且是一个文件，它将被覆盖。

2.shutil.copy2（）

用于将一个文件复制到另一个位置，并尝试保留原始文件的元数据，如修改时间和访问权限。这个函数是 shutil 模块中用于文件复制的多个选项之一，特别是当你需要保持文件属性与原始文件一致时非常有用。

shutil.copy2() 函数接受两个参数：

src_file：要复制的源文件的路径。
dst_file：目标文件的路径，即文件将被复制到的位置。

如果源文件 src_file 存在，shutil.copy2() 将创建一个与源文件相同的副本，并将文件内容复制到 dst_file 指定的位置。同时，它会尝试将源文件的元数据（如修改时间、访问权限等）复制到目标文件。如果目标文件已经存在，它将被源文件的内容覆盖。

shutil.copy2() 与 shutil.copy() 的主要区别在于对文件元数据的处理。shutil.copy() 仅复制文件内容，而不会尝试复制文件的元数据。如果你只需要复制文件内容，而不关心文件的元数据，那么使用 shutil.copy() 可能更为高效。

import time

time 模块提供了处理时间的函数，例如获取当前时间、格式化日期和时间、计时等

1.time.time()

2.time.localtime()

用于将时间戳（一个表示自纪元（Epoch）以来经过的秒数的浮点数）转换为本地时间。纪元通常指的是 UTC 时间 1970 年 1 月 1 日 00:00:00。

当你传递一个时间戳给 time.localtime() 函数时，它会返回一个 struct_time 对象，该对象包含了本地时间的详细信息，如年、月、日、小时、分钟、秒等。

3.time.strftime（）

用于将 struct_time 类型的时间信息格式化为指定的字符串格式。struct_time 对象通常由 time.localtime()、time.gmtime() 或 time.struct_time() 等函数返回，包含了时间的各个组成部分，如年、月、日、小时、分钟、秒等。

import time

# 获取当前时间的 struct_time 对象
current_time = time.localtime()

# 格式化时间字符串
formatted_time = time.strftime('%Y-%m-%d %H:%M:%S', current_time)

print(formatted_time)

在这个例子中，time.strftime() 函数接受两个参数：

格式化字符串：包含格式说明符的字符串，用于指定输出时间字符串的格式。例如，'%Y-%m-%d %H:%M:%S' 表示年-月-日时:分:秒的格式。
struct_time 对象：包含时间信息的对象，由 time.localtime() 等函数返回。

time.strftime() 函数中的格式说明符有多种，以下是一些常用的格式说明符：

%Y: 年份，以四位数表示（例如，2024）。
%m: 月份，以两位数表示（01 到 12）。
%d: 一个月中的第几天，以两位数表示（01 到 31）。
%H: 小时，以两位数表示（00 到 23）。
%M: 分钟，以两位数表示（00 到 59）。
%S: 秒，以两位数表示（00 到 59）。
%A: 星期几的全名（例如，Monday）。
%a: 星期几的缩写（例如，Mon）。
%B: 月份的全名（例如，April）。
%b: 月份的缩写（例如，Apr）。

time.strftime() 函数在需要将时间信息转换为特定格式的字符串时非常有用，例如在生成日志文件、创建时间戳或显示时间信息给用户时。通过选择合适的格式说明符，你可以轻松地创建出符合要求的时间字符串。

import traceback

提供了用于获取、格式化和操作 Python 程序中的堆栈跟踪信息的功能

1.traceback.format_exc()

用于格式化当前线程的堆栈跟踪信息为字符串。当程序中发生未捕获的异常时，这个函数可以生成一个包含异常类型、异常消息和详细的调用栈信息的字符串。

这个函数通常在异常处理的 except 块中使用，以便于记录或输出异常的详细信息。format_exc() 会捕获当前线程的堆栈跟踪，并将其转换为可读的格式。

下面是 traceback.format_exc() 函数的基本用法：

import traceback

try:
    # 尝试执行可能会抛出异常的代码
    1 / 0  # 这里会发生除以零的异常
except Exception as e:
    # 当捕获到异常时，format_exc() 会生成堆栈跟踪信息
    exc_info = traceback.format_exc()
    print(exc_info

输出将类似于：

Traceback (most recent call last):
  File "example.py", line 6, in <module>
    1 / 0
ZeroDivisionError: division by zero

在这个例子中，当除以零的异常发生时，except 块捕获了异常，并调用了 traceback.format_exc() 来生成堆栈跟踪信息。这个信息包括了异常发生的文件名、行号以及具体的异常类型和消息。

traceback.format_exc() 函数在调试程序时非常有用，因为它提供了详细的错误上下文信息，有助于快速定位问题所在。此外，你也可以将生成的堆栈跟踪信息保存到日志文件中，或者发送给开发者或系统管理员进行分析。

需要注意的是，traceback.format_exc() 只适用于当前线程，如果你的程序中有多个线程，并且想要捕获其他线程的异常信息，你需要在每个线程中分别调用 format_exc()，或者使用其他方法来收集和格式化堆栈跟踪信息。

import paramiko

paramiko 是一个开源的 Python 模块，提供了 SSHv2 协议的实现，允许你通过 SSH 进行网络通信。它常用于远程服务器管理、文件传输、端口转发等任务。

使用 paramiko，你可以创建 SSH 客户端和服务器，执行远程命令，以及通过 SFTP（SSH 文件传输协议）和 SCP（SSH 拷贝协议）进行文件传输。paramiko 支持加密和身份验证，确保了通信的安全性。

以下是一些使用 paramiko 的基本示例：

1.创建 SSH 客户端并连接到远程服务器：

import paramiko

# 初始化一个 SSH 客户端
client = paramiko.SSHClient()

# 连接到远程服务器
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect('hostname', username='user', password='passwd')

# 执行远程命令
stdin, stdout, stderr = client.exec_command('/path/to/remote/command')
output = stdout.read().decode()

# 断开连接
client.close()

2.通过 SFTP 传输文件：

import paramiko

# 创建一个 SFTP 客户端
sftp = paramiko.SFTPClient.from_transport(client.get_transport())

# 上传文件
sftp.put('local/path/to/file', 'remote/path/to/file')

# 下载文件
sftp.get('remote/path/to/file', 'local/path/to/file')

# 关闭 SFTP 客户端
sftp.close()

3.使用 SCP 协议复制文件：

import paramiko

# 设置远程服务器的连接信息
hostname = 'example.com'
username = 'user'
password = 'pass'
local_path = '/local/path/to/file'
remote_path = '/remote/path/to/file'

# 创建SCP客户端实例
scp_client = paramiko.SCPClient()

# 连接到远程服务器
scp_client.connect(hostname, username=username, password=password)

# 将本地文件复制到远程服务器
scp_client.put(local_path, remote_path)

# 关闭SCP连接
scp_client.close()

1. paramiko.Transport

paramiko.Transport 是 paramiko 库中的一个类，用于建立 SSH 传输层连接。这个连接是加密的，并且提供了数据传输的基础。paramiko.Transport 类通常用于创建一个新的传输层通道，然后可以通过它来建立一个安全的通信层（即 SSH 会话）。

创建 paramiko.Transport 实例时，你需要提供远程服务器的地址和端口号。然后，你可以使用 connect 方法来完成 SSH 握手和认证过程。认证可以通过提供用户名和密码、密钥文件等方式进行。

下面是使用 paramiko.Transport 建立连接的基本步骤：

import paramiko

# 远程服务器的地址和端口
hostname = 'example.com'
port = 22  # SSH 标准端口是 22

# 创建一个 Transport 对象
transport = paramiko.Transport((hostname, port))

# 连接到远程服务器，进行 SSH 认证
transport.connect(username='user', password='passwd')

# 现在你可以通过 transport 对象进行进一步的操作，比如创建 SFTP 或 SSH 客户端
# ...

# 关闭连接
transport.close()

paramiko.Transport 类是 paramiko 库中实现 SSH 功能的基础，它负责处理 SSH 协议的细节，如密钥交换、会话加密和压缩等。通过使用 paramiko.Transport，你可以在 Python 程序中实现复杂的 SSH 功能，而无需关心底层的网络通信细节。

2.paramiko.SFTPClient

paramiko.SFTPClient 是 paramiko 库中的一个类，用于提供对 SFTP（SSH 文件传输协议）的支持。SFTP 是一种安全协议，用于在网络上进行文件传输，它基于 SSH 协议，提供了加密的文件访问和文件传输功能。

当你通过 paramiko 建立一个安全的 SSH 连接后，你可以使用 SFTPClient 类来执行文件和目录的操作，如上传、下载、重命名、删除等。SFTPClient 可以从一个已建立的 Transport 对象创建，也可以直接从 SSHClient 对象的 open_sftp() 方法获取。

以下是使用 paramiko.SFTPClient 的一个基本示例：

import paramiko

# 设置远程服务器的连接信息
hostname = 'example.com'
port = 22  # SSH 标准端口是 22
username = 'user'
password = 'passwd'

# 创建一个 Transport 对象
transport = paramiko.Transport((hostname, port))

# 连接到远程服务器，进行 SSH 认证
transport.connect(username=username, password=password)

# 从已建立的 Transport 对象创建 SFTPClient 实例
sftp_client = paramiko.SFTPClient.from_transport(transport)

# 使用 SFTPClient 上传文件
local_file_path = '/local/path/to/file.txt'
remote_file_path = '/remote/path/to/file.txt'
sftp_client.put(local_file_path, remote_file_path)

# 关闭 SFTPClient 实例
sftp_client.close()

# 关闭 Transport 对象
transport.close()

在这个例子中，我们首先创建了一个 Transport 对象，并指定了远程服务器的主机名和端口号。然后，我们调用 connect 方法并提供认证信息（用户名和密码）来建立一个安全的连接。

一旦 SSH 连接建立，我们使用 paramiko.SFTPClient.from_transport() 类方法从 Transport 对象创建了一个 SFTPClient 实例。这个 SFTPClient 实例可以用于执行 SFTP 协议支持的各种文件操作。

我们使用 SFTPClient 的 put 方法将本地文件 local_file_path 上传到远程服务器的 remote_file_path 路径。文件上传完成后，我们关闭了 SFTPClient 实例和 Transport 对象，以释放资源并结束与远程服务器的连接。

1.`SFTPClient.put()`

SFTPClient.put() 是 paramiko 库中的一个方法，用于将本地文件系统中的文件上传到远程服务器上。这个方法是 SFTPClient 类的一部分，SFTPClient 提供了一套用于通过SFTP协议与远程服务器进行文件传输和操作的接口。

put() 方法的基本用法如下：

sftp.put(local_path, remote_path, callback=None)

local_path：要上传的本地文件的路径。
remote_path：远程服务器上的目标路径，文件将被上传到这个位置。
callback：一个可选的回调函数，用于在文件传输过程中提供进度更新。这个函数应该接受两个参数：传输的字节数和文件的总字节数。

put() 方法会将指定的本地文件上传到远程服务器的指定路径。如果上传成功，它会返回一个 SFTPResponse 对象，该对象包含了一些关于传输操作的信息，如状态码和消息。如果发生错误，它会抛出一个异常。

import smtplib

用于发送邮件的Python标准库

以下是使用smtplib发送电子邮件的基本步骤：

1.导入库：

import smtplib

2.设置SMTP服务器：您需要知道SMTP服务器的地址和端口。这通常可以在您的电子邮件服务提供商的帮助文档中找到。例如，对于Gmail，服务器地址是smtp.gmail.com，端口是587（使用TLS）或465（使用SSL）。

server = smtplib.SMTP('smtp.gmail.com', 587)
server.starttls() # 如果您的服务器支持TLS

3.登录到SMTP服务器：使用您的电子邮件地址和密码登录到SMTP服务器。

server.login('your_email@example.com', 'your_password')

4.设置电子邮件信息：创建一个包含发件人、收件人和邮件内容的email.message对象。

from_email = 'your_email@example.com'
to_email = 'recipient_email@example.com'
subject = 'Subject line'
body = 'This is the body of the email.'

email_message = """\
From: %s
To: %s
Subject: %s

%s
""" % (from_email, to_email, subject, body)

5.发送电子邮件：使用server.sendmail()方法发送电子邮件。

server.sendmail(from_email, to_email, email_message)

6.退出SMTP服务器：发送完邮件后，退出SMTP服务器。

server.quit()

1.smtplib.SMTP()

是 Python 标准库中用于发送电子邮件的 SMTP 客户端的构造函数。通过这个构造函数，你可以创建一个 SMTP 对象，然后使用该对象与 SMTP 服务器进行交互，发送电子邮件。

以下是 smtplib.SMTP() 构造函数的基本用法：

import smtplib

# 创建一个 SMTP 对象，指定 SMTP 服务器的主机名和端口号
smtp_server = 'smtp.example.com'  # 替换为你的 SMTP 服务器地址
smtp_port = 587  # 替换为你的 SMTP 服务器端口，通常是 25, 587 或 465

server = smtplib.SMTP(smtp_server, smtp_port)

创建了 SMTP 对象后，你可以使用它来登录 SMTP 服务器、发送邮件以及断开连接等。以下是一些常用的方法：

server.connect(): 连接到 SMTP 服务器。如果你在构造函数中已经指定了服务器地址和端口，这个方法可以省略，因为 smtplib 会自动尝试连接。
server.ehlo(): 向服务器发送 EHLO 命令，用于标识客户端并启动一个会话。这是一个好习惯，尽管有些 SMTP 服务器可能不需要它。
server.starttls(): 开启一个 TLS 会话，以提供加密通信。这是推荐的做法，特别是在发送敏感信息时。
server.login(user, password): 使用用户名和密码登录到 SMTP 服务器。
server.sendmail(from_addr, to_addr_list, msg): 发送邮件。from_addr 是发件人地址，to_addr_list 是收件人地址列表，msg 是邮件内容（如果是使用 sendmail 方法）。
server.send_message(message): 发送邮件。message 是一个 email.message.EmailMessage 对象或其子类的对象。
server.quit(): 完成邮件发送后，发送 QUIT 命令到服务器以关闭会话。

2.connect（）

connect方法是用于建立与SMTP服务器的连接。在smtplib.SMTP类实例化后，通常会自动调用connect方法来建立连接。不过，connect方法也可以被显式地调用，特别是在需要指定服务器地址和端口时。

smtpObj.connect(mail_host, 25)

3.sendmail（）和.send_message（）

sendmail方法和send_message方法都是smtplib.SMTP类提供的方法，用于发送电子邮件，但它们在使用方式和接收的参数上有所不同。

sendmail方法:
- sendmail方法是比较旧的API，它接收两个参数：发件人邮箱地址和收件人邮箱地址。
- 然后，你需要提供一个字符串形式的邮件内容，其中包含了邮件的头部和正文。
- 这个方法不推荐用于新的代码，因为它不支持发送复杂的邮件结构，如带有附件或HTML内容的邮件。
示例代码：
```
server.sendmail(from_addr, to_addr, message.as_string())
```

send_message方法:

send_message是一个较新的API，它接收一个email.message.Message对象作为参数。
这个对象可以是使用email模块创建的，它允许你构建复杂的邮件结构，包括附件、HTML内容、多个收件人等。
send_message方法更加灵活和强大，推荐用于新的项目。

示例代码：

server.send_message(message)

在实际应用中，send_message方法更加常用，因为它提供了更好的邮件处理能力和更简洁的代码结构。而sendmail方法虽然简单，但在处理复杂邮件时可能会受到限制。

这里是一个使用send_message方法的简单示例：

from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

# 创建一个多部分邮件对象
msg = MIMEMultipart()
msg['From'] = 'from@example.com'
msg['To'] = 'to@example.com'
msg['Subject'] = 'Test Subject'

# 添加文本正文
body = MIMEText('This is the email body.')
msg.attach(body)

# 发送邮件
server.send_message(msg)

在这个示例中，我们创建了一个MIMEMultipart对象来构建一个包含文本正文的邮件。如果你需要添加附件或图片，你可以继续使用attach方法来添加MIMEText、MIMEImage、MIMEAudio等对象。

总的来说，send_message方法提供了更多的功能和灵活性，是现代Python邮件编程的首选方法。

import MIMEText

from email.mime.text import MIMEText  #用于创建纯文本邮件的模块。

MIMEText类

MIMEText是Python email 库中的一个类，用于创建包含文本内容的MIME邮件部分。这个类是 email.mime.nonmultipart.MIMEBase 的一个子类，专门用于处理文本数据。当你需要在电子邮件中添加纯文本内容时，可以使用 MIMEText 类来创建一个文本部分。

MIMEText 类的构造函数接受几个参数：

text：这是要添加到邮件中的文本内容，通常是一个字符串。
_subtype：这是一个可选参数，指定文本的MIME子类型。对于纯文本内容，这个参数通常是 'plain'，表示纯文本格式。其他可能的值包括 'html' 用于HTML格式的邮件正文。
_charset：这是一个可选参数，指定文本内容的字符编码。'utf-8' 是一个常用的字符编码，因为它可以表示世界上大多数语言的字符。

创建 MIMEText 对象后，你可以进一步设置它的头部字段，例如 Content-Type 和 Content-Transfer-Encoding。这些字段告诉邮件客户端如何处理邮件正文。对于纯文本内容，Content-Transfer-Encoding 通常设置为 'quoted-printable' 或 'base64'，以确保邮件中的文本可以安全地通过电子邮件系统传输，即使它们包含特殊字符。

下面是一个使用 MIMEText 类创建纯文本邮件正文的简单示例：

from email.mime.text import MIMEText

# 创建一个纯文本邮件正文部分
text_part = MIMEText('这是一封邮件的正文内容。', 'plain', 'utf-8')

# 可以继续设置邮件正文的头部字段
text_part['Subject'] = '邮件主题'
text_part['From'] = 'sender@example.com'
text_part['To'] = 'recipient@example.com'

在这个示例中，我们创建了一个包含中文文本内容的 MIMEText 对象，并设置了邮件的 Subject（主题）、From（发件人）和 To（收件人）头部字段。这个对象可以被附加到一个 MIMEMultipart 消息中，然后发送出去。

import MIMEMultipart

from email.mime.multipart import MIMEMultipart #用于创建多部分邮件，通常用于包含附件的邮件。

MIMEMultipart类

MIMEMultipart是Python标准库email中的一个类，它用于创建多部分（multipart）的MIME消息。MIME（Multipurpose Internet Mail Extensions）是一种扩展的电子邮件标准，允许邮件包含不同格式的内容，比如文本、图片、音频、视频以及附件等。

在email库中，MIMEMultipart类提供了一个方便的方式来构建包含多个部分的消息，这些部分可以是文本、HTML、图片或者其他类型的数据。每个部分都是MIMEBase类的实例，可以通过attach方法添加到MIMEMultipart对象中。

当你创建一个MIMEMultipart对象时，你可以指定一个子类型（subtype），这个子类型默认是'mixed'。子类型'mixed'表示消息包含的各个部分是混合在一起的，通常用于包含附件的邮件。如果你想构建一个包含HTML和纯文本两个版本的邮件，以便不同的邮件客户端可以选择适合自己的版本，你可以使用子类型'alternative'。

下面是一个简单的例子，展示了如何使用MIMEMultipart来创建一个包含纯文本和HTML两部分的邮件：

from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

# 创建一个MIMEMultipart对象，子类型为'alternative'
msg = MIMEMultipart(subtype='alternative')

# 添加纯文本部分
text = MIMEText('This is the plain text version of the message.')
msg.attach(text)

# 添加HTML部分
html = MIMEText('<b>This is the HTML version of the message.</b>', 'html')
msg.attach(html)

在这个例子中，msg对象现在包含了两个部分：一个纯文本消息和一个HTML消息。当这个多部分消息被发送时，支持HTML的邮件客户端将显示HTML内容，而只支持纯文本的客户端将显示纯文本内容。

1.`attach()`

MIMEMultipart 类的 attach() 方法是 Python email 库中用于构建多部分邮件内容的一个关键功能。当你创建一个 MIMEMultipart 对象时，你实际上是在创建一个可以包含多个独立邮件部分的消息框架。这些部分可以是文本内容、HTML内容、图片、附件等，它们将共同构成一个完整的电子邮件。

使用 attach() 方法时，你可以向 MIMEMultipart 对象中添加 MIMEBase 类的子类实例，如 MIMEText、MIMEImage、MIMEAudio 等。每次调用 attach() 方法时，你都在向邮件中添加一个新的部分。这些部分将按照添加的顺序排列，并且在邮件的头部中，每个部分都会有相应的 MIME 类型和边界（boundary）标识。

下面是 attach() 方法的一个使用示例：

from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

# 创建一个多部分邮件消息
msg = MIMEMultipart()

# 添加一个纯文本部分
text_part = MIMEText('这是邮件的纯文本内容。', 'plain', 'utf-8')
msg.attach(text_part)

# 可以继续添加更多的部分
# 例如，添加一个HTML部分
html_part = MIMEText('<h1>这是邮件的HTML内容</h1>', 'html', 'utf-8')
msg.attach(html_part)

# 添加其他类型的部分，如附件等
# ...

# 最终，msg对象将包含多个邮件部分，形成一个完整的多部分邮件

在这个示例中，我们首先创建了一个 MIMEMultipart 对象 msg，然后通过 attach() 方法添加了一个纯文本部分和一个HTML部分。每个部分都是 MIMEText 类的实例，它们分别代表邮件的不同内容格式。

attach() 方法使得邮件的构建变得模块化和灵活，允许开发者根据需要轻松地向邮件中添加不同类型的内容。这种方法在创建复杂的电子邮件（如新闻通讯、通知邮件等）时尤其有用，因为它们通常包含多种格式的内容和附件。

import Header

from email.header import Header #用于处理邮件头部的编码。

Header 类

Header 类是 Python email 库中的一个模块，它用于处理邮件头部（Headers）的编码和解码。邮件头部通常包含多元数据，比如发件人、收件人、主题等信息，这些信息对于邮件的传输和显示至关重要。Header 类提供了一种方法来确保邮件头部的字段值能够正确地处理非ASCII字符，例如中文、日文或其他需要编码的字符。

当你创建一个 Header 对象时，你可以传递两个参数：

s：这是头部字段的原始字符串值。
charset：这是字符集的名称，用于指定字符串的编码方式。常见的字符集包括 'utf-8'、'iso-8859-1'（西欧语言）等。

Header 类会自动将字符串按照指定的字符集进行编码，并生成一个适当的 Content-Type 头部字段，以便邮件客户端能够正确地显示和处理这些字符。

下面是一个使用 Header 类的例子：

from email.header import Header

# 创建一个Header对象，将中文主题进行UTF-8编码
subject = Header('你好，世界！', charset='utf-8')

# 打印编码后的头部字段
print(subject)

输出可能会是这样的：

Subject: =?utf-8?Q?=E4=BD=A0=BC=E5=A5=BD=EF=BC=8C=E4=B8=96=E7=95=8C=EF=BC=81?=

如你所见，Header 类将中文字符编码为 ASCII 兼容的编码（在这种情况下使用的是 Q 编码），同时添加了必要的 Content-Type 头部，以便邮件客户端可以正确地解码和显示原始的非ASCII字符。

在处理邮件时，使用 Header 类可以确保邮件头部的字符正确地被编码和解码，从而避免乱码和信息丢失的问题。这对于创建国际化的电子邮件应用程序尤为重要。

message['Subject'] = Header(subject, 'utf-8')

python字典的方法

1.字典.setdefault（）

setdefault 方法是 Python 字典（dict 类型）的一个内置方法，它用于设置或获取字典中的键对应的值。这个方法的主要特点是，如果指定的键在字典中不存在，它会将该键添加到字典中，并赋予其一个默认值；如果键已经存在，则不会更改其值。

setdefault 方法的基本语法如下：

dict.setdefault(key, default=None)

key：要设置或查询的键。
default：如果 key 不在字典中，这个方法将使用这个值来设置 key 的值。默认值为 None。

示例：

# 创建一个空字典
my_dict = {}

# 使用 setdefault 添加一个新键值对
my_dict.setdefault('apple', 5)
print(my_dict)  # 输出: {'apple': 5}

# 再次使用 setdefault，但这次键已经存在，所以不会改变字典
my_dict.setdefault('apple', 10)
print(my_dict)  # 输出仍然是: {'apple': 5}

# 使用 setdefault 更新已存在的键值
my_dict.setdefault('banana', 20)
print(my_dict)  # 输出: {'apple': 5, 'banana': 20}

2.字典`[].append()`

在Python中，字典名后使用[]和.append()方法通常是用来向字典中的列表值追加元素。字典是一种可变容器模型，且可存储任意类型对象，其中的每个键值对用冒号:分隔。

假设我们有一个字典my_dict，我们想要向它的某个键对应的列表中追加一个元素，可以这样做：

my_dict = {
    "key1": ["item1", "item2"],
    "key2": ["item3"]
}

# 向键为"key1"的列表中追加一个新元素"item3"
my_dict["key1"].append("item4")

print(my_dict)  # 输出: {'key1': ['item1', 'item2', 'item4'], 'key2': ['item3']}

在这个例子中，my_dict是一个字典，它有两个键（"key1" 和 "key2"），对应的值是列表。使用.append()方法将字符串"item4"添加到了"key1"对应的列表中。

如果字典中某个键原本不是列表类型，使用.append()会引发错误。确保在尝试追加元素之前，字典中对应的键包含的是一个列表。

此外，如果尝试追加的键在字典中不存在，Python会抛出一个KeyError异常。为了避免这个错误，你可以使用dict.get()方法来检查键是否存在，或者使用dict.setdefault()方法来设置默认值（如果键不存在的话）:

my_dict = {}

# 使用setdefault确保键存在，如果不存在则初始化为空列表
my_dict.setdefault("new_key", []).append("new item")

print(my_dict)  # 输出: {'new_key': ['new item']}

在这个例子中，setdefault()方法用于设置默认值。如果"new_key"在字典中不存在，它会被添加到字典中，并且其值被初始化为一个空列表。然后，使用.append()方法向这个列表中添加一个新元素。

各种方法的使用例子：

1.setdefault+time.strftime+time.localtime

runCfg.setdefault('logFile',runCfg['logDir']+time.strftime("%Y%m%d", time.localtime())+'.txt')

这行代码使用了 Python 字典的 `setdefault` 方法，结合 `time.strftime` 函数来生成一个基于当前本地时间的日志文件名，并将其设置为 `runCfg` 字典中的 `'logFile'` 键对应的值。如果 `'logFile'` 键在 `runCfg` 字典中不存在，它将被添加到字典中；如果已存在，其值将被更新。

让我们逐步分析这行代码：

1. `runCfg`：这是一个字典，通常用于存储程序运行时的配置信息。

2. `setdefault` 方法：这是字典的一个方法，用于为字典设置默认值。如果指定的键不存在，则将其添加到字典中，并赋予指定的默认值。如果键已存在，`setdefault` 方法不会更改其值。

3. `'logFile'`：这是字典中的一个键，其值将被设置为一个日志文件的名称。

4. `runCfg['logDir']`：这是从 `runCfg` 字典中获取的 `'logDir'` 键对应的值，它表示日志文件应该存放的目录。

5. `time.strftime("%Y%m%d", time.localtime())`：这部分代码调用 `time.strftime` 函数来格式化当前的本地时间。格式字符串 `"%Y%m%d"` 表示年和月日的组合，例如 `"20240411"`。`time.localtime()` 函数返回一个 `struct_time` 对象，表示当前的本地时间。

6. `'.txt'`：这是文件名的扩展名，表示文件是一个文本文件。

综合起来，这行代码的作用是创建一个以当前日期（年月日）为名称的日志文件路径，并将其设置为 `runCfg` 字典中的 `'logFile'` 键的值。例如，如果当前日期是 2024 年 4 月 11 日，并且 `runCfg['logDir']` 是 `/path/to/logs/`，那么 `'logFile'` 的值将会是 `/path/to/logs/20240411.txt`。

这种设置日志文件名的方法在日志记录和数据存储中非常有用，因为它可以确保每天或每次程序运行时都有一个新的日志文件，从而便于管理和分析日志数据。

.format(）方法

str.format() 是 Python 中的一个字符串格式化方法，它允许你创建一个格式化的字符串，其中包含一个或多个占位符，这些占位符由大括号 {} 表示。你可以使用位置参数或关键字参数将值插入到这些占位符中。

以下是一些 str.format() 的使用示例：

1.使用位置参数

welcome_message = "Hello, {0}! Today is {1}."
print(welcome_message.format("Alice", "Monday"))

输出：

Hello, Alice! Today is Monday.

2.使用关键字参数

welcome_message = "Hello, {name}! Today is {day}."
print(welcome_message.format(name="Alice", day="Monday"))

输出：

Hello, Alice! Today is Monday.

3.使用索引

welcome_message = "Hello, {0}! Your number is {1}."
print(welcome_message.format("Alice", 42))

Hello, Alice! Your number is 42.

4.格式化数字和日期

number = 12345.6789
print("Formatted number: {:.2f}".format(number))

from datetime import datetime
current_time = datetime.now()
print("Current time: {0:%Y-%m-%d %H:%M:%S}".format(current_time))

Formatted number: 12345.68
Current time: 2024-04-18 12:34:56

5.填充和对其

print("Left aligned: {0:<10}".format("left"))
print("Right aligned: {0:>10}".format("right"))
print("Centered: {0:^10}".format("center"))

Left aligned: left      
Right aligned:       right
Centered:   center

{0:<10} 是一个格式化字符串的表达式，其中：

0 表示索引，指的是 format() 方法中第一个参数的位置。
: 是格式指定符的开始。
< 是填充对齐方式，表示左对齐。
^ 是填充对齐方式，表示居中对齐。
10 是宽度，表示最终的字符串长度应该是 10 个字符。

因此，{0:<10} 的意思是：将 format() 方法中的第一个参数格式化为一个左对齐的字符串，如果该参数的字符数不足 10 个，则在右侧填充空格，直到总长度达到 10 个字符。

.join(）

`.join()` 是一个Python中的字符串方法，它将一个可迭代对象（如列表、元组等）中的元素连接成一个字符串。`.join()` 方法接受一个可迭代的参数，并将该可迭代中的每个元素连接起来，元素之间用调用 `.join()` 的字符串作为分隔符。

这里有几个关键点：

1. `.join()` 方法调用的主体必须是一个字符串。
2. 传递给 `.join()` 的参数是一个可迭代对象，其中每个元素都将被连接。
3. 如果可迭代对象中的元素不是字符串，它们将被转换成字符串。

下面是一些使用 `.join()` 方法的例子：

连接字符串列表

words = ['Hello', 'World', 'Python', 'is', 'awesome']
sentence = ' '.join(words)
print(sentence)  # 输出: Hello World Python is awesome

在这个例子中，我们使用一个空格字符串 `' '` 作为分隔符，将列表中的单词连接成一个完整的句子。

连接数字

numbers = [1, 2, 3, 4, 5]
number_string = '-'.join(map(str, numbers))
print(number_string)  # 输出: 1-2-3-4-5

在这个例子中，我们首先使用 `map()` 函数将数字列表中的每个数字转换为字符串，然后使用 `'-'` 作为分隔符将它们连接起来。

使用特定的分隔符

items = ['apple', 'banana', 'cherry']
separator = ', '
fruits = separator.join(items)
print(fruits)  # 输出: apple, banana, cherry

在这个例子中，我们使用 `', '` 作为分隔符，将列表中的元素连接起来，形成了一个以逗号分隔的字符串。