python - 如何覆盖 python 中的嵌入函数/定义值

Question

如果我的问题中的术语不正确，我提前道歉。我想知道是否可以覆盖隐藏在一堆连续的类调用深处的变量，您也无法直接访问该变量，但仍然会影响结果。

这是我尝试编写的一个示例，希望能让我的问题更加清晰。

我有 3 个 python 模块，test1.py、test2.py 和 test3.py。每个模块都有一个类和一些定义。 Test2.py 是代码运行的地方。

测试1.py

class A(object):
    def __init__(self, value=5):
        self.a = value
    def foo(self, value3 = 7, value4 = 5):
        from test3 import D
        c = self.a + value3 + value4
        d = D()
        e = d.B()
        f = c + e
        return f

class B(object):
    def __init__(self, value = 1):
        self.d = value
        object1 = A(self.d)
        self.fooReturn = object1.foo()
    def bar(self, value2 = 3):
        f = value2
        g = self.fooReturn + self.d + f
        return g

测试3.py

class D(object):
    def __init__(self, value=6, wanted_value=9):
        self.value = value + wanted_value
    def A(self, value3 = 4):
        self.value3 = value3 * 2
        return self.value3
    def B(self, value4 = 5):
        valuex = self.A()
        value5 = value4 + self.value + valuex
        return value5

测试2.py

from test1 import B

if __name__ == '__main__':
    test = B(4)
    result = test.bar()
    print result

返回值:-

55

我很抱歉它看起来如此复杂，这是我试图使值看起来超出正常范围的方式:)

基本上我想做的是找出如何重新定义 Test3.py、D 类、init def 中“wanted_value”的值，同时不更改 Test2 中的“if” .py。

if __name__ == '__main__':
    test = B(4)
    result = test.bar()
    print result

我认为可能的一种方法是在 Test2.py 中重新定义 D 类定义，并使用全局变量将对原始 D 类的任何调用重定向到修改后的 D 类。

例如

测试2.py

from test1 import B
from test3 import D

class Dx(D):
    # add the value I want to use to 'wanted_value'
    def __init__(self, value=6, wanted_value=3):
        self.value = value + wanted_value

# create a global
D.__init__ = Dx.__init__

if __name__ == '__main__':
    test = B(4)
    result = test.bar()
    print result

此错误表示“必须使用 Dx 实例作为第一个参数调用未绑定(bind)的方法_init_()”。

所以这显然是不正确的，但是如果这些是使其工作而不必重新定义整个 D 类的方法？

任何帮助都会很棒。很明显，我的继承知识并不是太热门:)

谢谢。

Answer 1

通常，无法执行此操作被视为一项功能。将关注点分离到不同的模块/类中的全部目的是解耦实现，以便对代码的某一部分进行小的更改不会影响到破坏其他地方的其他内容。

您的Test2.py仅使用类B。在理想的世界中，它不必关心该类的实现。如果B的实现方式使得它对D的依赖不是B接口(interface)的一部分(即没有参数或返回) D 类型的值，也不需要任何参数来让 B 的用户控制 D 的初始化)，那么您的代码使用B 不应依赖于 B 在内部使用 D 的事实。通过改变 D 来调整从 B 获得的行为会将您与 B 的特定实现结合起来，并且作为副作用会破坏任何其他用途D 期望 wanted_value 具有通常的默认值。

在模块范围内执行此操作特别邪恶，因为也使用 D 的其他不相关模块将受到您对类 D 的更改的影响，也可能不会受到影响，具体取决于是否您的模块已经导入，这可能发生在程序完全不相关的部分。

<小时/>

所以这些都是你通常不应该这样做的原因。假设您已经考虑过这一点，以及是否有其他方法可以得到您想要的东西，并确定这确实是您想要的，那么无论如何，您都可以这样做。 :)

你实际上走在正确的道路上。问题是您在类 Dx 上定义了 __init__，然后尝试将其传输到 D。但是当你执行 Dx.__init__ 时，你不会得到函数对象，而是得到一个“未绑定(bind)方法”(在 Python 2.x 中；这个概念从 Python 3 中消失了)。 “未绑定(bind)方法”几乎与函数一模一样，但它检查其第一个参数(通常是 self)实际上是您从中检索它的类的实例。由于 D 的 __init__ 方法将在 D 的实例上调用，而不是在您检索的类的实例上调用 Dx.__init__ 来自 (Dx)，这是行不通的。

但是没有必要把它放在一个类中。您可以只 def __init__，然后分配 D.__init__ = __init__。

如果这只是更改方法的默认参数，则另一种方法是直接获取默认值。这是一个例子:

class Foo(object):
    def __init__(self, apple='orange'):
        self.apple = apple

f = Foo()
print f.apple     # orange

Foo.__init__.im_func.func_defaults = ('octopus',)
f = Foo()
print f.apple     # octopus

无论您采取哪种方式，最好在创建特殊的 B 之前对 D 进行全局破解，并在之后恢复它。也许你应该将它包装在一个函数中:

def specialB():
    # save original value of __init__ or func_defaults
    try:
        # hack for D goes here
        b = B()
    finally:
        # restore original value of __init__ or func_defaults
    return b