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__ 等特殊方法来控制属性的访问、设置和删除方式。我们可以重写这些方法来创建一些非常有趣的行为。
立即学习“Python免费学习笔记（深入）”；
例如，我们可以创建一个记录所有属性访问的类：
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学校
我们在媒体上
科技考拉洞察 | 时代与回响世界 | 投资者中央媒体 | 令人费解的谜团 | 科学与时代媒介 | 现代印度教
