python中pickle库用法举例详解

目录

• pickle库
• 1. 导入 pickle 模块
• 2. 序列化（pickle.dump() 和 pickle.dumps()）
• 2.1 pickle.dumps()
• 2.2 pickle.dump()
• 3. 反序列化（pickle.load() 和 pickle.loads()）
• 3.1 pickle.loads()
• 3.2 pickle.load()
• 4. 支持的对象类型
• 5. 不支持的对象类型
• 6. 协议版本
• 7. 安全性问题
• 8. 与 json 模块的比较
• 9. 示例：序列化和反序列化自定义类实例
• 序列化
• 1. 数据持久化
• 2. 数据传输
• 3. 数据共享与协作
• 4. 缓存和优化
• 总结

pickle库

pickle 是 python 标准库中的一个模块，它可以将 Python 对象（如列表、字典、类实例等）转换为字节流，这个过程称为“序列化”；反之，也可以将字节流转换回 Python 对象，这个过程称为“反序列化”。：

1. 导入 pickle 模块

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

import pickle

2. 序列化（pickle.dump() 和 javascript;pickle.dumps()）

2.1 pickle.dumps()

pickle.dumps() 函数用于将 Python 对象序列化为字节流，返回一个字节对象。

import pickle

data = {'name': 'Alice', 'age': 25}
# 序列化对象
serialized_data = pickle.dumps(data)
print(type(serialized_data))  # <class 'bytes'>
print(serialized_data)

2.2 pickle.dump()

pickle.dump() 函数用于将 Python 对象序列化并直接写入文件对象。

import pickle

data = [1, 2, 3, 4, 5]
# 打开一个文件以二进制写入模式
with open('data.pickle', 'wb') asphp file:
    # 将对象序列化并写入文件
    pickle.dump(data, file)

3. 反序列化（pickle.load() 和 pickle.loads()）

3.1 pickle.loads()

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

import pickle

data = {'name': 'Bob', 'age': 30}
serialized_data = pickle.dumps(data)
# 反序列化字节流
deserialized_data = pickle.loads(serialized_data)
print(deserialized_data)  # {'name': 'Bob', 'age': 30}

3.2 pickle.load()

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

import pickle

# 打开一个文件以二进制读取模式
with open('data.pickle', 'rb') as file:
    # 从文件中读取并反序列化对象
    loaded_data = pickle.load(file)
 编程客栈   print(loaded_data)  # [1, 2, 3, 4, 5]

4. 支持的对象类型

pickle 可以处理大多数 Python 内置对象类型，包括：

• 布尔值、整数、浮点数、复数等基本数据类型。
• 字符串、字节、字节数组。
• 列表、元组、集合、字典等容器类型。
• 函数（仅限于全局作用域内定义的函数）。
• 类（仅限于全局作用域内定义的类）和类实例。

5. 不支持的对象类型

• 生成器、迭代器、文件对象等。
• 部分内置对象（如 open() 返回的文件对象、sockets 对象等）。

6. 协议版本

pickle 支持多个协议版本，不同的协议版本在性能和兼容性上有所不同。可以通过 pickle.HIGHEST_PROTOCOL 获取当前 Python 版本支持的最高协议版本，也可以在 dump() 和 dumps() 函数中指定协议版本。

import pickle

data = {'key': 'value'}
# 使用最高协议版本进行序列化
serialized_data = pickle.dumps(data, protocol=pickle.HIGHEST_PROTOCOL)

7. 安全性问题

pickle 反序列化操作存在安全风险，因为它可以执行任意代码。如果从不可信的源接收 pickle 数据，可能会导致代码注入攻击。因此，在反序列化数据时，要确保数据来源是可信的。

8. 与 json 模块的比较

• 数据格式：pickle 序列化后的数据是二进制格式，而 json 序列化后的数据是文本格式。
• 支持的对象类型：pickle 可以处理更广泛的 Python 对象类型，而 json 只能处理基本数据类型和部分容器类型。
• 安全性：json 反序列化相对安全，因为它只能处理纯数据，而 pickle 反序列化存在安全风险。

9. 示例：序列化和反序列化自定义类实例

import pickle

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

    def __str__(self):
        return f"Person(name={self.name}, age={self.age})"

# 创建一个 Person 类的实例
person = Person('Charlie', 35)

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

# 反序列化实例
deserialized_person = pickle.loads(serialized_person)
print(deserialized_person)  # Person(name=Charliandroide, age=35)

序列化

序列化是将对象的状态信息转换为可以存储或传输的形式（如字节序列、文本等）的过程。在不同的应用场景中，序列化发挥着重要的作用，以下从几个方面详细介绍序列化的作用：

1. 数据持久化

• 存储对象到磁盘：在许多应用程序中，需要将程序运行过程中的对象保存到磁盘上，以便在程序下次启动时能够恢复这些对象的状态。例如，一个游戏程序可能需要保存玩家的游戏进度，包括玩家的角色信息、关卡进度、道具列表等。通过序列化，可以将这些对象转换为字节流，然后存储到文件中。下次游戏启动时，再从文件中读取字节流并反序列化，恢复玩家的游戏进度。

import pickle

class Player:
    def __init__(self, name, level):
        self.name = name
        self.level = level

# 创建一个玩家对象
player = Player("Alice", 10)

# 将玩家对象序列化并保存到文件
with open('player_data.pickle', 'wb') as file:
    pickle.dump(player, file)

# 下次启动程序时，从文件中读取并反序列化对象
with open('player_data.pickle', 'rb') as file:
    loaded_player = pickle.load(file)
    print(f"Player name: {loaded_player.name}, Level: {loaded_player.level}")

• 数据库存储：在数据库中存储复杂的对象时，序列化也非常有用。有些数据库（如 NoSQL 数据库）可以直接存储二进制数据，通过将对象序列化后存储到数据库中，可以方便地保存和检索对象信息。

2. 数据传输

• 网络通信：在网络编程中，不同的计算机或进程之间需要进行数据交换。由于网络传输的数据必须是二进制形式，因此需要将对象序列化为字节流后才能在网络上传输。例如，在客户端 - 服务器架构中，客户端可能需要将用户的请求对象（如登录请求、查询请求等）序列化后发送给服务器，服务器接收到字节流后再进行反序列化，解析出请求信息并进行相应的处理。常见的网络协议如 HTTP、TCP 等都可以传输序列化后的数据。

import socket
import pickle

# 服务器端
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('localhost', 8888))
server_socket.listen(1)

print("Waiting for a connection...")
conn, addr = server_socket.accept()
print(f"Connected by {addr}")

# 接收序列化的数据
data = conn.recv(1024)
# 反序列化数据
received_object = pickle.loads(data)
print(f"Received object: {received_object}")

conn.close()

# 客户端
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect(('localhost', 8888))

# 要发送的对象
data_to_send = {'message': 'Hello, server!'}
# 序列化对象
serialized_data = pickle.dumps(data_to_send)
# 发送序列化的数据
client_socket.sendall(serialized_dandroidata)

client_socket.close()

• 进程间通信（IPC）：在多进程编程中，不同的进程之间需要进行数据交换。序列化可以将对象转换为可以在进程间传输的格式，从而实现进程间的通信。例如，在 Python 的 multiprocessing 模块中，进程之间可以通过管道（Pipe）、队列（Queue）等方式进行通信，这些通信机制内部会使用序列化和反序列化来处理对象的传输。

3. 数据共享与协作

• 分布式系统：在分布式系统中，不同的节点（计算机或服务器）之间需要共享数据和协同工作。序列化可以将对象在不同节点之间进行传输和共享，使得各个节点能够处理和操作相同的数据。例如，在一个分布式计算系统中，主节点可以将任务对象序列化后分发给各个工作节点，工作节点接收到任务对象后进行反序列化，然后执行相应的任务。
• 跨语言交互：在一些跨语言的应用场景中，不同的编程语言可能需要共享数据。通过选择一种通用的序列化格式（如 JSON、XML 等），可以实现不同语言之间的数据交互。例如，一个 Python 程序可以将数据序列化为 JSON 格式，然后将 JSON 数据发送给一个 Java 程序，Java 程序再将 JSON 数据反序列化后进行处理。

4. 缓存和优化

• 缓存机制：在一些应用程序中，为了提高性能，会使用缓存来存储经常使用的数据。通过将对象序列化后存储在缓存中，可以减少对象的创建和初始化时间。当需要使用这些数据时，直接从缓存中读取并反序列化，避免了重复计算和数据库查询。例如，在 Web 应用程序中，可以使用缓存（如 Redis）来存储用户的会话信息，将用户会话对象序列化后存储在 Redis 中，下次用户访问时直接从 Redis 中读取并反序列化，提高响应速度。
• 数据压缩：序列化过程中可以对数据进行压缩，减少数据的存储空间和传输带宽。例如，一些序列化库（如 Protocol Buffers）支持数据压缩功能，通过将对象序列化并压缩后存储或传输，可以节省大量的资源。

综上所述，序列化在数据持久化、传输、共享和缓存等方面都有着重要的作用，是现代软件开发中不可或缺的技术之一。

总结

到此这篇关于python中pickle库用法的文章就介绍到这了,更多相关python pickle库内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！