类的内置方法

类的内置方法

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__的结果