36插件化开发_slots_radd-创新互联
目录
插件化开发...1
动态导入：...1
插件化编程技术：...3
__slots__.4
未实现和未实现异常：...6
运算符重载中的反向方法：...6
插件化开发
例：notepad++中插件；firefox、chrome插件；eclipse；
动态导入：
运行时，根据用户（程序员）需求（如提供字符串），找到模块的资源动态加载起来；
1、__import__()，内建函数；
2、importlib.import_module()，import_module(name, package=None)，支持绝对导入和相对导入，相对导入则必须要设置package；
import语句本质上就是调用__import__()这个函数，但不建议直接使用__import__()，建议使用importlib.import_module()；
1、内建函数__import__()；
__import __(name,globals=None,locals=None,fromlist=(),level=0)
name，模块名；
sys = __import__('sys') #等价于import sys，运行时加载
例：
example_module_test1.py
class A:
def show(self):
print(type(self).__name__)
print(type(self.__module__))
example_plugins.py
if __name__ == '__main__':
mod = __import__('example_module_test1') #同import example_module_test1
getattr(mod,'A')().show()
输出：
A
例：
def plugin_load():
mod = __import__('example_module_test1') #加载后会放到sys.modules里，搜索顺序是在sys.path中找
# print(type(mod)) #
getattr(mod,'A')().show() #getattr(object, name[, default]) -> value，等价于mod.A().show()
# mod.A().show()
if __name__ == '__main__':
plugin_load()
输出：
A
例：
def plugin_load(plugin_name:str,sep=':'):
m,_,c = plugin_name.partition(sep)
mod = __import__(m)
cls = getattr(mod,c)
return cls()
if __name__ == '__main__':
# plugin_load()
plugin_load('example_module_test1:A').show()
2、importlib.import_module()：
例：
import importlib
def plugin_load(plugin_name:str,sep=':'):
# m,_,c = plugin_name.partition(sep)
m,c = plugin_name.split(sep)
mod = importlib.import_module(m) #推荐用此种，不要用__import__()
cls = getattr(mod,c)
return cls()
if __name__ == '__main__':
# plugin_load()
plugin_load('example_module_test1:A').show()
输出：
A
插件化编程技术：
依赖的技术：
reflection，反射，运行时获取类型的信息，可动态维护类型数据；
动态import，推荐使用importlib.import_module()，实现动态import模块的能力；
多线程，可开启一个线程，等待用户输入，从而加载指定名称的模块；
加载的时机：
程序启动时？还是程序运行中？
程序启动时，像pycharm这样的工具，需要很多组件，这些组件也可能是插件，启动的时候扫描固定的目录，加载插件；
程序运行时，程序运行过程中，接受用户指令或请求，启动相应的插件；
两种方式各有利弊，如果插件过多，会导致程序启动很慢，如果用户需要时加载，若插件太多或依赖多，插件也会启动慢；
所以先加载必须的、常用的插件，其它插件使用时，发现需要，动态载入；
应用：
软件的设计不可能尽善尽美，或在某些功能上，不可能做的专业，需要专业的客户自己增强；
如notepadd++，它只需要做好一个文本编辑器就可以了，其它增强功能都通过插件的方式提供，如拼写检查、HTML预览、正则插件等；要定义规范、定义插件从哪里加载、如何加载、必须实现的功能等；
接口和插件区别：
接口往往是暴露出来的功能，接口指的是操作（方法|函数），如模块提供了函数和方法，加载模块后调用这些函数完成功能；接口也是一种规范，它约定了必须实现的功能（必须提供某名称的函数），但不关心怎么实现这个功能；api，application program interface；url指向的是后台应用中某个类的方法；
插件是把模块加载到系统中，运行它，增强当前系统功能，或提供系统不具备的功能，往往插件技术应用在框架设计中，系统本身设计简单化、轻量级、实现基本功能后，其它功能通过插件加入进来，方便扩展；
销售：
插件化需求，旗舰版、家庭版；
另一些软件把相应功能的菜单隐藏了，通过序列号可打开隐藏的这些功能；
软件达到一定规模，必须做成框架，越需要插件化思想；常用的先加载，不常用的懒加载；
__slots__
都是字典惹的祸，字典为了提升查询效率，必须用空间换时间（为了hash得占用一定的空间）；
一般来说，一个对象，属性都存储在字典中便于查询，问题不大；但如果数百万个对象，字典就有点大了；这个时候，能否把属性字典__dict__给省了；py提供了__slots__；
可理解为就给这几个槽位放东西，用__slots__规定有什么样的属性；
实例用；标准库中用得多；
限制实例暴露出的属性供别人使用；
类属性不影响；
应用场景：
未来可能产生大量实例，这些实例中有不需要的属性，用__slots__暴露出可用的属性，且用元组形式列出（是可迭代对象均可，一个属性时字符串也可）；
当要使用数百万个对象，且内存容量较为紧张的场景；
__slots__ = 'p1'或__slots__ = 'p1','p2'均可，建议用元组形式__slots__ = ('p1','p2')，__slots__告诉解释器，实例的属性都叫什么，一般来说既然要节约内存，最好还是用元组，一旦类提供了__slots__就阻止实例产生__dict__来保存实例的属性；
继承类的实例不受__slots__影响，__slots__管不到自己的子类，控制不了子类；__slots__不影响子类实例，不会继承下去，除非子类里面自己也定义了__slots__；__slots__一般在子类上用，而且是最下面的子类，父类功能不全；
例：
class A:
x = 123
__slots__ = ('p1','p2') #__slots__ = 'p1'或__slots__ = 'p1','p2'均可，建议用元组形式__slots__ = ('p1','p2')，__slots__告诉解释器，实例的属性都叫什么，一般来说既然要节约内存，最好还是用元组，一旦类提供了__slots__就阻止实例产生__dict__来保存实例的属性
def __init__(self):
self.p1 = 1
self.p2 = 2
def showme(self):
print('I am A.{}'.format(self.p1))
print(A.__dict__)
# print(A().__dict__) #X，实例属性被限制，实例的__dict__消失了
print(A().__slots__)
a = A()
a.p2 = 200
# a.x = 300 # AttributeError: 'A' object attribute 'x' is read-only
A.x = 500
输出：
{'__module__': '__main__', 'x': 123, '__slots__': ('p1', 'p2'), '__init__':
('p1', 'p2')
1 200
例：
class A:
x = 123
__slots__ = ('p1','p2')
def __init__(self):
self.p1 = 1
self.p2 = 2
def showme(self):
print('I am A.{}'.format(self.p1))
class B(A):
def __init__(self):
self.b1 = 500
print(B().__dict__) #继承类的实例不受__slots__影响，__slots__管不到自己的子类，控制不了子类；__slots__不影响子类实例，不会继承下去，除非子类里面自己也定义了__slots__；__slots__一般在子类上用，而且是最下面的子类，父类功能不全
输出：
{'b1': 500}
未实现和未实现异常：
print(type(NotImplemented))
print(type(NotImplementedError))
输出：
例：
class A:
def showme(self):
raise NotImplementedError
print(A().showme())
运算符重载中的反向方法：
例：
class Add:
def __init__(self,x:int):
self.x = x
def __add__(self, other):
print('__add__',self)
# return self.x + other.x
return self.x + other
# def __add__(self, other):
# print('__add__',self)
# try:
# res = self.x + other.x
# except:
# try:
# o = int(other)
# except:
# o = 0
# res = self.x + o
# return res
# def __add__(self, other):
# print('__add__',self)
# try:
# o = int(other.x)
# except:
# o = 0
# return self.x + 0
def __iadd__(self, other):
print('__iadd__',self)
return self.x + other.x
def __radd__(self, other):
print('__radd__',self)
# return self.x + other.x
return self + other
a = Add(4)
b = Add('abc')
# print(a+b)
# print(a+=b)
# print(b+a)
# print(a+1) #不是1（int）没有实现__add__()，int中有所有的方法
print(1+a) #1+a等价于1.__add__(a)，而Int类实现了__add__()，不过这个方法对于这种加法的返回值是NotImplemented，解释器发现是这个值，就会发起对第二操作对象的__radd__()调用
输出：
__radd__ <__main__.Add object at 0x7f42d83acfd0>
__add__ <__main__.Add object at 0x7f42d83acfd0>
5
例：
class Add:
def __init__(self,x:int):
self.x = x
def __add__(self, other):
print('__add__',self)
return self.x + other.x
def __iadd__(self, other):
print('__iadd__',self)
return self.x + other.x
def __radd__(self, other):
print('__radd__',self)
# return self.x + other.x
return self + other
class B:
def __init__(self,x):
self.x = x
a = Add(4)
b = B(6)
print(a+b)
print(b+a) #b+a等价于b.__add__(a)，但类B没有实现__add__()，就去找a的__radd__()方法
输出：
__add__ <__main__.Add object at 0x7f02a03f7160>
10
__radd__ <__main__.Add object at 0x7f02a03f7160>
__add__ <__main__.Add object at 0x7f02a03f7160>
10
另外有需要云服务器可以了解下创新互联cdcxhl.cn，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。
文章标题：36插件化开发_slots_radd-创新互联
转载注明：http://6mz.cn/article/isici.html