python面对对象编程----2：__init__

面对对象编程估计我们最早接触到的就是__init__了，也就是实例的初始化处理过程：

1：来看看最基础的__init__

 class Card(object):　　　　　　　　　　　　　　　#抽象类Card，并不用于实例化
     def __init__( self, rank, suit ):
         self.suit= suit
         self.rank= rank
         self.hard, self.soft = self._points()
         print("try")

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

 class AceCard( Card ):
     def _points( self ):
         return 1, 11

 class FaceCard( Card ):

     def _points( self ):
         return 10, 10

 cards = [ AceCard('A', 'spade'), NumberCard('','clube'), NumberCard('','diamond'),]　　　　
   #注意此地，若子类没有写__init__方法，那么在实例化时会完整的继承实现一遍父类的__init__,所以这里会打印出三个'try'

2：在子类中使用__init__

 在子类中写__init__方法的目的要么是实际传入参数（此地），要么是添加其他属性或者操作，都可以通过super()来获得父类__init__方法。否则不用写就会自动继承执行父类的__init__方法

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

 class NumberCard( Card ):
     def __init__( self, rank, suit ):
         super().__init__( str(rank), suit, rank, rank )     #在子类中使用super().__init__(*args)要传入除了self外所有参数

 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 )

3：没有__init__方法：

　　完全没有__init__方法的类经常是作为策略类使用，策略类就是把一些列相关操作集合起来的类，通过方法传入的参数来进行一些列操作

　　例如下面的游戏操作策略类，通过传入手牌这一参数决定了每一方法的使用。

 class GameStrategy:
     def insurance( self, hand ):        #hand是手牌
         return False
     def split( self, hand ):
         return False
     def double( self, hand ):
         return False
     def hit( self, hand ):
         return sum(c.hard for c in hand.cards) <= 17

4：若init方法太繁琐，有时用 静态方法 生成并且返回实例会更清晰简洁

　　这里模拟了庄家发牌的过程，庄家手上先拿到n张牌（n个人），然后通过静态方法split（分发）出去

 class Hand5:
     def __init__( self, dealer_card, *cards ):
         self.dealer_card= dealer_card
         self.cards = list(cards)

     @staticmethod
     def freeze( other ):　　　　　　#冻结手牌
         hand= Hand5( other.dealer_card, *other.cards )
         return hand

     @staticmethod
     def split( other, card0, card1 ):
         hand0= Hand5( other.dealer_card, other.cards[0], card0 )
         hand1= Hand5( other.dealer_card, other.cards[1], card1 )
         return hand0, hand1

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

 d = Deck()
 h = Hand5( d.pop(), d.pop(), d.pop() )
 s1, s2 = Hand5.split( h, d.pop(), d.pop() )

5:另一种初始化属性的方法：

　　#常用情况：
 1 class Player:
     def __init__( self, table, bet_strategy, game_strategy ):
         self.bet_strategy = bet_strategy
         self.game_strategy = game_strategy
         self.table= table

 #也可以写成这样
 class Player2:
     def __init__( self, **kw ):
         """Must provide table, bet_strategy, game_strategy."""
         self.__dict__.update( kw )　　　　#__dict__见下，dict.update(name='pd',...)可添加键值对
　　
   P = Player2(table = table,bet_strategy = bet_strategy, game_strategy = game_strategy)　#注意实例化的参数形式　　　

 #上面方法虽然扩展性好，但是implicit。适合用于做基类，在此基础上可以明确声明一部分初始化参数
 class Player3( Player ):
     def __init__( self, table, bet_strategy, game_strategy, **extras):
         self.bet_strategy = bet_strategy
         self.game_strategy = game_strategy
         self.table= table
         self.__dict__.update( extras )

 >>> class aha(object):
 ...     def __init__(self,name,age):
 ...             self.name = name
 ...             self.age = age
 ...
 >>> aha.__dict__
 dict_proxy({'__dict__': <attribute '__dict__' of 'aha' objects>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'aha' objects>, '__doc__': None, '__init__': <function __init__ at 0x0000000002C35908>})
 >>> a=aha('pd',12)
 >>> a.__dict__
 {'age': 12, 'name': 'pd'}

关于__dict__

6：带检验初始化

 class ValidPlayer:
     def __init__( self, table, bet_strategy, game_strategy ):
         assert isinstance( table, Table )                   #assert遇错误会报错并且中断程序
         assert isinstance( bet_strategy, BettingStrategy )
         assert isinstance( game_strategy, GameStrategy )
         self.bet_strategy = bet_strategy
         self.game_strategy = game_strategy
         self.table= table

 #但这违背了python动态语言的特性，在用python时我们希望能够动态传入，但是应该写doc给programmer提醒，并且若有人没有按动态传入，可log后再分析

 class ValidPlayer:
     """
         Creates a new player associated with a table,and configured with proper betting and play strategies
         :param table: an instance of :class:`Table`
         :param bet_strategy: an instance of :class:`BettingStrategy`
         :param game_strategy: an instance of :class:`GameStrategy`
         通过 ValidPlayer.__doc__ 访问这段话
     """
     def __init__( self, table, bet_strategy, game_strategy ):
         assert isinstance( table, Table )                   #assert遇错误会报错中断
         assert isinstance( bet_strategy, BettingStrategy )
         assert isinstance( game_strategy, GameStrategy )
         self.bet_strategy = bet_strategy
         self.game_strategy = game_strategy
         self.table= table