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、语法


__ior__(self, other, /)
    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、用法


# 038、__ior__方法：
# 1、位运算类(BitSet)
class BitSet:
    def __init__(self, value=0):
        self.value = value
 
    def __ior__(self, other):
        self.value |= other.value
        return self
if __name__ == '__main__':
    b1 = BitSet(5)  # 二进制 101
    b2 = BitSet(3)  # 二进制 011
    b1 |= b2
    print(bin(b1.value))  # 输出：0b111
 
# 2、集合就地合并
class MySet(set):
    def __ior__(self, other):
        self.update(other)
        return self
if __name__ == '__main__':
    s1 = MySet({1, 2, 3})
    s2 = {3, 4, 5}
    s1 |= s2
    print(s1)  # 输出：MySet({1, 2, 3, 4, 5})
 
# 3、自定义列表就地添加元素
class MyList(list):
    def __ior__(self, other):
        if isinstance(other, list):
            self.extend(other)
        return self
if __name__ == '__main__':
    l1 = MyList([1, 2, 3])
    l2 = [4, 5, 6]
    l1 |= l2
    print(l1)  # 输出：[1, 2, 3, 4, 5, 6]
 
# 4、自定义二进制字符串操作
class BinaryString:
    def __init__(self, value):
        self.value = value
    def __ior__(self, other):
        if isinstance(other, BinaryString):
            self.value = bin(int(self.value, 2) | int(other.value, 2))[2:]
        return self
    def __str__(self):
        return self.value
if __name__ == '__main__':
    b1 = BinaryString('1010')
    b2 = BinaryString('0110')
    b1 |= b2
    print(b1)  # 输出：'1110'
 
# 5、自定义整数范围类
class IntRange:
    def __init__(self, start, end):
        self.start = min(start, end)
        self.end = max(start, end)
    def __ior__(self, other):
        if isinstance(other, IntRange):
            self.start = min(self.start, other.start)
            self.end = max(self.end, other.end)
        return self
    def __str__(self):
        return f'[{self.start}, {self.end}]'
if __name__ == '__main__':
    r1 = IntRange(1, 5)
    r2 = IntRange(4, 10)
    r1 |= r2
    print(r1)  # 输出：'[1, 10]'
 
# 6、自定义权限类
class Permission:
    READ = 1
    WRITE = 2
    EXECUTE = 4
    def __init__(self, value=0):
        self.value = value
    def __ior__(self, other):
        if isinstance(other, Permission):
            self.value |= other.value
        return self
    def __str__(self):
        perms = []
        if self.value & Permission.READ:
            perms.append('READ')
        if self.value & Permission.WRITE:
            perms.append('WRITE')
        if self.value & Permission.EXECUTE:
            perms.append('EXECUTE')
        return ', '.join(perms)
if __name__ == '__main__':
    p1 = Permission(Permission.READ | Permission.WRITE)
    p2 = Permission(Permission.EXECUTE)
    p1 |= p2
    print(p1)  # 输出：'READ, WRITE, EXECUTE'
 
# 7、自定义图形颜色类
class Color:
    RED = 1
    GREEN = 2
    BLUE = 4
    def __init__(self, value=0):
        self.value = value
    def __ior__(self, other):
        if isinstance(other, Color):
            self.value |= other.value
        return self
    def __str__(self):
        colors = []
        if self.value & Color.RED:
            colors.append('RED')
        if self.value & Color.GREEN:
            colors.append('GREEN')
        if self.value & Color.BLUE:
            colors.append('BLUE')
        return ', '.join(colors)
if __name__ == '__main__':
    c1 = Color(Color.RED | Color.GREEN)
    c2 = Color(Color.BLUE)
    c1 |= c2
    print(c1)  # 输出：'RED, GREEN, BLUE'
 
# 8、自定义标签集合类
class TagSet:
    def __init__(self, tags=None):
        self.tags = set(tags or [])
    def __ior__(self, other):
        if isinstance(other, TagSet):
            self.tags.update(other.tags)
        return self
    def __str__(self):
        return ', '.join(sorted(self.tags))
if __name__ == '__main__':
    tags1 = TagSet(['python', 'data-science'])
    tags2 = TagSet(['data-science', 'machine-learning'])
    tags1 |= tags2
    print(tags1)  # 输出：'data-science, machine-learning, python'
 
# 9、自定义坐标范围类
class CoordinateRange:
    def __init__(self, x_start, x_end, y_start, y_end):
        self.x_start = min(x_start, x_end)
        self.x_end = max(x_start, x_end)
        self.y_start = min(y_start, y_end)
        self.y_end = max(y_start, y_end)
    def __ior__(self, other):
        if isinstance(other, CoordinateRange):
            self.x_start = min(self.x_start, other.x_start)
            self.x_end = max(self.x_end, other.x_end)
            self.y_start = min(self.y_start, other.y_start)
            self.y_end = max(self.y_end, other.y_end)
        return self
    def __str__(self):
        return f'[{self.x_start}, {self.x_end}] x [{self.y_start}, {self.y_end}]'
if __name__ == '__main__':
    range1 = CoordinateRange(1, 3, 2, 4)
    range2 = CoordinateRange(2, 5, 3, 6)
    range1 |= range2
    print(range1)  # 输出：[1, 5] x [2, 6]
 
# 10、自定义版本控制类
class Version:
    def __init__(self, major=0, minor=0, patch=0):
        self.major = major
        self.minor = minor
        self.patch = patch
    def __ior__(self, other):
        if isinstance(other, Version):
            if other.major > self.major:
                self.major = other.major
                self.minor = other.minor
                self.patch = other.patch
            elif other.major == self.major and other.minor > self.minor:
                self.minor = other.minor
                self.patch = other.patch
            elif other.major == self.major and other.minor == self.minor and other.patch > self.patch:
                self.patch = other.patch
        return self
    def __str__(self):return f"{self.major}.{self.minor}.{self.patch}"
if __name__ == '__main__':
    v1 = Version(1, 2, 3)
    v2 = Version(1, 3, 0)
    v1 |= v2
    print(v1) # 输出：1.3.0
    v3 = Version(2, 0, 0)
    v1 |= v3
    print(v1) # 输出：2.0.0
 
# 11、自定义时间区间类
from datetime import datetime, timedelta
class TimeInterval:
    def __init__(self, start_time, end_time):
        self.start_time = start_time
        self.end_time = end_time
    def __ior__(self, other):
        if isinstance(other, TimeInterval):
            if self.end_time < other.start_time:
                # 两个区间不重叠，无需合并
                pass
            elif self.start_time > other.end_time:
                # 第一个区间在第二个之后，用第二个区间的起始时间更新第一个区间的起始时间
                self.start_time = other.start_time
            elif self.start_time <= other.start_time <= self.end_time:
                # 第二个区间的起始时间在第一个区间内，无需更新起始时间
                pass
            # 更新结束时间
            self.end_time = max(self.end_time, other.end_time)
        return self
    def __str__(self):
        return f"{self.start_time.strftime('%Y-%m-%d %H:%M:%S')} - {self.end_time.strftime('%Y-%m-%d %H:%M:%S')}"
if __name__ == '__main__':
    start1 = datetime(2019, 3, 13, 8, 0, 0)
    end1 = datetime(2024, 6, 3, 11, 0, 0)
    start2 = datetime(2024, 3, 13, 8, 30, 0)
    end2 = datetime(2024, 6, 3, 11, 0, 0)
    interval1 = TimeInterval(start1, end1)
    interval2 = TimeInterval(start2, end2)
    interval1 |= interval2
    print(interval1)  # 输出：2019-03-13 08:00:00 - 2024-06-03 11:00:00
 
# 12、自定义图片编辑类
class ImageEdit:
    def __init__(self):
        self.edits = {}
    def crop(self, x, y, width, height):
        # 假设我们存储编辑为字典形式，'crop' 是一个键，后面跟着参数
        self.edits['crop'] = (x, y, width, height)
    def rotate(self, degrees):
        self.edits['rotate'] = degrees
        # ... 可以添加其他编辑方法
    def __ior__(self, other):
        if isinstance(other, ImageEdit):
            # 合并另一个编辑对象的编辑效果
            self.edits.update(other.edits)
        return self
    def apply_edits(self, image):
        # 这里仅作为示例，不实现真正的图片编辑逻辑
        # 实际中，这里应该使用图像处理库（如PIL）来应用编辑效果
        print(f"Applying edits to image: {self.edits}")
        # 假设我们已经应用了编辑并返回了处理后的图片（这里仅返回原始图片作为示例）
        return image
if __name__ == '__main__':
    edit1 = ImageEdit()
    edit1.crop(10, 10, 200, 200)
    edit1.rotate(45)
    edit2 = ImageEdit()
    edit2.rotate(90)
    # 合并编辑效果
    edit1 |= edit2
    # 假设我们有一个图片对象image
    image = "output.jpg"
    # 应用编辑效果（这里仅打印编辑信息）
    edited_image = edit1.apply_edits(image)
    print("Edits applied:", edit1.edits)  # 输出：{'crop': (10, 10, 200, 200), 'rotate': 90}

39、isub方法

39-1、语法


__isub__(self, other, /)
    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、用法


# 039、__isub__方法：
# 1、简单的整数类
class Integer:
    def __init__(self, value):
        self.value = value
    def __isub__(self, other):
        if isinstance(other, int):
            self.value -= other
            return self
        else:
            raise TypeError("Unsupported operand type(s) for -=: '{}' and '{}'".format(
                type(self).__name__, type(other).__name__))
    def __repr__(self):
        return str(self.value)
if __name__ == '__main__':
    a = Integer(10)
    b = 2
    a -= b
    print(a)  # 输出: 8
 
# 2、分数类
from fractions import Fraction
class MyFraction:
    def __init__(self, numerator, denominator=1):
        self.value = Fraction(numerator, denominator)
    def __isub__(self, other):
        if isinstance(other, (int, float, Fraction, MyFraction)):
            if isinstance(other, MyFraction):
                other = other.value
            self.value -= other
            return self
        else:
            raise TypeError("Unsupported operand type(s) for -=: '{}' and '{}'".format(
                type(self).__name__, type(other).__name__))
    def __repr__(self):
        return str(self.value)
if __name__ == '__main__':
    f = MyFraction(1, 2)
    f -= MyFraction(1, 4)
    print(f)  # 输出: 1/4
 
# 3、复数类
class ComplexNumber:
    def __init__(self, real, imag=0):
        self.real = real
        self.imag = imag
    def __isub__(self, other):
        if isinstance(other, (int, float, ComplexNumber)):
            if isinstance(other, ComplexNumber):
                other_real, other_imag = other.real, other.imag
            else:
                other_real, other_imag = other, 0
            self.real -= other_real
            self.imag -= other_imag
            return self
        else:
            raise TypeError("Unsupported operand type(s) for -=: '{}' and '{}'".format(
                type(self).__name__, type(other).__name__))
    def __repr__(self):
        return f"{self.real}+{self.imag}j"
if __name__ == '__main__':
    c = ComplexNumber(1, 2)
    c -= 3
    print(c)  # 输出: -2+2j
 
# 4、点类(二维)
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __isub__(self, other):
        if isinstance(other, Point):
            self.x -= other.x
            self.y -= other.y
            return self
        else:
            raise TypeError("Unsupported operand type(s) for -=: '{}' and '{}'".format(
                type(self).__name__, type(other).__name__))
    def __repr__(self):
        return f"({self.x}, {self.y})"
if __name__ == '__main__':
    p = Point(5, 3)
    p -= Point(1, 1)
    print(p)  # 输出: (4, 2)
 
# 5、列表减法(移除元素)
class MyList:
    def __init__(self, items):
        self.items = list(items)
    def __isub__(self, other):
        if isinstance(other, (list, set, tuple)):
            for item in other:
                if item in self.items:
                    self.items.remove(item)
            return self
        else:
            raise TypeError("Unsupported operand type(s) for -=: '{}' and '{}'".format(
                type(self).__name__, type(other).__name__))
    def __repr__(self):
        return str(self.items)
if __name__ == '__main__':
    lst = MyList([1, 2, 3, 4, 5])
    lst -= [2, 4]
    print(lst) # 输出: [1, 3, 5]
 
# 6、集合的差集
class MySet(set):
    def __isub__(self, other):
        if isinstance(other, (set, frozenset)):
            super().__isub__(other)
            return self
        else:
            raise TypeError("Unsupported operand type(s) for -=: '{}' and '{}'".format(
                type(self).__name__, type(other).__name__))
if __name__ == '__main__':
    s = MySet({1, 2, 3, 4, 5})
    s -= {2, 4}
    print(s)  # 输出: MySet({1, 3, 5})
 
# 7、自定义栈的弹出操作(模拟就地减法)
class Stack:
    def __init__(self):
        self.items = []
    def push(self, item):
        self.items.append(item)
    def __isub__(self, count):
        if isinstance(count, int) and count > 0 and count <= len(self.items):
            self.items = self.items[:-count]
            return self
        else:
            raise ValueError("Count must be a positive integer not greater than stack size.")
    def __repr__(self):
        return str(self.items)
 
if __name__ == '__main__':
    # 使用（这里的 `-=` 并不符合栈的标准操作，但仅为示例）
    stk = Stack()
    stk.push(1)
    stk.push(2)
    stk.push(3)
    stk -= 2  # 弹出顶部两个元素
    print(stk)  # 输出: [1]
 
# 8、矩阵类(二维列表)
class Matrix:
    def __init__(self, matrix):
        self.matrix = [row[:] for row in matrix]  # 浅拷贝，确保独立性
    def __isub__(self, other):
        if isinstance(other, Matrix) and len(self.matrix) == len(other.matrix) and all(
                len(row) == len(other_row) for row, other_row in zip(self.matrix, other.matrix)):
            for i in range(len(self.matrix)):
                for j in range(len(self.matrix[i])):
                    self.matrix[i][j] -= other.matrix[i][j]
            return self
        else:
            raise ValueError("Matrix dimensions must agree")
    def __repr__(self):
        return str(self.matrix)
if __name__ == '__main__':
    A = Matrix([[1, 2], [3, 4]])
    B = Matrix([[1, 1], [1, 1]])
    A -= B
    print(A)  # 输出: [[0, 1], [2, 3]]
 
# 9、计数器类(字典的变种)
class Counter:
    def __init__(self, initial=None):
        self.counts = {}
        if initial is not None:
            for item, count in initial.items():
                self.counts[item] = count
    def __isub__(self, other):
        if isinstance(other, dict):
            for item, count in other.items():
                if item in self.counts:
                    self.counts[item] -= count
                    if self.counts[item] <= 0:
                        del self.counts[item]
            return self
        else:
            raise TypeError("Unsupported operand type(s) for -=: '{}' and '{}'".format(
                type(self).__name__, type(other).__name__))
    def __repr__(self):
        return f"Counter({self.counts})"
if __name__ == '__main__':
    c = Counter({'apple': 3, 'banana': 2})
    c -= {'apple': 1, 'orange': 1}  # 注意：'orange' 初始不存在于计数器中
    print(c)  # 应该输出: Counter({'apple': 2, 'banana': 2})
 
# 10、自定义范围类(Range的变种)
class CustomRange:
    def __init__(self, start, stop=None, step=1):
        if stop is None:
            start, stop = 0, start
        self.start = start
        self.stop = stop
        self.step = step
    def __isub__(self, other):
        if isinstance(other, int) and other >= 0:
            if self.step > 0:
                self.stop = max(self.start, self.stop - other)
            else:
                self.start = min(self.start, self.start + other)
            return self
        else:
            raise ValueError("Unsupported operand type or value for -= on CustomRange")
    def __iter__(self):
        current = self.start
        while self.step > 0 and current < self.stop or self.step < 0 and current > self.stop:
            yield current
            current += self.step
    def __repr__(self):
        return f"CustomRange({self.start}, {self.stop}, {self.step})"
if __name__ == '__main__':
    rng = CustomRange(1, 10)
    for i in rng:
        print(i, end=' ') # 输出: 1 2 3 4 5 6 7 8 9
    print()
    rng -= 3
    for i in rng:
        print(i, end=' ') # 输出: 1 2 3 4 5 6

40、iter方法

40-1、语法


__iter__(self, /)
    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、用法


# 040、__iter__方法：
# 1、简单的列表迭代器
class SimpleList:
    def __init__(self, data):
        self.data = data
    def __iter__(self):
        return iter(self.data)
lst = SimpleList([3, 5, 6, 8, 10, 11, 24])
for item in lst:
    print(item)
# 3
# 5
# 6
# 8
# 10
# 11
# 24
 
# 2、斐波那契数列迭代器
class Fibonacci:
    def __init__(self, max_value):
        self.max_value = max_value
        self.a, self.b = 0, 1
    def __iter__(self):
        return self
    def __next__(self):
        if self.a > self.max_value:
            raise StopIteration
        fib = self.a
        self.a, self.b = self.b, self.a + self.b
        return fib
fib = Fibonacci(100)
for num in fib:
    print(num)
# 0
# 1
# 1
# 2
# 3
# 5
# 8
# 13
# 21
# 34
# 55
# 89
 
# 3、文件逐行读取迭代器
class LineIterator:
    def __init__(self, filename):
        self.file = open(filename, 'r')
    def __iter__(self):
        return self
    def __next__(self):
        line = self.file.readline()
        if not line:
            raise StopIteration
        return line.strip()
    def __del__(self):
        self.file.close()
 
it = LineIterator('test.txt')
for line in it:
    print(line)
 
# 4、字符串迭代器(按字符)
class StringIterator:
    def __init__(self, string):
        self.string = string
        self.index = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.index >= len(self.string):
            raise StopIteration
        char = self.string[self.index]
        self.index += 1
        return char
str_it = StringIterator('hello')
for char in str_it:
    print(char)
# h
# e
# l
# l
# o
 
# 5、字典迭代器(按键)
class DictKeyIterator:
    def __init__(self, dictionary):
        self.dictionary = dictionary
        self.keys = iter(dictionary.keys())
    def __iter__(self):
        return self
    def __next__(self):
        return next(self.keys)
d = {'a': 1, 'b': 2, 'c': 3}
it = DictKeyIterator(d)
for key in it:
    print(key)
# a
# b
# c
 
# 6、自定义集合迭代器(按特定顺序，如降序)
class SortedSetIterator:
    def __init__(self, set_data):
        self.set_data = sorted(set_data, reverse=True)
        self.index = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.index >= len(self.set_data):
            raise StopIteration
        item = self.set_data[self.index]
        self.index += 1
        return item
s = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}
it = SortedSetIterator(s)
for item in it:
    print(item)
# 9
# 6
# 5
# 4
# 3
# 2
# 1

五、推荐阅读

1、Python筑基之旅

2、Python函数之旅

3、Python算法之旅

4、博客个人主页

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/697921