动态类创建-Python

以下是场景：

我有两门课：

class A:
  pass:

class B:
  pass

现在我想创建一个客户端，因为我需要一个小的实用程序方法，当我将类名传递给该实用程序时，它应该返回我的类模板/对象，例如：class a，class B，例如

get_obj（class a）

现在，这可能吗？若有，请建议一种方法，因为我现在在网上并没有得到任何正确的答案

希望我说的有道理。

标准库函数创建并返回一个类。它在内部使用

exec

。这可能是你所需要的灵感

源代码：

标准库函数创建并返回一个类。它在内部使用

exec

。这可能是你所需要的灵感

---

源代码：

这里是一个可能的实现。所有代码都包含在一个“.py”文件中

class A:                                                                                            
   pass                                                                                             


class B:                                                                                            
   pass                                                                                             

# map class name to class                                                                                                    
_classes = {                                                                                        
         A.__name__: A,                                                                             
         B.__name__: B,                                                                             
}                                                                                                   

def get_obj(cname):                                                                                       
    return _classes[cname]()                                                                            

# test the function                                                                                                    
if __name__ == '__main__':                                                                          
   print get_obj('A')   

它将产生以下输出

<__main__.A instance at 0x1026ea950>

---

下面是一个可能的实现。所有代码都包含在一个“.py”文件中

class A:                                                                                            
   pass                                                                                             


class B:                                                                                            
   pass                                                                                             

# map class name to class                                                                                                    
_classes = {                                                                                        
         A.__name__: A,                                                                             
         B.__name__: B,                                                                             
}                                                                                                   

def get_obj(cname):                                                                                       
    return _classes[cname]()                                                                            

# test the function                                                                                                    
if __name__ == '__main__':                                                                          
   print get_obj('A')   

它将产生以下输出

<__main__.A instance at 0x1026ea950>

globals（）

返回包含模块全局范围内定义的所有符号的字典（包括类

a

和

B

）：

a_和b_module.py

A类：合格
乙级：及格
def get_cls（cls_名称）：
返回globals（）[cls_name]

如果您想要简单

如果调用此函数的代码位于模块内部，则可以完全删除该函数，并直接使用

globals（）[cls\u name]

如果调用此函数的代码在模块外部，则可以使用

getattr

函数：

a_和b_module.py

A类：合格
乙级：及格

另一个_file.py

导入a_和b_模块
cls_name='A'
所选的cls=getattr（a和b模块，cls名称）

如果您希望完全控制

上述方法的问题在于，它可能返回a_和b_module.py中定义的任何内容，而不将自身限制为

a

和

b

。如果要确保只能返回A和B：

A类：合格
乙级：及格
允许的_类=（'A'，'B'）
def get_cls（cls_名称）：
在允许的\u类中断言cls\u名称
返回globals（）[cls_name]

注意：您可能还对的概念感兴趣。

globals（）

返回包含模块全局范围内定义的所有符号的字典（包括类

a

和

B

）：

a_和b_module.py

A类：合格
乙级：及格
def get_cls（cls_名称）：
返回globals（）[cls_name]

如果您想要简单

如果调用此函数的代码位于模块内部，则可以完全删除该函数，并直接使用

globals（）[cls\u name]

如果调用此函数的代码在模块外部，则可以使用

getattr

函数：

a_和b_module.py

A类：合格
乙级：及格

另一个_file.py

导入a_和b_模块
cls_name='A'
所选的cls=getattr（a和b模块，cls名称）

如果您希望完全控制

上述方法的问题在于，它可能返回a_和b_module.py中定义的任何内容，而不将自身限制为

a

和

b

。如果要确保只能返回A和B：

A类：合格
乙级：及格
允许的_类=（'A'，'B'）
def get_cls（cls_名称）：
在允许的\u类中断言cls\u名称
返回globals（）[cls_name]

---

注意：您可能还对的概念感兴趣。

将类设为Yes，您可以使用

dict

像

cls={'classA'：a，'classB'：B}

，然后您可以调用

cls.get（'classA'）

来实现

get\u obj

。虽然这只是一个开始，但如果没有更多关于你真正想要做什么的细节，实际答案可能会大不相同。你为什么需要它？这个方法返回的空类有什么好处？将这些类设为Yes，您可以使用

dict

像

cls={'classA'：a，'classB'：B}

，然后您可以调用

cls.get（'classA'）

来实现

get\u obj

。虽然这只是一个开始，但如果没有更多关于你真正想要做什么的细节，实际答案可能会大不相同。你为什么需要它？这个方法返回的空类有什么好处？有趣的是，考虑到语言设计者自己似乎对使用

exec

进行此类操作没有问题，人们对这个答案投了反对票。@RickTeachey我投了反对票，因为问题不在于定义类。是关于定义小型实用程序方法，当我将类名传递给该实用程序时，该方法应返回我的类模板/对象，例如：类A、类B。我认为我们需要原始询问者进一步澄清它到底应该做什么。不管他想要的是像@AnthonyKong的答案中那样的dict查找，还是更具动态性的内容。有趣的是，考虑到语言设计者自己似乎对使用

exec

进行此类操作没有问题，人们对这个答案投了反对票。@RickTeachey我投了反对票，因为问题不在于定义类。是关于定义小型实用程序方法，当我将类名传递给该实用程序时，该方法应返回我的类模板/对象，例如：类A、类B。我认为我们需要原始询问者进一步澄清它到底应该做什么。无论他想要的只是@AnthonyKong的答案中的dict查找，还是更具动态性的内容。