class Vector2d:

 def __init__(self, x, y):
 self.x = x
 self.y = y

 def __iter__(self):
 return (n for n in (self.x, self.y))

class Vector2d:

 def __init__(self, x, y):
 self.__x = x
 self.__y = y

 @property
 def x(self):
 return self.__x

 @property
 def y(self):
 return self.__y

 def __iter__(self):
 return (i for i in (self.x, self.y))

>>> class Foo:
... 　　def __getitem__(self, pos):
... 　　　　return range(0, 30, 10)[pos]
...
>>> f = Foo()
>>> f[1]

>>> for i in f: print(i)
...



>>> 20 in f
True
>>> 15 in f
False

class FrenchDeck:
 ranks = [str(n) for n in range(2, 11)] + list('JQKA')
 suits = 'spades diamonds clubs hearts'.split()

 def __init__(self):
 self._cards = [Cards(rank, suit) for suit in self.suits
      for rank in self.ranks]

 def __len__(self):
 return len(self._cards)

 def __getitem__(self, pos):
 return self._cards[pos]

>>> from random import shuffle
>>> my_list = list(range(1, 11))
>>> shuffle(my_list)
>>> my_list
[5, 7, 9, 2, 10, 1, 8, 6, 4, 3]

Traceback (most recent call last):
 File "/Users/demon/PycharmProjects/FluentPython/接口：從協(xié)議到抽象基類/FrenchDeck.py", line 37, in <module>
 shuffle(deck)
 File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/random.py", line 274, in shuffle
 x[i], x[j] = x[j], x[i]
TypeError: 'FrenchDeck' object does not support item assignment　　

from collections import namedtuple
from random import shuffle

Cards = namedtuple('Cards', ['rank', 'suit'])

class FrenchDeck:
 ranks = [str(n) for n in range(2, 11)] + list('JQKA')
 suits = 'spades diamonds clubs hearts'.split()

 def __init__(self):
 self._cards = [Cards(rank, suit) for suit in self.suits
      for rank in self.ranks]

 def __len__(self):   #獲取長度的len
 return len(self._cards)

 def __getitem__(self, position): #能夠支持切片取值的處理
 return self._cards[position]


deck = FrenchDeck()    #實(shí)例化

def set_card(deck, position, card):  #猴子不定，其實(shí)就是啟動(dòng)調(diào)用內(nèi)部__setitem__設(shè)置值得外部函數(shù)
 deck._cards[position] = card

FrenchDeck.__setitem__ = set_card  #把猴子補(bǔ)丁傳遞給內(nèi)部的魔術(shù)方法
shuffle(deck)    #打亂洗牌的序列
print(deck[:5])    #獲取前五個(gè)卡牌的值

[Cards(rank='K', suit='diamonds'), Cards(rank='4', suit='spades'), Cards(rank='A', suit='clubs'), Cards(rank='K', suit='spades'), Cards(rank='6', suit='clubs')]　　

import collections


Card = collections.namedtuple('Card', ['rank', 'suit'])


class FrenchDeck2(collections.MutableSequence):
 ranks = [str(i) for i in range(1, 11)] + list('JQKA')
 suits = 'spades diamonds clubs hearts'.split()

 def __init__(self):
 self._cards = [Card(rank, suit) for suit in self.suits
     for rank in self.ranks]

 def __len__(self):    #支持查看長度
 return len(self._cards)

 def __getitem__(self, position):  #支持切片
 return self._cards[position]

 def __setitem__(self, position, value):  #支持洗牌
 self._cards[position] = value

 def __delitem__(self, position):  #但是繼承MutableSequence的類必須實(shí)現(xiàn) __delitem__ 方法，這是MutableSequence 類的一個(gè)抽象方法。
 del self._cards[position]

 def insert(self, position, value):  #此外，還要實(shí)現(xiàn)insert方法，這是MutableSequence類的第三個(gè)抽象方法
 self._cards.insert(position, value)

import abc


class Tombola(abc.ABC):      #自己定義的抽象基類要繼承abc.ABC

 @abc.abstractmethod
 def load(self, iterable):     #抽象方法使用@abstractmethod裝飾器標(biāo)記，而且定義體中通常只有文檔字符串
 """從可迭代對象中添加元素"""

 @abc.abstractmethod
 def pick(self):      #根據(jù)文檔字符串，如果沒有元素可選，應(yīng)該拋出LookupError
 """隨機(jī)刪除元素，然后返回
  如果實(shí)例為空，這個(gè)方法應(yīng)該拋出'LookupError'
 """

 def loaded(self):      #抽象基類可以包含具體方法
 """如果至少有一個(gè)元素，返回`True`，否則返回`False`。"""
 return bool(self.inspect())

 def inspect(self):
 """返回一個(gè)有序元組，由當(dāng)前元素構(gòu)成。"""
 items = []
 while True:
  try:
  items.append(self.pick())   
  except LookupError:
  break
 self.load(items)     #使用 .load(...)把所有元素放回去
 return tuple(sorted(items))    #返回排序好的items攻loaded調(diào)用

BaseException
├── SystemExit
├── KeyboardInterrupt
├── GeneratorExit
└── Exception
 ├── StopIteration
 ├── ArithmeticError
 │ ├── FloatingPointError
 │ ├── OverflowError
 │ └── ZeroDivisionError
 ├── AssertionError
 ├── AttributeError
 ├── BufferError
 ├── EOFError
 ├── ImportError
 ├── LookupError #我們在 Tombola.inspect 方法中處理的是 LookupError 異常 
 │ ├── IndexError #IndexError 是 LookupError 的子類，嘗試從序列中獲取索引超過最后位置的元素時(shí)拋出 
 │ └── KeyError #使用不存在的鍵從映射中獲取元素時(shí)，拋出 KeyError 異常
 ├── MemoryError
 ... etc.

>>> from tombola import Tombola
>>> class Fake(Tombola): 　　　　　　　　　　　　　　# 把Fake聲明為Tombole的子類，繼承抽象類
...  def pick(self):
...  return 13
...
>>> Fake 　　　　　　　　　　　　　　　　　　　　　　　 # 創(chuàng)建Fake類，目前木有毛線問題~
<class '__main__.Fake'>
>>> f = Fake() 　　　　　　　　　　　　　　　　　　　　#　報(bào)錯(cuò)了，Python認(rèn)為Fake類是抽象類，因?yàn)闆]有實(shí)現(xiàn)load方法
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Fake with abstract methods load

class Tombola(metaclass=abc.ABCMeta):
 # ...

class Tombola(object): # 這是Python 2！??！
 __metaclass__ = abc.ABCMeta
 # ...　　

class MyABC(abc.ABC):
 @classmethod
 @abc.abstractmethod
 def an_abstract_classmethod(cls, ...):
 pass 

import random
import abc


class Tombola(abc.ABC):      #自己定義的抽象基類要繼承abc.ABC

 @abc.abstractmethod
 def load(self, iterable):     #抽象方法使用@abstractmethod裝飾器標(biāo)記，而且定義體中通常只有文檔字符串
 """從可迭代對象中添加元素"""

 @abc.abstractmethod
 def pick(self):      #根據(jù)文檔字符串，如果沒有元素可選，應(yīng)該拋出LookupError
 """隨機(jī)刪除元素，然后返回
  如果實(shí)例為空，這個(gè)方法應(yīng)該拋出'LookupError'
 """

 def loaded(self):      #抽象基類可以包含具體方法
 """如果至少有一個(gè)元素，返回`True`，否則返回`False`。"""
 return bool(self.inspect())

 def inspect(self):
 """返回一個(gè)有序元組，由當(dāng)前元素構(gòu)成。"""
 items = []
 while True:
  try:
  items.append(self.pick())
  except LookupError:
  break
 self.load(items)     #使用 .load(...)把所有元素放回去
 return tuple(sorted(items))    #返回排序好的items攻loaded調(diào)用


#下面的代碼應(yīng)該單端放到一個(gè)py文件中，為了省事，就不在單獨(dú)放到一個(gè)模塊里面導(dǎo)入了~

class BigoCage(Tombola):     #明確指定BingoCage類擴(kuò)展Tombola類

 def __init__(self, items):
 self._randomizer = random.SystemRandom()  #假設(shè)我們將在線上游戲中使用這個(gè)。random.SystemRandom使用os.urandom(...) 函數(shù)實(shí)現(xiàn)randomAPI
 self._items = []
 self.load(items)     #委托.load(...)方法實(shí)現(xiàn)初始加載

 def load(self, items):
 self._items.extend(items)    #如果通過load方法傳遞一個(gè)可迭代的對象進(jìn)來，可以擴(kuò)展到以后的self._items的列表中
 self._randomizer.shuffle(self._items)   #沒有使用random.shuffle而是使用了SystemRandom中的shuffle方法

 def pick(self):
 try:
  return self._items.pop()
 except IndexError:
  raise LookupError('pick from empty BingoCage')

 def __call__(self):
 self.pick()

b = BigoCage(range(10))
print(b.pick())

import random

from tombola import Tombola


class LotteryBlower(Tombola):

 def __init__(self, iterable):
 self._balls = list(iterable)  #創(chuàng)建一個(gè)副本

 def load(self, iterbale):
 self._balls.extend(iterbale)  #把一個(gè)可迭代的對象添加到列表中

 def pick(self):
 try:
  position = random.randrange(len(self._balls)) #獲取一個(gè)隨機(jī)數(shù)
 except ValueError:
  raise LookupError('pick from empty LotteryBlower')
 return self._balls.pop(position)  #刪除列表中通過列表長度獲取的隨機(jī)數(shù)位置的索引值

 def loaded(self):
 return bool(self._balls)

 def inspect(self):
 return tuple(sorted(self._balls))