• Python魔法之旅-魔法方法(08)

    目录

    一、概述

    1、定义

    2、作用

    二、应用场景

    1、构造和析构

    2、操作符重载

    3、字符串和表示

    4、容器管理

    5、可调用对象

    6、上下文管理

    7、属性访问和描述符

    8、迭代器和生成器

    9、数值类型

    10、复制和序列化

    11、自定义元类行为

    12、自定义类行为

    13、类型检查和转换

    14、自定义异常

    三、学习方法

    1、理解基础

    2、查阅文档

    3、编写示例

    4、实践应用

    5、阅读他人代码

    6、参加社区讨论

    7、持续学习

    8、练习与总结

    9、注意兼容性

    10、避免过度使用

    四、魔法方法

    26、__getstate__方法

    26-1、语法

    26-2、参数

    26-3、功能

    26-4、返回值

    26-5、说明

    26-6、用法

    27、__gt__方法

    27-1、语法

    27-2、参数

    27-3、功能

    27-4、返回值

    27-5、说明

    27-6、用法

    28、__setstate__方法

    28-1、语法

    28-2、参数

    28-3、功能

    28-4、返回值

    28-5、说明

    28-6、用法

    五、推荐阅读

    1、Python筑基之旅

    2、Python函数之旅

    3、Python算法之旅

    4、博客个人主页
    ​​​​​​​

    一、概述

    1、定义

            魔法方法(Magic Methods/Special Methods，也称特殊方法或双下划线方法)是Python中一类具有特殊命名规则的方法，它们的名称通常以双下划线(`__`)开头和结尾。

            魔法方法用于在特定情况下自动被Python解释器调用，而不需要显式地调用它们，它们提供了一种机制，让你可以定义自定义类时具有与内置类型相似的行为。

    2、作用

            魔法方法允许开发者重载Python中的一些内置操作或函数的行为，从而为自定义的类添加特殊的功能。

    二、应用场景

    1、构造和析构

    1-1、__init__(self, [args...])：在创建对象时初始化属性。
    1-2、__new__(cls, [args...])：在创建对象时控制实例的创建过程(通常与元类一起使用)。
    1-3、__del__(self)：在对象被销毁前执行清理操作，如关闭文件或释放资源。

    2、操作符重载

    2-1、__add__(self, other)、__sub__(self, other)、__mul__(self, other)等：自定义对象之间的算术运算。
    2-2、__eq__(self, other)、__ne__(self, other)、__lt__(self, other)等：定义对象之间的比较操作。

    3、字符串和表示

    3-1、__str__(self)：定义对象的字符串表示，常用于print()函数。
    3-2、__repr__(self)：定义对象的官方字符串表示，用于repr()函数和交互式解释器。

    4、容器管理

    4-1、__getitem__(self, key)、__setitem__(self, key, value)、__delitem__(self, key)：用于实现类似列表或字典的索引访问、设置和删除操作。
    4-2、__len__(self)：返回对象的长度或元素个数。

    5、可调用对象

    5-1、__call__(self, [args...])：允许对象像函数一样被调用。

    6、上下文管理

    6-1、__enter__(self)、__exit__(self, exc_type, exc_val, exc_tb)：用于实现上下文管理器，如with语句中的对象。

    7、属性访问和描述符

    7-1、__getattr__, __setattr__, __delattr__：这些方法允许对象在访问或修改不存在的属性时执行自定义操作。
    7-2、描述符(Descriptors)是实现了__get__, __set__, 和__delete__方法的对象，它们可以控制对另一个对象属性的访问。

    8、迭代器和生成器

    8-1、__iter__和__next__：这些方法允许对象支持迭代操作，如使用for循环遍历对象。
    8-2、__aiter__, __anext__：这些是异步迭代器的魔法方法，用于支持异步迭代。

    9、数值类型

    9-1、__int__(self)、__float__(self)、__complex__(self)：定义对象到数值类型的转换。
    9-2、__index__(self)：定义对象用于切片时的整数转换。

    10、复制和序列化

    10-1、__copy__和__deepcopy__：允许对象支持浅复制和深复制操作。
    10-2、__getstate__和__setstate__：用于自定义对象的序列化和反序列化过程。

    11、自定义元类行为

    11-1、__metaclass__(Python 2)或元类本身(Python 3)：允许自定义类的创建过程，如动态创建类、修改类的定义等。

    12、自定义类行为

    12-1、__init__和__new__：用于初始化对象或控制对象的创建过程。
    12-2、__init_subclass__：在子类被创建时调用，允许在子类中执行一些额外的操作。

    13、类型检查和转换

    13-1、__instancecheck__和__subclasscheck__：用于自定义isinstance()和issubclass()函数的行为。

    14、自定义异常

    14-1、你可以通过继承内置的Exception类来创建自定义的异常类，并定义其特定的行为。

    三、学习方法

            要学好Python的魔法方法，你可以遵循以下方法及步骤：

    1、理解基础

            首先确保你对Python的基本语法、数据类型、类和对象等概念有深入的理解，这些是理解魔法方法的基础。

    2、查阅文档

            仔细阅读Python官方文档中关于魔法方法的部分，文档会详细解释每个魔法方法的作用、参数和返回值。你可以通过访问Python的官方网站或使用help()函数在Python解释器中查看文档。

    3、编写示例

            为每个魔法方法编写简单的示例代码，以便更好地理解其用法和效果，通过实际编写和运行代码，你可以更直观地感受到魔法方法如何改变对象的行为。

    4、实践应用

            在实际项目中尝试使用魔法方法。如，你可以创建一个自定义的集合类，使用__getitem__、__setitem__和__delitem__方法来实现索引操作。只有通过实践应用，你才能更深入地理解魔法方法的用途和重要性。

    5、阅读他人代码

            阅读开源项目或他人编写的代码，特别是那些使用了魔法方法的代码，这可以帮助你学习如何在实际项目中使用魔法方法。通过分析他人代码中的魔法方法使用方式，你可以学习到一些新的技巧和最佳实践。

    6、参加社区讨论

            参与Python社区的讨论，与其他开发者交流关于魔法方法的使用经验和技巧，在社区中提问或回答关于魔法方法的问题，这可以帮助你更深入地理解魔法方法并发现新的应用场景。

    7、持续学习

            Python语言和其生态系统不断发展，新的魔法方法和功能可能会不断被引入，保持对Python社区的关注，及时学习新的魔法方法和最佳实践。

    8、练习与总结

            多做练习，通过编写各种使用魔法方法的代码来巩固你的理解，定期总结你学到的知识和经验，形成自己的知识体系。

    9、注意兼容性

            在使用魔法方法时，要注意不同Python版本之间的兼容性差异，确保你的代码在不同版本的Python中都能正常工作。

    10、避免过度使用

            虽然魔法方法非常强大，但过度使用可能会导致代码难以理解和维护，在编写代码时，要权衡使用魔法方法的利弊，避免滥用。

            总之，学好Python的魔法方法需要不断地学习、实践和总结，只有通过不断地练习和积累经验，你才能更好地掌握这些强大的工具，并在实际项目中灵活运用它们。

    四、魔法方法

    26、__getstate__方法

    26-1、语法
    1. __getstate__(self, /)
    2.     Helper for pickle
    26-2、参数

    26-2-1、self(必须)：一个对实例对象本身的引用，在类的所有方法中都会自动传递。 

    26-2-2、/(可选)：这是从Python 3.8开始引入的参数注解语法，它表示这个方法不接受任何位置参数(positional-only parameters)之后的关键字参数(keyword arguments)。

    26-3、功能

            用于返回对象的状态，这样该对象就可以被pickle模块序列化为字节流，以便之后可以通过pickle.loads()反序列化回原始对象。

    26-4、返回值

            返回一个可以被pickle模块序列化的对象，通常是一个字典，其中包含了重构对象所需的所有状态信息。

    26-5、说明

            如果你的类有动态生成的属性或者使用了__slots__来限制实例属性，那么你可能需要更仔细地编写__getstate__和__setstate__方法来确保所有必要的信息都被正确地序列化和反序列化。

    26-6、用法
    1. # 026、__getstate__方法：
    2. # 1、基本示例
    3. import pickle
    4. class MyClass:
    5.     def __init__(self, x, y):
    6.         self.x = x
    7.         self.y = y
    8.     def __getstate__(self):
    9.         return {'x': self.x, 'y': self.y}
    10.     def __setstate__(self, state):
    11.         self.x = state['x']
    12.         self.y = state['y']
    13. if __name__ == '__main__':
    14.     # 序列化和反序列化
    15.     obj = MyClass(10, 24)
    16.     serialized_obj = pickle.dumps(obj)
    17.     deserialized_obj = pickle.loads(serialized_obj)
    18.     print(deserialized_obj.x, deserialized_obj.y)  # 输出: 10 24
    19.  
    20. # 2、忽略某些属性
    21. class Person:
    22.     def __init__(self, name, age, password):
    23.         self.name = name
    24.         self.age = age
    25.         self._password = password  # 不想在序列化中包含密码
    26.     def __getstate__(self):
    27.         return {'name': self.name, 'age': self.age}
    28.     def __setstate__(self, state):
    29.         self.name = state['name']
    30.         self.age = state['age']
    31.         self._password = None  # 假设在反序列化时重置密码
    32.  
    33. # 3、自定义序列化格式
    34. class Point:
    35.     def __init__(self, x, y):
    36.         self.x = x
    37.         self.y = y
    38.     def __getstate__(self):
    39.         return (self.x, self.y)  # 使用元组而不是字典
    40.     def __setstate__(self, state):
    41.         self.x, self.y = state
    42.  
    43. # 4、处理不可序列化的属性
    44. import socket
    45. class Connection:
    46.     def __init__(self, host, port):
    47.         self.host = host
    48.         self.port = port
    49.         self.socket = socket.socket()  # 不可序列化
    50.     def __getstate__(self):
    51.         # 不包括 socket 对象
    52.         return {'host': self.host, 'port': self.port}
    53.     def __setstate__(self, state):
    54.         self.host = state['host']
    55.         self.port = state['port']
    56.         self.socket = socket.socket()  # 在反序列化时重新创建 socket
    57.  
    58. # 5、序列化和反序列化时执行额外操作
    59. class LoggedClass:
    60.     def __init__(self, data):
    61.         self.data = data
    62.     def __getstate__(self):
    63.         print("Serializing...", self.data)
    64.         return {'data': self.data}
    65.     def __setstate__(self, state):
    66.         print("Deserializing...", state['data'])
    67.         self.data = state['data']
    68.  
    69. # 6、处理集合类型
    70. class SetExample:
    71.     def __init__(self, items):
    72.         self.items = set(items)
    73.     def __getstate__(self):
    74.         return {'items': list(self.items)}  # 将集合转换为列表
    75.     def __setstate__(self, state):
    76.         self.items = set(state['items'])  # 将列表转换回集合
    77.  
    78. # 7、嵌套对象
    79. class Inner:
    80.     def __init__(self, value):
    81.         self.value = value
    82. class Outer:
    83.     def __init__(self, inner):
    84.         self.inner = inner
    85.     def __getstate__(self):
    86.         return {'inner': self.inner.__getstate__()}  # 嵌套对象也需要序列化
    87.     def __setstate__(self, state):
    88.         self.inner = Inner.__new__(Inner)  # 创建新实例
    89.         self.inner.__setstate__(state['inner'])  # 反序列化嵌套对象
    90.  
    91. # 8、带有文件和文件描述符的对象
    92. import os
    93. class FileHandler:
    94.     def __init__(self, filename):
    95.         self.filename = filename
    96.         self.file = open(filename, 'rb')
    97.     def __getstate__(self):
    98.         # 关闭文件描述符，只保存文件名
    99.         self.file.close()
    100.         return {'filename': self.filename}
    101.     def __setstate__(self, state):
    102.         self.filename = state['filename']
    103.         self.file = open(self.filename, 'rb')
    104.  
    105. # 9、带有循环引用的对象
    106. class Node:
    107.     def __init__(self, value, next_node=None):
    108.         self.value = value
    109.         self.next_node = next_node
    110.     def __getstate__(self):
    111.         # 处理循环引用，通常使用弱引用或特殊标记
    112.         # 这里简化处理，只保存值和下一个节点的ID（如果可用）
    113.         if self.next_node is not None:
    114.             next_id = id(self.next_node)
    115.         else:
    116.             next_id = None
    117.         return {'value': self.value, 'next_id': next_id}
    118.     def __setstate__(self, state):
    119.         self.value = state['value']
    120.         self.next_node = None  # 初始为空
    121.         # 在这里，你可能需要一个节点ID到节点的映射来恢复循环引用
    122.  
    123. # 10、带有线程或进程的对象
    124. import threading
    125. class ThreadedClass:
    126.     def __init__(self):
    127.         self.thread = threading.Thread(target=self.run)
    128.         self.thread.start()
    129.     def run(self):
    130.         # 模拟线程运行
    131.         pass
    132.     def __getstate__(self):
    133.         # 线程不能序列化，所以只保存其他数据（如果有的话）
    134.         # 这里假设没有其他数据可保存，所以返回空字典
    135.         return {}
    136.     def __setstate__(self, state):
    137.         # 在反序列化时，重新创建线程（如果需要的话）
    138.         # 但通常不推荐这样做，因为线程状态难以恢复
    139.         pass
    140.         # 注意：线程和进程状态通常不能序列化，因为它们与特定执行环境紧密相关

    27、__gt__方法

    27-1、语法
    1. __gt__(self, other, /)
    2.     Return self > other
    27-2、参数

    27-2-1、self(必须)：一个对实例对象本身的引用，在类的所有方法中都会自动传递。 

    27-2-2、other(必须)：表示与self进行比较的另一个对象。

    27-2-3、/(可选)：这是从Python 3.8开始引入的参数注解语法，它表示这个方法不接受任何位置参数(positional-only parameters)之后的关键字参数(keyword arguments)。

    27-3、功能

            用于定义对象之间的“大于”(greater than)比较操作。

    27-4、返回值

            返回一个布尔值(True或False)，如果self大于other，则返回True；反之，则返回False。

    27-5、说明

            如果self.value大于other.value，则方法返回True；否则，你可以根据需要选择返回False或者抛出一个异常。

    27-6、用法
    1. # 027、__gt__方法：
    2. # 1、比较两个数字类
    3. class Number:
    4.     def __init__(self, value):
    5.         self.value = value
    6.     def __gt__(self, other):
    7.         if isinstance(other, Number):
    8.             return self.value > other.value
    9.         return NotImplemented
    10. if __name__ == '__main__':
    11.     a = Number(5)
    12.     b = Number(3)
    13.     print(a > b)  # True
    14.  
    15. # 2、比较两个字符串长度
    16. class StringLength:
    17.     def __init__(self, string):
    18.         self.string = string
    19.     def __gt__(self, other):
    20.         if isinstance(other, StringLength):
    21.             return len(self.string) > len(other.string)
    22.         return NotImplemented
    23. if __name__ == '__main__':
    24.     s1 = StringLength("hello")
    25.     s2 = StringLength("world")
    26.     print(s1 > s2)  # False
    27.  
    28. # 3、比较两个日期对象
    29. from datetime import date
    30. class DateWrapper:
    31.     def __init__(self, year, month, day):
    32.         self.date = date(year, month, day)
    33.  
    34.     def __gt__(self, other):
    35.         if isinstance(other, DateWrapper):
    36.             return self.date > other.date
    37.         return NotImplemented
    38. if __name__ == '__main__':
    39.     d1 = DateWrapper(2024, 3, 13)
    40.     d2 = DateWrapper(2024, 6, 1)
    41.     print(d1 > d2)  # False
    42.  
    43. # 4、比较两个自定义分数类
    44. from fractions import Fraction
    45. class MyFraction:
    46.     def __init__(self, numerator, denominator):
    47.         self.fraction = Fraction(numerator, denominator)
    48.     def __gt__(self, other):
    49.         if isinstance(other, MyFraction):
    50.             return self.fraction > other.fraction
    51.         return NotImplemented
    52. if __name__ == '__main__':
    53.     f1 = MyFraction(3, 2)
    54.     f2 = MyFraction(1, 1)
    55.     print(f1 > f2)  # True
    56.  
    57. # 5、比较两个点的坐标(二维空间)
    58. class Point:
    59.     def __init__(self, x, y):
    60.         self.x = x
    61.         self.y = y
    62.     def __gt__(self, other):
    63.         if isinstance(other, Point):
    64.             # 比较x坐标，如果相等则比较y坐标
    65.             if self.x == other.x:
    66.                 return self.y > other.y
    67.             return self.x > other.x
    68.         return NotImplemented
    69. if __name__ == '__main__':
    70.     p1 = Point(3, 6)
    71.     p2 = Point(5, 11)
    72.     print(p1 > p2)  # False
    73.  
    74. # 6、比较两个矩形的面积
    75. class Rectangle:
    76.     def __init__(self, width, height):
    77.         self.width = width
    78.         self.height = height
    79.     @property
    80.     def area(self):
    81.         return self.width * self.height
    82.     def __gt__(self, other):
    83.         if isinstance(other, Rectangle):
    84.             return self.area > other.area
    85.         return NotImplemented
    86. if __name__ == '__main__':
    87.     r1 = Rectangle(3, 6)
    88.     r2 = Rectangle(5, 11)
    89.     print(r1 > r2)  # False
    90.  
    91. # 7、 比较两个列表的长度
    92. class ListWrapper:
    93.     def __init__(self, lst):
    94.         self.lst = lst
    95.     def __gt__(self, other):
    96.         if isinstance(other, ListWrapper):
    97.             return len(self.lst) > len(other.lst)
    98.         return NotImplemented
    99. if __name__ == '__main__':
    100.     lw1 = ListWrapper([1, 2, 3])
    101.     lw2 = ListWrapper([1, 2])
    102.     print(lw1 > lw2)  # True
    103.  
    104. # 8、比较两个字典的键的数量
    105.  
    106. class DictWrapper:
    107.     def __init__(self, dct):
    108.         self.dct = dct
    109.     def __gt__(self, other):
    110.         if isinstance(other, DictWrapper):
    111.             return len(self.dct.keys()) > len(other.dct.keys())
    112.         return NotImplemented
    113. if __name__ == '__main__':
    114.     dw1 = DictWrapper({'a': 1, 'b': 2})
    115.     dw2 = DictWrapper({'a': 1})
    116.     print(dw1 > dw2) # True
    117.  
    118. # 9、比较两个自定义员工类的薪资
    119. class Employee:
    120.     def __init__(self, name, salary):
    121.         self.name = name
    122.         self.salary = salary
    123.     def __gt__(self, other):
    124.         if isinstance(other, Employee):
    125.             return self.salary > other.salary
    126.         return NotImplemented
    127. if __name__ == '__main__':
    128.     emp1 = Employee('Myelsa', 50000)
    129.     emp2 = Employee('Jimmy', 48000)
    130.     print(emp1 > emp2)  # True
    131.  
    132. # 10、比较两个自定义时间段的时长
    133. from datetime import timedelta
    134. class TimePeriod:
    135.     def __init__(self, start, end):
    136.         self.start = start
    137.         self.end = end
    138.     @property
    139.     def duration(self):
    140.         return self.end - self.start
    141.     def __gt__(self, other):
    142.         if isinstance(other, TimePeriod):
    143.             return self.duration > other.duration
    144.         return NotImplemented
    145. if __name__ == '__main__':
    146.     tp1 = TimePeriod(timedelta(hours=2), timedelta(hours=3))
    147.     tp2 = TimePeriod(timedelta(hours=1), timedelta(hours=2))
    148.     print(tp1 > tp2)  # False
    149.     # 注意：这里的timedelta对象不能直接相减，这里的示例仅用于展示结构
    150.  
    151. # 11、比较两个自定义成绩类的分数
    152. class Grade:
    153.     def __init__(self, score):
    154.         self.score = score
    155.     def __gt__(self, other):
    156.         if isinstance(other, Grade):
    157.             return self.score > other.score
    158.         return NotImplemented
    159. if __name__ == '__main__':
    160.     g1 = Grade(90)
    161.     g2 = Grade(85)
    162.     print(g1 > g2)  # True
    163.  
    164. # 12、比较两个自定义商品的价格
    165. class Product:
    166.     def __init__(self, name, price):
    167.         self.name = name
    168.         self.price = price
    169.     def __gt__(self, other):
    170.         if isinstance(other, Product):
    171.             return self.price > other.price
    172.         return NotImplemented
    173. if __name__ == '__main__':
    174.     p1 = Product('Laptop', 1000)
    175.     p2 = Product('Phone', 800)
    176.     print(p1 > p2)  # True

    28、__setstate__方法

    28-1、语法
    1. __setstate__(self, state, /)
    2.     Set state information for unpickling
    28-2、参数

    28-2-1、self(必须)：一个对实例对象本身的引用，在类的所有方法中都会自动传递。 

    28-2-2、state(必须)：一个对象(通常是一个字典)，包含了在序列化时由 __getstate__ 方法返回的状态信息。

    28-2-3、/(可选)：这是从Python 3.8开始引入的参数注解语法，它表示这个方法不接受任何位置参数(positional-only parameters)之后的关键字参数(keyword arguments)。

    28-3、功能

            使用传入的state参数(通常是一个字典或其他数据结构)来重新构造对象的内部状态。

    28-4、返回值

            没有返回值，即返回None。

    28-5、说明

            在__setstate__方法内部，你可以根据state中的数据来设置对象的属性、调用其他方法或执行其他必要的操作，以确保对象在反序列化后具有与序列化时相同的状态。

    28-6、用法
    1. # 028、__setstate__方法：
    2. # 1、基本示例
    3. import pickle
    4. class MyClass:
    5.     def __init__(self, x, y):
    6.         self.x = x
    7.         self.y = y
    8.     def __getstate__(self):
    9.         return {'x': self.x, 'y': self.y}
    10.     def __setstate__(self, state):
    11.         self.x = state['x']
    12.         self.y = state['y']
    13. if __name__ == '__main__':
    14.     # 序列化和反序列化
    15.     obj = MyClass(10, 24)
    16.     serialized_obj = pickle.dumps(obj)
    17.     deserialized_obj = pickle.loads(serialized_obj)
    18.     print(deserialized_obj.x, deserialized_obj.y)  # 输出: 10 24
    19.  
    20. # 2、忽略某些属性
    21. class Person:
    22.     def __init__(self, name, age, password):
    23.         self.name = name
    24.         self.age = age
    25.         self._password = password  # 不想在序列化中包含密码
    26.     def __getstate__(self):
    27.         return {'name': self.name, 'age': self.age}
    28.     def __setstate__(self, state):
    29.         self.name = state['name']
    30.         self.age = state['age']
    31.         self._password = None  # 假设在反序列化时重置密码
    32.  
    33. # 3、自定义序列化格式
    34. class Point:
    35.     def __init__(self, x, y):
    36.         self.x = x
    37.         self.y = y
    38.     def __getstate__(self):
    39.         return (self.x, self.y)  # 使用元组而不是字典
    40.     def __setstate__(self, state):
    41.         self.x, self.y = state
    42.  
    43. # 4、处理不可序列化的属性
    44. import socket
    45. class Connection:
    46.     def __init__(self, host, port):
    47.         self.host = host
    48.         self.port = port
    49.         self.socket = socket.socket()  # 不可序列化
    50.     def __getstate__(self):
    51.         # 不包括 socket 对象
    52.         return {'host': self.host, 'port': self.port}
    53.     def __setstate__(self, state):
    54.         self.host = state['host']
    55.         self.port = state['port']
    56.         self.socket = socket.socket()  # 在反序列化时重新创建 socket
    57.  
    58. # 5、序列化和反序列化时执行额外操作
    59. class LoggedClass:
    60.     def __init__(self, data):
    61.         self.data = data
    62.     def __getstate__(self):
    63.         print("Serializing...", self.data)
    64.         return {'data': self.data}
    65.     def __setstate__(self, state):
    66.         print("Deserializing...", state['data'])
    67.         self.data = state['data']
    68.  
    69. # 6、处理集合类型
    70. class SetExample:
    71.     def __init__(self, items):
    72.         self.items = set(items)
    73.     def __getstate__(self):
    74.         return {'items': list(self.items)}  # 将集合转换为列表
    75.     def __setstate__(self, state):
    76.         self.items = set(state['items'])  # 将列表转换回集合
    77.  
    78. # 7、嵌套对象
    79. class Inner:
    80.     def __init__(self, value):
    81.         self.value = value
    82. class Outer:
    83.     def __init__(self, inner):
    84.         self.inner = inner
    85.     def __getstate__(self):
    86.         return {'inner': self.inner.__getstate__()}  # 嵌套对象也需要序列化
    87.     def __setstate__(self, state):
    88.         self.inner = Inner.__new__(Inner)  # 创建新实例
    89.         self.inner.__setstate__(state['inner'])  # 反序列化嵌套对象
    90.  
    91. # 8、带有文件和文件描述符的对象
    92. import os
    93. class FileHandler:
    94.     def __init__(self, filename):
    95.         self.filename = filename
    96.         self.file = open(filename, 'rb')
    97.     def __getstate__(self):
    98.         # 关闭文件描述符，只保存文件名
    99.         self.file.close()
    100.         return {'filename': self.filename}
    101.     def __setstate__(self, state):
    102.         self.filename = state['filename']
    103.         self.file = open(self.filename, 'rb')
    104.  
    105. # 9、带有循环引用的对象
    106. class Node:
    107.     def __init__(self, value, next_node=None):
    108.         self.value = value
    109.         self.next_node = next_node
    110.     def __getstate__(self):
    111.         # 处理循环引用，通常使用弱引用或特殊标记
    112.         # 这里简化处理，只保存值和下一个节点的ID（如果可用）
    113.         if self.next_node is not None:
    114.             next_id = id(self.next_node)
    115.         else:
    116.             next_id = None
    117.         return {'value': self.value, 'next_id': next_id}
    118.     def __setstate__(self, state):
    119.         self.value = state['value']
    120.         self.next_node = None  # 初始为空
    121.         # 在这里，你可能需要一个节点ID到节点的映射来恢复循环引用
    122.  
    123. # 10、带有线程或进程的对象
    124. import threading
    125. class ThreadedClass:
    126.     def __init__(self):
    127.         self.thread = threading.Thread(target=self.run)
    128.         self.thread.start()
    129.     def run(self):
    130.         # 模拟线程运行
    131.         pass
    132.     def __getstate__(self):
    133.         # 线程不能序列化，所以只保存其他数据（如果有的话）
    134.         # 这里假设没有其他数据可保存，所以返回空字典
    135.         return {}
    136.     def __setstate__(self, state):
    137.         # 在反序列化时，重新创建线程（如果需要的话）
    138.         # 但通常不推荐这样做，因为线程状态难以恢复
    139.         pass
    140.         # 注意：线程和进程状态通常不能序列化，因为它们与特定执行环境紧密相关

    五、推荐阅读

    1、Python筑基之旅

    2、Python函数之旅

    3、Python算法之旅

    4、博客个人主页

  • 相关阅读:
    国科大体系结构习题 | 第二章 计算机系统结构基础
    k8s Seata1.5.1
    认识 Cookie 和 Session
    纯手工总结超详细关于计算机网络的五层知识点，看看你都掌握了没
    Apache HTTPD 多后缀解析漏洞
    GBase 8c获取结果集中的数据
    一图读懂「五度情报站」全盘视野，情报智取，先知先行，决策有道！
    21天打卡挑战学习MySQL——《容器部署MySQL》第三周 第八篇
    阿里云消息团队创新论文被软件工程顶会 FM 2024 录用
    泡泡玛特加速海外布局，泰国首店开业吸引超千名粉丝排队
  • 原文地址：https://blog.csdn.net/ygb_1024/article/details/139356778