Python魔法之旅-魔法方法(15)_python的魔法函数官方文档

目录

一、概述

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

四、魔法方法

47、__mod__方法

47-1、语法

47-2、参数

47-3、功能

47-4、返回值

47-5、说明

47-6、用法

48、__mul__方法

48-1、语法

48-2、参数

48-3、功能

48-4、返回值

48-5、说明

48-6、用法

49、__ne__方法

49-1、语法

49-2、参数

49-3、功能

49-4、返回值

49-5、说明

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

四、魔法方法

47、__mod__方法

47-1、语法

__mod__(self, other, /)
    Return self % other

47-2、参数

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

47-2-2、other(必须)：表示对self进行取模操作的另一个对象或值。

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

47-3、功能

        用于定义对象之间取模(求余数)的操作。

47-4、返回值

        返回一个值，该值表示self除以other的余数。

47-5、说明

        取模操作的规则是：

47-5-1、如果self和other都是整数，那么结果是self除以other的余数。

47-5-2、如果self和other是浮点数，那么结果也是浮点数，表示self除以other的余数。但是要注意，浮点数取模的行为在不同的系统和Python版本之间可能略有不同，因为浮点数的精度问题。

47-5-3、如果self或other是你自定义的类的实例，并且该类定义了 __mod__ 方法，那么Python将调用该方法来执行取模操作。

47-6、用法

# 047、__mod__方法：
# 1、自定义整数类
class CustomInt:
    def __init__(self, value):
        self.value = int(value)
    def __mod__(self, other):
        if isinstance(other, CustomInt):
            other_value = other.value
        else:
            other_value = int(other)
        return CustomInt(self.value % other_value)
    def __str__(self):
        return str(self.value)
if __name__ == '__main__':
    a = CustomInt(10)
    b = CustomInt(3)
    result = a % b
    print(str(result))  # 输出: 1
 
# 2、颜色轮循环
class ColorWheel:
    def __init__(self, colors):
        self.colors = colors
        self.current_index = 0
    def __mod__(self, n):
        return self.current_index % n
    def get_next_color(self):
        self.current_index = (self.current_index + 1) % len(self.colors)
        return self.colors[self.current_index]
    def set_color_index(self, index):
        self.current_index = index % len(self.colors)
    def __repr__(self):
        return f"ColorWheel(current_color={self.colors[self.current_index]})"
if __name__ == '__main__':
    colors = ['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']
    color_wheel = ColorWheel(colors)
    for _ in range(10):
        print(color_wheel.get_next_color())
    color_wheel.set_color_index(10)
    print(color_wheel)  # 输出当前颜色轮的状态
 
# 3、日期偏移
from datetime import datetime, timedelta
class CustomDate:
    def __init__(self, year, month, day):
        self.date = datetime(year, month, day)
    def __mod__(self, days):
        delta = timedelta(days=days)
        new_date = self.date + delta
        cycle_length = 7
        offset_within_cycle = (new_date.weekday() + 1) % cycle_length
        adjusted_date = new_date - timedelta(days=new_date.weekday()) + timedelta(days=offset_within_cycle)
        return CustomDate(adjusted_date.year, adjusted_date.month, adjusted_date.day)
    def __str__(self):
        return self.date.strftime("%Y-%m-%d")
if __name__ == '__main__':
    date1 = CustomDate(2024, 6, 4)
    print(date1)  # 输出:2024-06-04
    offset_date = date1 % 10
    print(offset_date)  # 输出:2024-06-15

48、__mul__方法

48-1、语法

__mul__(self, other, /)
    Return self * other

48-2、参数

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

48-2-2、 other(必须)：表示与self相乘的另一个对象或值。

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

48-3、功能

        用于定义当对象使用*运算符进行乘法操作时的行为。

48-4、返回值

        返回一个值，该值表示self与other相乘的结果。

48-5、说明

        无

48-6、用法

# 048、__mul__方法：
# 1、矩阵乘法
class Matrix:
    # 假设这是一个简单的2x2矩阵类
    def __init__(self, data):
        self.data = data
    def __mul__(self, other):
        if len(self.data) != len(other.data[0]):
            raise ValueError("矩阵维度不匹配!")
        result = [[0 for _ in range(len(other.data[0]))] for _ in range(len(self.data))]
        for i in range(len(self.data)):
            for j in range(len(other.data[0])):
                for k in range(len(other.data)):
                    result[i][j] += self.data[i][k] * other.data[k][j]
        return Matrix(result)
if __name__ == '__main__':
    A = Matrix([[3, 6], [5, 11]])
    B = Matrix([[10, 8], [10, 24]])
    C = A * B
    print(C.data)  # 输出：[[90, 168], [160, 304]]
 
# 2、复数乘法
class ComplexNumber:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
    def __mul__(self, other):
        real = self.real * other.real - self.imag * other.imag
        imag = self.real * other.imag + self.imag * other.real
        return ComplexNumber(real, imag)
if __name__ == '__main__':
    c1 = ComplexNumber(5, 11)
    c2 = ComplexNumber(10, 24)
    c3 = c1 * c2
    print(c3.real, c3.imag)  # 输出：-214 230
 
# 3、向量点积
class Vector:
    def __init__(self, data):
        self.data = data
    def __mul__(self, other):
        if len(self.data) != len(other.data):
            raise ValueError("向量维度不匹配！")
        result = sum(a * b for a, b in zip(self.data, other.data))
        return result
if __name__ == '__main__':
    v1 = Vector([1, 2, 3])
    v2 = Vector([4, 5, 6])
    dot_product = v1 * v2
    print(dot_product)  # 输出：32
 
# 4、多项式乘法
class Polynomial:
    def __init__(self, coeffs):
        self.coeffs = coeffs
    def __mul__(self, other):
        # 假设coeffs是降幂排列的系数列表
        result_coeffs = [0] * (len(self.coeffs) + len(other.coeffs) - 1)
        for i, a in enumerate(self.coeffs):
            for j, b in enumerate(other.coeffs):
                result_coeffs[i + j] += a * b
        # 删除结果中的前导零
        while result_coeffs and result_coeffs[-1] == 0:
            result_coeffs.pop()
        return Polynomial(result_coeffs)
if __name__ == '__main__':
    p1 = Polynomial([1, 2, 3])  # 表示 3x^2 + 2x + 1
    p2 = Polynomial([4, 5])  # 表示 5x + 4
    p3 = p1 * p2
    print(p3.coeffs)  # 输出：[4, 13, 22, 15]
 
# 5、分数乘法
from fractions import Fraction
class RationalNumber:
    def __init__(self, numerator, denominator):
        self.numerator = numerator
        self.denominator = denominator
        self.simplify()
    def simplify(self):
        # 简化分数
        g = self.gcd(self.numerator, self.denominator)
        self.numerator //= g
        self.denominator //= g
    def gcd(self, a, b):
        while b:
            a, b = b, a % b
        return a
    def __mul__(self, other):
        return RationalNumber(
            self.numerator * other.numerator,
            self.denominator * other.denominator
        )
    def __str__(self):
        return f"{self.numerator}/{self.denominator}"
if __name__ == '__main__':
    r1 = RationalNumber(1, 2)
    r2 = RationalNumber(3, 4)
    r3 = r1 * r2
    print(r3)  # 输出: 3/8
 
# 6、货币乘法(例如，计算总价)
class Money:
    def __init__(self, amount, currency='USD'):
        self.amount = amount
        self.currency = currency
    def __mul__(self, other):
        if not isinstance(other, (int, float)):
            raise TypeError("Cannot multiply Money with non-numeric value.")
        return Money(self.amount * other, self.currency)
    def __str__(self):
        return f"{self.amount} {self.currency}"
if __name__ == '__main__':
    m1 = Money(10, 'EUR')
    total = m1 * 2
    print(total)  # 输出: 20 EUR
 
# 7、向量与标量乘法
class Vector:
    def __init__(self, *components):
        self.components = components
    def __mul__(self, scalar):
        if isinstance(scalar, (int, float)):
            return Vector(*[component * scalar for component in self.components])
        else:
            raise TypeError("Unsupported operand type for multiplication with Vector.")
    def __str__(self):
        return f"({', '.join(map(str, self.components))})"
if __name__ == '__main__':
    v = Vector(1, 2, 3)
    s = 2
    scaled_v = v * s
    print(scaled_v)  # 输出：(2, 4, 6)
 
# 8、自定义四则运算类
class CustomArithmetic:
    def __init__(self, value):
        self.value = value
    def __mul__(self, other):
        if isinstance(other, CustomArithmetic):
            return CustomArithmetic(self.value * other.value)
        elif isinstance(other, (int, float)):
            return CustomArithmetic(self.value * other)
        else:
            raise TypeError("Unsupported operand type for multiplication.")
    def __str__(self):
        return str(self.value)
if __name__ == '__main__':
    a = CustomArithmetic(10)
    b = CustomArithmetic(24)
    c = a * b
    print(c)  # 输出:240

49、__ne__方法

49-1、语法

__ne__(self, other, /)
    Return self != other

49-2、参数

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

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

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

49-3、功能

        用于定义对象之间的“不等于”比较操作。

49-4、返回值

        返回一个布尔值：如果self和other不相等，则返回True；如果它们相等，则返回False。

49-5、说明

        无

49-6、用法

# 049、__ne__方法：
# 1、简单的数字类
class Number:
    def __init__(self, value):
        self.value = value
    def __ne__(self, other):
        if isinstance(other, Number):
            return self.value != other.value
        return NotImplemented
if __name__ == '__main__':
    n1 = Number(5)
    n2 = Number(5)
    print(n1 != n2)  # 输出：False
 
# 2、字符串包装类
class StringWrapper:
    def __init__(self, string):
        self.string = string
    def __ne__(self, other):
        if isinstance(other, StringWrapper):
            return self.string != other.string
        return NotImplemented
if __name__ == '__main__':
    s1 = StringWrapper("hello")
    s2 = StringWrapper("world")
    print(s1 != s2)  # 输出：True
 
# 3、坐标点类
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __ne__(self, other):
        if isinstance(other, Point):
            return self.x != other.x or self.y != other.y
        return NotImplemented
if __name__ == '__main__':
    p1 = Point(1, 2)
    p2 = Point(1, 2)
    print(p1 != p2)  # 输出：False
 
# 4、用户名密码类(仅比较用户名)
class Credentials:
    def __init__(self, username, password):
        self.username = username
        self.password = password
    def __ne__(self, other):
        if isinstance(other, Credentials):
            return self.username != other.username
        return NotImplemented
if __name__ == '__main__':
    c1 = Credentials("user", "pass")
    c2 = Credentials("user", "otherpass")
    print(c1 != c2)  # 输出：False，注意这里仅比较了用户名
 
# 5、日期类
from datetime import date
class Date:
    def __init__(self, year, month, day):
        self.date = date(year, month, day)
    def __ne__(self, other):
        if isinstance(other, Date):
            return self.date != other.date
        return NotImplemented
if __name__ == '__main__':
    d1 = Date(2024, 3, 15)
    d2 = Date(2024, 3, 16)
    print(d1 != d2)  # 输出：True
 
# 6、矩形类(比较面积)
class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def area(self):
        return self.width * self.height
    def __ne__(self, other):
        if isinstance(other, Rectangle):
            return self.area() != other.area()
        return NotImplemented
if __name__ == '__main__':
    r1 = Rectangle(3, 4)
    r2 = Rectangle(2, 6)
    print(r1 != r2)  # 输出：False
 
# 7、电子邮件地址类
class EmailAddress:
    def __init__(self, address):
        self.address = address
    def __ne__(self, other):
        if isinstance(other, EmailAddress):
            return self.address.lower() != other.address.lower()
        return NotImplemented
if __name__ == '__main__':
    e1 = EmailAddress("user@example.com")
    e2 = EmailAddress("User@Example.com")  # 大小写不同
    print(e1 != e2)  # 输出：False
 
# 8、文件路径类(忽略大小写和路径分隔符)
import os
class FilePath:
    def __init__(self, path):
        self.path = os.path.normpath(path).lower()
    def __ne__(self, other):
        if isinstance(other, FilePath):
            return self.path != other.path
        return NotImplemented
if __name__ == '__main__':
    p1 = FilePath("/home/user/documents/file.txt")
    p2 = FilePath("/home/USER/Documents/FILE.TXT")  # 忽略大小写和路径分隔符
    print(p1 != p2)  # 输出：False
 
# 9、字典包装类(比较键和值)
class DictWrapper:
    def __init__(self, dictionary):
        self.dictionary = dictionary
    def __ne__(self, other):
        if isinstance(other, DictWrapper):
            return self.dictionary != other.dictionary
        return NotImplemented
if __name__ == '__main__':
    d1 = DictWrapper({"a": 1, "b": 2})
    d2 = DictWrapper({"a": 1, "b": 3})
    print(d1 != d2)  # 输出：True
 
# 10、集合包装类
class SetWrapper:
    def __init__(self, set_items):
        self.set_items = set(set_items)
    def __ne__(self, other):
        if isinstance(other, SetWrapper):
            return self.set_items != other.set_items
        return NotImplemented
if __name__ == '__main__':
    s1 = SetWrapper({1, 2, 3})
    s2 = SetWrapper({1, 2, 4})
    print(s1 != s2)  # 输出：True

五、推荐阅读

1、Python筑基之旅

2、Python函数之旅

3、Python算法之旅

4、博客个人主页