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

四、魔法方法

62、reversed方法

62-1、语法


__reversed__(self, /)
    Return a reverse iterator over the dict keys

62-2、参数

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

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

62-3、功能

提供一个定制化的方式来反向遍历对象中的元素。

62-4、返回值

返回一个迭代器对象，该迭代器在迭代时按相反的顺序产生对象的元素。

62-5、说明

迭代器是一个实现了迭代器协议的对象，即它应该有一个__iter__方法返回迭代器本身，以及一个__next__方法用于按需产生序列中的下一个元素。

62-6、用法


# 062、__reversed__方法：
# 1、列表封装类
class ListWrapper:
    def __init__(self, lst):
        self.lst = lst
    def __reversed__(self):
        return reversed(self.lst)
if __name__ == '__main__':
    lw = ListWrapper([1, 2, 3, 4])
    for item in reversed(lw):
        print(item)
# 4
# 3
# 2
# 1
 
# 2、字符串封装类
class StringWrapper:
    def __init__(self, s):
        self.s = s
    def __reversed__(self):
        return reversed(self.s)
if __name__ == '__main__':
    sw = StringWrapper("Myelsa")
    for char in reversed(sw):
        print(char, end='') # 输出：asleyM
 
# 3、自定义集合类
class CustomSet:
    def __init__(self, items):
        self.items = set(items)
    def __reversed__(self):
        # 集合是无序的，但为了示例我们转换为列表然后反转
        return reversed(list(self.items))
if __name__ == '__main__':
    cs = CustomSet([3, 1, 4, 1, 5])
    for item in reversed(cs):
        print(item)
# 5
# 4
# 3
# 1
 
# 4、栈类(使用列表作为底层数据结构)
class Stack:
    def __init__(self):
        self.items = []
    def push(self, item):
        self.items.append(item)
    def __reversed__(self):
        return reversed(self.items)
if __name__ == '__main__':
    s = Stack()
    s.push(1)
    s.push(2)
    s.push(3)
    for item in reversed(s):
        print(item)
# 3
# 2
# 1
 
# 5、队列类(使用列表作为底层数据结构)
class Queue:
    def __init__(self):
        self.items = []
    def enqueue(self, item):
        self.items.append(item)
    def __reversed__(self):
        return reversed(self.items)
if __name__ == '__main__':
    q = Queue()
    q.enqueue(1)
    q.enqueue(2)
    q.enqueue(3)
    for item in reversed(q):
        print(item)
# 3
# 2
# 1
 
# 6、自定义字典类(反转键值对)
class ReversedDict:
    def __init__(self, dict_items):
        self.items = dict_items
    def __reversed__(self):
        return [(v, k) for k, v in self.items.items()]
if __name__ == '__main__':
    rd = ReversedDict({'a': 1, 'b': 2, 'c': 3})
    for value, key in reversed(rd):  # 现在rd直接返回一个列表，可以被reversed处理
        print(f"{key}: {value}")
# a: 1
# b: 2
# c: 3
 
# 7、有向图反转边
class Graph:
    def __init__(self, num_vertices):
        self.num_vertices = num_vertices
        self.adj_list = [[] for _ in range(num_vertices)]
    def add_edge(self, u, v):
        self.adj_list[u].append(v)
    def reverse_edges(self):
        # 反转所有边的方向
        reversed_adj_list = [[] for _ in range(self.num_vertices)]
        for u in range(self.num_vertices):
            for v in self.adj_list[u]:
                reversed_adj_list[v].append(u)
        self.adj_list = reversed_adj_list
if __name__ == '__main__':
    graph = Graph(5)
    graph.add_edge(0, 1)
    graph.add_edge(1, 2)
    graph.add_edge(2, 3)
    graph.add_edge(3, 4)
    print("Original graph:")
    # 打印图的邻接表（省略具体实现）
    graph.reverse_edges()
    print("Reversed graph:")
    # 打印反转后图的邻接表（省略具体实现）
 
# 8、矩阵转置
import numpy as np
def transpose_matrix(matrix):
    return np.transpose(matrix)
if __name__ == '__main__':
    matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    print("Original matrix:")
    print(matrix)
    transposed_matrix = transpose_matrix(matrix)
    print("Transposed matrix:")
    print(transposed_matrix)
 
# 9、矩阵水平翻转
def horizontal_flip_matrix(matrix):
    return matrix[:, ::-1]
if __name__ == '__main__':
    matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    flipped_horizontally = horizontal_flip_matrix(matrix)
    print("Matrix flipped horizontally:")
    print(flipped_horizontally)
 
# 10、矩阵垂直翻转
def vertical_flip_matrix(matrix):
    return matrix[::-1, :]
if __name__ == '__main__':
    matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    flipped_vertically = vertical_flip_matrix(matrix)
    print("Matrix flipped vertically:")
    print(flipped_vertically)

63、rfloordiv方法

63-1、语法


__rfloordiv__(self, other, /)
    Return other // self

63-2、参数

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

63-2-2、other(必须)：表示除法的左侧操作数。

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

63-3、功能

用于定义当对象在右侧使用“地板除”(即整数除法，丢弃余数)运算符//时的行为。

63-4、返回值

返回值应该是执行地板除操作后的结果，即如果self和other都是数字，那么这个方法应该返回other除以self的整数部分(向下取整)。

63-5、说明

__rfloordiv__方法的定义并不常见，因为大多数情况下，我们都是在左侧对象上定义__floordiv__方法来处理地板除操作，然而，在某些情况下，当需要确保自定义类型在与其他类型进行地板除时具有特定行为时，__rfloordiv__方法可能很有用。

63-6、用法


# 063、__rfloordiv__方法：
略，实战中很少用到此方法，一般都是用__floordiv__方法替代实现

64、rlshift方法

64-1、语法


__rlshift__(self, other, /)
    Return other << self

64-2、参数

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

64-2-2、other(必须)：表示左移操作的左侧操作数。

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

64-3、功能

用于定义当对象在右侧使用左移(<<)运算符时的行为。

64-4、返回值

返回值应该是执行左移操作后的结果，即如果self表示要左移的位数，而other是一个整数或支持左移操作的数字类型，那么这个方法应该返回other左移self位数后的结果。

64-5、说明

__rlshift__方法通常与自定义类型的实现一起使用，以提供非标准类型的左移行为。然而，在大多数日常编程任务中，你可能不需要自己实现这个方法，因为Python的内置数字类型已经提供了左移操作的定义。

64-6、用法


# 064、__rlshift__方法：
略，实战中一般很少用到此方法，一般都是通过__lshift__方法替代实现

五、推荐阅读

1、Python筑基之旅

2、Python函数之旅

3、Python算法之旅

4、博客个人主页

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】