32、Python 字典、集合与对象序列化全解析

Python 字典、集合与对象序列化全解析

1. 集合元素存在性判断及集合运算

1.1 集合元素存在性判断

在 Python 中，要判断一个特定元素是否存在于集合中，可使用 in 操作符。例如：

my_set = {1, 2, 3, 4}
element = 3
if element in my_set:
    print(f"{element} 存在于集合中")
else:
    print(f"{element} 不存在于集合中")

1.2 集合运算示例

以下是一些常见集合运算的代码示例及结果分析：

1.2.1 并集运算

set1 = set([10, 20, 30])
set2 = set([100, 200, 300])
set3 = set1.union(set2)
print(set3)  # 输出: {10, 20, 30, 100, 200, 300}

1.2.2 交集运算

set1 = set([1, 2, 3, 4])
set2 = set([3, 4, 5, 6])
set3 = set1.intersection(set2)
print(set3)  # 输出: {3, 4}

1.2.3 差集运算

set1 = set([1, 2, 3, 4])
set2 = set([3, 4, 5, 6])
set3 = set1.difference(set2)
print(set3)  # 输出: {1, 2}

1.2.4 对称差集运算

set1 = set(['a', 'b', 'c'])
set2 = set(['b', 'c', 'd'])
set3 = set1.symmetric_difference(set2)
print(set3)  # 输出: {'a', 'd'}

1.3 子集与超集判断

set1 = set([1, 2, 3, 4])
set2 = set([2, 3])
if set2.issubset(set1):
    print("set2 是 set1 的子集")
if set1.issuperset(set2):
    print("set1 是 set2 的超集")

1.4 集合运算总结表格

运算类型	操作符	方法	描述
并集	\|	union()	返回包含两个集合所有元素的新集合
交集	&	intersection()	返回两个集合共同元素的新集合
差集	-	difference()	返回只存在于第一个集合的元素组成的新集合
对称差集	^	symmetric_difference()	返回只存在于一个集合中的元素组成的新集合

1.5 集合运算流程图

graph LR
    A[集合 A] --> B(并集)
    C[集合 B] --> B
    B --> D{结果集合}
    A --> E(交集)
    C --> E
    E --> D
    A --> F(差集 A - B)
    C --> F
    F --> D
    A --> G(对称差集)
    C --> G
    G --> D

2. 对象序列化（Pickling）

2.1 什么是对象序列化

对象序列化是将对象转换为字节流的过程，这样可以将对象保存到文件中，以便后续检索。在 Python 中，对象序列化也称为“pickling”。Python 标准库提供了 pickle 模块来实现对象的序列化和反序列化。

2.2 对象序列化步骤

2.2.1 序列化对象

要序列化对象，需要执行以下步骤：
1. 导入 pickle 模块。
2. 以二进制写入模式（ 'wb' ）打开文件。
3. 调用 pickle.dump() 方法将对象写入文件。
4. 关闭文件。

以下是一个简单的示例，将字典对象序列化到文件中：

import pickle
phonebook = {'Chris': '555−1111', 'Katie': '555−2222', 'Joanne': '555−3333'}
output_file = open('phonebook.dat', 'wb')
pickle.dump(phonebook, output_file)
output_file.close()

2.2.2 反序列化对象

要从文件中检索并反序列化对象，需要执行以下步骤：
1. 导入 pickle 模块。
2. 以二进制读取模式（ 'rb' ）打开文件。
3. 调用 pickle.load() 方法从文件中读取并反序列化对象。
4. 关闭文件。

以下是一个简单的示例，从文件中反序列化字典对象：

import pickle
input_file = open('phonebook.dat', 'rb')
pb = pickle.load(input_file)
print(pb)
input_file.close()

2.3 完整示例代码

2.3.1 序列化示例代码

# This program demonstrates object pickling.
import pickle

# main function
def main():
    again = 'y'  # To control loop repetition
    # Open a file for binary writing.
    output_file = open('info.dat', 'wb')
    # Get data until the user wants to stop.
    while again.lower() == 'y':
        # Get data about a person and save it.
        save_data(output_file)
        # Does the user want to enter more data?
        again = input('Enter more data? (y/n): ')
    # Close the file.
    output_file.close()

# The save_data function gets data about a person,
# stores it in a dictionary, and then pickles the
# dictionary to the specified file.
def save_data(file):
    # Create an empty dictionary.
    person = {}
    # Get data for a person and store
    # it in the dictionary.
    person['name'] = input('Name: ')
    person['age'] = int(input('Age: '))
    person['weight'] = float(input('Weight: '))
    # Pickle the dictionary.
    pickle.dump(person, file)

# Call the main function.
main()

2.3.2 反序列化示例代码

# This program demonstrates object unpickling.
import pickle

# main function
def main():
    end_of_file = False  # To indicate end of file
    # Open a file for binary reading.
    input_file = open('info.dat', 'rb')
    # Read to the end of the file.
    while not end_of_file:
        try:
            # Unpickle the next object.
            person = pickle.load(input_file)
            # Display the object.
            display_data(person)
        except EOFError:
            # Set the flag to indicate the end
            # of the file has been reached.
            end_of_file = True
    # Close the file.
    input_file.close()

# The display_data function displays the person data
# in the dictionary that is passed as an argument.
def display_data(person):
    print('Name:', person['name'])
    print('Age:', person['age'])
    print('Weight:', person['weight'])
    print()

# Call the main function.
main()

2.4 对象序列化流程图

graph LR
    A[对象] --> B(导入 pickle 模块)
    B --> C(以 'wb' 模式打开文件)
    C --> D(pickle.dump(对象, 文件))
    D --> E(关闭文件)
    E --> F(保存到文件)
    G(文件) --> H(导入 pickle 模块)
    H --> I(以 'rb' 模式打开文件)
    I --> J(pickle.load(文件))
    J --> K(关闭文件)
    K --> L(恢复对象)

2.5 对象序列化步骤总结表格

操作类型	步骤	代码示例
序列化	1. 导入 pickle 模块 2. 以 'wb' 模式打开文件 3. 调用 pickle.dump() 方法 4. 关闭文件	python<br>import pickle<br>output_file = open('data.dat', 'wb')<br>pickle.dump(obj, output_file)<br>output_file.close()<br>
反序列化	1. 导入 pickle 模块 2. 以 'rb' 模式打开文件 3. 调用 pickle.load() 方法 4. 关闭文件	python<br>import pickle<br>input_file = open('data.dat', 'rb')<br>obj = pickle.load(input_file)<br>input_file.close()<br>

3. 字典与集合操作的复习与拓展

3.1 字典操作复习

3.1.1 字典基本操作总结

操作	描述	示例代码
判断键是否存在	使用 in 操作符	python<br>dct = {'a': 1, 'b': 2}<br>if 'a' in dct:<br> print('键 a 存在')<br>
删除元素	使用 del 语句	python<br>dct = {'a': 1, 'b': 2}<br>del dct['a']<br>print(dct)<br>
获取元素数量	使用 len() 函数	python<br>dct = {'a': 1, 'b': 2}<br>print(len(dct))<br>
创建空字典	使用 {}	python<br>dct = {}<br>
随机弹出键值对	使用 popitem() 方法	python<br>dct = {'a': 1, 'b': 2}<br>item = dct.popitem()<br>print(item)<br>
弹出指定键值对	使用 pop() 方法	python<br>dct = {'a': 1, 'b': 2}<br>value = dct.pop('a')<br>print(value)<br>
获取指定键的值	使用 get() 方法	python<br>dct = {'a': 1, 'b': 2}<br>value = dct.get('a', 'Not found')<br>print(value)<br>
获取所有键值对	使用 items() 方法	python<br>dct = {'a': 1, 'b': 2}<br>items = dct.items()<br>print(items)<br>

3.1.2 字典操作流程图

graph LR
    A[字典] --> B{判断键是否存在}
    B -- 存在 --> C(获取值)
    B -- 不存在 --> D(处理不存在情况)
    A --> E(删除元素)
    A --> F(获取元素数量)
    A --> G(创建空字典)
    A --> H(随机弹出键值对)
    A --> I(弹出指定键值对)
    A --> J(获取指定键的值)
    A --> K(获取所有键值对)

3.2 集合操作复习

3.2.1 集合基本操作总结

操作	描述	示例代码
创建集合	使用 set() 函数	python<br>myset = set([1, 2, 3])<br>
添加单个元素	使用 add() 方法	python<br>myset = set([1, 2, 3])<br>myset.add(4)<br>print(myset)<br>
添加多个元素	使用 update() 方法	python<br>myset = set([1, 2, 3])<br>myset.update([4, 5])<br>print(myset)<br>
删除元素（不报错）	使用 discard() 方法	python<br>myset = set([1, 2, 3])<br>myset.discard(2)<br>print(myset)<br>
删除元素（报错）	使用 remove() 方法	python<br>myset = set([1, 2, 3])<br>myset.remove(2)<br>print(myset)<br>

3.2.2 集合操作流程图

graph LR
    A[集合] --> B(创建集合)
    B --> C(添加单个元素)
    B --> D(添加多个元素)
    B --> E(删除元素（不报错）)
    B --> F(删除元素（报错）)
    B --> G(集合运算)
    G --> H(并集)
    G --> I(交集)
    G --> J(差集)
    G --> K(对称差集)

4. 综合示例与应用

4.1 字典与集合综合应用示例

以下是一个综合应用字典和集合的示例，实现一个简单的联系人管理系统：

# 初始化联系人字典
contacts = {}

# 添加联系人函数
def add_contact():
    name = input("请输入联系人姓名: ")
    phone = input("请输入联系人电话: ")
    contacts[name] = phone
    print(f"联系人 {name} 已添加。")

# 删除联系人函数
def delete_contact():
    name = input("请输入要删除的联系人姓名: ")
    if name in contacts:
        del contacts[name]
        print(f"联系人 {name} 已删除。")
    else:
        print(f"联系人 {name} 不存在。")

# 显示所有联系人函数
def show_contacts():
    if not contacts:
        print("联系人列表为空。")
    else:
        for name, phone in contacts.items():
            print(f"{name}: {phone}")

# 主程序
while True:
    print("\n联系人管理系统")
    print("1. 添加联系人")
    print("2. 删除联系人")
    print("3. 显示所有联系人")
    print("4. 退出")
    choice = input("请输入你的选择: ")
    if choice == '1':
        add_contact()
    elif choice == '2':
        delete_contact()
    elif choice == '3':
        show_contacts()
    elif choice == '4':
        break
    else:
        print("无效的选择，请重新输入。")

4.2 联系人管理系统流程图

graph LR
    A[开始] --> B{选择操作}
    B -- 1. 添加联系人 --> C(添加联系人函数)
    B -- 2. 删除联系人 --> D(删除联系人函数)
    B -- 3. 显示所有联系人 --> E(显示所有联系人函数)
    B -- 4. 退出 --> F[结束]
    C --> B
    D --> B
    E --> B

4.3 总结

通过本文，我们详细介绍了 Python 中字典、集合的基本操作，以及对象序列化的方法。字典和集合是 Python 中非常重要的数据结构，它们在数据处理、存储和检索方面有着广泛的应用。对象序列化则为我们提供了一种将复杂对象保存到文件并在需要时恢复的有效方式。希望本文能帮助你更好地理解和运用这些知识，在实际项目中发挥它们的优势。