Python 自动化脚本系列：第3集

21. 使用 cryptography 自动化文件加密

Python 的 cryptography 库提供了一种安全的方式，使用对称加密算法对文件进行加密和解密。你可以自动化加密和解密文件的过程来保护敏感数据。

示例：文件加密和解密

假设你想使用对称加密算法加密一个文件，然后解密它。下面是使用 cryptography 库自动化此任务的方法：

from cryptography.fernet import Fernet  
  
# 要加密的文件  
file_to_encrypt = 'sensitive_data.txt'  
  
# 生成密钥  
key = Fernet.generate_key()  
  
# 使用密钥创建 Fernet 密码器  
cipher = Fernet(key)  
  
# 读取文件内容  
with open(file_to_encrypt, 'rb') as file:  
    data = file.read()  
  
# 加密数据  
encrypted_data = cipher.encrypt(data)  
  
# 将加密数据写入新文件  
with open('encrypted_file.txt', 'wb') as file:  
    file.write(encrypted_data)  
  
print("文件加密成功。")  
  
# 解密文件  
with open('encrypted_file.txt', 'rb') as file:  
    encrypted_data = file.read()  
  
decrypted_data = cipher.decrypt(encrypted_data)  
  
# 将解密后的数据写入新文件  
with open('decrypted_file.txt', 'wb') as file:  
    file.write(decrypted_data)  
  
print("文件解密成功。")

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

这段代码首先使用 Fernet.generate_key() 生成一个随机的加密密钥。然后，它使用生成的密钥创建了一个 Fernet 密码器。使用 open() 以二进制模式（‘rb’）读取要加密的文件内容。然后，使用 Fernet 密码器的 encrypt() 方法对数据进行加密。加密后的数据使用 open() 以二进制写入模式（‘wb’）写入了一个名为 ‘encrypted_file.txt’ 的新文件。要解密文件，它从 ‘encrypted_file.txt’ 中读取加密数据，然后使用 Fernet 密码器的 decrypt() 方法对其进行解密。解密后的数据然后写入名为 ‘decrypted_file.txt’ 的新文件。最后，它打印出成功加密和解密文件的消息。

22. 使用 gzip 自动化文件压缩

Python 的 gzip 模块允许你使用 gzip 压缩算法对文件进行压缩和解压缩。你可以自动化压缩文件的过程以节省存储空间并减少文件传输时间。

示例：压缩和解压文件

假设你想使用 gzip 压缩一个文件，然后解压它。下面是使用 Python 自动化此任务的方法：

import gzip  
  
# 要压缩的文件  
file_to_compress = 'example.txt'  
  
# 压缩文件  
with open(file_to_compress, 'rb') as file_in:  
    with gzip.open(file_to_compress + '.gz', 'wb') as file_out:  
        file_out.writelines(file_in)  
  
print("文件压缩成功。")  
  
# 解压文件  
with gzip.open(file_to_compress + '.gz', 'rb') as file_in:  
    with open('decompressed_file.txt', 'wb') as file_out:  
        file_out.writelines(file_in)  
  
print("文件解压成功。")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

这段代码使用 open() 以二进制模式（‘rb’）读取要压缩的文件内容。然后，它使用 gzip.open() 以二进制写入模式（‘wb’）创建了一个具有相同文件名和 ‘.gz’ 扩展名的新的 gzip 文件。原始文件的内容使用 writelines() 写入到 gzip 文件中。要解压文件，它使用 gzip.open() 以二进制读取模式（‘rb’）打开 gzip 文件。然后，它将解压缩的内容写入名为 ‘decompressed_file.txt’ 的新文件中。最后，它打印出成功压缩和解压文件的消息。

23. 使用 Pillow 自动化图片缩放

Python 的 Pillow 库

提供了一种简单的方式来操作图像，包括调整它们的大小。你可以自动化将多个图像调整为特定大小的过程。

示例：调整多个图像的大小

假设你有一个包含图像的目录，你想将所有图像调整为特定大小。下面是使用 Pillow 自动化此任务的方法：

from PIL import Image  
import os  
  
# 包含图像的目录  
image_directory = 'path/to/image/directory'  
  
# 调整后的图像大小  
new_size = (800, 600)  
  
# 迭代目录中的图像  
for filename in os.listdir(image_directory):  
    if filename.endswith('.jpg') or filename.endswith('.png'):  
        # 打开图像  
        image_path = os.path.join(image_directory, filename)  
        image = Image.open(image_path)  
          
        # 调整图像大小  
        resized_image = image.resize(new_size)  
          
        # 保存调整后的图像  
        resized_image.save(os.path.join(image_directory, 'resized_' + filename))  
  
print("图像调整大小成功。")

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

这段代码迭代指定图像目录中的文件。它检查每个文件是否具有 ‘.jpg’ 或 ‘.png’ 扩展名以识别图像文件。对于每个图像文件，它使用 Pillow 库的 Image.open() 打开图像。然后，使用 resize() 方法将图像调整为所需大小。调整大小后的图像使用 save() 方法保存到相同目录中，并以 ‘resized_’ 作为前缀的新文件名。最后，它打印出成功调整图像大小的消息。

24. 使用 Python 自动化文件删除

Python 的 os 模块提供了文件和目录操作的函数，包括删除文件的函数。你可以根据特定条件自动化删除文件的过程。

示例：删除超过指定年龄的文件

假设你想删除一个目录中超过指定年龄的文件（例如，30 天）。下面是使用 Python 自动化此任务的方法：

import os  
import time  
  
# 包含文件的目录  
directory = 'path/to/directory'  
  
# 时间阈值（秒为单位）（例如，30 天）  
age_threshold = 30 * 24 * 60 * 60  
  
# 获取当前时间戳  
current_time = time.time()  
  
# 迭代目录中的文件  
for filename in os.listdir(directory):  
    file_path = os.path.join(directory, filename)  
      
    # 检查文件是否超过时间阈值  
    if os.path.isfile(file_path) and current_time - os.path.getmtime(file_path) > age_threshold:  
        # 删除文件  
        os.remove(file_path)  
        print(f"已删除：{filename}")  
  
print("文件删除完成。")

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

这段代码定义了包含文件的目录和时间阈值（以秒为单位，例如 30 天）。它使用 time.time() 获取当前时间戳。然后，它迭代指定目录中的文件。对于每个文件，它使用 os.path.isfile() 检查是否为文件（而不是目录），并检查其修改时间（os.path.getmtime()）是否超过时间阈值。如果文件满足条件，则使用 os.remove() 删除文件，并打印一条指示文件已被删除的消息。最后，它打印一条指示文件删除过程已完成的消息。

25. 使用 shutil 自动化文件复制

Python 的 shutil 模块提供了用于文件和目录管理的高级操作，包括复制文件的函数。你可以自动化将文件从一个目录复制到另一个目录的过程。

示例：从一个目录复制文件到另一个目录

假设你想将文件从一个目录复制到另一个目录。下面是使用 shutil 模块自动化此任务的方法：

import os  
import shutil  
  
# 包含要复制文件的源目录  
source_directory = 'path/to/source/directory'  
  
# 将文件复制到的目标目录  
destination_directory = 'path/to/destination/directory'  
  
# 迭代源目录中的文件  
for filename in os.listdir(source_directory):  
    source_path = os.path.join(source_directory, filename)  
    destination_path = os.path.join(destination_directory, filename)  
      
    # 从源复制文件到目标  
    shutil.copy2(source_path, destination_path)  
    print(f"已复制：{filename}")  
  
print("文件复制完成。")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

这段代码定义了包含要复制文件的源目录和将文件复制到的目标目录。它迭代源目录中的文件。对于每个文件，它使用 os.path.join() 构造源路径和目标路径。使用 shutil.copy2() 函数将文件从源路径复制到目标路径。它保留文件元数据，如时间戳和权限。打印一条指示每个文件已复制的消息，最后打印一条指示文件复制过程已完成的消息。

26. 使用 tarfile 自动化文件打包

Python 的 tarfile 模块允许你创建和提取 tar 存档。你可以自动化将文件打包到 tar 存档中以及从 tar 存档中提取文件的过程。

示例：创建和提取 tar 存档

假设你想创建一个包含多个文件的 tar 存档，并稍后从存档中提取文件。下面是使用 tarfile 模块自动化此任务的方法：

import tarfile  
  
# 要包含在存档中的文件  
files_to_archive = ['file1.txt', 'file2.txt', 'file3.txt']  
  
# 存档的名称  
archive_name = 'example.tar'  
  
# 创建 tar 存档  
with tarfile.open(archive_name, 'w') as tar:  
    for file in files_to_archive:  
        tar.add(file)  
  
print("tar 存档创建成功。")  
  
# 从 tar 存档中提取文件  
with tarfile.open(archive_name, 'r') as tar:

  
    tar.extractall()  
  
print("文件提取成功。")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

这段代码定义了要包含在 tar 存档中的文件列表和存档的名称。它使用 tarfile.open() 以写入模式（‘w’）打开 tar 存档。然后，它迭代要存档的文件，并使用 add() 方法将每个文件添加到存档中。要从 tar 存档中提取文件，它使用 tarfile.open() 以读取模式（‘r’）打开存档，并使用 extractall() 方法提取所有文件。最后，它打印出成功创建 tar 存档和从存档中提取文件的消息。

27. 使用 Selenium 自动化网页截图捕获

Selenium 是一个强大的自动化 web 浏览器的工具。你可以使用 Selenium 来编程方式捕获网页的截图。

示例：捕获网页的截图

假设你想捕获一个特定网页的截图。下面是使用 Selenium 自动化此任务的方法：

from selenium import webdriver  
  
# 要捕获截图的网页的 URL  
url = 'https://www.example.com'  
  
# 创建 Chrome 驱动程序的新实例  
driver = webdriver.Chrome()  
  
# 导航到网页  
driver.get(url)  
  
# 捕获截图  
driver.save_screenshot('screenshot.png')  
  
# 关闭浏览器  
driver.quit()  
  
print("截图捕获成功。")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

这段代码使用 Selenium 自动化了捕获网页截图的过程。它使用 webdriver.Chrome() 创建了 Chrome 驱动程序的新实例。然后，它使用 get() 方法导航到指定的 URL。save_screenshot() 方法用于捕获当前网页的截图，并将其保存为 ‘screenshot.png’。最后，它使用 quit() 方法关闭浏览器，并打印出成功捕获截图的消息。

28. 使用 hashlib 自动化文件哈希计算

Python 的 hashlib 模块提供了生成文件的加密哈希的函数。你可以自动化计算文件的哈希以确保其完整性。

示例：计算文件的 SHA-256 哈希

假设你想计算文件的 SHA-256 哈希。下面是使用 hashlib 模块自动化此任务的方法：

import hashlib  
  
# 要计算哈希的文件  
file_path = 'path/to/file'  
  
# 创建 SHA-256 哈希对象  
sha256_hash = hashlib.sha256()  
  
# 打开文件并读取其内容  
with open(file_path, 'rb') as file:  
    for chunk in iter(lambda: file.read(4096), b''):  
        sha256_hash.update(chunk)  
  
# 获取哈希的十六进制表示  
hash_hex = sha256_hash.hexdigest()  
  
print(f"文件的 SHA-256 哈希：{hash_hex}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这段代码定义了要计算哈希的文件的路径。它使用 hashlib.sha256() 创建了一个 SHA-256 哈希对象。然后，它使用 open() 以二进制读取模式（‘rb’）打开文件。使用 iter() 和 read() 以 4096 字节的块读取文件。每个块都传递给哈希对象的 update() 方法来更新哈希计算。最后，它使用 hexdigest() 方法获取计算的哈希的十六进制表示，并打印出来。

29. 使用 filecmp 自动化文件比较

Python 的 filecmp 模块提供了用于比较文件和目录的函数。你可以自动化比较文件以检查它们是否相同或不同的过程。

示例：比较两个文件

假设你想比较两个文件以检查它们是否相同。下面是使用 filecmp 模块自动化此任务的方法：

import filecmp  
  
# 要比较的文件  
file1 = 'path/to/file1'  
file2 = 'path/to/file2'  
  
# 比较文件  
if filecmp.cmp(file1, file2):  
    print("文件相同。")  
else:  
    print("文件不同。")

1
2
3
4
5
6
7
8
9
10
11
12
13

这段代码定义了要比较的两个文件的路径。它使用 filecmp.cmp() 函数比较两个文件的内容。如果文件相同，则打印一条消息指示文件相同。否则，打印一条消息指示文件不同。

30. 使用 os 自动化修改文件权限

Python 的 os 模块提供了修改文件权限的函数。你可以使用 os.chmod() 函数自动化修改文件权限的过程。

示例：更改文件权限

假设你想将文件的权限更改为使其对所有者可读、可写和可执行。下面是使用 os 模块自动化此任务的方法：

import os  
  
# 要修改权限的文件  
file_path = 'path/to/file'  
  
# 设置文件权限  
os.chmod(file_path, 0o755)  
  
print("文件权限修改成功。")

1
2
3
4
5
6
7
8
9
10
11

这段代码定义了要修改权限的文件的路径。它使用 os.chmod() 函数更改文件权限。0o755 参数表示所需权限的八进制表示。在这种情况下，它使文件对所有者可读、可写和可执行，并对其他用户可读和可执行。最后，它打印一条消息指示文件权限已成功修改。

总结

今天主要介绍了 Python对文件的一些操作，包括压缩文件、加密文件、文件之间的比较等。