猴子修补@property

想法：替换属性描述符以允许在某些对象上设置。除非以这种方式显式设置值，否则将调用原始属性 getter。

问题是如何存储显式设置的值。我们不能使用按修补对象键控的对象，因为 1） 它们不一定在标识上具有可比性;2） 这样可以防止修补的对象被垃圾回收。对于 1） 我们可以编写一个包装对象并按标识覆盖比较语义的 2） 我们可以使用 .但是，我无法让这两者一起工作。dictHandleweakref.WeakKeyDictionary

因此，我们使用一种不同的方法，使用“不太可能的属性名称”将显式设置的值存储在对象本身上。当然，这个名字仍然有可能与某些东西发生冲突，但这几乎是 Python 等语言所固有的。

这不适用于缺少插槽的对象。不过，对于弱裁判来说，也会出现类似的问题。__dict__

class Foo:
    @property
    def bar (self):
        return 'original'

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

    def __eq__(self, other):
        return self._obj is other._obj

    def __hash__(self):
        return id (self._obj)


_monkey_patch_index = 0
_not_set            = object ()
def monkey_patch (prop):
    global _monkey_patch_index, _not_set
    special_attr = '$_prop_monkey_patch_{}'.format (_monkey_patch_index)
    _monkey_patch_index += 1

    def getter (self):
        value = getattr (self, special_attr, _not_set)
        return prop.fget (self) if value is _not_set else value

    def setter (self, value):
        setattr (self, special_attr, value)

    return property (getter, setter)

Foo.bar = monkey_patch (Foo.bar)

f = Foo()
print (Foo.bar.fset)
print(f.bar)  # baz
f.bar = 42    # MAGIC!
print(f.bar)  # 42

子类化基类 （） 并使用属性更改单个实例的类以匹配新的子类：Foo__class__

>>> class Foo:
...     @property
...     def bar(self):
...         return 'Foo.bar'
...
>>> f = Foo()
>>> f.bar
'Foo.bar'
>>> class _SubFoo(Foo):
...     bar = 0
...
>>> f.__class__ = _SubFoo
>>> f.bar
0
>>> f.bar = 42
>>> f.bar
42

看起来您需要从属性转到数据描述符和非数据描述符的领域。属性只是数据描述符的专用版本。函数是非数据描述符的一个示例，当您从实例中检索它们时，它们会返回一个方法，而不是函数本身。

非数据描述符只是具有方法的类的实例。与数据描述符的唯一区别是它也有一个方法。属性最初有一个引发错误的方法，除非您提供 setter 函数。__get____set____set__

你可以通过编写你自己的琐碎的非数据描述符来真正轻松地实现你想要的东西。

class nondatadescriptor:
    """generic nondata descriptor decorator to replace @property with"""
    def __init__(self, func):
        self.func = func

    def __get__(self, obj, objclass):
        if obj is not None:
            # instance based access
            return self.func(obj)
        else:
            # class based access
            return self

class Foo:
    @nondatadescriptor
    def bar(self):
        return "baz"

foo = Foo()
another_foo = Foo()

assert foo.bar == "baz"
foo.bar = 42
assert foo.bar == 42
assert another_foo.bar == "baz"
del foo.bar
assert foo.bar == "baz"
print(Foo.bar)

使这一切起作用的是引擎盖下的逻辑.我目前找不到合适的文档，但检索顺序是：__getattribute__

1. 在类上定义的数据描述符被赋予最高优先级（同时具有 和 的对象），并调用它们的方法。__get____set____get__
2. 对象本身的任何属性。
3. 在类上定义的非数据描述符（仅具有方法的对象）。__get__
4. 类上定义的所有其他属性。
5. 最后，对象的方法作为最后的手段（如果已定义）被调用。__getattr__

from module import ClassToPatch

def get_foo(self):
    return 'foo'

setattr(ClassToPatch, 'foo', property(get_foo))

要对属性进行猴子修补，有一种更简单的方法：

from module import ClassToPatch

def get_foo(self):
    return 'foo'

ClassToPatch.foo = property(get_foo)

还可以修补属性设置器。使用 @fralau 的答案：

from module import ClassToPatch

def foo(self, new_foo):
    self._foo = new_foo

ClassToPatch.foo = ClassToPatch.foo.setter(foo)

参考

如果有人需要修补属性，同时能够调用原始实现，下面是一个示例：

@property
def _cursor_args(self, __orig=mongoengine.queryset.base.BaseQuerySet._cursor_args):
    # TODO: remove this hack when we upgrade MongoEngine
    # https://github.com/MongoEngine/mongoengine/pull/2160
    cursor_args = __orig.__get__(self)
    if self._timeout:
        cursor_args.pop("no_cursor_timeout", None)
    return cursor_args


mongoengine.queryset.base.BaseQuerySet._cursor_args = _cursor_args