国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

Python 面向?qū)ο缶幊讨改?讀書筆記

cncoder / 1791人閱讀

摘要:可以賦值對象的生命周期主要是有創(chuàng)建初始化銷毀。顯示而非隱式對于每個(gè)方法,都應(yīng)當(dāng)顯示的制定要初始化的變量。每當(dāng)創(chuàng)建一個(gè)對象,會(huì)創(chuàng)建一個(gè)空對象,然后調(diào)用該對象的函數(shù),提供了初始化的操作。以點(diǎn)為例作為說明。

第一部分 用特殊方法實(shí)現(xiàn)Python風(fēng)格的類

為了實(shí)現(xiàn)更好的可擴(kuò)展性,Python語言提供了大量的特殊方法,它們大致分為以下幾類。

特性訪問

可調(diào)用對象

集合

數(shù)字

上下文

迭代器

第一章 使用__init()__方法

Python中一切事物皆對象!!!!!!
__init__()方法記住兩點(diǎn):

__init()__(初始化)是對象生命周期的開始,每個(gè)對象必須正確初始化才能夠正常的工作。

__init__()可以賦值

對象的生命周期主要是有創(chuàng)建、初始化、銷毀。
‘顯示而非隱式’:對于每個(gè)__init__()方法,都應(yīng)當(dāng)顯示的制定要初始化的變量。
每當(dāng)創(chuàng)建一個(gè)對象,python會(huì)創(chuàng)建一個(gè)空對象,然后調(diào)用該對象的__init__()函數(shù),提供了初始化的操作。

</>復(fù)制代碼

  1. # 以21點(diǎn)為例作為說明。
  2. class Card(object):
  3. def __init__(self, suit, rank):
  4. self.suit = suit
  5. self.rank = rank
  6. self.hard, self.soft = self._points()
  7. class NumberCard(Card):
  8. def _points(self):
  9. return int(self.rank), int(self.rank)
  10. class AceCard(Card):
  11. def _points(self):
  12. return 1, 11
  13. class FaceCard(Card):
  14. def _points(self):
  15. return 10, 10
  16. class Suit(object):
  17. def __init__(self,name,symbol):
  18. self.name = name
  19. self.symbol = symbol
  20. Club,Diamond,Heart,Spade = Suit("Club","?"),Suit("Diamond","?"),Suit("Heart","?"),Suit("Spade","?")
通過工廠函數(shù)來調(diào)用__init__():

</>復(fù)制代碼

  1. def card(rank, suit):
  2. if rank == 1:
  3. return AceCard("A", suit)
  4. elif 2 <= rank < 11:
  5. return NumberCard(str(rank), suit)
  6. elif 11 <= rank < 14:
  7. name = {11: "J", 12: "Q", 13: "K"}[rank]
  8. return FaceCard(name, suit)
  9. else:
  10. raise Exception("rank out of range")

</>復(fù)制代碼

  1. 這個(gè)函數(shù)通過傳入牌面值rank 和花色值suit來創(chuàng)建card對象.

</>復(fù)制代碼

  1. deck = [card(rank, suit) for rank in range(1, 14) for suit in (Club, Diamond, Heart, Spade)]
  2. print(deck[0].rank,deck[0].suit.symbol)

這段代碼完成了52張牌對象的創(chuàng)建.

使用映射和類來簡化設(shè)計(jì).

由于類是第一級別的對象,從rank參數(shù)射到對象是很容易的事情.
下面的Card類工廠就是使用映射實(shí)現(xiàn)的版本.

</>復(fù)制代碼

  1. def card4(rank,suit):
  2. class_ = {1:AceCard,11:FaceCard,12:FaceCard,13:FaceCard}.get(rank,NumberCard)
  3. return class_(rank,suit)

需要修改映射邏輯,除了提供Card子類,還需要提供rank對象的字符串結(jié)果.如何實(shí)現(xiàn)這兩部分映射,有四種常見方案.

可以建立兩個(gè)并行映射

可以映射為一個(gè)二元組.

可以映射為partial()函數(shù).

可以考慮修改類定義的完成映射邏輯.

1.并行映射

</>復(fù)制代碼

  1. def card5(rank,suit):
  2. class_ = {1:AceCard,11:FaceCard,12:FaceCard,13:FaceCard}.get(rank,NumberCard)
  3. rank_str = {1:"A",11: "J", 12: "Q", 13: "K"}.get(rank,str(rank))
  4. return class_(rank_str,suit)

這樣是不值得做的,帶來映射鍵1,11,12,13的邏輯重復(fù).

不要使用并行結(jié)構(gòu),并行結(jié)構(gòu)應(yīng)該被元祖或者一些更好的組合所代替

映射到一個(gè)牌面值的元組

</>復(fù)制代碼

  1. def card6(rank,suit):
  2. class_,rank_str= {
  3. 1:(AceCard,"A"),
  4. 11:(FaceCard,"J"),
  5. 12:(FaceCard,"Q"),
  6. 13:(FaceCard,"K")
  7. }.get(rank,(NumberCard,str(rank)))
  8. return class_(rank_str,suit)

從rank值映射到類對象時(shí)很少見的,而且兩個(gè)參數(shù)只有一個(gè)用于對象的初始化.從rank映射到一個(gè)相對簡單的類或者是函數(shù)對象,而不必提供目的不明確的參數(shù),這才是明智的選擇.

3.partial 函數(shù)設(shè)計(jì)

</>復(fù)制代碼

  1. def card7(rank,suit):
  2. from functools import partial
  3. part_class = {
  4. 1:partial(AceCard,"A"),
  5. 11:partial(FaceCard,"J"),
  6. 12:partial(FaceCard,"Q"),
  7. 13:partial(FaceCard,"K")
  8. }.get(rank,partial(NumberCard,str(rank)))
  9. return part_class(suit)

通過調(diào)用partial()函數(shù)然后復(fù)制給part_class,完成于rank對象的管的關(guān)聯(lián),可以使用同樣的方式來創(chuàng)建suit對象,并且完成最終的Card對象的創(chuàng)建.partial()函數(shù)的使用在函數(shù)時(shí)編程中是很常見的.當(dāng)時(shí)用的是函數(shù)而非對象方法的時(shí)候就可以考慮使用.

大致上,partial()函數(shù)在面向?qū)ο缶幊讨胁皇呛艹S?我們可以簡單的的提供構(gòu)造函數(shù)不同版本來做相同的事情.partial()函數(shù)和構(gòu)造對象時(shí)的流暢接口很類似.

工廠模式的流暢的API設(shè)計(jì)

有時(shí)候我們定義類中的方法必須按照特定的順序來調(diào)用.這種順序調(diào)用的方法和創(chuàng)建 partial() 函數(shù)的方式非常類似.

我們可以在流暢接口函數(shù)中設(shè)置可以返回self值的rank對象,然后傳入花色類從而創(chuàng)建Card實(shí)例/

以下是Card工廠流暢接口的定義,包含兩個(gè)函數(shù),他們必須按照順序調(diào)用.

</>復(fù)制代碼

  1. class CardFactory(object):
  2. def rank(self,rank):
  3. self.class_,self.rank_str = {
  4. 1:(AceCard,"A"),
  5. 11:(FaceCard,"J"),
  6. 12:(FaceCard,"Q"),
  7. 13:(FaceCard,"K")
  8. }.get(rank,(NumberCard,str(rank)))
  9. def suit(self,suit):
  10. return self.class_(self.rank_str,suit)

先使用rank()函數(shù)更新了構(gòu)造函數(shù)的狀態(tài),然后通過suit()函數(shù)創(chuàng)造了 最終的Card對象.

</>復(fù)制代碼

  1. def A (rank):
  2. a,b ={ # 本身為一個(gè)字典的傳遞值.返回對應(yīng)的值.是dict的get方法
  3. 1: (AceCard, "A"),
  4. 11: (FaceCard, "J"),
  5. 12: (FaceCard, "Q"),
  6. 13: (FaceCard, "K")
  7. }.get(rank, (NumberCard, str(rank)))
  8. return a,b # 返回的是一個(gè)tuple(),a 為 , b 為"3"
  9. a = A(3)
  10. print(a)

我們先實(shí)例化一個(gè)工廠對象,然然后在創(chuàng)建Card實(shí)例,這用方式?jīng)]有利用__init__() 在Card類層級結(jié)構(gòu)的作用,改變的是調(diào)用者創(chuàng)建創(chuàng)建對象的方式.

在每個(gè)子類中實(shí)現(xiàn)__init__()方法

以下代碼演示了如何把__init__()方法提到基類Card中實(shí)現(xiàn)的過程.然后在子類中可以重用基類的實(shí)現(xiàn).

</>復(fù)制代碼

  1. class Card(object):
  2. def __init__(self, rank, suit, hard, soft):
  3. self.rank = rank
  4. self.suit = suit
  5. self.hard = hard
  6. self.soft = soft
  7. class NumberCard(Card):
  8. def __init__(self, rank, suit):
  9. super().__init__(str(rank), suit, rank, rank)
  10. class AceCard(Card):
  11. def __init__(self, rank, suit):
  12. super(AceCard, self).__init__("A", suit, 1, 11)
  13. class FaceCard(Card):
  14. def __init__(self, rank, suit):
  15. super(FaceCard, self).__init__({11: "J",
  16. 12: "Q",
  17. 13: "K"}[rank], suit, 10, 10)
  18. def card10(rank,suit):
  19. if rank == 1:
  20. return AceCard(rank,suit)
  21. elif 2<= rank < 11:
  22. return NumberCard(rank,suit)
  23. elif 11<= rank <14:
  24. return FaceCard(rank,suit)
  25. else:
  26. raise Exception("Rank out of range")

在這里重構(gòu)了基類中的__init__,雖然將它復(fù)雜化,但是這樣的權(quán)衡是正常的.

使用工廠函數(shù)封裝的復(fù)雜性

</>復(fù)制代碼

  1. `__init__()`方法和工廠函數(shù)之間存在一些權(quán)衡,通常直接調(diào)動(dòng)比"程序員友好"`__init__()`函數(shù)并把復(fù)雜性分發(fā)給工廠函數(shù)更好.當(dāng)需要封裝復(fù)雜的構(gòu)造函數(shù)邏輯時(shí),考慮使用工廠函數(shù)則更好.
簡單的組合對象

一個(gè)組合對象也可以稱作容器.

如果業(yè)務(wù)邏輯相對簡單,為什么定義新類?

類的定義的一個(gè)優(yōu)勢是:

類給對象提供了簡單的,不需要實(shí)現(xiàn)的接口.

設(shè)計(jì)集合類,通常是下面三種策略:

封裝:這個(gè)實(shí)際是基于現(xiàn)有集合類來定義一個(gè)新類,屬于外觀模式的一個(gè)使用場景.

擴(kuò)展:這個(gè)設(shè)計(jì)是對現(xiàn)有集合類進(jìn)行擴(kuò)展,通常使用定義子類的方式來實(shí)現(xiàn).

創(chuàng)建:即重新設(shè)計(jì).

以上是面向?qū)ο笤O(shè)計(jì)的核心.

封裝集合類

以下是對內(nèi)部集合進(jìn)行封裝設(shè)計(jì).

</>復(fù)制代碼

  1. import random
  2. class Deck(object):
  3. def __init__(self):
  4. self._cards = [card6(r+1,s) for r in range(13) for s in (Club,Diamond,Heart,Spade)]
  5. random.shuffle(self._cards)
  6. def pop(self):
  7. return self._cards.pop()
  8. d = Deck()
  9. hand = [d.pop(),d.pop()]

一般來說買外觀模式或者封裝類中的方法實(shí)現(xiàn)只是對底層對象相應(yīng)函數(shù)的代理調(diào)用.

</>復(fù)制代碼

  1. class Desk3(list):
  2. def __init__(self, decks=1):
  3. super(Desk3, self).__init__()
  4. for i in range(decks):
  5. self.extend(card6(r + 1, s) for r in range(13) for s in (Club, Diamond, Heart, Spade))
  6. random.shuffle(self)
  7. burn = random.random(1,52)
  8. for i in range(burn):
  9. self.pop()

這里我們使用了基類的 __init__()函數(shù)來創(chuàng)建了一個(gè)空集合,然后調(diào)用了 self.extrend()來吧多副牌加載到發(fā)牌機(jī)中.

復(fù)雜的組合對象

模擬打牌策略

</>復(fù)制代碼

  1. class Hand:
  2. def __init__(self,dealer_card):
  3. self.dealer_card = dealer_card
  4. self.cards = []
  5. def hard_total(self):
  6. return sum(c.hard for c in self.cards)
  7. def soft_total(self):
  8. return sum(c.soft for c in self.cards)
  9. d = Deck()
  10. h = Hand(d.pop())
  11. h.cards.append(d.pop())
  12. h.cards.append(d.pop())

需要一個(gè)一個(gè)的添加非常不方便

完成組合對象的初始化

__init__()初始化方法應(yīng)當(dāng)返回一個(gè)完成的對象,當(dāng)然這個(gè)是理想的情況.而這樣也帶來復(fù)雜性,因?yàn)橐獎(jiǎng)?chuàng)建的對象內(nèi)部可能包含了集合,集合里面又包含了其他對象.

通常考慮使用一個(gè)流暢的接口來完成逐個(gè)講對象添加到集合的操作,同時(shí)將集合對象作為構(gòu)造函數(shù)來完成初始化.例如:

</>復(fù)制代碼

  1. class Hand2:
  2. def __init__(self, dealer_card, *cards):
  3. self.dealer_card = dealer_card
  4. self.cards = list(cards)
  5. def hard_total(self):
  6. return sum(c.hard for c in self.cards)
  7. def soft_total(self):
  8. return sum(c.soft for c in self.cards)
  9. d = Deck()
  10. h = Hand2(d.pop(),d.pop(),d.pop(),d.pop())
  11. print(h.cards)
不帶__init__方法的無狀態(tài)對象

一個(gè)策略對象以插件的形式復(fù)合在主對象上來完成一種算法或邏輯.它或許以來主對象中的數(shù)據(jù),策略對象自身并不攜帶任何數(shù)據(jù).通常策略類會(huì)和亨元設(shè)計(jì)模式一起使用:在策略對象中避免內(nèi)部存儲(chǔ).所需要的值都從策略對象方法參數(shù)傳入.策略對象自身是無狀態(tài)的.可以把它看做是一系列函數(shù)的集合.

這里定義了一個(gè)類給Player實(shí)例提供了游戲的選擇模式,以下這個(gè)策略包括拿牌和下注.

</>復(fù)制代碼

  1. class GameStrategy:
  2. def insurnace(self, hand):
  3. return False
  4. def split(self, hand):
  5. return False
  6. def double(self, hand):
  7. return False
  8. def hit(self, hand):
  9. return False

每個(gè)函數(shù)需要傳入已有的Hand對象,函數(shù)邏輯所需要的數(shù)據(jù)基于現(xiàn)有的可用信息.意味著數(shù)據(jù)來自于莊家跟玩家的手牌.

一起其他的類定義

玩家有兩張策略:打牌和下注.每個(gè)Player實(shí)例回合模擬器進(jìn)行很多次交互.我們這里把這個(gè)模擬器命名為Table

Table類的職責(zé)需要配合Player實(shí)例完成以下事件:

玩家必須要基于玩牌策略初始化一個(gè)牌局.

隨后玩家會(huì)得到一手牌

如果

以下是Table類中投注和牌的邏輯處理相關(guān)的代碼

</>復(fù)制代碼

  1. class Table:
  2. def __init__(self):
  3. # 生成52張牌
  4. self.deck = Deck()
  5. def place_bet(self, amount):
  6. print("Bet", amount)
  7. def get_hand(self):
  8. try:
  9. # self.hand = Hand2(d.pop(), d.pop(), d.pop())
  10. # self.hole_card = d.pop() 書上是這么寫的我認(rèn)為不對,改為下面寫法
  11. self.hand = Hand2(self.deck.pop(), self.deck.pop(), self.deck.pop())
  12. self.hole_card = self.deck.pop()
  13. except IndexError:
  14. # Out of cards: need to shuffle
  15. self.deck = Deck()
  16. return self.get_hand()
  17. print("Deal", self.hand)
  18. return self.hand
  19. # 沒有看明白hand從何而來,所以也未找到insure的方法。估計(jì)是寫錯(cuò)了。
  20. def can_insure(self, hand):
  21. return hand.dealer_card.insure
  22. class BettingStrategy:
  23. def bet(self):
  24. raise NotImplementedError("No bet method")
  25. def record_win(self):
  26. pass
  27. def record_lose(self):
  28. pass
  29. class Flat(BettingStrategy):
  30. def bet(self):
  31. return 1

上面的那一段代碼還未看懂需要以后再來看一遍.

多策略的__init__()方法

</>復(fù)制代碼

  1. class Hand4:
  2. def __init__(self, *args, **kwargs):
  3. print(len(args),args,kwargs)
  4. if len(args) == 1 and isinstance(args[0], Hand4):
  5. other = args[0]
  6. self.dealer_card = other.dealer_card
  7. self.cards = other.cards
  8. elif len(args) == 2 and isinstance(args[0], Hand4) and "split" in kwargs:
  9. # Split an existing hand
  10. other, card = args
  11. self.dealer_card = other.dealer_card
  12. self.cards = [other.cards[kwargs["split"]], card]
  13. elif len(args) == 3:
  14. # Bulid a fresh ,new hand
  15. dealer_card,*cards = args
  16. self.dealer_card = dealer_card
  17. self.cards = list(cards)
  18. else:
  19. raise TypeError("Invaild constructor args= {0!r} kw={1!r}".format(args,kwargs))
  20. def __str__(self):
  21. return ",".join(map(str,self.cards))
  22. d = Deck()
  23. h = Hand4(d.pop(),d.pop(),d.pop())
  24. print(h)
  25. # s1 = Hand4(h,d.pop(),split = 0)
  26. # s2 = Hand4(h,d.pop(),split = 1)

</>復(fù)制代碼

  1. class Hand5:
  2. def __init__(self,dealer_card,*cards):
  3. self.dealer_card = dealer_card
  4. self.cards = list(cards)
  5. @staticmethod
  6. def freeze(other):
  7. hand = Hand5(other.dealer_card,*other.cards)
  8. return hand
  9. @staticmethod
  10. def split(other,card0,card1):
  11. hand0 = Hand5(other.dealer_card,other.cards[0],card0)
  12. hand1 = Hand5(other.dealer_card,other.cards[1],card1)
  13. return hand0,hand1
  14. def __str__(self):
  15. return ",".join(map(str,self.cards))
  16. d = Deck()
  17. h = Hand5(d.pop(),d.pop(),d.pop())
  18. s1,s2 = Hand5.split(h,d.pop(),d.pop())

上面這段代碼實(shí)現(xiàn)了:當(dāng)?shù)谝惠啺l(fā)完牌是,dealer手牌有一張,Player手牌有兩張,當(dāng)手牌的兩張牌相同的時(shí)候玩家可以選擇分牌,將手中的的兩張牌分為兩組牌,繼續(xù)進(jìn)行游戲.然后發(fā)牌器會(huì)給Palyer每組牌中個(gè)發(fā)一張牌

更多的__init__()技術(shù)

以下是Player類的定義,初始化使用兩個(gè)策略對象和一個(gè)table對象

文章版權(quán)歸作者所有,未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為,您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請注明本文地址:http://m.specialneedsforspecialkids.com/yun/44466.html

相關(guān)文章

  • 《JavaScript 權(quán)威指南讀書筆記 1 - 簡介

    摘要:原文第一章主要介紹的大概情況基本語法。通過和來引用對象屬性或數(shù)組元素的值就構(gòu)成一個(gè)表達(dá)式。 原文:https://keelii.github.io/2016/06/16/javascript-definitive-guide-note-0/ 第一章 主要介紹 JavaScript 的大概情況、基本語法。之前沒有 JavaScript 基礎(chǔ)的看不懂也沒關(guān)系,后續(xù)章節(jié)會(huì)有進(jìn)一步的詳細(xì)說明...

    sydMobile 評論0 收藏0
  • 新書《JavaScript面向對象編程指南(第2版)》

    摘要:前段時(shí)間在網(wǎng)絡(luò)上看了車洪才老先生編寫阿富汗語詞典的故事。年,萬字,完稿時(shí)已斗轉(zhuǎn)星移。然而書的修成不都如此嗎前有明朝的永樂大典,近有車洪才老先生的阿富汗語詞典我還看過一部電影編舟記,講述的便是一部字典歷經(jīng)十余年的修成。然而我們對此坦然以待。 我記得去年的這個(gè)時(shí)候我丟了工作,然后每天就是跑步、譯書、跑步、譯書。非常單調(diào)的日子過了兩個(gè)多月。這種日子過的時(shí)候并沒有過多地覺得什么,但是譯完交稿的...

    silencezwm 評論0 收藏0
  • 流暢的python讀書筆記-第一章Python 數(shù)據(jù)模型

    摘要:第一章數(shù)據(jù)類型隱式方法利用快速生成類方法方法通過下標(biāo)找元素自動(dòng)支持切片操作可迭代方法與如果是一個(gè)自定義類的對象,那么會(huì)自己去調(diào)用其中由你實(shí)現(xiàn)的方法。若返回,則會(huì)返回否則返回。一個(gè)對象沒有函數(shù),解釋器會(huì)用作為替代。 第一章 python數(shù)據(jù)類型 1 隱式方法 利用collections.namedtuple 快速生成類 import collections Card = collec...

    tomener 評論0 收藏0
  • 流暢的python讀書筆記-第一章Python 數(shù)據(jù)模型

    摘要:第一章數(shù)據(jù)類型隱式方法利用快速生成字典方法方法通過下標(biāo)找元素自動(dòng)支持切片操作可迭代方法與如果是一個(gè)自定義類的對象,那么會(huì)自己去調(diào)用其中由你實(shí)現(xiàn)的方法。若返回,則會(huì)返回否則返回。一個(gè)對象沒有函數(shù),解釋器會(huì)用作為替代。 第一章 python數(shù)據(jù)類型 1 隱式方法 利用collections.namedtuple 快速生成字典 import collections Card = coll...

    FullStackDeveloper 評論0 收藏0
  • 雙十二大前端工程師讀書清單

    摘要:本文最早為雙十一而作,原標(biāo)題雙大前端工程師讀書清單,以付費(fèi)的形式發(fā)布在上。發(fā)布完本次預(yù)告后,捕捉到了一個(gè)友善的吐槽讀書清單也要收費(fèi)。這本書便從的異步編程講起,幫助我們設(shè)計(jì)快速響應(yīng)的網(wǎng)絡(luò)應(yīng)用,而非簡單的頁面。 本文最早為雙十一而作,原標(biāo)題雙 11 大前端工程師讀書清單,以付費(fèi)的形式發(fā)布在 GitChat 上。發(fā)布之后在讀者圈群聊中和讀者進(jìn)行了深入的交流,現(xiàn)免費(fèi)分享到這里,不足之處歡迎指教...

    余學(xué)文 評論0 收藏0

發(fā)表評論

0條評論

cncoder

|高級講師

TA的文章

閱讀更多
最新活動(dòng)
閱讀需要支付1元查看
<