我们专注攀枝花网站设计 攀枝花网站制作 攀枝花网站建设
成都网站建设公司服务热线:400-028-6601

网站建设知识

十年网站开发经验 + 多家企业客户 + 靠谱的建站团队

量身定制 + 运营维护+专业推广+无忧售后,网站问题一站解决

36插件化开发_slots_radd-创新互联

目录

创新互联致力于互联网网站建设与网站营销,提供网站建设、成都网站设计、网站开发、seo优化、网站排名、互联网营销、重庆小程序开发公司、公众号商城、等建站开发,创新互联网站建设策划专家,为不同类型的客户提供良好的互联网应用定制解决方案,帮助客户在新的全球化互联网环境中保持优势。

插件化开发...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__': , 'showme': , 'p1': , 'p2': , '__doc__': None}

('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))

输出:

   #是个值,单值,是NotImplementedType类的实例

   #是类型,是异常,返回type,父类RuntimeError-->父类Exception

例:

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://shouzuofang.com/article/isici.html

其他资讯