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