Python Pickle 模块的基本使用(42)

Android 小码峰啊

于 2025-06-19 07:00:00 发布

阅读量982

点赞数 8

CC 4.0 BY-SA版权

分类专栏： Python入门文章标签： python 开发语言

本文链接：https://blog.csdn.net/qq_19641309/article/details/148645051

Python入门专栏收录该内容

43 篇文章

订阅专栏

Python Pickle 模块的基本使用

一、引言

在 Python 编程里，数据的持久化与交换是极为常见的需求。当我们需要把程序中的数据保存到文件里，以便后续使用，或者在不同程序间传递数据时，就需要一种有效的数据序列化与反序列化机制。Python 的 pickle 模块正是为此而生，它能将 Python 对象转化为字节流，也就是序列化，还能把字节流还原成 Python 对象，即反序列化。这一特性使得我们能够方便地保存和恢复 Python 对象的状态。

本文会详细介绍 pickle 模块的基本使用，涵盖序列化与反序列化的基础操作、处理不同类型对象、与文件交互、安全性考量等内容。每个步骤都会配有带详细注释的源码示例，助力你全面掌握 pickle 模块的使用方法。

二、Pickle 模块概述

2.1 什么是 Pickle

pickle 是 Python 标准库中的一个模块，其主要功能是实现 Python 对象的序列化和反序列化。序列化指的是把 Python 对象转换为字节流的过程，而反序列化则是将字节流还原为 Python 对象的过程。借助 pickle 模块，我们能够把复杂的 Python 对象（像列表、字典、类实例等）保存到文件或者在网络中传输。

2.2 为什么使用 Pickle

数据持久化：可以把程序运行时的对象状态保存到文件中，下次运行程序时再恢复这些对象。
数据交换：在不同的 Python 程序之间方便地传递对象。
对象状态保存：对于一些复杂的对象，如机器学习模型，可使用 pickle 保存其训练好的状态。

2.3 Pickle 的局限性

安全性问题：pickle 反序列化时可能执行任意代码，存在安全风险，因此不要对不可信来源的数据进行反序列化操作。
兼容性问题：不同版本的 Python 可能在 pickle 格式上存在差异，可能导致反序列化失败。
只能用于 Python：pickle 是 Python 特有的序列化机制，无法与其他编程语言直接兼容。

三、基本的序列化和反序列化

3.1 导入 Pickle 模块

在使用 pickle 模块之前，需要先导入它。

import pickle  # 导入 pickle 模块，用于对象的序列化和反序列化

3.2 序列化对象

使用 pickle.dumps() 函数可以将 Python 对象序列化为字节流。

import pickle

# 定义一个 Python 对象，这里是一个字典
data = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 使用 pickle.dumps() 函数将对象序列化为字节流
serialized_data = pickle.dumps(data)
print(serialized_data)  # 打印序列化后的字节流

在上述代码中，我们先定义了一个字典 data，然后使用 pickle.dumps() 函数将其转换为字节流，并将结果存储在 serialized_data 变量中，最后打印该字节流。

3.3 反序列化对象

使用 pickle.loads() 函数可以将字节流反序列化为 Python 对象。

import pickle

# 定义一个字节流，这里是之前序列化得到的字节流
serialized_data = b'\x80\x04\x95\x1d\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x04name\x94\x8c\x05Alice\x94\x8c\x03age\x94K\x19\x8c\x04city\x94\x8c\x08New York\x94u.'

# 使用 pickle.loads() 函数将字节流反序列化为 Python 对象
deserialized_data = pickle.loads(serialized_data)
print(deserialized_data)  # 打印反序列化后的对象

在这段代码中，我们使用 pickle.loads() 函数将之前序列化得到的字节流还原为 Python 对象，并将结果存储在 deserialized_data 变量中，最后打印该对象。

四、处理不同类型的对象

4.1 处理基本数据类型

pickle 可以对 Python 的基本数据类型（如整数、浮点数、字符串、列表、字典等）进行序列化和反序列化。

import pickle

# 定义不同类型的基本数据
integer_data = 42  # 整数
float_data = 3.14  # 浮点数
string_data = "Hello, World!"  # 字符串
list_data = [1, 2, 3, 4, 5]  # 列表
dict_data = {'a': 1, 'b': 2, 'c': 3}  # 字典

# 序列化基本数据
serialized_integer = pickle.dumps(integer_data)
serialized_float = pickle.dumps(float_data)
serialized_string = pickle.dumps(string_data)
serialized_list = pickle.dumps(list_data)
serialized_dict = pickle.dumps(dict_data)

# 反序列化基本数据
deserialized_integer = pickle.loads(serialized_integer)
deserialized_float = pickle.loads(serialized_float)
deserialized_string = pickle.loads(serialized_string)
deserialized_list = pickle.loads(serialized_list)
deserialized_dict = pickle.loads(serialized_dict)

# 打印反序列化后的对象
print(deserialized_integer)
print(deserialized_float)
print(deserialized_string)
print(deserialized_list)
print(deserialized_dict)

在上述代码中，我们定义了不同类型的基本数据，然后分别对它们进行序列化和反序列化操作，最后打印反序列化后的对象。

4.2 处理自定义类的实例

pickle 也能处理自定义类的实例，但需要确保类的定义在反序列化时是可用的。

import pickle

# 定义一个自定义类
class Person:
    def __init__(self, name, age):
        self.name = name  # 初始化姓名属性
        self.age = age  # 初始化年龄属性

    def introduce(self):
        print(f"My name is {self.name} and I am {self.age} years old.")  # 定义介绍方法

# 创建一个 Person 类的实例
person = Person("Bob", 30)

# 序列化 Person 类的实例
serialized_person = pickle.dumps(person)

# 反序列化 Person 类的实例
deserialized_person = pickle.loads(serialized_person)

# 调用反序列化后的对象的方法
deserialized_person.introduce()

在这段代码中，我们定义了一个 Person 类，创建了该类的一个实例 person，然后对其进行序列化和反序列化操作，最后调用反序列化后的对象的 introduce() 方法。

4.3 处理嵌套对象

pickle 能够递归地处理嵌套对象，如包含列表、字典的对象。

import pickle

# 定义一个嵌套对象
nested_data = {
    'list': [1, 2, {'a': 'apple', 'b': 'banana'}],
    'dict': {'key1': [10, 20], 'key2': {'nested_key': 'value'}}
}

# 序列化嵌套对象
serialized_nested_data = pickle.dumps(nested_data)

# 反序列化嵌套对象
deserialized_nested_data = pickle.loads(serialized_nested_data)

# 打印反序列化后的对象
print(deserialized_nested_data)

在上述代码中，我们定义了一个包含列表和字典的嵌套对象 nested_data，对其进行序列化和反序列化操作，最后打印反序列化后的对象。

五、与文件交互

5.1 将对象保存到文件

使用 pickle.dump() 函数可以将 Python 对象直接保存到文件中。

import pickle

# 定义一个 Python 对象，这里是一个列表
data = [1, 2, 3, 4, 5]

# 打开一个文件以二进制写入模式
with open('data.pickle', 'wb') as file:
    # 使用 pickle.dump() 函数将对象保存到文件中
    pickle.dump(data, file)

在这段代码中，我们定义了一个列表 data，然后使用 pickle.dump() 函数将其保存到 data.pickle 文件中。

5.2 从文件中加载对象

使用 pickle.load() 函数可以从文件中读取字节流并反序列化为 Python 对象。

import pickle

# 打开一个文件以二进制读取模式
with open('data.pickle', 'rb') as file:
    # 使用 pickle.load() 函数从文件中加载对象
    loaded_data = pickle.load(file)

# 打印加载后的对象
print(loaded_data)

在上述代码中，我们使用 pickle.load() 函数从 data.pickle 文件中读取字节流并反序列化为 Python 对象，最后打印该对象。

六、Pickle 的协议

6.1 什么是 Pickle 协议

pickle 协议是指 pickle 模块在序列化对象时所采用的格式和规则。不同的协议版本在序列化速度、兼容性和文件大小等方面存在差异。

6.2 协议版本

Python 的 pickle 模块支持多个协议版本，从 0 到 5。较新的协议版本通常具有更高的性能和更多的特性，但可能在旧版本的 Python 中不兼容。

6.3 指定协议版本

在使用 pickle.dumps() 或 pickle.dump() 函数时，可以通过 protocol 参数指定协议版本。

import pickle

data = {'name': 'Charlie', 'age': 35}

# 使用协议版本 4 进行序列化
serialized_data = pickle.dumps(data, protocol=4)

# 打印序列化后的字节流
print(serialized_data)

在这段代码中，我们使用 pickle.dumps() 函数并指定 protocol=4 来对 data 字典进行序列化。

七、Pickle 的安全性考量

7.1 安全风险

pickle 反序列化时可能执行任意代码，这是因为 pickle 会在反序列化过程中调用对象的 __reduce__() 方法，攻击者可以构造恶意的字节流来执行危险代码。

7.2 安全建议

仅对可信来源的数据进行反序列化：不要对来自不可信源的字节流进行反序列化操作。
使用其他安全的序列化方式：如果需要处理不可信数据，可以考虑使用其他安全的序列化方式，如 JSON。

以下是一个简单的示例，展示恶意代码在反序列化时可能带来的风险：

import pickle

# 定义一个恶意类
class MaliciousClass:
    def __reduce__(self):
        import os
        # 执行危险命令，这里以删除文件为例
        return (os.system, ('rm -rf important_file.txt',))

# 创建恶意类的实例
malicious_obj = MaliciousClass()

# 序列化恶意对象
serialized_malicious = pickle.dumps(malicious_obj)

# 反序列化恶意对象（请勿在实际环境中运行此代码）
# pickle.loads(serialized_malicious)

在上述代码中，我们定义了一个 MaliciousClass 类，其 __reduce__() 方法会执行一个危险的系统命令。如果对该类的实例进行反序列化，就会执行这个危险命令。因此，要避免对不可信数据进行反序列化。

八、总结与展望

8.1 总结

Python 的 pickle 模块为我们提供了一种方便的方式来实现 Python 对象的序列化和反序列化。它可以处理各种类型的 Python 对象，包括基本数据类型、自定义类的实例和嵌套对象。通过 pickle.dump() 和 pickle.load() 函数，我们可以将对象保存到文件中并在需要时恢复。同时，pickle 支持不同的协议版本，允许我们根据需求选择合适的协议。

然而，pickle 也存在一些局限性，如安全性问题和兼容性问题。在使用 pickle 时，需要特别注意只对可信来源的数据进行反序列化操作，以避免潜在的安全风险。

8.2 展望

随着 Python 在各个领域的广泛应用，对数据序列化和反序列化的需求也会不断增加。未来，pickle 模块可能会进一步优化，提高序列化和反序列化的性能，同时加强安全性。此外，可能会有更多的工具和库与 pickle 集成，提供更便捷的序列化解决方案。对于开发者来说，需要在使用 pickle 时权衡其优缺点，根据具体场景选择合适的序列化方式。同时，随着 Python 生态系统的发展，可能会出现更多安全、高效的序列化机制。