Paython 面向对象进阶（day27）
面向对象进阶
isinstance和issubclass
isinstance() :判断一个对象是不是这个类的实例，如果这个类有父类，那么这个对象也是其父类的对象
issubclass() : 判断两个类是不是父子关系，接受两个参数（子类，父类）
isinstance(obj,cls)检查是否obj是否是类 cls 的对象
class Foo:
pass
s=Foo()
print(isinstance(s,Foo)) #True
issubclass(sub, super)检查sub类是否是 super 类的派生类
class Foo(object):
pass
class Bar(Foo):
pass
print(issubclass(Bar, Foo)) #True
反射
反射: 把一个字符串数据类型的变量变成一个真实存在在这个程序中的变量名，并且能够使用它
python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）
下列方法适用于类和对象（一切皆对象，类本身也是一个对象）
#-对象中的反射
class Foo: f = '类的静态变量' def __init__(self,name,age): self.name=name self.age=age def say_hi(self): print('hi,%s'%self.name) obj=Foo('egon',73) #检测是否含有某属性和方法 print(obj.__dict__) # 查看对象中的方法和属性 {'name': 'egon', 'age': 73} print(hasattr(obj,'name')) #True print(hasattr(obj,'say_hi')) #True print(hasattr(obj,'aaa')) #False #获取属性 n=getattr(obj,'name') # = obj.name print(n) # egon n= obj.name print(n) # egon func=getattr(obj,'say_hi') print(func) # <bound method Foo.say_hi of <__main__.Foo object at 0x0000000001E805F8>> func() # hi,egon func=getattr(obj,'aaa','bbb') print(func) # bbb #设置属性 setattr(obj,'sb',True) #obj.sb=True print(obj.sb) #True print(obj.__dict__) # 查看对象中的方法和属性 {'name': 'egon', 'age': 73, 'sb': True} setattr(obj,'show_name',lambda self:self.name+'sb') # obj.show_name() print(obj.show_name(obj)) # egonsb print(obj.__dict__) # {'name': 'egon', 'age': 73, 'sb': True, 'show_name': <function <lambda> at 0x0000000001D13E18>} #删除属性 delattr(obj,'age') delattr(obj,'show_name') delattr(obj,'show_name111')#不存在,则报错
#-类中的反射
class Foo: f = '类的静态变量' def __init__(self,name,age): self.name=name self.age=age def say_hi(self): print('hi,%s'%self.name) obj=Foo('egon',73) print(Foo.__dict__) #{'__module__': '__main__', 'f': '类的静态变量', '__init__': <function Foo.__init__ at 0x00000000029D5BF8>, # 'say_hi': <function Foo.say_hi at 0x00000000029D5C80>, '__dict__': <attribute '__dict__' of 'Foo' objects>, # '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None} print(hasattr(Foo,'f')) # True print(getattr(Foo,'say_hi')) # <function Foo.say_hi at 0x00000000029D5C80> getattr(Foo,'say_hi')() #会报错 如果传个实例化对象就不会 getattr(Foo,'say_hi')(obj) # hi,egon setattr(Foo,'a','abc') # Foo.a='abc' print(Foo.__dict__) # 最后多了一个 'a': 'abc' print(Foo.a) # abc delattr(Foo,'a') delattr(Foo,'say_hi') delattr(Foo,'f') print(Foo.__dict__) # {'__module__': '__main__', '__init__': <function Foo.__init__ at 0x00000000029E5BF8>, # '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None}
#-类中的反射与类方法，静态方法结合使用
class Foo(object): staticField = "old boy" def __init__(self): self.name = 'wupeiqi' @classmethod def func(cls): return cls.staticField @classmethod def func1(cls,a): return a+cls.staticField @staticmethod def bar(): return 'bar' a='a' print(Foo.staticField) # old boy print(getattr(Foo, 'staticField')) # old boy print(getattr(Foo, 'bar')()) # bar 调用静态方法 print(getattr(Foo, 'func')()) # old boy 调用类中方法 print(getattr(Foo, 'func1')(a)) # aold boy 调用类方法，并往其中传参
#-当前模块的反射
import sys def s1(): print ('s1') def s2(): print ('s2')
xiaoxuanxuan = 2222
this_module = sys.modules[__name__] # 在自己文件中__name__会变成__main__ 自身文件的模块名 用模块名.属性或方法查看
print(getattr(this_module, 'xiaoxuanxuan')) #22222
print(hasattr(this_module, 's1')) # True
getattr(this_module, 's2')() # s2
#导入其他模块，利用反射查找该模块是否存在某个方法
# module_test.py与index.py在同一目录下
# 在module_test.py中
def test():
print('from the test')
# 在index.py中
import module_test as obj
print(hasattr(obj,'test')) # True
getattr(obj,'test')() # from the test
__str__和__repr__
改变对象的字符串显示__str__,__repr__
自定制格式化字符串__format__
'''
str函数或者print函数--->obj.__str__()
repr或者交互式解释器--->obj.__repr__()
如果__str__没有被定义,那么就会使用__repr__来代替输出
注意:这俩方法的返回值必须是字符串,否则抛出异常
'''
class School:
def __init__(self,name,addr,type):
self.name=name
self.addr=addr
self.type=type
def __repr__(self):
return 'School(%s,%s)' %(self.name,self.addr)
# def __str__(self):
# return '(%s,%s)' %(self.name,self.addr)
s1=School('oldboy1','北京','私立')
print('from repr: ',repr(s1)) # from repr: School(oldboy1,北京)
print('from str: ',str(s1)) # from repr: School(oldboy1,北京)
print(s1) # School(oldboy1,北京)
class B:
def __str__(self):
return 'str : class B'
def __repr__(self):
return 'repr : class B'
b=B()
print('%s'%b) # str : class B
print('%r'%b) # repr : class B
class Animal:
def __init__(self,kind,name):
self.kind = kind
self.name = name
def __str__(self):
return 'str : %s : %s'%(self.kind,self.name)
def __repr__(self):
return 'repr : %s : %s'%(self.kind,self.name)
cat = Animal('cat','guolei')
print('%s'%cat) # str : cat : guolei
print('%r'%cat) # repr : cat : guolei
print(str(cat)) # str : cat : guolei
print(repr(cat)) # repr : cat : guolei
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=name
self.addr=addr
self.type=type
def __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_spec
if not format_spec or format_spec not in format_dict:
format_spec='nat'
fmt=format_dict[format_spec]
# obj=self
return fmt.format(obj=self)
s1=School('oldboy1','北京','私立')
print(format(s1,'nat')) # oldboy1-北京-私立
__del__
析构方法，当对象在内存中被释放时，自动触发执行。 或者使用 del 对象 自动触发类中__del__
class Foo:
def __del__(self):
print('执行我啦')
f1=Foo()
del f1
print('------->')
#输出结果
执行我啦
------->
class A:
def __del__(self):
print('aaa')
class B:
def __del__(self):
print('bbb')
a=A()
b = B()
print('ccc')
#输出
ccc
aaa
bbb
item系列
__getitem__\__setitem__\__delitem__
class Animal:
def __init__(self,name):
self.name = name
def __getitem__(self, item):
return getattr(self,item)
def __setitem__(self, key, value):
setattr(self,key,value)
def __delitem__(self, key):
delattr(self,key)
cat = Animal('guolei')
print(cat['name']) #去类中找getitem方法 guolei
cat['sex'] = '公' #去类中找setitem方法
print(cat.sex) #公
print(cat['sex']) #公
print(cat.__dict__) #{'name': 'guolei', 'sex': '公'}
del cat['name'] # 去类中找delattr方法
print(cat.__dict__) #{'sex': '公'}
__new__
单例模式 实例始终只有一个 他的属性可以随着你的改变而改变
#正常情况下，示例化后先进行__new__方法，在父类object方法中new出一个新对象，给予__init__方法中的self，这就是正常情况下实例化对象的步骤
#即先去元祖那里，创建一个人（裸体的人），再为这个人穿衣服（在__init__方法中的self实例化）
class A: def __init__(self): 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(a.x)
#输出：
in new function
in init function
1
class Singleton:
def __new__(cls, *args, **kw):
if not hasattr(cls, '_instance'):
orig = super(Singleton, cls)
cls._instance = orig.__new__(cls, *args, **kw)
return cls._instance
one = 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
print(one is two)
class Teacher: #创建一个老师类
__isinstance = None #创建一个私有静态变量来装裸着的对象
def __new__(cls, *args, **kwargs): #创建一个裸着的对象
if not cls.__isinstance: #如果__isinstance属性为None
cls.__isinstance = object.__new__(cls) #用object.__new__创建一个裸着的对象
return cls.__isinstance #返回一个对象
def __init__(self,name,cloth): #self就是cls.__isinstance返回的对象
self.name = name #给self的name属性赋值
self.cloth = cloth #给self的cloth属性赋值
刘老师 = Teacher('刘永熹','白色')
print(刘老师.name,刘老师.cloth) # 刘永熹 白色
王老师 = Teacher('王庆帅','黑色')
print(刘老师.name,刘老师.cloth) # 王庆帅 黑色
print(王老师.name,王老师.cloth) # 王庆帅 黑色
print(刘老师,王老师) #<__main__.Teacher object at 0x00000000027C0630> <__main__.Teacher object at 0x00000000027C0630>
__call__
对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
print('__call__')
obj = Foo() # 执行 __init__
obj() # 执行 __call__
__len__
对于 __len__ 方法的执行是由len(对象)后触发的，即：len(对象)
class A:
def __init__(self):
self.a = 1
self.b = 2
def __len__(self):
return len(self.__dict__)
a = A()
print(len(a)) # 2
print(a.__dict__) # {'a': 1, 'b': 2}
__hash__
对于 __hash__ 方法的执行是由hash(对象)后触发的，即：hash(对象)
class A:
def __init__(self):
self.a = 1
self.b = 2
def __hash__(self):
return hash(str(self.a)+str(self.b))
a = A()
print(hash(a)) # -7422275419112235454 每次运行都不相同
__eq__
对于 __eq__ 方法的执行是由 对象 == 对象 后触发的，即：对象 == 对象
class A:
def __init__(self):
self.a = 1
self.b = 2
def __eq__(self,obj): # ==前面是对象，==后面是变量
if self.a == obj.a and self.b == obj.b:
return True
a = A()
b = A()
print(a == b) # True
class FranchDeck: ranks = [str(n) for n in range(2,11)] + list('JQKA') suits = ['红心','方板','梅花','黑桃'] def __init__(self): self._cards = [Card(rank,suit) for rank in FranchDeck.ranks for suit in FranchDeck.suits] def __len__(self): return len(self._cards) def __getitem__(self, item): return self._cards[item] def __setitem__(self, key, value): self._cards[key] = value deck = FranchDeck() print(deck[0]) from random import choice print(choice(deck)) print(choice(deck)) from random import shuffle shuffle(deck) print(deck[:5])
from collections import namedtuple Card = namedtuple('Card',['rank','suit']) class FranchDeck: ranks = [str(n) for n in range(2,11)] + list('JQKA') suits = ['红心','方板','梅花','黑桃'] def __init__(self): self._cards = [Card(rank,suit) for rank in FranchDeck.ranks for suit in FranchDeck.suits] def __len__(self): return len(self._cards) def __getitem__(self, item): return self._cards[item] def __setitem__(self, key, value): self._cards[key] = value deck = FranchDeck() print(deck[0]) # 第一张 Card(rank='2', suit='红心') from random import choice print(choice(deck)) #随机抽一张 Card(rank='2', suit='黑桃') print(choice(deck)) #随机抽一张 Card(rank='A', suit='梅花') from random import shuffle shuffle(deck) print(deck[:5]) # 抽五张
class Person: def __init__(self,name,age,sex): self.name = name self.age = age self.sex = sex def __hash__(self): return hash(self.name+self.sex) def __eq__(self, other): if self.name == other.name and self.sex == other.sex:return True p_lst = [] for i in range(84): p_lst.append(Person('egon',i,'male')) print(p_lst) # 一百个对象的列表 print(set(p_lst)) # 只有一个对象，set()方法运行了类中的__hash__与__eq__方法
啊啊
浙公网安备 33010602011771号