isinstance和issubclass
isinstance(obj,cls)? ? ??#?檢查是否obj是否是類 cls 的對象
class Foo(object):passobj = Foo()isinstance(obj, Foo) # tureissubclass(sub, super)? # 檢查sub類是否是 super 類的派生類
class Foo(object):passclass Bar(Foo):passissubclass(Bar, Foo) # ture反射
1 什么是反射
反射的概念是由Smith在1982年首次提出的，主要是指程序可以訪問、檢測和修改它本身狀態或行為的一種能力（自省）。這一概念的提出很快引發了計算機科學領域關于應用反射性的研究。它首先被程序語言的設計領域所采用,并在Lisp和面向對象方面取得了成績。
2 python面向對象中的反射：通過字符串的形式操作對象相關的屬性。python中的一切事物都是對象（都可以使用反射）
四個可以實現自省的函數 hasattr getattr setattr delattr
下列方法適用于類和對象（一切皆對象，類本身也是一個對象）,還可以反射類中的模塊，查看模塊是否存在，總而言之，只要能用a.b 的都可以用
class Foo:f = '類的靜態變量'def __init__(self,name,age):self.name=nameself.age=agedef say_hi(self):print('hi,%s'%self.name)obj=Foo('egon',73)# hasattr(*args, **kwargs) 檢測是否含有某屬性
print(hasattr(obj,'name'))
print(hasattr(obj,'say_hi'))# getattr(object, name, default=None) 獲取屬性
n = getattr(obj,'name')
print(n) # egon
func = getattr(obj,'say_hi')
func() # hi,egon
print(getattr(obj,'aaaaaaaa','不存在啊')) # 不存在啊# setattr(x, y, v) 設置屬性
setattr(obj,'sb',True)
setattr(obj,'show_name',lambda self:self.name+'sb')
print(obj.__dict__) # {'name': 'egon', 'age': 73, 'sb': True, 'show_name': <function <lambda> at 0x00000207DFFE6598>}
print(obj.show_name(obj)) # egonsb# delattr(x, y) 刪除屬性
delattr(obj,'age')
delattr(obj,'show_name')
delattr(obj,'show_name111') # 不存在,則報錯__str__、__repr__和__fromat__
改變對象的字符串顯示__str__,__repr__，自定制格式化字符串__format__
str函數 或者 print函數? ?---> obj.__str__()
repr 或者 交互式解釋器 ---> obj.__repr__()
如果__str__沒有被定義,那么就會使用__repr__來代替輸出(備胎)
注意:這倆方法的返回值必須是字符串,否則拋出異常
#_*_coding:utf-8_*_format_dict={'nat':'{obj.name}-{obj.addr}-{obj.type}',#學校名-學校地址-學校類型'tna':'{obj.type}:{obj.name}:{obj.addr}',#學校類型:學校名:學校地址'tan':'{obj.type}/{obj.addr}/{obj.name}',#學校類型/學校地址/學校名
}
class School:def __init__(self,name,addr,type):self.name=nameself.addr=addrself.type=typedef __repr__(self):return 'School(%s,%s)' %(self.name,self.addr)def __str__(self):return '(%s,%s)' %(self.name,self.addr)def __format__(self, format_spec):# if format_specif not format_spec or format_spec not in format_dict:format_spec='nat'fmt = format_dict[format_spec]return fmt.format(obj=self)s1=School('oldboy1','北京','私立')
print('from repr: ',repr(s1)) # from repr: School(oldboy1,北京)
print('from str: ',str(s1)) # from str: (oldboy1,北京)
print(s1) # (oldboy1,北京)print(format(s1,'nat')) # oldboy1-北京-私立
print(format(s1,'tna')) # 私立:oldboy1:北京
print(format(s1,'tan')) # 私立/北京/oldboy1
print(format(s1,'asfdasdffd')) # oldboy1-北京-私立__del__
析構方法，當對象在內存中被釋放時，自動觸發執行。
注：此方法一般無須定義，因為Python是一門高級語言，程序員在使用時無需關心內存的分配和釋放，因為此工作都是交給Python解釋器來執行，所以，析構函數的調用是由解釋器在進行垃圾回收時自動觸發執行的。
class Foo:def __del__(self):print('執行我啦')f1=Foo()
del f1
print('------->')# 輸出結果
執行我啦
------->item系列
使類中的靜態變量可以像使用字典的方式一樣使用，__getitem__? ?\__setitem__? ? ?\__delitem__
class Foo:def __init__(self,name):self.name=namedef __getitem__(self, item):print(self.__dict__[item])def __setitem__(self, key, value):self.__dict__[key]=valuedef __delitem__(self, key):print('del obj[key]時,我執行')self.__dict__.pop(key)def __delattr__(self, item):print('del obj.key時,我執行')self.__dict__.pop(item)f1=Foo('sb')
f1['age']=18 # 等同于f1.setitem('age',18)
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alex'
print(f1.__dict__) # {'name': 'alex'}__new__
構造方法，__new__ 實在執行__init__ 之前執行的，object 已實現該方法，所以一般不用寫，作用是創建一個self
class A:def __init__(self):self.x = 1print('in init function')def __new__(cls, *args, **kwargs):print('in new function')return object.__new__(A, *args, **kwargs)a = A()
print(a.x)單例模式
class Singleton:def __new__(cls, *args, **kw):if not hasattr(cls, '_instance'): # 判斷類的命名空間中是否存在變量_instancecls._instance = object.__new__(cls, *args, **kw) # 在類的命名空間中加了一個私有的靜態變量_instancereturn cls._instanceone = Singleton()
two = Singleton()two.a = 3
print(one.a) # 3
# one和two完全相同,可以用id(), ==, is檢測
print(id(one)) # 29097904
print(id(two)) # 29097904
print(one == two) # True ，實際調用__eq__ 方法
print(one is two) # True__call__
對象后面加括號，觸發執行。
注：構造方法的執行是由創建對象觸發的，即：對象 = 類名() ；而對于 __call__ 方法的執行是由對象后加括號觸發的，即：對象() 或者 類()()
class Foo:def __init__(self):passdef __call__(self, *args, **kwargs):print('__call__')obj = Foo() # 執行 __init__
obj() # 執行 __call____len__
class A:def __init__(self):self.a = 1self.b = 2def __len__(self):return len(self.__dict__)
a = A()
print(len(a))__hash__
object中未實現，如果有需求，需要自己實現
class A:def __init__(self):self.a = 1self.b = 2def __hash__(self):return hash(str(self.a)+str(self.b))
a = A()
print(hash(a))__eq__
object已實現
class A:def __init__(self):self.a = 1self.b = 2def __eq__(self,obj):if self.a == obj.a and self.b == obj.b:return True
a = A()
b = A()
print(a == b)集合set判斷的依據是 先判斷__eq__ ，如果相同，在判斷__hash__， 如果兩者都相同，則認為相同
String類型的equals方法 只比較內容 不比較是否來引用同一個對象
== 實際調用__eq__ 方法，判斷值是否相等
is 判斷的是內存地址，= 賦值時賦值的內存地址 ， 如果賦值時使用字符串，列表等，存在小地址池的原因，也會存在內存地址相同的情況 ，is 運算符比 == 效率高，在變量和None進行比較時，應該使用 is
)