Python 基于实例化变量动态重写类方法

我想实现一个类，该类基于实例化变量从不同的文件导入/重写方法，该变量根据变量将Python定向到不同的脚本（/mixin类），以便重写方法

因此，如果我实例化了

MyClass（“foo”）

，它将把

/foo.py

中的函数作为类方法。或者，如果我实例化了

MyClass（“bar”）

，它将包含

/bar.py

的函数作为类方法

为了更清楚地理解我的意思，请参见下面的示例。我完全知道我下面展示的不是有效的Python，但希望它能传达我的意思

我不关心

foo

和

bar

是作为类本身编写的，还是作为一个充满简单Python函数定义的文件编写的，但我在示例中使用了后者

---

假设我有两个脚本

foo.py

和

bar.py

，它们全部包括：

foo.py：

method1(self):
   return "Method 1 Overridden from foo.py"

bar.py：

method2(self):
   return "Method 2 Overridden from bar.py"

我的普通课程设置如下：

def BaseClass():
   def __init__:
      #instantiate class
   def method1(self):
      return "Method 1 - Not Overridden"
   def method2(self):
      return "Method 2 - Not Overridden"

def DynamicClass(BaseClass):
   def __init__(self,configstring):
      super().__init__()
      override_methods(configstring)

我希望输出如下：

>>> a = DynamicClass()
>>>a.method1()
Method 1 - Not Overridden
>>>a.method2()
Method 2 - Not Overridden

>>> b = DynamicClass("foo")
>>>b.method1()
Method 1 Overridden from foo.py
>>>b.method2()
Method 2 - Not Overridden

>>> c = DynamicClass("bar")
>>>c.method1()
Method 1 - Not Overridden
>>>c.method2()
Method 2 Overridden from bar.py

---

再解释一下我问题的“原因”：我想处理大量数据，并根据这些数据做不同的事情。处理数据的步骤是一致的（例如有一个

预处理

步骤、一个

通知管理员

步骤、一个

主处理

步骤和一个

垃圾收集

步骤），但每个步骤中发生的情况都非常不同，这取决于数据的

类型

我想实现一个泛型类，将每个步骤封装为一个方法，如下所示（仅适用于更广泛的默认方法）：

然后让各种文件仅覆盖我需要为每个步骤覆盖的方法：

foo.py
bar.py

然后使用数据itelf作为参数实例化该类：

processor = DynamicClass(dataobject)
processor.pre-processing()
processor.notify-admins()
processor.main-processing()
processor.garbage-collect()

我想你要找的是工厂模式。您应该做的是让每个模块定义基类的子类，并在全局字典中“注册”它们自己（在基类的模块中维护，例如作为静态变量）。然后，您可以使用字典根据允许您标识数据类型的任何键来获取要实例化的子类

基类文件：

# base.py

class Base:
    # ...

factory = dict()

子类文件：

# foo.py
import base

class Foo(base.Base):
    # override whatever you need

base.factory["FOO"] = Foo


呼叫代码：

# mainProgram.py
import base
import foo
import bar

# ...
DataType   = "FOO"
DataObject = base.factory[DataType]()  # will create an instance of Foo

我想你要找的是工厂模式。您应该做的是让每个模块定义基类的子类，并在全局字典中“注册”它们自己（在基类的模块中维护，例如作为静态变量）。然后，您可以使用字典根据允许您标识数据类型的任何键来获取要实例化的子类

基类文件：

# base.py

class Base:
    # ...

factory = dict()

子类文件：

# foo.py
import base

class Foo(base.Base):
    # override whatever you need

base.factory["FOO"] = Foo


呼叫代码：

# mainProgram.py
import base
import foo
import bar

# ...
DataType   = "FOO"
DataObject = base.factory[DataType]()  # will create an instance of Foo

也许我没有完全理解你的问题，但是你为什么要使用
DynamicClass
而不是创建直接继承
BaseClass
的
Foo
和
Bar
类？因为我不知道如何根据变量在调用
Foo
和
Bar
之间切换。Alain T.的回答建议了一种方法，只要我能让它工作……如果这是您的实际问题，请使用类似以下的字典：
d={'foo'：foo'，bar'：bar}
并基于键实例化类：
var='foo'；instance=d['foo']（）
。也许我没有完全理解你的问题，但是您使用
DynamicClass
而不是创建直接继承
BaseClass
的
Foo
和
Bar
类有什么原因吗？因为我不知道如何根据变量在调用
Foo
和
Bar
之间切换。Alain T.的回答建议了一种方法，只要我能让它工作……如果这是您的实际问题，请使用类似以下的字典：
d={'foo'：foo'，bar'：bar}
并基于键实例化类：
var='foo'；instance=d['foo']（）
。我遵循您所说的概念，但无法让实现正常工作。即使给出了最小的实现，
import foo
抛出
NameError:name'Base'未定义
。我忘了在子类文件中添加import Base。我遵循了您所说的概念，但无法使实现工作。即使给出了最小的实现，
import foo
抛出
namererror:name'Base'未定义
。我忘了在子类文件中添加import Base