Python 隐藏的超能力：掌握编码魔法的元对象协议

在文章实战开发的过程中，我们经常会遇到一些这样那样的问题，然后要卡好半天，等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《Python 隐藏的超能力：掌握编码魔法的元对象协议》，聊聊，希望可以帮助到正在努力赚钱的你。

python 的元对象协议 (mop) 是一项强大的功能，可让我们调整该语言的核心工作方式。这就像进入后台了解 python 的内部运作一样。让我们探索这个迷人的世界，看看如何让 python 随心所欲。

mop 的核心就是自定义对象的行为方式。我们可以改变它们的创建方式、访问属性的方式，甚至方法的调用方式。这是非常酷的东西。

让我们从对象创建开始。在python中，当我们创建一个新类时，默认使用类型元类。但是我们可以创建自己的元类来改变类的构建方式。这是一个简单的例子：

class mymeta(type):
    def __new__(cls, name, bases, attrs):
        attrs['custom_attribute'] = 'i was added by the metaclass'
        return super().__new__(cls, name, bases, attrs)

class myclass(metaclass=mymeta):
    pass

print(myclass.custom_attribute)  # output: i was added by the metaclass

在此示例中，我们创建了一个元类，该元类向它创建的每个类添加自定义属性。这只是元类的冰山一角。

现在，我们来谈谈属性访问。 python 使用 __getattr__、__setattr__ 和 __delattr__ 等特殊方法来控制属性的访问、设置和删除方式。我们可以重写这些方法来创建一些非常有趣的行为。

例如，我们可以创建一个记录所有属性访问的类：

class loggingclass:
    def __getattr__(self, name):
        print(f"accessing attribute: {name}")
        return super().__getattribute__(name)

obj = loggingclass()
obj.some_attribute  # output: accessing attribute: some_attribute

这是一个简单的示例，但您可以想象这对于调试或创建代理对象有多么强大。

说到代理，它们是我们可以使用 mop 实现的另一个很酷的功能。代理是代表另一个对象的对象，拦截并可能修改与原始对象的交互。这是一个基本示例：

class proxy:
    def __init__(self, obj):
        self._obj = obj

    def __getattr__(self, name):
        print(f"accessing {name} through proxy")
        return getattr(self._obj, name)

class realclass:
    def method(self):
        return "i'm the real method"

real = realclass()
proxy = proxy(real)
print(proxy.method())  # output: accessing method through proxy \n i'm the real method

此代理在将属性访问传递给真实对象之前记录所有属性访问。您可以将其用于延迟加载、访问控制甚至分布式系统等。

现在，我们来谈谈描述符。这些对象定义了其他对象的属性应如何表现。它们是属性、类方法和静态方法背后的魔力。我们可以创建自己的描述符来实现自定义行为。这是确保属性始终为正的描述符的简单示例：

class positivenumber:
    def __init__(self):
        self._value = 0

    def __get__(self, obj, objtype):
        return self._value

    def __set__(self, obj, value):
        if value < 0:
            raise valueerror("must be positive")
        self._value = value

class myclass:
    number = positivenumber()

obj = myclass()
obj.number = 10  # this works
obj.number = -5  # this raises a valueerror

此描述符确保数字属性始终为正。如果我们尝试将其设置为负值，则会引发错误。

我们还可以使用 mop 来实现延迟加载属性。这些属性在实际需要时才进行计算。我们可以这样做：

class lazyproperty:
    def __init__(self, function):
        self.function = function
        self.name = function.__name__

    def __get__(self, obj, type=none):
        if obj is none:
            return self
        value = self.function(obj)
        setattr(obj, self.name, value)
        return value

class expensiveobject:
    @lazyproperty
    def expensive_attribute(self):
        print("computing expensive attribute...")
        return sum(range(1000000))

obj = expensiveobject()
print("object created")
print(obj.expensive_attribute)  # only now is the attribute computed
print(obj.expensive_attribute)  # second access is instant

在此示例中，在首次访问之前不会计算昂贵的属性。之后，它的值将被缓存以供将来访问。

mop 还允许我们在 python 中重载运算符。这意味着我们可以通过加法、减法甚至比较等内置操作来定义对象的行为方式。这是一个简单的例子：

class vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return vector(self.x + other.x, self.y + other.y)

    def __str__(self):
        return f"vector({self.x}, {self.y})"

v1 = vector(1, 2)
v2 = vector(3, 4)
print(v1 + v2)  # output: vector(4, 6)

在本例中，我们定义了 vector 对象应如何添加在一起。我们可以对减法、乘法或任何其他我们想要的运算执行相同的操作。

mop 的更高级用途之一是实现虚拟子类。这些类的行为就好像它们是另一个类的子类，即使它们不是传统意义上的继承。我们可以使用 __subclasshook__ 方法来做到这一点：

from abc import abc, abstractmethod

class drawable(abc):
    @classmethod
    def __subclasshook__(cls, c):
        if cls is drawable:
            if any("draw" in b.__dict__ for b in c.__mro__):
                return true
        return notimplemented

    @abstractmethod
    def draw(self): pass

class square:
    def draw(self):
        print("drawing a square")

print(issubclass(square, drawable))  # output: true

在此示例中，square 被视为 drawable 的子类，因为它实现了一个绘制方法，即使它没有显式继承自 drawable。

我们还可以使用 mop 来创建特定领域的语言功能。例如，我们可以创建一个自动记忆函数结果的装饰器：

import functools

def memoize(func):
    cache = {}
    @functools.wraps(func)
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrapper

@memoize
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(100))  # this computes quickly despite the recursive nature

这个记忆装饰器使用缓存来存储之前计算的结果，大大加快了斐波那契计算器等递归函数的速度。

mop 还可用于优化关键代码路径的性能。例如，我们可以使用 __slots__ 来减少我们创建许多实例的对象的内存占用：

class Point:
    __slots__ = ['x', 'y']

    def __init__(self, x, y):
        self.x = x
        self.y = y

# This Point class uses less memory than a normal class would

通过定义 __slots__，我们准确地告诉 python 我们的类将具有哪些属性。这使得 python 能够优化内存使用，如果我们要创建数百万个这样的对象，这可能会很重要。

python 中的元对象协议是一个强大的工具，它允许我们在基础层面上自定义语言。我们可以改变对象的创建方式、属性的访问方式，甚至基本操作的工作方式。这使我们能够灵活地创建强大的、富有表现力的 api，并以其他方式无法实现的方式优化我们的代码。

从创建自定义描述符和代理到实现虚拟子类和特定领域的语言功能，mop 开辟了一个充满可能性的世界。它允许我们改变 python 的规则来满足我们的特定需求，无论是为了性能优化、创建更直观的 api，还是实现复杂的设计模式。

然而，能力越大，责任越大。虽然 mop 允许我们做一些非常酷的事情，但明智地使用它也很重要。过度使用可能会导致代码难以理解和维护。与任何高级功能一样，权衡其优点和潜在缺点至关重要。

最后，掌握元对象协议让我们更深入地了解 python 的底层工作原理。它使我们能够编写更高效、更具表现力的代码，并以我们以前认为不可能的方式解决问题。无论您是要构建复杂的框架、优化性能关键型代码，还是只是探索 python 的深度，mop 都是您的武器库中的强大工具。

---

我们的创作

一定要看看我们的创作：

投资者中心 | 智能生活 | 时代与回响 | 令人费解的谜团 | 印度教 | 精英开发 | js学校

---

我们在媒体上

科技考拉洞察 | 时代与回响世界 | 投资者中央媒体 | 令人费解的谜团 | 科学与时代媒介 | 现代印度教

本篇关于《Python 隐藏的超能力：掌握编码魔法的元对象协议》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！