python面對對象編程------4：類基本的特殊方法__str__,__repr__,__hash__,__new__,__bool__,6大比較方法

一：string相關：__str__(),__repr__(),__format__()
　　str方法更面向人類閱讀，print（）使用的就是str
　　repr方法更面對python，目標是希望生成一個放入eval方法就能夠執行的python語句字符串
　　注意，不要一看到format方法就認為他是用來取代%賦值的
    *在里format方法可通過后面的!r與!s來指定使用repr還是str,即此時就不是用的format方法了，而是調用的repr或者str
　　    format有兩種參數形式：
   　　     1："",此類可以直接用str(...)來返回
      　　  2:format(someobject, specification),
         　　 e.g:"{0:06.4f}", the 06.4f is the format specification that applies to item 0 of the argument list to be formatted
　　        format很少用到，在此先略過（書61頁）

class Hand:
    def __init__( self, name, *friends ):
        self.name = name
        self.friends= list(friends)

    def __str__( self ):
        return ", ".join( map(str, self.friends) )

    def __repr__( self ):
        return "{__class__.__name__}({self.name!r}, {_cards_str})".format(__class__=self.__class__,_cards_str=", ".join( map(repr, self.friends) ),self=self)

a = Hand("pd","DK","Nancy")
print(str(a))
print(repr(a))
# 輸出：
# DK, Nancy, yao
# Hand('pd', 'DK', 'Nancy')

 

二：__hash__(),__eq__()

　　python有兩個hash庫,密碼學的hashlib,zlib的adler32()與crc32()
　　對於簡單數字這兩個庫都不用，直接用hash函數就行,hash函數常用於set，dict等定位其中元素
　　python每個對象都有個id，本質上id是其內存地址，is比較是基於id的，可用id(x)查看其值，而基類object的__hash__方法就是將其id/16取整后作為integer返回：
　　需要注意的是只有immutable數值類型才能用hash方法，list與dict沒有。所以，如果我們創建的是mutable的對象，就讓hash函數返回None就行了

　　__eq__() 方法,用於==對比，是基於hash值的。

　　對於immutable object，hash返回基於id的變數，eq用id相比就可以了。而mutable object寫eq，hash返回None

#使用默認eq與hash
class Card:
    insure= False
    def __init__( self, rank, suit, hard, soft ):
        self.rank= rank
        self.suit= suit
        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().__init__( "A", suit, 1, 11 )
class FaceCard( Card ):
    def __init__( self, rank, suit ):
        super().__init__( {11: 'J', 12: 'Q', 13: 'K' }[rank], suit, 10, 10 )

c1 = AceCard( 1, '?' )
c2 = AceCard( 1, '?' )

print(id(c1),id(c2))
print(id(c1)/16,id(c2)/16)
print(hash(c1),hash(c2))
print(c1==c2)
print(c1 is c2)
print( set([c1,c2]) )

# 輸出：
# 42444656 42444688
# 2652791.0 2652793.0
# 2652791 2652793
# False
# False
# {AceCard(suit='?', rank='A'), AceCard(suit='?', rank='A')}

　　由上可以看出：
      同一個類參數相同的兩個實例其各種比較[id, is, ==, hash，set去重]都不一樣
      在現實中使用是有問題的，比如這里面如果我們要比較兩張牌則這兩張應該看為相同,所以我們需要改寫其eq方法，讓其不基於id來達到目的

#改進版，重寫eq與hash
class Card2:
    insure= False
    def __init__( self, rank, suit, hard, soft ):
        self.rank= rank
        self.suit= suit
        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))
print(id(c1)/16,id(c2)/16)
print(hash(c1),hash(c2))            #變為相等的數字，但是需要注意的是已經不是 id/16
print(c1==c2)                       #變為True
print(c1 is c2)
print( set([c1,c2]) )

 

　　 對於mutable object，在這里依然用card做示范，但其實是不貼切的，card應該是immutable的。注意hash返回None的寫法

class Card3:
    insure= False
    def __init__( self, rank, suit, hard, soft ):
        self.rank= rank
        self.suit= suit
        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
        # and self.hard == other.hard and self.soft == other.soft

    __hash__ = None         #！！！！！！！！！

class AceCard3( Card3 ):
    insure= True
    def __init__( self, rank, suit ):
        super().__init__( "A", suit, 1, 11 )


c1 = AceCard3( 1, '?' )
c2 = AceCard3( 1, '?' )

print(id(c1),id(c2))
print(id(c1)/16,id(c2)/16)
print(hash(c1),hash(c2))              #報錯：TypeError: unhashable type: 'AceCard3'
print(c1==c2)                         #True
print(c1 is c2)
print( set([c1,c2]) )                 #報錯：TypeError: unhashable type: 'AceCard3'，由於不能hash，自然不能用於set數據結構

 

  對於mutable object，若想對其實例進行數值分析，
  可以寫一個immutable的子類，將實例傳入后完全copy下來，再對copy份進行寫hash處理：
  如下面的Hand類，可以寫一個不可變的FrozenHand類來對其進行hash數值處理

class Hand:
    def __init__( self, dealer_card, *cards ):
        self.dealer_card= dealer_card
        self.cards= list(cards)
    def __str__( self ):
        return ", ".join( map(str, self.cards) )
    def __repr__( self ):
        return "{__class__.__name__}({dealer_card!r}, {_cards_str})".format(__class__=self.__class__,_cards_str=", ".join( map(repr, self.cards) ),**self.__dict__ )
    def __eq__( self, other ):
        return self.cards == other.cards and self.dealer_card ==other.dealer_card
    __hash__ = None

import sys
class FrozenHand( Hand ):
    def __init__( self, *args, **kw ):
        if len(args) == 1 and isinstance(args[0], Hand):
            # Clone a hand
            other= args[0]
            self.dealer_card= other.dealer_card
            self.cards= other.cards
        else:
            # Build a fresh hand
            super().__init__( *args, **kw )
    def __hash__( self ):
        h= 0
        for c in self.cards:
            h = (h + hash(c)) % sys.hash_info.modulus
        return h

stats = defaultdict(int)
d= Deck()                               #Deck是一堆牌
h = Hand( d.pop(), d.pop(), d.pop() )
h_f = FrozenHand( h )
stats[h_f] += 1

 

三：__bool__

　　使用：
   　　 if xxx:
      　　  ...         #True
　　    else:
   　　     ...         #False
　　python認為為False的情況：
　　    1：False
　　    2: 0
　　    3：空:‘’，【】，（），{}
　　注：自帶的bool函數可用於測定並返回True還是False，
　　    如 bool(0),bool([]),bool('')都返回False

#對於Deck類，添加__bool__方法：
def __bool__( self ):
    return bool( self._cards )

#如果是繼承 list 類，可能如下書寫：
def __bool__( self ):
    return super().__bool__( self )

 

四：6大比較方法

     x<y calls x.__lt__(y)
     x<=y calls x.__le__(y)
     x==y calls x.__eq__(y)
     x!=y calls x.__ne__(y)
     x>y calls x.__gt__(y)
     x>=y calls x.__ge__(y)

class BlackJackCard_p:
    def __init__( self, rank, suit ):
        self.rank= rank
        self.suit= suit

    def __lt__( self, other ):
        print( "Compare {0} < {1}".format( self, other ) )
        return self.rank < other.rank

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

>>> two = BlackJackCard_p( 2, '?' )
>>> three = BlackJackCard_p( 3, '?' )
>>> two < three
Compare 2? < 3?       （*）
True
>>> two > three       （*）
Compare 3? < 2?
False
>>> two == three
False
>>> two <= three
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unorderable types: BlackJackCard_p() <= BlackJackCard_p()

　　　由（*）看出：  two < three的比較時用的是two.__lt__(three)
      　　         two>three由於沒有__gt__(),用的是three.__lt__(two)
　　　由於這種機制，我們可以只提供四種方法來包含上面六種：
　　　　　　　　    __eq__(), __ne__(), __lt__(), __le__().

　　1:同類實例比較

class BlackJackCard:
    def __init__( self, rank, suit, hard, soft ):
        self.rank= rank
        self.suit= suit
        self.hard= hard
        self.soft= soft
    def __lt__( self, other ):
        if not isinstance( other, BlackJackCard ):
            return NotImplemented
        return self.rank < other.rank
    def __le__( self, other ):
        try:
            return self.rank <= other.rank
        except AttributeError:
            return NotImplemented
    def __gt__( self, other ):
        if not isinstance( other, BlackJackCard ):
            return NotImplemented
        return self.rank > other.rank
    def __ge__( self, other ):
        if not isinstance( other, BlackJackCard ):
            return NotImplemented
        return self.rank >= other.rank
    def __eq__( self, other ):
        if not isinstance( other, BlackJackCard ):
            return NotImplemented
        return self.rank == other.rank and self.suit == other.suit      #比較==時多了對於suit的檢查，而比較大小時只比較了rank
    def __ne__( self, other ):
        if not isinstance( other, BlackJackCard ):
            return NotImplemented
"""
注意其上實現的六個比較方法中有兩種檢驗方式：
    1：explicit的用isinstance檢驗是不是BlackJackCard的類實例
    2：implicit的用try語句，此種除非是某個類剛好有rank屬性才會發生比較，
    實際上第二種方法更好，因錯出現剛好有rank屬性的類又用來比較的概率十分小，而可以用來擴展為別的紙牌游戲的牌與之的比較
"""
>>> two = card21( 2, '?' )
>>> three = card21( 3, '?' )
>>> two_c = card21( 2, '?' )

>>> two == two_c
False
>>> two.rank == two_c.rank
True
>>> two < three
True
>>> two_c < three
True
>>> two < 2                                 #報錯是因為__lt__()方法用isinstance檢驗了類型，非同類就報錯
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unorderable types: Number21Card() < int()
>>> two == 2                                #此地沒有報錯是因為遇到NotImplemented,python會交換他們.在此即是變成int.__eq__()
False

 

　　  2：異類實例比較

#下面主要是用isinstance來判斷相應的可能的異類的類型，再做處理
class Hand:
    def __init__( self, dealer_card, *cards ):
        self.dealer_card= dealer_card
        self.cards= list(cards)
    def __str__( self ):
        return ", ".join( map(str, self.cards) )
    def __repr__( self ):
        return "{__class__.__name__}({dealer_card!r}, {_cards_str})".format(__class__=self.__class__,_cards_str=", ".join( map(repr, self.cards) ),**self.__dict__ )
    def __eq__( self, other ):
        if isinstance(other,int):
            return self.total() == other
        try:
            return (self.cards == other.cards and self.dealer_card == other.dealer_card)
        except AttributeError:
            return NotImplemented
    def __lt__( self, other ):
        if isinstance(other,int):
            return self.total() < other
        try:
            return self.total() < other.total()
        except AttributeError:
            return NotImplemented
    def __le__( self, other ):
        if isinstance(other,int):
            return self.total() <= other
        try:
            return self.total() <= other.total()
        except AttributeError:
            return NotImplemented
    __hash__ = None
    def total( self ):
        delta_soft = max( c.soft-c.hard for c in self.cards )
        hard = sum( c.hard for c in self.cards )
        if hard+delta_soft <= 21:
            return hard+delta_soft
        return hard

>>> two = card21( 2, '?' )
>>> three = card21( 3, '?' )
>>> two_c = card21( 2, '?' )
>>> ace = card21( 1, '?' )
>>> cards = [ ace, two, two_c, three ]
>>> h= Hand( card21(10,'?'), *cards )
>>> print(h)
A?, 2?, 2?, 3?
>>> h.total()
18
>>> h2= Hand( card21(10,'?'), card21(5,'?'), *cards )
>>> print(h2)
5?, A?, 2?, 2?, 3?
>>> h2.total()
13
>>> h < h2
False
>>> h > h2
True
>>> h == 18
True
>>> h < 19
True
>>> h > 17
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unorderable types: Hand() > int()

 

五：immutable object的__new__

　　首先說明為何講immutable object的__new__，因為mutable object可以直接在__init__中加入新參數而immutable object是不行的：

# 可變對象：
class cL(list):
    def __init__(self,value,mutable):
        super().__init__(value)
        self.mutable = mutable
aha = cL([2,3,4],'mumu')
#注意此處的value參數，用help(list)可看到：list(iterable) -> new list initialized from iterable's items
print(aha,aha.mutable)
# 輸出：[2, 3, 4] mumu，可見多了個mutable屬性

　　__new__()默認就是staticmethod，不需要寫@satticmethod
　　對於不可變對象的子類並不能夠直接通過__init__方法創造更多的屬性，只有通過__new__方法才行
　　__new__( cls, *args, **kw ).
　　    cls：即將要實例化的類，此參數在實例化時由Python解釋器自動提供
   　　 *arg & **kw: with the exception of the cls argument, will be passed to __init__() as part of the standard Python behavior.
　　__new__必須要有返回值，返回實例化出來的實例，且在后一步的__init__方法中就是對這個返回的實例進行操作
　　默認的__new__()方法調用的是super().__new__(cls)

class Float_Units( float ):
    def __new__( cls, value, unit ):            
        obj= super().__new__( cls, value )  #實例化父類object，並用value初始化
        obj.unit= unit                      #給父類object添加了屬性unit，這樣由於繼承關系也就有了此屬性
        return obj                          #返回實例
speed= Float_Units( 6.5, "knots" )
print(speed)
print(speed.unit)
# 輸出：
# 6.5
# knots     可見，能夠賦值value以及添加屬性unit