Python魔法之旅-魔法方法(12)

目录

一、概述

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

四、魔法方法

38、__ior__方法

38-1、语法

38-2、参数

38-3、功能

38-4、返回值

38-5、说明

38-6、用法

39、__isub__方法

39-1、语法

39-2、参数

39-3、功能

39-4、返回值

39-5、说明

39-6、用法

40、__iter__方法

40-1、语法

40-2、参数

40-3、功能

40-4、返回值

40-5、说明

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

四、魔法方法

38、__ior__方法

38-1、语法
  1. __ior__(self, other, /)
  2.     Return self |= other
38-2、参数

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

38-2-2、 other(必须)：表示要与self进行按位或操作的另一个对象，即__ior__ 法操作的右侧操作数。

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

38-3、功能

        用于定义对象的就地按位或(bitwise in-place OR)操作。

38-4、返回值

        返回self的引用(如果进行了就地修改)或一个新的对象(尽管不推荐)。

38-5、说明

        如果就地修改不可行或不合适，则可以选择返回一个新的对象，但这不是推荐的做法，因为它会违反 __ior__ 方法的预期语义。

38-6、用法
  1. # 038、__ior__方法：
  2. # 1、位运算类(BitSet)
  3. class BitSet:
  4.     def __init__(self, value=0):
  5.         self.value = value
  6.  
  7.     def __ior__(self, other):
  8.         self.value |= other.value
  9.         return self
  10. if __name__ == '__main__':
  11.     b1 = BitSet(5)  # 二进制 101
  12.     b2 = BitSet(3)  # 二进制 011
  13.     b1 |= b2
  14.     print(bin(b1.value))  # 输出：0b111
  15.  
  16. # 2、集合就地合并
  17. class MySet(set):
  18.     def __ior__(self, other):
  19.         self.update(other)
  20.         return self
  21. if __name__ == '__main__':
  22.     s1 = MySet({1, 2, 3})
  23.     s2 = {3, 4, 5}
  24.     s1 |= s2
  25.     print(s1)  # 输出：MySet({1, 2, 3, 4, 5})
  26.  
  27. # 3、自定义列表就地添加元素
  28. class MyList(list):
  29.     def __ior__(self, other):
  30.         if isinstance(other, list):
  31.             self.extend(other)
  32.         return self
  33. if __name__ == '__main__':
  34.     l1 = MyList([1, 2, 3])
  35.     l2 = [4, 5, 6]
  36.     l1 |= l2
  37.     print(l1)  # 输出：[1, 2, 3, 4, 5, 6]
  38.  
  39. # 4、自定义二进制字符串操作
  40. class BinaryString:
  41.     def __init__(self, value):
  42.         self.value = value
  43.     def __ior__(self, other):
  44.         if isinstance(other, BinaryString):
  45.             self.value = bin(int(self.value, 2) | int(other.value, 2))[2:]
  46.         return self
  47.     def __str__(self):
  48.         return self.value
  49. if __name__ == '__main__':
  50.     b1 = BinaryString('1010')
  51.     b2 = BinaryString('0110')
  52.     b1 |= b2
  53.     print(b1)  # 输出：'1110'
  54.  
  55. # 5、自定义整数范围类
  56. class IntRange:
  57.     def __init__(self, start, end):
  58.         self.start = min(start, end)
  59.         self.end = max(start, end)
  60.     def __ior__(self, other):
  61.         if isinstance(other, IntRange):
  62.             self.start = min(self.start, other.start)
  63.             self.end = max(self.end, other.end)
  64.         return self
  65.     def __str__(self):
  66.         return f'[{self.start}, {self.end}]'
  67. if __name__ == '__main__':
  68.     r1 = IntRange(1, 5)
  69.     r2 = IntRange(4, 10)
  70.     r1 |= r2
  71.     print(r1)  # 输出：'[1, 10]'
  72.  
  73. # 6、自定义权限类
  74. class Permission:
  75.     READ = 1
  76.     WRITE = 2
  77.     EXECUTE = 4
  78.     def __init__(self, value=0):
  79.         self.value = value
  80.     def __ior__(self, other):
  81.         if isinstance(other, Permission):
  82.             self.value |= other.value
  83.         return self
  84.     def __str__(self):
  85.         perms = []
  86.         if self.value & Permission.READ:
  87.             perms.append('READ')
  88.         if self.value & Permission.WRITE:
  89.             perms.append('WRITE')
  90.         if self.value & Permission.EXECUTE:
  91.             perms.append('EXECUTE')
  92.         return ', '.join(perms)
  93. if __name__ == '__main__':
  94.     p1 = Permission(Permission.READ | Permission.WRITE)
  95.     p2 = Permission(Permission.EXECUTE)
  96.     p1 |= p2
  97.     print(p1)  # 输出：'READ, WRITE, EXECUTE'
  98.  
  99. # 7、自定义图形颜色类
  100. class Color:
  101.     RED = 1
  102.     GREEN = 2
  103.     BLUE = 4
  104.     def __init__(self, value=0):
  105.         self.value = value
  106.     def __ior__(self, other):
  107.         if isinstance(other, Color):
  108.             self.value |= other.value
  109.         return self
  110.     def __str__(self):
  111.         colors = []
  112.         if self.value & Color.RED:
  113.             colors.append('RED')
  114.         if self.value & Color.GREEN:
  115.             colors.append('GREEN')
  116.         if self.value & Color.BLUE:
  117.             colors.append('BLUE')
  118.         return ', '.join(colors)
  119. if __name__ == '__main__':
  120.     c1 = Color(Color.RED | Color.GREEN)
  121.     c2 = Color(Color.BLUE)
  122.     c1 |= c2
  123.     print(c1)  # 输出：'RED, GREEN, BLUE'
  124.  
  125. # 8、自定义标签集合类
  126. class TagSet:
  127.     def __init__(self, tags=None):
  128.         self.tags = set(tags or [])
  129.     def __ior__(self, other):
  130.         if isinstance(other, TagSet):
  131.             self.tags.update(other.tags)
  132.         return self
  133.     def __str__(self):
  134.         return ', '.join(sorted(self.tags))
  135. if __name__ == '__main__':
  136.     tags1 = TagSet(['python', 'data-science'])
  137.     tags2 = TagSet(['data-science', 'machine-learning'])
  138.     tags1 |= tags2
  139.     print(tags1)  # 输出：'data-science, machine-learning, python'
  140.  
  141. # 9、自定义坐标范围类
  142. class CoordinateRange:
  143.     def __init__(self, x_start, x_end, y_start, y_end):
  144.         self.x_start = min(x_start, x_end)
  145.         self.x_end = max(x_start, x_end)
  146.         self.y_start = min(y_start, y_end)
  147.         self.y_end = max(y_start, y_end)
  148.     def __ior__(self, other):
  149.         if isinstance(other, CoordinateRange):
  150.             self.x_start = min(self.x_start, other.x_start)
  151.             self.x_end = max(self.x_end, other.x_end)
  152.             self.y_start = min(self.y_start, other.y_start)
  153.             self.y_end = max(self.y_end, other.y_end)
  154.         return self
  155.     def __str__(self):
  156.         return f'[{self.x_start}, {self.x_end}] x [{self.y_start}, {self.y_end}]'
  157. if __name__ == '__main__':
  158.     range1 = CoordinateRange(1, 3, 2, 4)
  159.     range2 = CoordinateRange(2, 5, 3, 6)
  160.     range1 |= range2
  161.     print(range1)  # 输出：[1, 5] x [2, 6]
  162.  
  163. # 10、自定义版本控制类
  164. class Version:
  165.     def __init__(self, major=0, minor=0, patch=0):
  166.         self.major = major
  167.         self.minor = minor
  168.         self.patch = patch
  169.     def __ior__(self, other):
  170.         if isinstance(other, Version):
  171.             if other.major > self.major:
  172.                 self.major = other.major
  173.                 self.minor = other.minor
  174.                 self.patch = other.patch
  175.             elif other.major == self.major and other.minor > self.minor:
  176.                 self.minor = other.minor
  177.                 self.patch = other.patch
  178.             elif other.major == self.major and other.minor == self.minor and other.patch > self.patch:
  179.                 self.patch = other.patch
  180.         return self
  181.     def __str__(self):return f"{self.major}.{self.minor}.{self.patch}"
  182. if __name__ == '__main__':
  183.     v1 = Version(1, 2, 3)
  184.     v2 = Version(1, 3, 0)
  185.     v1 |= v2
  186.     print(v1) # 输出：1.3.0
  187.     v3 = Version(2, 0, 0)
  188.     v1 |= v3
  189.     print(v1) # 输出：2.0.0
  190.  
  191. # 11、自定义时间区间类
  192. from datetime import datetime, timedelta
  193. class TimeInterval:
  194.     def __init__(self, start_time, end_time):
  195.         self.start_time = start_time
  196.         self.end_time = end_time
  197.     def __ior__(self, other):
  198.         if isinstance(other, TimeInterval):
  199.             if self.end_time < other.start_time:
  200.                 # 两个区间不重叠，无需合并
  201.                 pass
  202.             elif self.start_time > other.end_time:
  203.                 # 第一个区间在第二个之后，用第二个区间的起始时间更新第一个区间的起始时间
  204.                 self.start_time = other.start_time
  205.             elif self.start_time <= other.start_time <= self.end_time:
  206.                 # 第二个区间的起始时间在第一个区间内，无需更新起始时间
  207.                 pass
  208.             # 更新结束时间
  209.             self.end_time = max(self.end_time, other.end_time)
  210.         return self
  211.     def __str__(self):
  212.         return f"{self.start_time.strftime('%Y-%m-%d %H:%M:%S')} - {self.end_time.strftime('%Y-%m-%d %H:%M:%S')}"
  213. if __name__ == '__main__':
  214.     start1 = datetime(2019, 3, 13, 8, 0, 0)
  215.     end1 = datetime(2024, 6, 3, 11, 0, 0)
  216.     start2 = datetime(2024, 3, 13, 8, 30, 0)
  217.     end2 = datetime(2024, 6, 3, 11, 0, 0)
  218.     interval1 = TimeInterval(start1, end1)
  219.     interval2 = TimeInterval(start2, end2)
  220.     interval1 |= interval2
  221.     print(interval1)  # 输出：2019-03-13 08:00:00 - 2024-06-03 11:00:00
  222.  
  223. # 12、自定义图片编辑类
  224. class ImageEdit:
  225.     def __init__(self):
  226.         self.edits = {}
  227.     def crop(self, x, y, width, height):
  228.         # 假设我们存储编辑为字典形式，'crop' 是一个键，后面跟着参数
  229.         self.edits['crop'] = (x, y, width, height)
  230.     def rotate(self, degrees):
  231.         self.edits['rotate'] = degrees
  232.         # ... 可以添加其他编辑方法
  233.     def __ior__(self, other):
  234.         if isinstance(other, ImageEdit):
  235.             # 合并另一个编辑对象的编辑效果
  236.             self.edits.update(other.edits)
  237.         return self
  238.     def apply_edits(self, image):
  239.         # 这里仅作为示例，不实现真正的图片编辑逻辑
  240.         # 实际中，这里应该使用图像处理库（如PIL）来应用编辑效果
  241.         print(f"Applying edits to image: {self.edits}")
  242.         # 假设我们已经应用了编辑并返回了处理后的图片（这里仅返回原始图片作为示例）
  243.         return image
  244. if __name__ == '__main__':
  245.     edit1 = ImageEdit()
  246.     edit1.crop(10, 10, 200, 200)
  247.     edit1.rotate(45)
  248.     edit2 = ImageEdit()
  249.     edit2.rotate(90)
  250.     # 合并编辑效果
  251.     edit1 |= edit2
  252.     # 假设我们有一个图片对象image
  253.     image = "output.jpg"
  254.     # 应用编辑效果（这里仅打印编辑信息）
  255.     edited_image = edit1.apply_edits(image)
  256.     print("Edits applied:", edit1.edits)  # 输出：{'crop': (10, 10, 200, 200), 'rotate': 90}

39、__isub__方法

39-1、语法
  1. __isub__(self, other, /)
  2.     Return self -= other
39-2、参数

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

39-2-2、 other(必须)：表示与self 进行减法操作的对象，即__isub__方法操作的右侧操作数。

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

39-3、功能

        用于定义对象的就地减法赋值操作(in-place subtraction assignment)。

39-4、返回值

        返回 self 的引用(如果进行了就地修改)或一个新的对象(尽管不推荐)。

39-5、说明

        如果就地修改不可行或不合适，则可以选择返回一个新的对象，但这不是推荐的做法，因为它会违反 __isub__ 方法的预期语义。

39-6、用法
  1. # 039、__isub__方法：
  2. # 1、简单的整数类
  3. class Integer:
  4.     def __init__(self, value):
  5.         self.value = value
  6.     def __isub__(self, other):
  7.         if isinstance(other, int):
  8.             self.value -= other
  9.             return self
  10.         else:
  11.             raise TypeError("Unsupported operand type(s) for -=: '{}' and '{}'".format(
  12.                 type(self).__name__, type(other).__name__))
  13.     def __repr__(self):
  14.         return str(self.value)
  15. if __name__ == '__main__':
  16.     a = Integer(10)
  17.     b = 2
  18.     a -= b
  19.     print(a)  # 输出: 8
  20.  
  21. # 2、分数类
  22. from fractions import Fraction
  23. class MyFraction:
  24.     def __init__(self, numerator, denominator=1):
  25.         self.value = Fraction(numerator, denominator)
  26.     def __isub__(self, other):
  27.         if isinstance(other, (int, float, Fraction, MyFraction)):
  28.             if isinstance(other, MyFraction):
  29.                 other = other.value
  30.             self.value -= other
  31.             return self
  32.         else:
  33.             raise TypeError("Unsupported operand type(s) for -=: '{}' and '{}'".format(
  34.                 type(self).__name__, type(other).__name__))
  35.     def __repr__(self):
  36.         return str(self.value)
  37. if __name__ == '__main__':
  38.     f = MyFraction(1, 2)
  39.     f -= MyFraction(1, 4)
  40.     print(f)  # 输出: 1/4
  41.  
  42. # 3、复数类
  43. class ComplexNumber:
  44.     def __init__(self, real, imag=0):
  45.         self.real = real
  46.         self.imag = imag
  47.     def __isub__(self, other):
  48.         if isinstance(other, (int, float, ComplexNumber)):
  49.             if isinstance(other, ComplexNumber):
  50.                 other_real, other_imag = other.real, other.imag
  51.             else:
  52.                 other_real, other_imag = other, 0
  53.             self.real -= other_real
  54.             self.imag -= other_imag
  55.             return self
  56.         else:
  57.             raise TypeError("Unsupported operand type(s) for -=: '{}' and '{}'".format(
  58.                 type(self).__name__, type(other).__name__))
  59.     def __repr__(self):
  60.         return f"{self.real}+{self.imag}j"
  61. if __name__ == '__main__':
  62.     c = ComplexNumber(1, 2)
  63.     c -= 3
  64.     print(c)  # 输出: -2+2j
  65.  
  66. # 4、点类(二维)
  67. class Point:
  68.     def __init__(self, x, y):
  69.         self.x = x
  70.         self.y = y
  71.     def __isub__(self, other):
  72.         if isinstance(other, Point):
  73.             self.x -= other.x
  74.             self.y -= other.y
  75.             return self
  76.         else:
  77.             raise TypeError("Unsupported operand type(s) for -=: '{}' and '{}'".format(
  78.                 type(self).__name__, type(other).__name__))
  79.     def __repr__(self):
  80.         return f"({self.x}, {self.y})"
  81. if __name__ == '__main__':
  82.     p = Point(5, 3)
  83.     p -= Point(1, 1)
  84.     print(p)  # 输出: (4, 2)
  85.  
  86. # 5、列表减法(移除元素)
  87. class MyList:
  88.     def __init__(self, items):
  89.         self.items = list(items)
  90.     def __isub__(self, other):
  91.         if isinstance(other, (list, set, tuple)):
  92.             for item in other:
  93.                 if item in self.items:
  94.                     self.items.remove(item)
  95.             return self
  96.         else:
  97.             raise TypeError("Unsupported operand type(s) for -=: '{}' and '{}'".format(
  98.                 type(self).__name__, type(other).__name__))
  99.     def __repr__(self):
  100.         return str(self.items)
  101. if __name__ == '__main__':
  102.     lst = MyList([1, 2, 3, 4, 5])
  103.     lst -= [2, 4]
  104.     print(lst) # 输出: [1, 3, 5]
  105.  
  106. # 6、集合的差集
  107. class MySet(set):
  108.     def __isub__(self, other):
  109.         if isinstance(other, (set, frozenset)):
  110.             super().__isub__(other)
  111.             return self
  112.         else:
  113.             raise TypeError("Unsupported operand type(s) for -=: '{}' and '{}'".format(
  114.                 type(self).__name__, type(other).__name__))
  115. if __name__ == '__main__':
  116.     s = MySet({1, 2, 3, 4, 5})
  117.     s -= {2, 4}
  118.     print(s)  # 输出: MySet({1, 3, 5})
  119.  
  120. # 7、自定义栈的弹出操作(模拟就地减法)
  121. class Stack:
  122.     def __init__(self):
  123.         self.items = []
  124.     def push(self, item):
  125.         self.items.append(item)
  126.     def __isub__(self, count):
  127.         if isinstance(count, int) and count > 0 and count <= len(self.items):
  128.             self.items = self.items[:-count]
  129.             return self
  130.         else:
  131.             raise ValueError("Count must be a positive integer not greater than stack size.")
  132.     def __repr__(self):
  133.         return str(self.items)
  134.  
  135. if __name__ == '__main__':
  136.     # 使用（这里的 `-=` 并不符合栈的标准操作，但仅为示例）
  137.     stk = Stack()
  138.     stk.push(1)
  139.     stk.push(2)
  140.     stk.push(3)
  141.     stk -= 2  # 弹出顶部两个元素
  142.     print(stk)  # 输出: [1]
  143.  
  144. # 8、矩阵类(二维列表)
  145. class Matrix:
  146.     def __init__(self, matrix):
  147.         self.matrix = [row[:] for row in matrix]  # 浅拷贝，确保独立性
  148.     def __isub__(self, other):
  149.         if isinstance(other, Matrix) and len(self.matrix) == len(other.matrix) and all(
  150.                 len(row) == len(other_row) for row, other_row in zip(self.matrix, other.matrix)):
  151.             for i in range(len(self.matrix)):
  152.                 for j in range(len(self.matrix[i])):
  153.                     self.matrix[i][j] -= other.matrix[i][j]
  154.             return self
  155.         else:
  156.             raise ValueError("Matrix dimensions must agree")
  157.     def __repr__(self):
  158.         return str(self.matrix)
  159. if __name__ == '__main__':
  160.     A = Matrix([[1, 2], [3, 4]])
  161.     B = Matrix([[1, 1], [1, 1]])
  162.     A -= B
  163.     print(A)  # 输出: [[0, 1], [2, 3]]
  164.  
  165. # 9、计数器类(字典的变种)
  166. class Counter:
  167.     def __init__(self, initial=None):
  168.         self.counts = {}
  169.         if initial is not None:
  170.             for item, count in initial.items():
  171.                 self.counts[item] = count
  172.     def __isub__(self, other):
  173.         if isinstance(other, dict):
  174.             for item, count in other.items():
  175.                 if item in self.counts:
  176.                     self.counts[item] -= count
  177.                     if self.counts[item] <= 0:
  178.                         del self.counts[item]
  179.             return self
  180.         else:
  181.             raise TypeError("Unsupported operand type(s) for -=: '{}' and '{}'".format(
  182.                 type(self).__name__, type(other).__name__))
  183.     def __repr__(self):
  184.         return f"Counter({self.counts})"
  185. if __name__ == '__main__':
  186.     c = Counter({'apple': 3, 'banana': 2})
  187.     c -= {'apple': 1, 'orange': 1}  # 注意：'orange' 初始不存在于计数器中
  188.     print(c)  # 应该输出: Counter({'apple': 2, 'banana': 2})
  189.  
  190. # 10、自定义范围类(Range的变种)
  191. class CustomRange:
  192.     def __init__(self, start, stop=None, step=1):
  193.         if stop is None:
  194.             start, stop = 0, start
  195.         self.start = start
  196.         self.stop = stop
  197.         self.step = step
  198.     def __isub__(self, other):
  199.         if isinstance(other, int) and other >= 0:
  200.             if self.step > 0:
  201.                 self.stop = max(self.start, self.stop - other)
  202.             else:
  203.                 self.start = min(self.start, self.start + other)
  204.             return self
  205.         else:
  206.             raise ValueError("Unsupported operand type or value for -= on CustomRange")
  207.     def __iter__(self):
  208.         current = self.start
  209.         while self.step > 0 and current < self.stop or self.step < 0 and current > self.stop:
  210.             yield current
  211.             current += self.step
  212.     def __repr__(self):
  213.         return f"CustomRange({self.start}, {self.stop}, {self.step})"
  214. if __name__ == '__main__':
  215.     rng = CustomRange(1, 10)
  216.     for i in rng:
  217.         print(i, end=' ') # 输出: 1 2 3 4 5 6 7 8 9
  218.     print()
  219.     rng -= 3
  220.     for i in rng:
  221.         print(i, end=' ') # 输出: 1 2 3 4 5 6

40、__iter__方法

40-1、语法
  1. __iter__(self, /)
  2.     Implement iter(self)
40-2、参数

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

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

40-3、功能

        用于定义一个对象的迭代器。

40-4、返回值

        返回一个迭代器对象。

40-5、说明

        __iter__ 方法返回一个迭代器对象，该对象必须实现两个方法：__iter__ 和 __next__。

40-5-1、__iter__ 方法：返回迭代器自身，这允许在迭代过程中，即使对象本身被用作迭代器，也可以保持迭代的一致性。

40-5-2、__next__ 方法：返回迭代器中的下一个元素，当没有更多元素可迭代时，它应该引发一个StopIteration异常。

40-6、用法
  1. # 040、__iter__方法：
  2. # 1、简单的列表迭代器
  3. class SimpleList:
  4.     def __init__(self, data):
  5.         self.data = data
  6.     def __iter__(self):
  7.         return iter(self.data)
  8. lst = SimpleList([3, 5, 6, 8, 10, 11, 24])
  9. for item in lst:
  10.     print(item)
  11. # 3
  12. # 5
  13. # 6
  14. # 8
  15. # 10
  16. # 11
  17. # 24
  18.  
  19. # 2、斐波那契数列迭代器
  20. class Fibonacci:
  21.     def __init__(self, max_value):
  22.         self.max_value = max_value
  23.         self.a, self.b = 0, 1
  24.     def __iter__(self):
  25.         return self
  26.     def __next__(self):
  27.         if self.a > self.max_value:
  28.             raise StopIteration
  29.         fib = self.a
  30.         self.a, self.b = self.b, self.a + self.b
  31.         return fib
  32. fib = Fibonacci(100)
  33. for num in fib:
  34.     print(num)
  35. # 0
  36. # 1
  37. # 1
  38. # 2
  39. # 3
  40. # 5
  41. # 8
  42. # 13
  43. # 21
  44. # 34
  45. # 55
  46. # 89
  47.  
  48. # 3、文件逐行读取迭代器
  49. class LineIterator:
  50.     def __init__(self, filename):
  51.         self.file = open(filename, 'r')
  52.     def __iter__(self):
  53.         return self
  54.     def __next__(self):
  55.         line = self.file.readline()
  56.         if not line:
  57.             raise StopIteration
  58.         return line.strip()
  59.     def __del__(self):
  60.         self.file.close()
  61.  
  62. it = LineIterator('test.txt')
  63. for line in it:
  64.     print(line)
  65.  
  66. # 4、字符串迭代器(按字符)
  67. class StringIterator:
  68.     def __init__(self, string):
  69.         self.string = string
  70.         self.index = 0
  71.     def __iter__(self):
  72.         return self
  73.     def __next__(self):
  74.         if self.index >= len(self.string):
  75.             raise StopIteration
  76.         char = self.string[self.index]
  77.         self.index += 1
  78.         return char
  79. str_it = StringIterator('hello')
  80. for char in str_it:
  81.     print(char)
  82. # h
  83. # e
  84. # l
  85. # l
  86. # o
  87.  
  88. # 5、字典迭代器(按键)
  89. class DictKeyIterator:
  90.     def __init__(self, dictionary):
  91.         self.dictionary = dictionary
  92.         self.keys = iter(dictionary.keys())
  93.     def __iter__(self):
  94.         return self
  95.     def __next__(self):
  96.         return next(self.keys)
  97. d = {'a': 1, 'b': 2, 'c': 3}
  98. it = DictKeyIterator(d)
  99. for key in it:
  100.     print(key)
  101. # a
  102. # b
  103. # c
  104.  
  105. # 6、自定义集合迭代器(按特定顺序，如降序)
  106. class SortedSetIterator:
  107.     def __init__(self, set_data):
  108.         self.set_data = sorted(set_data, reverse=True)
  109.         self.index = 0
  110.     def __iter__(self):
  111.         return self
  112.     def __next__(self):
  113.         if self.index >= len(self.set_data):
  114.             raise StopIteration
  115.         item = self.set_data[self.index]
  116.         self.index += 1
  117.         return item
  118. s = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}
  119. it = SortedSetIterator(s)
  120. for item in it:
  121.     print(item)
  122. # 9
  123. # 6
  124. # 5
  125. # 4
  126. # 3
  127. # 2
  128. # 1

五、推荐阅读

1、Python筑基之旅

2、Python函数之旅

3、Python算法之旅

4、博客个人主页

遨游码海，我心飞扬
微信名片
注：本文转载自blog.csdn.net的神奇夜光杯的文章"https://myelsa1024.blog.csdn.net/article/details/139388485"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！