super)检查sub类是否是 super 类的派生类，反射的概

发布时间：2019-09-23 10:22编辑：美高梅网站浏览（78）

一. 反射

反射的概念是由Smith在一九八二年第贰回建议的，首假使指程序能够访问、检验和更改它自个儿情形或作为的一种力量。这一定义的提议高效引发了Computer科学领域有关使用反射性的钻研。它首先被程序语言的布署性领域所选用,并在Lisp和面向对象方面得到了战绩。

python面向对象中的**反射：通过字符串的款型操作对象相关的性质。python中的一切事物都以目的**

多个能够兑现自省的函数

下列方法适用于类和对象（一切皆对象，类自己也是一个指标）

***  getattr()   用于模块的取文件属性返回某属性**   hasattr()   判断检查对象是否拥有某个属性*    setattr()   函数置文件属性方法将对象中的属性设置为新的属性*    delattr()   删除对象中的属性,删除



class Foo:    f = '类的静态变量'    def __init__(self,name,age):        self.name=name        self.age=age    def say_hi:        print('hi,%s'%self.name)obj=Foo('egon',73)#检测是否含有某属性print(hasattr(obj,'name'))print(hasattr(obj,'say_hi'))#获取属性n=getattr(obj,'name')printfunc=getattr(obj,'say_hi')func()print(getattr(obj,'aaaaaaaa','不存在啊')) #报错#设置属性setattr(obj,'sb',True)setattr(obj,'show_name',lambda self:self.name+'sb')print(obj.__dict__)print(obj.show_name#删除属性delattr(obj,'age')delattr(obj,'show_name')delattr(obj,'show_name111')#不存在,则报错print(obj.__dict__)

对目的的反光

class Foo:     staticField = "old boy"     def __init__:        self.name = 'wupeiqi'     def func:        return 'func'     @staticmethod    def bar():        return 'bar' print getattr(Foo, 'staticField')print getattr(Foo, 'func')print getattr(Foo, 'bar')

对类的反光

import sysdef s1():    print 's1'def s2():    print 's2'this_module = sys.modules[__name__]hasattr(this_module, 's1')getattr(this_module, 's2')

当前模块的反射

#一个模块中的代码def test():    print('from the test')"""程序目录：    module_test.py    index.py 当前文件：    index.py"""# 另一个模块中的代码import module_test as obj#obj.test()print(hasattr(obj,'test'))getattr(obj,'test')()其他模块的示例

其余模块的反射

反射的利用：

刺探了反光的多少个函数。那么反射到底有怎么着用吧？它的行使场景是怎么吧？

明日让我们开拓浏览器，访谈三个网址，你单击登陆就跳转到登入分界面，你单击注册就跳转到注册分界面，等等，其实您单击的莫过于是三个个的链接，每一个链接都会有三个函数或许措施来管理。



class User:    def login:        print('欢迎来到登录页面')        def register:        print('欢迎来到注册页面')        def save:        print('欢迎来到存储页面')while 1:    choose = input('>>>').strip()    if choose == 'login':        obj = User()        obj.login()        elif choose == 'register':        obj = User()        obj.register()            elif choose == 'save':        obj = User()        obj.save()

没学反射此前的消除措施

class User:    def login:        print('欢迎来到登录页面')        def register:        print('欢迎来到注册页面')        def save:        print('欢迎来到存储页面')user = User()while 1:    choose = input('>>>').strip()    if hasattr(user,choose):        func = getattr(user,choose)        func()    else:        print('输入错误。。。。')

学了反光之后化解方法

有多轻松，一览无遗。

isinstance(obj,cls)检查是或不是obj是不是是类 cls 的靶子

二. 函数 vs 方法

学到这里，小编终于能回答你直接以来大概有的五个困惑。那就是，以前的上学中大家称len()为函数却称如str的strip为情势，那它到底叫什么？函数和章程有啥样界别和同样之处？小编在此处就标准的解释一下。



2.1 通过打字与印刷函数名鲜明



def func():    passprint  # <function func at 0x00000260A2E690D0>class A:    def func:        pass    print  # <function A.func at 0x0000026E65AE9C80>obj = A()print  # <bound method A.func of <__main__.A object at 0x00000230BAD4C9E8>>

View Code

1 class Foo(object):
2      pass
3   
4 obj = Foo()
5   
6 isinstance(obj, Foo)

2.2 通过types模块验证



from types import FunctionTypefrom types import MethodTypedef func():    passclass A:    def func:        passobj = A()print(isinstance(func,FunctionType))  # Trueprint(isinstance(A.func,FunctionType))  # Trueprint(isinstance(obj.func,FunctionType))  # Falseprint(isinstance(obj.func,MethodType))  # True

View Code

View Code

2.3 静态方法是函数



from types import FunctionTypefrom types import MethodTypeclass A:        def func:        pass        @classmethod    def func1:        pass        @staticmethod    def func2:        passobj = A()# 静态方法其实是函数# print(isinstance(A.func2,FunctionType))  # True# print(isinstance(obj.func2,FunctionType))  # True

View Code

issubclass(sub, super)检查sub类是还是不是是 super 类的派生类

2.4 函数与办法的分别

那么，函数和格局除了上述的不一致之处，我们还总括了须臾间几点分别。

函数的是显式传递数据的。如作者辈要指明为len()函数字传送递一些要拍卖多少。

函数则跟对象非亲非故。

主意中的数据则是隐式传递的。

格局可以操作类内部的数量。

措施跟对象是关乎的。如我辈在用strip()方法是，是或不是都以要透过str对象调用，举例大家有字符串s,然后s.strip()那样调用。是的，strip()方法属于str对象。

大家可能在经常中会口语化称呼函数和方式时不量体裁衣，不过大家心神要领悟二者之间的分别。

在其他语言中，如Java中唯有方法，C中独有函数，C++么，则取决于是还是不是在类中。



三. 双下方法

概念：双下方法是独特措施，他是解释器提供的 由爽下划线加方法名加双下划线 __方法名__的有着极度含义的艺术,双下方法首要是python源码技士使用的，大家在开辟中尽量不要使用双下方法，可是深入钻研双下方法，更便利于咱们涉猎源码。

调用：不相同的双下方法有例外的接触情势，就好比盗墓时接触的电动同样，无声无息就接触了双下方法，举个例子：__init__

1 class Foo(object):
2     pass
3  
4 class Bar(Foo):
5     pass
6  
7 issubclass(Bar, Foo)

3.01 __len__



class B:    def __len__:        print(666)b = B # len 一个对象就会触发 __len__方法。class A:    def __init__:        self.a = 1        self.b = 2    def __len__:        return len(self.__dict__)a = A()print

View Code

View Code

3.02 __hash__



class A:    def __init__:        self.a = 1        self.b = 2    def __hash__:        return hash(str+stra = A()print

View Code

反射

1 什么是反射

反射的概念是由Smith在1981年第二次建议的，首如果指程序能够访谈、检验和改变它自身意况或作为的一种本事（自省）。这一定义的提出高效掀起了电脑科学领域有关选取反射性的钻探。它首先被程序语言的统一计划领域所采纳,并在Lisp和面向对象方面得到了战表。

 

2 python面向对象中的反射：通过字符串的样式操作对象相关的习性。python中的一切事物都以目的（都能够利用反射）

多个能够兑现自省的函数

下列方法适用于类和对象（一切皆对象，类自身也是三个目的）



 1 class Foo:
 2     f = '类的静态变量'
 3     def __init__(self,name,age):
 4         self.name=name
 5         self.age=age
 6 
 7     def say_hi(self):
 8         print('hi,%s'%self.name)
 9 
10 obj=Foo('egon',73)
11 
12 #检测是否含有某属性
13 print(hasattr(obj,'name'))
14 print(hasattr(obj,'say_hi'))
15 
16 #获取属性
17 n=getattr(obj,'name')
18 print(n)
19 func=getattr(obj,'say_hi')
20 func()
21 
22 print(getattr(obj,'aaaaaaaa','不存在啊')) #报错
23 
24 #设置属性
25 setattr(obj,'sb',True)
26 setattr(obj,'show_name',lambda self:self.name+'sb')
27 print(obj.__dict__)
28 print(obj.show_name(obj))
29 
30 #删除属性
31 delattr(obj,'age')
32 delattr(obj,'show_name')
33 delattr(obj,'show_name111')#不存在,则报错
34 
35 print(obj.__dict__)

View Code



 1 class Foo(object):
 2  
 3     staticField = "old boy"
 4  
 5     def __init__(self):
 6         self.name = 'wupeiqi'
 7  
 8     def func(self):
 9         return 'func'
10  
11     @staticmethod
12     def bar():
13         return 'bar'
14  
15 print getattr(Foo, 'staticField')
16 print getattr(Foo, 'func')
17 print getattr(Foo, 'bar')

View Code



 1 import sys
 2 
 3 
 4 def s1():
 5     print 's1'
 6 
 7 
 8 def s2():
 9     print 's2'
10 
11 
12 this_module = sys.modules[__name__]
13 
14 hasattr(this_module, 's1')
15 getattr(this_module, 's2')

View Code

导入别的模块，利用反射查找该模块是还是不是留存有个别方法

3.03 __str__

假若二个类中定义了__str__措施，那么在打字与印刷 对象 时，默许输出该措施的重回值。



class A:    def __init__:        pass    def __str__:        return '太白'a = A()printprint('%s' % a)

View Code

__str__和__repr__

退换目的的字符串显示__str__,__repr__

自定制格式化字符串__美高梅手机网投，format__



 1 format_dict={
 2     'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型
 3     'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址
 4     'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名
 5 }
 6 class School:
 7     def __init__(self,name,addr,type):
 8         self.name=name
 9         self.addr=addr
10         self.type=type
11 
12     def __repr__(self):
13         return 'School(%s,%s)' %(self.name,self.addr)
14     def __str__(self):
15         return '(%s,%s)' %(self.name,self.addr)
16 
17     def __format__(self, format_spec):
18         # if format_spec
19         if not format_spec or format_spec not in format_dict:
20             format_spec='nat'
21         fmt=format_dict[format_spec]
22         return fmt.format(obj=self)
23 
24 s1=School('oldboy1','北京','私立')
25 print('from repr: ',repr(s1))
26 print('from str: ',str(s1))
27 print(s1)
28 
29 '''
30 str函数或者print函数--->obj.__str__()
31 repr或者交互式解释器--->obj.__repr__()
32 如果__str__没有被定义,那么就会使用__repr__来代替输出
33 注意:这俩方法的返回值必须是字符串,否则抛出异常
34 '''
35 print(format(s1,'nat'))
36 print(format(s1,'tna'))
37 print(format(s1,'tan'))
38 print(format(s1,'asfdasdffd'))

__format__



 1 class B:
 2 
 3      def __str__(self):
 4          return 'str : class B'
 5 
 6      def __repr__(self):
 7          return 'repr : class B'
 8 
 9 
10 b=B()
11 print('%s'%b)
12 print('%r'%b)

%r和%s

3.04 __repr__

美高梅网投网站，假如贰个类中定义了__repr__方法，那么在repr 时，私下认可输出该格局的再次回到值。



class A:    def __init__:        pass    def __repr__:        return '太白'a = A()printprint('%r'%a)

View Code

__del__

析构方法，当指标在内部存款和储蓄器中被放走时，自动触发推行。

注：此格局一般不要定义，因为Python是一门高档语言，技术员在运用时没有供给关怀内部存储器的分配和自由，因为此干活都以付诸Python解释器来施行，所以，析构函数的调用是由解释器在拓宽垃圾回收时自动触发推行的。



1 class Foo:
2 
3     def __del__(self):
4         print('执行我啦')
5 
6 f1=Foo()
7 del f1
8 print('------->')

__del__（析构方法）

3.05 __美高梅官方网站，call__

对象前面加括号，触发施行。

注：构造方法__new__的实行是由创设对象触发的，即：对象 = 类名() ；而对此 __call__ 方法的实施是由对象后加括号触发的，即：对象()



class Foo:    def __init__:        pass        def __call__(self, *args, **kwargs):        print('__call__')obj = Foo() # 执行 __init__obj()       # 执行 __call__

View Code

item系列



 1 class Foo:
 2     def __init__(self,name):
 3         self.name=name
 4 
 5     def __getitem__(self, item):
 6         print(self.__dict__[item])
 7 
 8     def __setitem__(self, key, value):
 9         self.__dict__[key]=value
10     def __delitem__(self, key):
11         print('del obj[key]时,我执行')
12         self.__dict__.pop(key)
13     def __delattr__(self, item):
14         print('del obj.key时,我执行')
15         self.__dict__.pop(item)
16 
17 f1=Foo('sb')
18 f1['age']=18
19 f1['age1']=19
20 del f1.age1
21 del f1['age']
22 f1['name']='alex'
23 print(f1.__dict__)

__getitem__/__setitem__/__delitem__

3.06__eq__



class A:    def __init__:        self.a = 1        self.b = 2    def __eq__:        if  self.a == obj.a and self.b == obj.b:            return Truea = A()b = A()print

View Code

__new__



1 class Foo:
2     def __init__(self):
3         self.x = 1
4         print('in init function')
5 
6     def __new__(cls, *args, **kwargs):
7         print('in new function')
8         return object.__new__(cls, *args, **kwargs)

__new__

3.07 __del__

析构方法，当目的在内部存款和储蓄器中被释放时，自动触发执行。

注：此办法一般不要定义，因为Python是一门高端语言，技术员在动用时没有要求关心内部存款和储蓄器的分配和刑释，因为此干活都以付出Python解释器来实行，所以，析构函数的调用是由解释器在实行垃圾回收时自动触发试行的。

__call__

目的前边加括号，触发实施。

注：构造方法的施行是由创设对象触发的，即：对象 = 类名() ；而对此 __call__ 方法的实践是由对象后加括号触发的，即：对象() 大概 类()()



 1 class Foo:
 2 
 3     def __init__(self):
 4         pass
 5     
 6     def __call__(self, *args, **kwargs):
 7 
 8         print('__call__')
 9 
10 
11 obj = Foo() # 执行 __init__
12 obj()       # 执行 __call__

__call__

3.08__new__



class A:    def __init__:        self.x = 1        print('in init function')    def __new__(cls, *args, **kwargs):        print('in new function')        return object.__new__(A, *args, **kwargs)a = A()print

View Code

class A:    __instance = None    def __new__(cls, *args, **kwargs):        if cls.__instance is None:            obj = object.__new__            cls.__instance = obj        return cls.__instance

单例格局

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。【采用单例模式动机、原因】对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID生成器。如在Windows中就只能打开一个任务管理器。如果不使用机制对窗口对象进行唯一化，将弹出多个窗口，如果这些窗口显示的内容完全一致，则是重复对象，浪费内存资源；如果这些窗口显示的内容不一致，则意味着在某一瞬间系统有多个状态，与实际不符，也会给用户带来误解，不知道哪一个才是真实的状态。因此有时确保系统中某个对象的唯一性即一个类只能有一个实例非常重要。如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。一个更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的模式动机。一、实例控制单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。二、灵活性因为类控制了实例化过程，所以类可以灵活更改实例化过程。一、开销虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。二、可能的开发混淆使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。三、对象生存期不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NET Framework的语言），只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用单例模式具体分析

单例格局具体分析

__len__



 1 class Foo:
 2     def __init__(self):
 3         self.a = 1
 4         self.b = 2
 5 
 6     def __len__(self):
 7         return len(self.__dict__)
 8 
 9 f = Foo()
10 print(len(f))

__len__

3.09 __item__系列



class Foo:    def __init__(self,name):        self.name=name    def __getitem__(self, item):        print(self.__dict__[item])    def __setitem__(self, key, value):        self.__dict__[key]=value    def __delitem__(self, key):        print('del obj[key]时,我执行')        self.__dict__.pop    def __delattr__(self, item):        print('del obj.key时,我执行')        self.__dict__.popf1=Foo('sb')f1['age']=18f1['age1']=19del f1.age1del f1['age']f1['name']='alex'print(f1.__dict__)

View Code

__hash__



 1 class Foo:
 2     def __init__(self):
 3         self.a = 1234
 4         self.b = 5678
 5 
 6     def __hash__(self):
 7         return hash(str(self.a) + str(self.b))
 8 
 9 f = Foo()
10 print(hash(f))

__hash__

3.10 上下文管理器相关

__enter__ __exit__



# 如果想要对一个类的对象进行with  as 的操作 不行。class A:    def __init__(self, text):        self.text = textwith A('大爷') as f1:    print

未曾他们不可能这么做

class A:        def __init__(self, text):        self.text = text        def __enter__:  # 开启上下文管理器对象时触发此方法        self.text = self.text + '您来啦'        return self  # 将实例化的对象返回f1        def __exit__(self, exc_type, exc_val, exc_tb):  # 执行完上下文管理器对象f1时触发此方法        self.text = self.text + '这就走啦'        with A('大爷') as f1:    printprint

有他们能够那样操作

class Diycontextor:    def __init__(self,name,mode):        self.name = name        self.mode = mode     def __enter__:        print "Hi enter here!!"        self.filehander = open(self.name,self.mode)        return self.filehander     def __exit__(self,*para):        print "Hi exit here"        self.filehander.close()  with Diycontextor('py_ana.py','r') as f:    for i in f:        print i

自定义文件管理器

有关例题：



class StarkConfig:    def __init__:        self.num = num        def run:        self()        def __call__(self, *args, **kwargs):        printclass RoleConfig(StarkConfig):    def __call__(self, *args, **kwargs):        print(345)    def __getitem__(self, item):        return self.num[item]v1 = RoleConfig('alex')v2 = StarkConfig('太白金星')# print# printv1.run()-------class UserInfo:    passclass Department:    passclass StarkConfig:    def __init__(self, num):        self.num = num        def changelist(self, request):        print(self.num, request)        def run:        self.changelist(999)class RoleConfig(StarkConfig):    def changelist(self, request):        print(666, self.num)class AdminSite:        def __init__:        self._registry = {}        def register(self, k, v):        self._registry[k] = vsite = AdminSite()site.register(UserInfo, StarkConfig)# 1 # obj = site._registry[UserInfo]()# 2obj = site._registry[UserInfo](100)obj.run()-------class UserInfo:    passclass Department:    passclass StarkConfig:    def __init__:        self.num = num    def changelist(self,request):        print(self.num,request)    def run:        self.changelist(999)class RoleConfig(StarkConfig):    def changelist(self,request):        print(666,self.num)class AdminSite:    def __init__:        self._registry = {}    def register:        self._registry[k] = vsite = AdminSite()site.register(UserInfo,StarkConfig)site.register(Department,RoleConfig)for k,row in site._registry.items():    row.run()-------class A:    list_display = []        def get_list:        self.list_display.insert(0,33)        return self.list_displays1 = A()print(s1.get_list-------class A:    list_display = [1, 2, 3]    def __init__:        self.list_display = []    def get_list:        self.list_display.insert(0, 33)        return self.list_displays1 = A()print(s1.get_list------class A:    list_display = []    def get_list:        self.list_display.insert(0,33)        return self.list_displayclass B:    list_display = [11,22]s1 = A()s2 = B()print(s1.get_listprint(s2.get_list

View Code

__eq__



 1 class Foo:
 2     def __init__(self):
 3         self.a = 1
 4         self.b = 2
 5 
 6     def __eq__(self, other):
 7         if self.a == other.a and self.b == other.b:
 8             return True
 9 
10 a = Foo()
11 b = Foo()
12 print(a == b)

View Code



 1 from collections import namedtuple
 2 Card = namedtuple('Card', ['rank', 'suit'])
 3 class FranchDeck:
 4     ranks = [str(n) for n in range(2,11)] + list('JQKA')
 5     suits = ['红心','方板','梅花','黑桃']
 6 
 7     def __init__(self):
 8         self._cards = [Card(rank,suit) for rank in FranchDeck.ranks
 9                                         for suit in FranchDeck.suits]
10 
11     def __len__(self):
12         return len(self._cards)
13 
14     def __getitem__(self, item):
15         return self._cards[item]
16 
17 deck = FranchDeck()
18 print(deck[0])
19 from random import choice
20 print(choice(deck))
21 print(choice(deck))

叶子游戏1



 1 from collections import namedtuple
 2 Card = namedtuple('Card', ['rank', 'suit'])
 3 class FranchDeck:
 4     ranks = [str(n) for n in range(2,11)] + list('JQKA')
 5     suits = ['红心','方板','梅花','黑桃']
 6 
 7     def __init__(self):
 8         self._cards = [Card(rank,suit) for rank in FranchDeck.ranks
 9                                         for suit in FranchDeck.suits]
10 
11     def __len__(self):
12         return len(self._cards)
13 
14     def __getitem__(self, item):
15         return self._cards[item]
16 
17     def __setitem__(self, key, value):
18         self._cards[key] = value
19 
20 deck = FranchDeck()
21 print(deck[0])
22 from random import choice
23 print(choice(deck))
24 print(choice(deck))
25 
26 from random import shuffle
27 shuffle(deck[:52])
28 print(deck[:5])

叶子游戏2



 1 class Person:
 2     def __init__(self, name, age, sex):
 3         self.name = name
 4         self.age = age
 5         self.sex = sex
 6 
 7     def __hash__(self):
 8         return hash(self.name + self.sex)
 9 
10     def __eq__(self, other):
11         if self.name == other.name or self.sex == other.sex:
12             return True
13 
14 
15 
16 p_lst = []
17 for i in range(84):
18     p_lst.append(Person('egon',i,'male'))
19 
20 print(p_lst)
21 print(set(p_lst))

对象去重

 

本文由美高梅网投网址发布于美高梅网站,转载请注明出处：super)检查sub类是否是 super 类的派生类，反射的概

关键词：