Python 面向對象編程指南 讀書筆記
第一部分 用特殊方法實現Python風格的類
爲了實現更好的可擴展性，Python語言提供了大量的特殊方法，它們大體分爲如下幾類。python
- 特性訪問
- 可調用對象
- 集合
- 數字
- 上下文
- 迭代器
第一章 使用__init()__方法
Python中一切事物皆對象！！！！！！
__init__()方法記住兩點：程序員
- __init()__（初始化）是對象生命週期的開始，每一個對象必須正確初始化纔可以正常的工做。
- __init__()能夠賦值
對象的生命週期主要是有建立、初始化、銷燬。
‘顯示而非隱式’：對於每一個__init__()方法，都應當顯示的制定要初始化的變量。
每當建立一個對象，python會建立一個空對象，而後調用該對象的__init__()函數，提供了初始化的操做。算法
# 以21點爲例做爲說明。
class Card(object):
def __init__(self, suit, rank):
self.suit = suit
self.rank = rank
self.hard, self.soft = self._points()
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
class Suit(object):
def __init__(self,name,symbol):
self.name = name
self.symbol = symbol
Club,Diamond,Heart,Spade = Suit('Club','♣'),Suit('Diamond','♦'),Suit('Heart','♥'),Suit('Spade','♠')
經過工廠函數來調用__init__():
def card(rank, suit):
if rank == 1:
return AceCard('A', suit)
elif 2 <= rank < 11:
return NumberCard(str(rank), suit)
elif 11 <= rank < 14:
name = {11: 'J', 12: 'Q', 13: 'K'}[rank]
return FaceCard(name, suit)
else:
raise Exception("rank out of range")
這個函數經過傳入牌面值rank 和花色值suit來建立card對象.
deck = [card(rank, suit) for rank in range(1, 14) for suit in (Club, Diamond, Heart, Spade)] print(deck[0].rank,deck[0].suit.symbol)
這段代碼完成了52張牌對象的建立.編程
使用映射和類來簡化設計.
因爲類是第一級別的對象,從rank參數射到對象是很容易的事情.
下面的Card類工廠就是使用映射實現的版本.設計模式
def card4(rank,suit):
class_ = {1:AceCard,11:FaceCard,12:FaceCard,13:FaceCard}.get(rank,NumberCard)
return class_(rank,suit)
須要修改映射邏輯,除了提供Card子類,還須要提供rank對象的字符串結果.如何實現這兩部分映射,有四種常見方案.app
- 能夠創建兩個並行映射
- 能夠映射爲一個二元組.
- 能夠映射爲partial()函數.
- 能夠考慮修改類定義的完成映射邏輯.
1.並行映射dom
def card5(rank,suit):
class_ = {1:AceCard,11:FaceCard,12:FaceCard,13:FaceCard}.get(rank,NumberCard)
rank_str = {1:'A',11: 'J', 12: 'Q', 13: 'K'}.get(rank,str(rank))
return class_(rank_str,suit)
這樣是不值得作的,帶來映射鍵1,11,12,13的邏輯重複.函數
不要使用並行結構,並行結構應該被元祖或者一些更好的組合所代替ui
- 映射到一個牌面值的元組
def card6(rank,suit):
class_,rank_str= {
1:(AceCard,'A'),
11:(FaceCard,'J'),
12:(FaceCard,'Q'),
13:(FaceCard,'K')
}.get(rank,(NumberCard,str(rank)))
return class_(rank_str,suit)
從rank值映射到類對象時不多見的,並且兩個參數只有一個用於對象的初始化.從rank映射到一個相對簡單的類或者是函數對象,而沒必要提供目的不明確的參數,這纔是明智的選擇.插件
3.partial 函數設計
def card7(rank,suit):
from functools import partial
part_class = {
1:partial(AceCard,'A'),
11:partial(FaceCard,'J'),
12:partial(FaceCard,'Q'),
13:partial(FaceCard,'K')
}.get(rank,partial(NumberCard,str(rank)))
return part_class(suit)
經過調用partial()函數而後複製給part_class,完成於rank對象的管的關聯,可使用一樣的方式來建立suit對象,而且完成最終的Card對象的建立.partial()函數的使用在函數時編程中是很常見的.當時用的是函數而非對象方法的時候就能夠考慮使用.
大體上,partial()函數在面向對象編程中不是很經常使用,咱們能夠簡單的的提供構造函數不一樣版原本作相同的事情.partial()函數和構造對象時的流暢接口很相似.
- 工廠模式的流暢的API設計
有時候咱們定義類中的方法必須按照特定的順序來調用.這種順序調用的方法和建立 partial() 函數的方式很是相似.
咱們能夠在流暢接口函數中設置能夠返回self值的rank對象,而後傳入花色類從而建立Card實例/
如下是Card工廠流暢接口的定義,包含兩個函數,他們必須按照順序調用.
class CardFactory(object):
def rank(self,rank):
self.class_,self.rank_str = {
1:(AceCard,'A'),
11:(FaceCard,'J'),
12:(FaceCard,'Q'),
13:(FaceCard,'K')
}.get(rank,(NumberCard,str(rank)))
def suit(self,suit):
return self.class_(self.rank_str,suit)
先使用rank()函數更新了構造函數的狀態,而後經過suit()函數創造了 最終的Card對象.
def A (rank):
a,b ={ # 自己爲一個字典的傳遞值.返回對應的值.是dict的get方法
1: (AceCard, 'A'),
11: (FaceCard, 'J'),
12: (FaceCard, 'Q'),
13: (FaceCard, 'K')
}.get(rank, (NumberCard, str(rank)))
return a,b # 返回的是一個tuple(),a 爲 <class '__main__.NumberCard'> , b 爲'3'
a = A(3)
print(a)
咱們先實例化一個工廠對象,然而後在建立Card實例,這用方式沒有利用__init__() 在Card類層級結構的做用,改變的是調用者建立建立對象的方式.
在每一個子類中實現__init__()方法
如下代碼演示瞭如何把__init__()方法提到基類Card中實現的過程.而後在子類中能夠重用基類的實現.
class Card(object):
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)
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)
def card10(rank,suit):
if rank == 1:
return AceCard(rank,suit)
elif 2<= rank < 11:
return NumberCard(rank,suit)
elif 11<= rank <14:
return FaceCard(rank,suit)
else:
raise Exception('Rank out of range')
在這裏重構了基類中的__init__,雖然將它複雜化,可是這樣的權衡是正常的.
使用工廠函數封裝的複雜性
在 `__init__()`方法和工廠函數之間存在一些權衡,一般直接調動比'程序員友好'的`__init__()`函數並把複雜性分發給工廠函數更好.當須要封裝複雜的構造函數邏輯時,考慮使用工廠函數則更好.
簡單的組合對象
一個組合對象也能夠稱做容器.
若是業務邏輯相對簡單,爲何定義新類?
類的定義的一個優點是:
- 類給對象提供了簡單的,不須要實現的接口.
設計集合類,一般是下面三種策略:
- 封裝:這個實際是基於現有集合類來定義一個新類,屬於外觀模式的一個使用場景.
- 擴展:這個設計是對現有集合類進行擴展,一般使用定義子類的方式來實現.
- 建立:即從新設計.
以上是面向對象設計的核心.
封裝集合類
如下是對內部集合進行封裝設計.
import random
class Deck(object):
def __init__(self):
self._cards = [card6(r+1,s) for r in range(13) for s in (Club,Diamond,Heart,Spade)]
random.shuffle(self._cards)
def pop(self):
return self._cards.pop()
d = Deck()
hand = [d.pop(),d.pop()]
通常來講買外觀模式或者封裝類中的方法實現只是對底層對象相應函數的代理調用.
class Desk3(list):
def __init__(self, decks=1):
super(Desk3, self).__init__()
for i in range(decks):
self.extend(card6(r + 1, s) for r in range(13) for s in (Club, Diamond, Heart, Spade))
random.shuffle(self)
burn = random.random(1,52)
for i in range(burn):
self.pop()
這裏咱們使用了基類的 __init__()函數來建立了一個空集合,而後調用了 self.extrend()來吧多副牌加載到發牌機中.
複雜的組合對象
模擬打牌策略
class Hand:
def __init__(self,dealer_card):
self.dealer_card = dealer_card
self.cards = []
def hard_total(self):
return sum(c.hard for c in self.cards)
def soft_total(self):
return sum(c.soft for c in self.cards)
d = Deck()
h = Hand(d.pop())
h.cards.append(d.pop())
h.cards.append(d.pop())
須要一個一個的添加很是不方便
完成組合對象的初始化
__init__()初始化方法應當返回一個完成的對象,固然這個是理想的狀況.而這樣也帶來複雜性,由於要建立的對象內部可能包含了集合,集合裏面又包含了其餘對象.
一般考慮使用一個流暢的接口來完成逐個講對象添加到集合的操做,同時將集合對象做爲構造函數來完成初始化.例如:
class Hand2:
def __init__(self, dealer_card, *cards):
self.dealer_card = dealer_card
self.cards = list(cards)
def hard_total(self):
return sum(c.hard for c in self.cards)
def soft_total(self):
return sum(c.soft for c in self.cards)
d = Deck()
h = Hand2(d.pop(),d.pop(),d.pop(),d.pop())
print(h.cards)
不帶__init__方法的無狀態對象
一個策略對象以插件的形式複合在主對象上來完成一種算法或邏輯.它或許以來主對象中的數據,策略對象自身並不攜帶任何數據.一般策略類會和亨元設計模式一塊兒使用:在策略對象中避免內部存儲.所須要的值都從策略對象方法參數傳入.策略對象自身是無狀態的.能夠把它看作是一系列函數的集合.
這裏定義了一個類給Player實例提供了遊戲的選擇模式,如下這個策略包括拿牌和下注.
class GameStrategy:
def insurnace(self, hand):
return False
def split(self, hand):
return False
def double(self, hand):
return False
def hit(self, hand):
return False
每一個函數須要傳入已有的Hand對象,函數邏輯所須要的數據基於現有的可用信息.意味着數據來自於莊家跟玩家的手牌.
一塊兒其餘的類定義
玩家有兩張策略:打牌和下注.每一個Player實例回合模擬器進行不少次交互.咱們這裏把這個模擬器命名爲Table
Table類的職責須要配合Player實例完成如下事件:
- 玩家必需要基於玩牌策略初始化一個牌局.
- 隨後玩家會獲得一手牌
- 若是
如下是Table類中投注和牌的邏輯處理相關的代碼
class Table:
def __init__(self):
# 生成52張牌
self.deck = Deck()
def place_bet(self, amount):
print('Bet', amount)
def get_hand(self):
try:
# self.hand = Hand2(d.pop(), d.pop(), d.pop())
# self.hole_card = d.pop() 書上是這麼寫的我認爲不對，改成下面寫法
self.hand = Hand2(self.deck.pop(), self.deck.pop(), self.deck.pop())
self.hole_card = self.deck.pop()
except IndexError:
# Out of cards: need to shuffle
self.deck = Deck()
return self.get_hand()
print('Deal', self.hand)
return self.hand
# 沒有看明白hand從何而來，因此也未找到insure的方法。估計是寫錯了。
def can_insure(self, hand):
return hand.dealer_card.insure
class BettingStrategy:
def bet(self):
raise NotImplementedError('No bet method')
def record_win(self):
pass
def record_lose(self):
pass
class Flat(BettingStrategy):
def bet(self):
return 1
上面的那一段代碼還未看懂須要之後再來看一遍.
多策略的__init__()方法
class Hand4:
def __init__(self, *args, **kwargs):
print(len(args),args,kwargs)
if len(args) == 1 and isinstance(args[0], Hand4):
other = args[0]
self.dealer_card = other.dealer_card
self.cards = other.cards
elif len(args) == 2 and isinstance(args[0], Hand4) and 'split' in kwargs:
# Split an existing hand
other, card = args
self.dealer_card = other.dealer_card
self.cards = [other.cards[kwargs['split']], card]
elif len(args) == 3:
# Bulid a fresh ,new hand
dealer_card,*cards = args
self.dealer_card = dealer_card
self.cards = list(cards)
else:
raise TypeError('Invaild constructor args= {0!r} kw={1!r}'.format(args,kwargs))
def __str__(self):
return ','.join(map(str,self.cards))
d = Deck()
h = Hand4(d.pop(),d.pop(),d.pop())
print(h)
# s1 = Hand4(h,d.pop(),split = 0)
# s2 = Hand4(h,d.pop(),split = 1)
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())
上面這段代碼實現了:當第一輪發完牌是,dealer手牌有一張,Player手牌有兩張,當手牌的兩張牌相同的時候玩家能夠選擇分牌,將手中的的兩張牌分爲兩組牌,繼續進行遊戲.而後發牌器會給Palyer每組牌中個發一張牌
更多的__init__()技術
如下是Player類的定義,初始化使用兩個策略對象和一個table對象
略
- 1. 《JavaScript面向對象的編程指南》--讀書筆記
- 2. 《javascript面向對象編程指南》讀書筆記
- 3. 《python 3 面向對象編程》讀書筆記
- 4. python 面向對象編程讀書筆記
- 5. 《Python面向對象編程指南》——導讀
- 6. JavaScript面向對象編程指南
- 7. 視頻教程-Python面向對象編程指南-Python
- 8. 《C++ Primer 4th》面向對象編程讀書筆記－－－protected成員
- 9. 讀書筆記-JavaScript面向對象編程（一）
- 10. 讀書筆記（雜）--簡述面向對象和麪向過程。
- 更多相關文章...
- • PHP 面向對象 - PHP教程
- • Lua 面向對象 - Lua 教程
- • Tomcat學習筆記（史上最全tomcat學習筆記）
- • 算法總結-雙指針
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 在windows下的虛擬機中,安裝華爲電腦的deepin操作系統
- 2. 強烈推薦款下載不限速解析神器
- 3. 【區塊鏈技術】孫宇晨：區塊鏈技術帶來金融服務的信任變革
- 4. 搜索引起的鏈接分析-計算網頁的重要性
- 5. TiDB x 微衆銀行 | 耗時降低 58%，分佈式架構助力實現普惠金融
- 6. 《數字孿生體技術白皮書》重磅發佈（附完整版下載）
- 7. 雙十一「避坑」指南：區塊鏈電子合同爲電商交易保駕護航！
- 8. 區塊鏈產業，怎樣「鏈」住未來？
- 9. OpenglRipper使用教程
- 10. springcloud請求一次好用一次不好用zuul Name or service not known