Py面试必问：说说魔术方法与应用

2024-05-18  本文已影响0人  Python小魔

在中高级Python开发面试中，面试官为了考察面试者是否了解面向对象编程，会通过Python魔术方法相关概念来变向提问

引言

定义和基本概念

魔术方法（Magic Methods） 是 Python 中一种特殊的函数，它们用于定义类的特定行为和属性。这些方法通常由 Python 解释器自动调用，而不是显式地在代码中调用。

它们允许你自定义类与内置操作符、函数和语法结构的交互方式，使得自定义对象能够像内置类型一样自然地使用。

命名约定

魔术方法的命名有特定的格式要求，它们都以双下划线__开头和结尾。这种命名约定使得这些方法在类中具有特殊的用途，不会与普通的方法名发生冲突。例如：

学习原因

常见魔术方法

初始化、删除、调用
字符串表示
数值运算
类型转换
集合操作
迭代协议
上下文管理
属性访问
描述符协议
比较操作

常见应用示例

字符串表示

__str__ 方法用于定义对象的字符串表示，通常用于用户友好的输出，而 __repr__ 方法用于定义对象的官方字符串表示，通常可以用来重建对象。

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __str__(self):
        return f"({self.x}, {self.y})"

    def __repr__(self):
        return f"Point({self.x}, {self.y})"

point = Point(3, 4)
print(str(point))  # 输出：(3, 4)
print(repr(point))  # 输出：Point(3, 4)
排序和比较

通过实现一系列比较运算的魔术方法，可以定义自定义类的排序和比较行为。

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score
    
    def __lt__(self, other):
        return self.score < other.score
    
    def __eq__(self, other):
        return self.score == other.score

    def __repr__(self):
        return f"Student({self.name}, {self.score})"

students = [
    Student("Alice", 85),
    Student("Bob", 75),
    Student("Charlie", 90)
]
# 根据分数排序
sorted_students = sorted(students)
print(sorted_students)

# 输出：[Student(Bob, 75), Student(Alice, 85), Student(Charlie, 90)]

在这个例子中，通过实现 __lt__ 方法，定义了对象的小于比较。因此可以使用 sorted() 函数对学生列表进行排序。

实现数值类

通过重载算术运算符的魔术方法，可以实现自定义数值类，如复数或矩阵。

class ComplexNumber:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
    
    def __add__(self, other):
        return ComplexNumber(
            self.real + other.real,
            self.imag + other.imag
        )
    
    def __mul__(self, other):
        return ComplexNumber(
            self.real * other.real - self.imag * other.imag,
            self.real * other.imag + self.imag * other.real
        )
    
    def __repr__(self):
        return f"{self.real} + {self.imag}i"

# 创建两个复数
c1 = ComplexNumber(2, 3)
c2 = ComplexNumber(4, 5)

# 复数加法
print(c1 + c2)  # 输出：6 + 8i

# 复数乘法
print(c1 * c2)  # 输出：-7 + 22i

在这个例子中，通过重载 __add__ 和 __mul__ 方法，实现了复数的加法和乘法

集合与序列协议

通过实现集合与序列协议相关的魔术方法，可以定义自定义容器类，使其支持索引和迭代。

比如我们要实现一个既能排序又能去重的SortedSet类：

class SortedSet:
    def __init__(self, items=None):
        self._items = sorted(set(items)) if items else []
    
    def __repr__(self):
        return f"SortedSet({self._items})"
    
    def __len__(self):
        return len(self._items)
    
    def __contains__(self, item):
        return item in self._items
    
    def __iter__(self):
        return iter(self._items)
    
    def __getitem__(self, index):
        return self._items[index]
    
    def add(self, item):
        if item not in self._items:
            self._items.append(item)
            self._items.sort()
    
    def remove(self, item):
        if item in self._items:
            self._items.remove(item)

# 测试 SortedSet 类
s = SortedSet([3, 1, 2, 3, 4])
print(s)           # 输出：SortedSet([1, 2, 3, 4])
print(len(s))      # 输出：4
print(2 in s)      # 输出：True
print(s[0])        # 输出：1
s.add(5)
print(s)           # 输出：SortedSet([1, 2, 3, 4, 5])
s.remove(2)
print(s)           # 输出：SortedSet([1, 3, 4, 5])
属性访问控制

通过实现属性访问相关的魔术方法，可以实现动态属性和代理模式。

class DynamicAttribute:
    def __getattr__(self, name):
        if name == "age":
            return 25
        elif name == "name":
            return "Alice"
        else:
            raise AttributeError(
                f"'DynamicAttribute' object has no attribute '{name}'"
            )

obj = DynamicAttribute()
print(obj.age)  # 输出：25
print(obj.name)  # 输出：Alice

在这个例子中，通过实现 __getattr__ 方法，动态地为对象添加属性。如果属性不存在，则会调用这个方法来获取属性值，这在Python一些的ORM框架中很常见。

构造查询语句

python中的运算符|、&其实可以对标SQL中的or、and，所以我们可以通过魔术方法来实现一些类似SQL语句拼接

# 注：代码块暂不考虑太多异常情况，比如not操作
class Q:
    def __init__(self, *expressions, operator="and", **kwargs):
        self.operator = operator
        self._expressions = expressions
        self._kwargs = kwargs

    def __or__(self, other):
        return Q(self, other, operator="or")

    def __str__(self):
        return self.translate()

    def translate(self):
        kv_sql = " and ".join([f"{k}={v}" for k, v in self._kwargs.items()])
        expr_sql = f" {self.operator} ".join([expr.translate() for expr in self._expressions])
        return expr_sql + (f" {self.operator} " + kv_sql if expr_sql and kv_sql else kv_sql)


# 示例用法
q1 = Q(name='Alice', height=168)
q2 = Q(age=25, gender=0)
q3 = Q(q1, age=25)

# 实现 OR 运算符
print(q1 | q2)
# 输出：name=Alice and height=168 or age=25 and gender=0
print(q3)
# 输出：name=Alice and height=168 and age=25

上面例子中kwargs参数代表的是参与and操作的拼接键值对参数，而|则表示两个对象要进行or操作的拼接，这样就可以实现类似ORM框架里的还原SQL字符串 拼接操作了

上下文管理

上下文管理是 Python 中用于管理资源的一种机制，它可以确保在进入和离开代码块时资源得到正确的管理和释放。在使用 with 语句时，Python 会调用对象的 __enter__ 方法来获取上下文管理器，并在离开代码块时调用 __exit__ 方法来释放资源。

class MyResource:
    def __enter__(self):
        print("Entering the resource")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting the resource")

    def operation(self):
        print("Performing operation")

# 使用上下文管理器
with MyResource() as resource:
    resource.operation()

# Outputs
# Entering the resource
# Performing operation
# Exiting the resource

在这个示例中，MyResource 类实现了上下文管理器。当进入 with 代码块时，Python 会调用 __enter__ 方法，然后执行其中的代码；当离开 with 代码块时，Python 会调用 __exit__ 方法，以确保资源被正确释放。

可调用对象

__call__ 方法使得一个对象可以像函数一样被调用，这对于实现可调用对象非常有用。当调用对象时，Python 解释器会自动调用对象的 __call__ 方法。

class MyCallable:
    def __call__(self, x):
        return x * 2

# 创建可调用对象
callable_obj = MyCallable()

# 调用可调用对象
result = callable_obj(5)
print(result)  # 输出：10

在这个示例中，MyCallable 类实现了 __call__ 方法，使得它的实例可以像函数一样被调用。当调用 callable_obj(5) 时，Python 实际上调用了 callable_obj.__call__(5)。

__new__ 和 __init__

__new__ 方法和 __init__ 方法都是 Python 中用于创建类实例的特殊方法，但它们的作用略有不同。

__new__ 方法在实例创建之前调用，用于创建实例对象，并返回一个新创建的实例。
__init__ 方法在实例创建之后调用，用于初始化实例对象的属性。

class MyClass:
    def __new__(cls, *args, **kwargs):
        print("Creating instance")
        instance = super().__new__(cls)
        return instance

    def __init__(self, x):
        print("Initializing instance")
        self.x = x

# 创建实例
obj = MyClass(5)

# Outputs
# Creating instance
# Initializing instance

在这个示例中，__new__ 方法在实例创建之前被调用，用于创建实例对象，而 __init__ 方法在实例创建之后被调用，用于初始化实例对象的属性。

总结

Python 魔术方法是一种特殊的命名约定，用双下划线包围，用于实现对象的特殊行为和操作。它们包括但不限于初始化、字符串表示、比较、算术运算、上下文管理等方面。通过合理使用魔术方法，可以提高代码的可读性、可维护性，并实现更灵活的编程逻辑，是面向对象编程里一种非常重要的实现方法。

上一篇 下一篇

猜你喜欢

热点阅读