类的内置方法
str 和 repr
class A:
def __str__(self):
return 'A的对象'
def __repr__(self):
return 'repr: A的对象'
a = A()
print(a) # A的对象 本质调用的是__str__，如果没实现，就调用__repr__，再找不到，用父类的
打印一个对象的时候，实际上是调用了这个对象所在类的__str__方法，打印的是这个方法的返回值
print(a.__str__()) # str不能给repr做备胎
print(a.__repr__()) # repr是str的备胎
print(str(a))
print(repr(a))
print('%s'%a)
print('%r'%a)
format
以特定格式输出
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 __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]
return fmt.format(obj=self)
s1=School('oldboy1','北京','私立')
print(format(s1,'nat'))
print(format(s1,'tna'))
print(format(s1,'tan'))
print(format(s1,'asfdasdffd'))
析构方法:执行删除对象的时候执行
class A:
def __del__(self):
'''
析构方法
这个方法只有在执行del A类的对象的时候才被触发
且先执行代码中的内容，再删除对象
如果我删除了这个对象，它还有一些其它的附属的内容也没有用了
我们就可以在这个方法中回收掉
:return:
'''
print('执行我了')
a = A()
import time
time.sleep(2)
item系列，访问属性的方式变了
class Foo:
def __init__(self,name):
self.name=name
def __getitem__(self, item):
return self.__dict__[item]
def __setitem__(self, key, value):
self.__dict__[key]=value
def __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')
print(f1['name'])
f1['age']=18 # 给f1添加一个属性
f1['age1']=19
del f1.age1 # 删除属性
del f1['age'] # 删除属性
f1['name']='alex' # 修改属性
print(f1.__dict__)
# 关于item系列:对象访问 如果是 对姓名[]，是因为内部实现了item系列的方法
__new__
对象的实例化
创造一个裸的对象 —— __new__
初始化
单例模式 —— 设计模式
一个类 从头到尾 只创建 一个对象
class Singleton:
def __new__(cls, *args, **kw):
if not hasattr(cls, '_instance'):
cls._instance = object.__new__(cls)
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)
__call__ 对象名()调用call
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
print('__call__')
obj = Foo() # 执行 __init__
obj() # 执行 __call__
Foo()() # 对象名()
__len__
class A:
def __init__(self):
self.a = 1
self.b = 2
def __len__(self):
return len(self.__dict__)
a = A()
print(len(a)) # 调用__len__
__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)) # 调用__hash__
__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) # 调用__eq__
纸牌游戏
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])
from random import choice
print(choice(deck)) # choice 依赖__len__和__getitem__
print(choice(deck)) # 随机抽牌
from random import shuffle
shuffle(deck) # 洗牌
print(deck._cards)
一个类有100个对象，每一个对象都用用三个属性:name，age，sex
如果两个对象的name和sex属性完全一致
我就认为这是一个对象
请对这100个对象进行去重
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__的结果