[python]动态实例化

前言

最近在查一个服务的问题时，看到有一段代码if .. elif ... 写了近百行，类似

1. if command == "xxx":
2.         obj = CommandX()
3.         obj.run()
4.         # ...
5. elif command == "yyy":
6.         obj = CommandY()
7.         obj.run()
8.     # ...
9. elif command == "zzz":
10.         obj = CommandZ()
11.         obj.run()
12.     # ...
14. # ...

复制代码

翻了下git记录，最开始其实只有两三个条件判断，后来command越加越多，就这么延续下来了。
代码逻辑其实没什么问题，也很简单明了，就是看起来有点丑，而且我还开了比较高的桌面缩放，导致一屏幕几乎都是这段if ... elif
看来看去越发觉得丑，先写个demo看看能不能跑通代码。
方式1, 字典映射

如果需要判断的条件比较少，用字典做映射还是挺方便的，但如果条件多，看起来还是挺丑的。

1. from abc import ABC, abstractmethod
3. class AbstractCommand(ABC):
4.     @abstractmethod
5.     def run(self):
6.         pass
8. class CommandA(AbstractCommand):
9.     def run(self):
10.         return "this is command A"
11.    
12. class CommandB(AbstractCommand):
13.     def run(self):
14.         return "this is command B"
15.    
16. class CommandC(AbstractCommand):
17.     def run(self):
18.         return "this is command C"
19.    
20. class CommandFactory:
21.     @staticmethod
22.     def create_command(command_type: str) -> AbstractCommand:
23.         command_mapping = {
24.             "cmda": CommandA,
25.             "cmdb": CommandB,
26.             "cmdc": CommandC
27.         }
28.         cls = command_mapping.get(command_type.lower())
29.         if not cls:
30.             raise ValueError(f"Unknown command type: {command_type}")
31.         return cls()
32.    
33. if __name__ == "__main__":
34.     cmd = CommandFactory.create_command("cmda")
35.     assert cmd.run() == "this is command A"
37.     cmd = CommandFactory.create_command("cmdb")
38.     assert cmd.run() == "this is command B"
40.     cmd = CommandFactory.create_command("cmdc")
41.     assert cmd.run() == "this is command CD"  # should be exception
43.     cmd = CommandFactory.create_command("cmdd")  # should be exception
44.     assert cmd.run() == "this is command D"

复制代码

方式2, __init_subclass__

《流畅的Python(第2版)》的最后一章提到了这个__init__subclass__，根据python官方文档：

当所在类派生子类时此方法就会被调用。cls 将指向新的子类。如果定义为一个普通实例方法，此方法将被隐式地转换为类方法。传给一个新类的关键字参数会被传给上级类的 __init_subclass__。 为了与其他使用 __init_subclass__ 的类兼容，应当去掉需要的关键字参数再将其他参数传给基类。

借助这个机制，可以在实现抽象基类时自动注册子类，避免手动维护注册表。

1. from abc import ABCMeta, abstractmethod
2. from threading import Lock
3. from collections import UserDict
5. class ThreadSafeDict(UserDict):
6.     """线程安全的字典"""
7.     def __init__(self):
8.         super().__init__()
9.         self._lock = Lock()
10.    
11.     def __setitem__(self, key, item):
12.         with self._lock:
13.             super().__setitem__(key, item)
15. class Command(metaclass=ABCMeta):
16.     registry = ThreadSafeDict()
18.     def __init__(self):
19.         pass
21.     @abstractmethod
22.     def run(self):
23.         pass
25.     def __init_subclass__(cls, **kwargs):
26.         super().__init_subclass__(**kwargs)
27.         cls.registry[cls.__name__.lower()] = cls  # 自动注册子类
29. # 子类定义即自动注册
30. class CommandA(Command):
31.     def run(self):
32.         return "this is command a!"
34. class CommandB(Command):
35.     def run(self):
36.         return "this is command b!"
38. class CommandC(Command):
39.     def run(self):
40.         return "this is command b!"
41.    
42. def create_command(command_type: str) -> Command:
43.     """工厂函数"""
44.     cls = Command.registry.get(command_type.lower())
45.     if not cls:
46.         raise ValueError(f"Unknown command type: {command_type}")
47.     return cls()
48.    
49. if __name__ == "__main__":
50.     cmd = create_command("CommandA")
51.     assert cmd.run() == "this is command a!"
52.     cmd = create_command("CommandB")
53.     assert cmd.run() == "this is command b!"
54.     cmd = create_command("CommandC")
55.     assert cmd.run() == "this is command cc!"  # should be exception
56.     cmd = create_command("CommandD")
57.     assert cmd.run() == "this is command b!"  # should be exception

复制代码

乍一看还是挺不错的，但是也有个缺点，那就是如果各个类分散在不同模块中，那么工厂函数所在的模块就要写一堆from xxx import ...
如果module和类命名比较规范，也可以这么动态加载类

1. import importlib
3. def create_class(module_name, class_name):
4.     module = importlib.import_module(module_name)
5.     cls = getattr(module, class_name)
6.     return cls()

复制代码

补充

自动注册类看起来炫，但是对代码阅读来说不是很直观。易读还是美观？这是一个问题。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

感谢分享

鼓励转贴优秀软件安全工具和文档！

谢谢分享，试用一下