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

    目录

    一、概述

    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、避免过度使用

    四、魔法方法

    44、__length_hint__方法

    44-1、语法

    44-2、参数

    44-3、功能

    44-4、返回值

    44-5、说明

    44-6、用法

    45、__lshift__方法

    45-1、语法

    45-2、参数

    45-3、功能

    45-4、返回值

    45-5、说明

    45-6、用法

    46、__lt__方法

    46-1、语法

    46-2、参数

    46-3、功能

    46-4、返回值

    46-5、说明

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

    四、魔法方法

    44、__length_hint__方法

    44-1、语法
    1. __length_hint__(self, /)
    2.     Private method returning an estimate of len(list(it))
    44-2、参数

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

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

    44-3、功能

            为那些需要知道迭代器大致长度的函数或方法提供一个长度提示。

    44-4、返回值

            返回一个整数或None。

    44-5、说明

       __length_hint__方法应该返回一个整数或None：

    44-5-1、如果返回整数，它应该是一个对迭代器长度的合理估计，这个估计可能并不总是准确的，但它应该尽可能接近实际长度。

    44-5-2、如果迭代器长度未知或无法合理估计，则应返回None。

    44-6、用法
    1. # 044、__length_hint__方法：
    2. # 1、简单的列表包装器
    3. class MyListWrapper:
    4.     def __init__(self, lst):
    5.         self.lst = lst
    6.     def __length_hint__(self):
    7.         return len(self.lst)
    8.  
    9. # 2、迭代器长度提示
    10. class MyIterator:
    11.     def __init__(self, numbers):
    12.         self.numbers = numbers
    13.         self.index = 0
    14.     def __iter__(self):
    15.         return self
    16.     def __next__(self):
    17.         if self.index < len(self.numbers):
    18.             result = self.numbers[self.index]
    19.             self.index += 1
    20.             return result
    21.         raise StopIteration
    22.     def __length_hint__(self):
    23.         return len(self.numbers) - self.index
    24.  
    25. # 3、动态生成的序列
    26. class DynamicSequence:
    27.     def __init__(self, start, end):
    28.         self.start = start
    29.         self.end = end
    30.     def __iter__(self):
    31.         return self
    32.     def __next__(self):
    33.         if self.start > self.end:
    34.             raise StopIteration
    35.         current = self.start
    36.         self.start += 1
    37.         return current
    38.     def __length_hint__(self):
    39.         return self.end - self.start + 1 if self.start <= self.end else 0
    40.  
    41. # 4、缓存长度的迭代器
    42. class CachedLengthIterator:
    43.     def __init__(self, iterable):
    44.         self.iterable = iterable
    45.         self._length = None
    46.     def __iter__(self):
    47.         return iter(self.iterable)
    48.     def __length_hint__(self):
    49.         if self._length is None:
    50.             self._length = sum(1 for _ in self.iterable)
    51.         return self._length
    52.  
    53. # 5、生成器长度提示(通常不准确，因为生成器是动态的)
    54. def my_generator(n):
    55.     for i in range(n):
    56.         yield i
    57. class GeneratorWrapper:
    58.     def __init__(self, generator_func, *args, **kwargs):
    59.         self.generator = generator_func(*args, **kwargs)
    60.         self._hint = None
    61.     def __iter__(self):
    62.         return iter(self.generator)
    63.     def __length_hint__(self):
    64.         if self._hint is None:
    65.             # 注意：这只是一个示例，对于真正的生成器可能不准确
    66.             self._hint = sum(1 for _ in self.generator)
    67.         return self._hint
    68.         # 使用示例：GeneratorWrapper(my_generator, 10)
    69.  
    70. # 6、模拟数据库查询结果
    71. class DatabaseQueryResult:
    72.     def __init__(self, count):
    73.         self.count = count
    74.     def __length_hint__(self):
    75.         return self.count
    76.  
    77. # 7、文件行数预估(基于文件大小)
    78. class FileLineCounterApprox:
    79.     def __init__(self, file_path, avg_line_length=100):  # 假设平均行长为100字节
    80.         self.file_path = file_path
    81.         self.avg_line_length = avg_line_length
    82.     def __length_hint__(self):
    83.         with open(self.file_path, 'rb') as file:
    84.             return file.seek(0, 2) // self.avg_line_length  # 粗略估计
    85.  
    86. # 8、树形结构节点数预估
    87. class TreeNode:
    88.     def __init__(self, value, children=None):
    89.         self.value = value
    90.         self.children = children if children is not None else []
    91.     def __length_hint__(self):
    92.         # 假设这是一个完全二叉树，用于示例
    93.         return (2 ** self.depth()) - 1 if self.is_full_binary_tree() else "unknown"
    94.     def depth(self):
    95.         # 需要实现一个计算树深度的函数
    96.         pass
    97.     def is_full_binary_tree(self):
    98.         # 需要实现一个检查树是否是完全二叉树的函数
    99.         pass
    100.         # 注意：在实际应用中，树的长度（即节点数）可能需要递归遍历才能准确计算
    101.  
    102. # 9、网络请求结果集大小预估
    103. class APIResult:
    104.     def __init__(self, response_headers):
    105.         self.response_headers = response_headers
    106.     def __length_hint__(self):
    107.         # 假设API响应头中包含了一个关于结果集大小的字段
    108.         content_length = self.response_headers.get('X-Result-Set-Size', None)
    109.         return int(content_length) if content_length is not None and content_length.isdigit() else "unknown"
    110.         # 注意：这个预估是基于假设的HTTP头字段，实际API可能不会有这样的字段
    111.  
    112. # 10、流式数据处理长度提示
    113. class StreamProcessor:
    114.     def __init__(self, stream):
    115.         self.stream = stream
    116.         self._processed_count = 0
    117.     def process(self, chunk_size=1024):
    118.         # 处理流数据，这里只是模拟
    119.         for _ in range(chunk_size):
    120.             # 假设每次处理一个数据单元
    121.             self._processed_count += 1
    122.     def __length_hint__(self):
    123.         # 流数据长度通常未知，但可以提供已处理的数量
    124.         return self._processed_count
    125.         # 注意：流数据的长度通常是未知的，除非有额外的信息或上下文
    126.  
    127. # 11、自定义集合大小预估
    128. class CustomSet:
    129.     def __init__(self, iterable=()):
    130.         self._set = set(iterable)
    131.         self._hint = None
    132.     def add(self, item):
    133.         self._set.add(item)
    134.         self._hint = None  # 清除长度提示缓存
    135.     def remove(self, item):
    136.         self._set.remove(item)
    137.         self._hint = None
    138.     def __iter__(self):
    139.         return iter(self._set)
    140.     def __len__(self):
    141.         return len(self._set)
    142.     def __length_hint__(self):
    143.         if self._hint is None:
    144.             self._hint = len(self)  # 只有在需要时才计算长度
    145.         return self._hint
    146.         # 注意：在实际应用中，集合的大小可以直接通过len()函数获取，但这里展示了如何使用__length_hint__进行缓存

    45、__lshift__方法

    45-1、语法
    1. __lshift__(self, other, /)
    2.     Return self << other
    45-2、参数

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

    45-2-2、 other(必须)：表示与self进行左移操作的另一个对象或整数。

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

    45-3、功能

            用于定义对象与左移位运算符<<的行为。

    45-4、返回值

            返回一个与self类型相同或兼容的对象，该对象表示self对象左移other位之后的结果。

    45-5、说明

            如果类没有定义__lshift__方法，并且尝试使用左移位运算符<<对其实例进行操作，将会引发一个TypeError。

    45-6、用法
    1. # 045、__lshift__方法：
    2. # 1、二进制位移
    3. class BinaryShift:
    4.     def __init__(self, value):
    5.         self.value = value
    6.     def __lshift__(self, other):
    7.         return BinaryShift(self.value << other)
    8. if __name__ == '__main__':
    9.     a = BinaryShift(4)
    10.     b = a << 2  # 相当于 4 << 2 = 16
    11.     print(b.value)  # 输出 16
    12.  
    13. # 2、整数列表左移
    14. class IntList:
    15.     def __init__(self, values):
    16.         self.values = values
    17.     def __lshift__(self, other):
    18.         if other < 0 or other >= len(self.values):
    19.             raise ValueError("Invalid shift amount")
    20.         return IntList(self.values[other:] + self.values[:other])
    21. if __name__ == '__main__':
    22.     lst = IntList([3, 5, 6, 8, 10, 11, 24])
    23.     shifted = lst << 2  # 相当于 [6, 8, 10, 11, 24, 3, 5]
    24.     print(shifted.values)  # 输出 [6, 8, 10, 11, 24, 3, 5]
    25.  
    26. # 3、字符串左移
    27. class StringShift:
    28.     def __init__(self, value):
    29.         self.value = value
    30.     def __lshift__(self, other):
    31.         if other < 0:
    32.             return StringShift(self.value[-other:] + self.value[:-other])
    33.         elif other >= len(self.value):
    34.             return StringShift(self.value)
    35.         else:
    36.             return StringShift(self.value[other:] + self.value[:other])
    37. if __name__ == '__main__':
    38.     s = StringShift("hello")
    39.     shifted = s << 2  # 相当于 "llohe"
    40.     print(shifted.value)  # 输出 "llohe"
    41.  
    42. # 4、时间戳左移(模拟时间偏移)
    43. from datetime import datetime, timedelta
    44. class TimestampShift:
    45.     def __init__(self, timestamp):
    46.         self.timestamp = timestamp
    47.     def __lshift__(self, other):
    48.         # 假设 other 是天数
    49.         return TimestampShift(self.timestamp + timedelta(days=other))
    50. if __name__ == '__main__':
    51.     now = datetime.now()
    52.     ts = TimestampShift(now)
    53.     future = ts << 10  # 10天后的时间
    54.     print(future.timestamp)  # 输出10天后的日期时间
    55.  
    56. # 5、图形对象的水平移动
    57. class Shape:
    58.     def __init__(self, x, y):
    59.         self.x = x
    60.         self.y = y
    61.     def __lshift__(self, other):
    62.         return Shape(self.x + other, self.y)
    63. if __name__ == '__main__':
    64.     rect = Shape(10, 24)
    65.     moved = rect << 5  # 向右移动5个单位
    66.     print(moved.x, moved.y)  # 输出 15 24
    67.  
    68. # 6、权重调整(模拟权重左移)
    69. class WeightedItem:
    70.     def __init__(self, value, weight):
    71.         self.value = value
    72.         self.weight = weight
    73.     def __lshift__(self, other):
    74.         # 假设 other 是权重增加的因子（例如，左移1位相当于权重乘以2）
    75.         return WeightedItem(self.value, self.weight * (2 ** other))
    76. if __name__ == '__main__':
    77.     item = WeightedItem('apple', 1)
    78.     item_with_higher_weight = item << 1  # 权重变为 2
    79.     print(item_with_higher_weight.weight)  # 输出 2
    80.  
    81. # 7、颜色深度调整(模拟颜色通道值的左移)
    82. class Color:
    83.     def __init__(self, r, g, b):
    84.         self.r = r
    85.         self.g = g
    86.         self.b = b
    87.     def __lshift__(self, other):
    88.         # 假设 other 是亮度增加的因子（注意：这里需要确保值在有效范围内）
    89.         return Color(min(self.r << other, 255), min(self.g << other, 255), min(self.b << other, 255))
    90. if __name__ == '__main__':
    91.     red = Color(255, 0, 0)
    92.     brighter_red = red << 1  # 增加亮度
    93.     print(brighter_red.r, brighter_red.g, brighter_red.b)  # 输出：255 0 0
    94.  
    95. # 8、频率调整(模拟音频信号频率的左移)
    96. class AudioSignal:
    97.     # 这里仅作为示例，实际音频处理会更复杂
    98.     def __init__(self, frequencies):
    99.         self.frequencies = frequencies
    100.     def __lshift__(self, other):
    101.         # 假设 other 是频率增加的因子（这在实际中是不准确的，仅作示例）
    102.         return AudioSignal([freq * (2 ** other) for freq in self.frequencies])
    103. if __name__ == '__main__':
    104.     signal = AudioSignal([100, 200, 300])
    105.     higher_freq_signal = signal << 1  # 模拟频率加倍
    106.     print(higher_freq_signal.frequencies)  # 输出:[200, 400, 600]
    107.  
    108. # 9、队列元素左移(删除头部元素并在尾部添加新元素)
    109. class Queue:
    110.     def __init__(self):
    111.         self.items = []
    112.     def enqueue(self, item):
    113.         self.items.append(item)
    114.     def dequeue(self):
    115.         if self.is_empty():
    116.             raise IndexError("Queue is empty")
    117.         return self.items.pop(0)
    118.     def is_empty(self):
    119.         return len(self.items) == 0
    120.     # 模拟左移（删除头部并添加新元素）
    121.     def __lshift__(self, new_item):
    122.         self.dequeue()
    123.         self.enqueue(new_item)
    124. if __name__ == '__main__':
    125.     q = Queue()
    126.     q.enqueue(1)
    127.     q.enqueue(2)
    128.     q.enqueue(3)
    129.     print(q.items)  # 输出 [1, 2, 3]
    130.     q << 4  # 删除1并添加4
    131.     print(q.items)  # 输出 [2, 3, 4]
    132.  
    133. # 10、价格调整(模拟折扣)
    134. class Price:
    135.     def __init__(self, value):
    136.         self.value = value
    137.     def __lshift__(self, discount_factor):
    138.         # 假设 discount_factor 是折扣的百分比（例如，左移1位代表打五折）
    139.         # 注意：这里的实现仅作为示例，真实的折扣计算会更复杂
    140.         return Price(self.value * (1 - discount_factor / 100))
    141. if __name__ == '__main__':
    142.     original_price = Price(100)
    143.     discounted_price = original_price << 50  # 假设代表打五折
    144.     print(discounted_price.value)  # 输出 50.0
    145.  
    146. # 11、时间线事件的前移
    147. class TimelineEvent:
    148.     def __init__(self, name, timestamp):
    149.         self.name = name
    150.         self.timestamp = timestamp
    151.     def __lshift__(self, time_delta):
    152.         # 将事件前移指定的时间量
    153.         self.timestamp -= time_delta
    154. if __name__ == '__main__':
    155.     event = TimelineEvent('Meeting', datetime.now())
    156.     print(event.timestamp)  # 输出当前时间
    157.     event << timedelta(hours=1)  # 将事件前移1小时
    158.     print(event.timestamp)  # 输出前移1小时后的时间
    159.  
    160. # 12、图形界面中的元素左移
    161. class GUIElement:
    162.     def __init__(self, x, y):
    163.         self.x = x
    164.         self.y = y
    165.     def __lshift__(self, shift_amount):
    166.         # 将元素向左移动指定的像素量
    167.         self.x = max(0, self.x - shift_amount)  # 确保元素不会移出容器的左侧边界
    168.     def __repr__(self):
    169.         # 为了更友好地打印GUIElement对象
    170.         return f"GUIElement(x={self.x}, y={self.y})"
    171. # 假设的GUI容器类（仅用于演示）
    172. class GUIContainer:
    173.     def __init__(self):
    174.         self.elements = []
    175.     def add_element(self, element):
    176.         # 添加元素到容器中（这里只是简单地将元素添加到列表中）
    177.         self.elements.append(element)
    178. # 主程序
    179. if __name__ == '__main__':
    180.     # 创建一个GUI容器
    181.     container = GUIContainer()
    182.     # 创建一个GUI元素（按钮）并添加到容器中（虽然在这里我们并不真正添加到GUI中）
    183.     button = GUIElement(100, 50)
    184.     # 假设有一个add_element方法添加到容器中（这里我们手动调用）
    185.     container.add_element(button)
    186.     # 将按钮向左移动20像素
    187.     button << 20  # 调用__lshift__方法
    188.     # 打印按钮的新位置
    189.     print(button)  # 输出类似：GUIElement(x=80, y=50)

    46、__lt__方法

    46-1、语法
    1. __lt__(self, other, /)
    2.     Return self < other
    46-2、参数

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

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

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

    46-3、功能

            用于定义对象之间“小于”关系的行为。

    46-4、返回值

            返回一个布尔值(True或False)，表示self是否小于other。

    46-5、说明

            如果没有在类中定义__lt__方法，并且尝试使用<运算符对其实例进行比较，将会引发一个TypeError，除非该类的实例是某个内置类型的子类(如int、float、str等)，这些内置类型已经定义了它们自己的__lt__方法。

    46-6、用法
    1. # 046、__lt__方法：
    2. # 1、自定义整数类
    3. class MyInt:
    4.     def __init__(self, value):
    5.         self.value = value
    6.     def __lt__(self, other):
    7.         if isinstance(other, MyInt):
    8.             return self.value < other.value
    9.         elif isinstance(other, int):
    10.             return self.value < other
    11.         else:
    12.             raise TypeError("Unsupported operand types for <: 'MyInt' and '{}'".format(type(other).__name__))
    13. if __name__ == '__main__':
    14.     a = MyInt(5)
    15.     b = MyInt(10)
    16.     print(a < b)  # True
    17.  
    18. # 2、自定义字符串长度比较
    19. class StringLength:
    20.     def __init__(self, s):
    21.         self.s = s
    22.     def __lt__(self, other):
    23.         if isinstance(other, StringLength):
    24.             return len(self.s) < len(other.s)
    25.         elif isinstance(other, int):
    26.             return len(self.s) < other
    27.         else:
    28.             raise TypeError("Unsupported operand types for <: 'StringLength' and '{}'".format(type(other).__name__))
    29. if __name__ == '__main__':
    30.     s1 = StringLength("apple")
    31.     s2 = StringLength("banana")
    32.     print(s1 < s2)  # True
    33.  
    34. # 3、自定义日期类
    35. from datetime import date
    36. class MyDate:
    37.     def __init__(self, year, month, day):
    38.         self.date = date(year, month, day)
    39.     def __lt__(self, other):
    40.         if isinstance(other, MyDate):
    41.             return self.date < other.date
    42.         else:
    43.             raise TypeError("Unsupported operand types for <: 'MyDate' and '{}'".format(type(other).__name__))
    44. if __name__ == '__main__':
    45.     d1 = MyDate(2024, 3, 13)
    46.     d2 = MyDate(2024, 6, 4)
    47.     print(d1 < d2)  # True
    48.  
    49. # 4、自定义二维点类
    50. class Point:
    51.     def __init__(self, x, y):
    52.         self.x = x
    53.         self.y = y
    54.     def __lt__(self, other):
    55.         if isinstance(other, Point):
    56.             return (self.x, self.y) < (other.x, other.y)
    57.         else:
    58.             raise TypeError("Unsupported operand types for <: 'Point' and '{}'".format(type(other).__name__))
    59. if __name__ == '__main__':
    60.     p1 = Point(3, 6)
    61.     p2 = Point(5, 11)
    62.     print(p1 < p2)  # True
    63.  
    64. # 5、自定义矩形面积比较
    65. class Rectangle:
    66.     def __init__(self, width, height):
    67.         self.width = width
    68.         self.height = height
    69.     @property
    70.     def area(self):
    71.         return self.width * self.height
    72.     def __lt__(self, other):
    73.         if isinstance(other, Rectangle):
    74.             return self.area < other.area
    75.         else:
    76.             raise TypeError("Unsupported operand types for <: 'Rectangle' and '{}'".format(type(other).__name__))
    77. if __name__ == '__main__':
    78.     rect1 = Rectangle(3, 6)
    79.     rect2 = Rectangle(5, 11)
    80.     print(rect1 < rect2)  # True
    81.  
    82. # 6、自定义字典按值排序比较(仅比较第一个值)
    83. class ValueSortedDict:
    84.     def __init__(self, dict_items):
    85.         self.dict_items = sorted(dict_items.items(), key=lambda x: x[1])
    86.     def __lt__(self, other):
    87.         if isinstance(other, ValueSortedDict):
    88.             return self.dict_items[0][1] < other.dict_items[0][1]
    89.         else:
    90.             raise TypeError("Unsupported operand types for <: 'ValueSortedDict' and '{}'".format(type(other).__name__))
    91. if __name__ == '__main__':
    92.     dict1 = {'a': 10, 'b': 24}
    93.     dict2 = {'c': 10, 'd': 8}
    94.     vsd1 = ValueSortedDict(dict1)
    95.     vsd2 = ValueSortedDict(dict2)
    96.     print(vsd1 < vsd2)  # False
    97.  
    98. # 7、自定义分数类，按分数值比较
    99. from fractions import Fraction
    100. class FractionWrapper:
    101.     def __init__(self, numerator, denominator):
    102.         self.fraction = Fraction(numerator, denominator)
    103.     def __lt__(self, other):
    104.         if isinstance(other, FractionWrapper):
    105.             return self.fraction < other.fraction
    106.         elif isinstance(other, Fraction):
    107.             return self.fraction < other
    108.         else:
    109.             raise TypeError("Unsupported operand types for <: 'FractionWrapper' and '{}'".format(type(other).__name__))
    110. if __name__ == '__main__':
    111.     frac1 = FractionWrapper(10, 24)
    112.     frac2 = FractionWrapper(3, 6)
    113.     print(frac1 < frac2)  # True
    114.  
    115. # 8、自定义复数类，按模长比较
    116. import math
    117. class ComplexNumber:
    118.     def __init__(self, real, imag):
    119.         self.real = real
    120.         self.imag = imag
    121.     @property
    122.     def modulus(self):
    123.         return math.sqrt(self.real ** 2 + self.imag ** 2)
    124.     def __lt__(self, other):
    125.         if isinstance(other, ComplexNumber):
    126.             return self.modulus < other.modulus
    127.         else:
    128.             raise TypeError("Unsupported operand types for <: 'ComplexNumber' and '{}'".format(type(other).__name__))
    129. if __name__ == '__main__':
    130.     c1 = ComplexNumber(3, 6)
    131.     c2 = ComplexNumber(5, 11)
    132.     print(c1 < c2)  # True
    133.  
    134. # 9、自定义时间戳类，按时间先后比较
    135. from datetime import datetime, timezone
    136. class Timestamp:
    137.     def __init__(self, timestamp):
    138.         self.timestamp = datetime.fromtimestamp(timestamp, tz=timezone.utc)
    139.     def __lt__(self, other):
    140.         if isinstance(other, Timestamp):
    141.             return self.timestamp < other.timestamp
    142.         elif isinstance(other, datetime):
    143.             return self.timestamp < other
    144.         else:
    145.             raise TypeError("Unsupported operand types for <: 'Timestamp' and '{}'".format(type(other).__name__))
    146. if __name__ == '__main__':
    147.     ts1 = Timestamp(1609459200)  # 2021-01-01 00:00:00 UTC
    148.     ts2 = Timestamp(1609545600)  # 2021-01-02 00:00:00 UTC
    149.     print(ts1 < ts2)  # True
    150.  
    151. # 10、自定义二维点类，按字典序比较
    152. class Point2D:
    153.     def __init__(self, x, y):
    154.         self.x = x
    155.         self.y = y
    156.     def __lt__(self, other):
    157.         if not isinstance(other, Point2D):
    158.             return NotImplemented
    159.         if self.x < other.x:
    160.             return True
    161.         elif self.x == other.x and self.y < other.y:
    162.             return True
    163.         return False
    164.     def __repr__(self):
    165.         return f"Point2D({self.x}, {self.y})"
    166. if __name__ == '__main__':
    167.     p1 = Point2D(1, 2)
    168.     p2 = Point2D(2, 1)
    169.     p3 = Point2D(1, 3)
    170.     print(p1 < p2)  # True
    171.     print(p1 < p3)  # True
    172.     print(p2 < p3)  # False
    173.  
    174. # 11、自定义图书类，按价格或出版时间比较
    175. from datetime import datetime
    176. class Book:
    177.     def __init__(self, title, author, price, publish_date):
    178.         self.title = title
    179.         self.author = author
    180.         self.price = price
    181.         self.publish_date = datetime.strptime(publish_date, '%Y-%m-%d')
    182.     def __repr__(self):
    183.         return f"Book(title={self.title}, author={self.author}, price={self.price}, publish_date={self.publish_date.strftime('%Y-%m-%d')})"
    184.     def __lt_by_price__(self, other):
    185.         if not isinstance(other, Book):
    186.             return NotImplemented
    187.         return self.price < other.price
    188.     def __lt_by_publish_date__(self, other):
    189.         if not isinstance(other, Book):
    190.             return NotImplemented
    191.         return self.publish_date < other.publish_date
    192. if __name__ == '__main__':
    193.     book1 = Book("Python Programming", "Alice", 39.99, "2022-01-01")
    194.     book2 = Book("Java for Beginners", "Bob", 29.99, "2021-05-15")
    195.     book3 = Book("Database Management", "Charlie", 49.99, "2022-06-30")
    196.     # 按价格比较
    197.     print(book1.__lt_by_price__(book2))  # True，因为book1的价格比book2高
    198.     print(book2.__lt_by_price__(book3))  # True，因为book2的价格比book3低
    199.     # 按出版时间比较
    200.     print(book1.__lt_by_publish_date__(book2))  # False，因为book1的出版时间比book2晚
    201.     print(book2.__lt_by_publish_date__(book3))  # True，因为book2的出版时间比book3早
    202.  
    203. # 12、自定义学生类，按成绩比较
    204. class Student:
    205.     def __init__(self, name, score):
    206.         self.name = name
    207.         self.score = score
    208.     def __repr__(self):
    209.         return f"Student(name={self.name}, score={self.score})"
    210.     def __lt__(self, other):
    211.         if not isinstance(other, Student):
    212.             return NotImplemented
    213.         return self.score < other.score
    214. if __name__ == '__main__':
    215.     student1 = Student("Myelsa", 85)
    216.     student2 = Student("Bruce", 90)
    217.     student3 = Student("Jimmy", 85)
    218.     # 按成绩比较
    219.     print(student1 < student2)  # True，因为student1的成绩比student2低
    220.     print(student1 < student3)  # False，因为student1和student3的成绩相同
    221.     print(student2 < student3)  # False，因为student2的成绩比student3高

    五、推荐阅读

    1、Python筑基之旅

    2、Python函数之旅

    3、Python算法之旅

    4、博客个人主页

  • 相关阅读:
    力扣：155. 最小栈（Python3）
    【LeetCode算法系列题解】第46~50题
    【昇腾产品应用】英码科技EA500I基于昇腾Mind SDK实现实时人体关键点检测
    yolov7训练自己的数据集及报错处理
    搜维尔科技：Touch触觉式力反馈设备与Touch X力反馈设备对比分析
    使用 http-proxy 代理 HTTP 请求时遇到的 the requested url is invalid 错误消息
    机器学习——决策树与随机森林
    “五育”并举育人体系构建的实践研究课题实施方案
    阿里巴巴深入浅出Springboot文档送给你，简直建议收藏
    还在每天玩单调的控制台窗口?赶紧进来!!!用EasyX画出自己的优美窗口(万字教程，一文入门)
  • 原文地址：https://blog.csdn.net/ygb_1024/article/details/139422349