与Python的无缝集成----基本特殊方法.(Mastering Objecting-oriented Python 笔记)

第二章 与Python的无缝集成----基本特殊方法.(Mastering Objecting-oriented Python 笔记)

python中有有一些特殊的方法,它们允许我们的类和python更好的集成

• __repr__():
• __str__()
• __format__()
• __hash__()
• __bool__()
• __bytes__()
• __lt__()
• __le__()
• __eq__()
• __ne__()
• __gt__()
• __ge__()
• __new__()
• __del__()

2.1 __repr__()和__str__()方法

• 通常str()方法表示的对象对用户更加友好.这个方法是有对象的__str__()方法实现的.

什么时候重写 __str__()跟__repr__()

• 非集合对象: 一个不包括其他集合对象的'简单'对象,这类对象格式通常不会特别复杂
• 集合对象:一个包括集合的对象,这类对象的格式化会非常复杂.

非集合对象的__repr__()和__str__()

问题1: 什么是集合?

class Card(object):
    def __init__(self, rank, suit):
        self.suit = suit
        self.rank = rank
        self.hard, self.soft = self._points()

    def __repr__(self):
        return '{__class__.__name__}(suit = {suit!r} , rank = {rank!r})'.format(
            __class__=self.__class__, **self.__dict__
        )

    def __str__(self):
        return '{rank}{suit}'.format(**self.__dict__)


class NumberCard(Card):
    def _points(self):
        return int(self.rank), int(self.rank)


x = NumberCard('2', '♣')
# 注意下面是重写后的
print(str(x))  # 2♣ 
print(x)       # 2♣
print(repr(x)) # NumberCard(suit = '♣' , rank = '2')

__format__()方法

注意：‘{0!r}'.format()和'{0!s}'.format()并不会调用__format__()方法,它们会调用__repr__()或者__str__().

__hash__()方法

内置hash()函数调用了__hash__()方法.哈希是一种将复杂的值简化为小整数的计算方式.

python有两个哈希库:

• hashlib
• zip 有两个搞笑的哈希函数adler32()和crc32()

hash()函数主要被用来创建set,forzenset,dict这些集合类的键.这些集合利用了不可变对象的哈希值来高效的查找集合中的对象

决定hash的对象

并非每个对象都需要提供一个哈希值,尤其是,当我们创建一个包含有状态,可改变对象的类时.这类不应该返回哈希值,__hash__的定义 应该是None

等价比较有三个层次：

• 哈希值相等：意味着两个结果可能相等.哈希值是判断两个对象有可能相等的快捷方式,如果哈希值不同,两个对象不可能相等,也不可能是同一个对象.
• 比较结果相等：意味着两个对象的哈希值已经是相等的，这个比较用的是==运算符.如果结果相等,那么两个对象的有可能是同一个.
• IDD 相等:这意味着两个对象是同一个对象,它们的哈希值仙童,并且使用==的比较结果相等,这个比较是用的是is运算符.

---

**基本哈希法(Fundametal Law of Hash):比较相等的对象的哈希值一定相等.

有关不可变对象和继承的默认行为

class Card(object):
    def __init__(self, rank, suit, hard, soft):
        self.suit = suit
        self.rank = rank
        self.hard = hard
        self.soft = soft

    def __repr__(self):
        return '{__class__.__name__}(suit = {suit!r} , rank = {rank!r})'.format(
            __class__=self.__class__, **self.__dict__
        )

    def __str__(self):
        return '{rank}{suit}'.format(**self.__dict__)


class NumberCard(Card):
    def __init__(self, rank, suit):
        super().__init__(str(rank), suit, rank, rank)


class AceCard(Card):
    def __init__(self, rank, suit):
        super(AceCard, self).__init__("A", suit, 1, 11)


class FaceCard(Card):
    def __init__(self, rank, suit):
        super(FaceCard, self).__init__({11: 'J',
                                        12: 'Q',
                                        13: 'K'}[rank], suit, 10, 10)



c1 = AceCard(1,'♣')
c2 = AceCard(1,'♣')
print(id(c1),id(c2)) # 52067024 52067120 

id()值不同意味着是不同的对象.
**is测试基于id()的值,哈希值根据id()值来计算的`

重载不可变对象

下面是一个重载了__hash__()和__eq__()定义的简单类.

class Card2(object):
    def __init__(self, rank, suit, hard, soft):
        self.suit = suit
        self.rank = rank
        self.hard = hard
        self.soft = soft

    def __repr__(self):
        return '{__class__.__name__}(suit = {suit!r} , rank = {rank!r})'.format(
            __class__=self.__class__, **self.__dict__
        )

    def __str__(self):
        return '{rank}{suit}'.format(**self.__dict__)

    def __eq__(self, other):
        return self.suit == other.suit and self.rank == other.rank

    def __hash__(self):
        return hash(self.suit) ^ hash(self.rank)


class AceCard2(Card2):
    insure = True

    def __init__(self, rank, suit):
        super().__init__("A", suit, 1, 11)


c1 = AceCard2(1, '♣')
c2 = AceCard2(1, '♣')

print(id(c1), id(c2))     # id 是不相同的
print(c1 is c2)           # False
print(hash(c1), hash(c2)) # hash是相同的
print(c1 == c2)           # True
print(set([c1,c2]))       # {AceCard2(suit = '♣' , rank = 'A')}

重载可变对象

下面的类层级结构中,我们重载了可变对象的 __hash__()和__eq__()

class Card3(object):
    def __init__(self, rank, suit, hard, soft):
        self.suit = suit
        self.rank = rank
        self.hard = hard
        self.soft = soft

    def __repr__(self):
        return '{__class__.__name__}(suit = {suit!r} , rank = {rank!r})'.format(
            __class__=self.__class__, **self.__dict__
        )

    def __str__(self):
        return '{rank}{suit}'.format(**self.__dict__)

    def __eq__(self, other):
        return self.suit == other.suit and self.rank == other.rank

    __hash__ = None

class AceCard3(Card3):
    insure = True

    def __init__(self, rank, suit):
        super().__init__("A", suit, 1, 11)


cc1 = AceCard3(1, '♣')
cc2 = AceCard3(1, '♣')

print(id(cc1), id(cc2))     # id 是不相同的
>>>8813424 8813616
print(cc1 is cc2)           # False

>>>print(hash(cc1), hash(cc2)) # TypeError: unhashable type: 'AceCard3'
Traceback (most recent call last):
  File "E:/cnki/cloudrepository/DataCleansingSystem/src/test/test_excel.py", line 113, in <module>
    print(set([cc1,cc2]))       # {AceCard2(suit = '♣' , rank = 'A')}
TypeError: unhashable type: 'AceCard3'

__hash__被设置为None,所以这些用Card3生成的对象不可以被哈希,也就无法通过hash()函数提供的哈希值了.

print(cc1 == cc2)           # True
print(set([cc1,cc2]))       # TypeError: unhashable type: 'AceCard3'

从可变的Hand类中生成一个不可变的Hand类