流畅的python学习笔记（一）：序章

• 写在前面
  人们总是倾向于追求自己熟悉的东西，这在大多数情况下限制了你的成长。python是一门极容易上手又强大的语言，但需要注意的是，正因为如此，所以很多python程序员只用到了其强大功能的一部分 。《流畅的python》并不是一本完整的python使用手册，而是强调python作为编程语言独有的特性，这些特性只是python才具备的，或者是在其他语言很少见的，这也是我想写该系列教程的主要原因。

• 目标读者
  如果你刚开始学python，本系列教程可能会有点超纲，除此之外，任何python程序员都能从中获益匪浅。

初窥门径

一摞Python风格的纸牌，初步展示python内置方法的强大。

import collections
from random import choice, choices

# namedtuple方法用来构建只有只有少数属性但是没有方法的对象
# 构建一个简单的类表示纸牌
Card = collections.namedtuple("Card", ["rank", "suit"])

# 花色排序
suit_values = dict(spades=3, hearts=2, diamonds=1, clubs=0)


class FrenchDeck:
	"""一摞有序的纸牌"""
    ranks = [str(n) for n in range(2, 11)] + list("JQKA")
    suits = 'spades diamonds clubs hearts'.split()

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

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

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

• 以上代码短小精悍，可读性极好。使用namedtuple方法构建一个纸牌基本类，在FrenchDeck类中，多次使用列表推导式生成列表，重写内置函数。
  len方法作用于对象时调用对象的__len__ 内置函数
  由于重写了__len__()内置函数，所以可以使用len()方法查看纸牌有多少张。

if __name__ == '__main__':
    deck = FrenchDeck()
    print(len(deck)) # 52

抽取指定位置的一张纸牌

'''由于重写了内置函数__getitem__, 故可以获取任意位置纸牌'''
deck = FrenchDeck()
print(deck[1])  # Card(rank='2', suit='diamonds')  方块2
print(deck[-1]) # Card(rank='A', suit='hearts') 红桃A

随机抽取一张纸牌

# choice函数：从一个序列中随机选出一个元素
from random import choice

deck = FrenchDeck()
random_card1 = choice(deck)
print(random_card1) # Card(rank='8', suit='diamonds') 方块8
random_card2 = choice(deck)
print(random_card2) # Card(rank='K', suit='spades') 黑桃K

现在已经可以体会到通过实现特殊方法来利用 Python 数据模型的两个好处

1. 作为你的类的用户，他们不必去记住标准操作的各式名称（“怎么得到元素的总数？是 .size() 还是 .length() 还是别的什么？”）
2. 可以更加方便地利用 Python 的标准库，比如 random.choice 函数，从而不用重新发明轮子

切片和迭代

'''
因为 __getitem__ 函数把 [] 操作交给了 self._cards 列表，
所以deck类自动支持切片（slicing）操作，并且支持迭代
'''
deck = FrenchDeck()
print(deck[:3]) # [Card(rank='2', suit='spades'), Card(rank='2', suit='diamonds'), Card(rank='2', suit='clubs')]
print(deck[12:13]) # [Card(rank='5', suit='spades')]

# 迭代
for card in deck:
    print(card)
"""print
Card(rank='2', suit='spades')
Card(rank='2', suit='diamonds')
Card(rank='2', suit='clubs')
Card(rank='2', suit='hearts')
Card(rank='3', suit='spades')
...
"""

# 反向迭代
for card in reversed(deck):
    print(card)
"""print
Card(rank='A', suit='hearts')
Card(rank='A', suit='clubs')
Card(rank='A', suit='diamonds')
Card(rank='A', suit='spades')
Card(rank='K', suit='hearts')
...
"""

in

'''
迭代通常是隐式的，如果一个集合类型没有实现 __contains__ 方法，那么 in 运算符就会按顺序做一次迭代搜索。
于是，in 运算符可以用在我们的 FrenchDeck 类上，因为它是可迭代的
'''
deck = FrenchDeck()
print(Card("Q","hearts") in deck) # True
print(Card("7","beasts") in deck) # False

排序

# 花色排序 黑桃最大、红桃次之、方块再次、梅花最小
suit_values = dict(spades=3, hearts=2, diamonds=1, clubs=0)

def spades_high(card) -> int:
	"""获取纸牌的排名"""
    rank_value = FrenchDeck.ranks.index(card.rank)  # 获取纸牌的索引值
    return rank_value * len(suit_values) + suit_values[card.suit]  # 通过索引值和花色得到大小排名
    
def card_sort(deck) -> list:
    """对纸牌排序"""
    return sorted(deck, key=spades_high)

if __name__ == '__main__':
    deck = FrenchDeck()
    for card in card_sort(deck):
        print(card)
"""print
Card(rank='2', suit='clubs')
Card(rank='2', suit='diamonds')
Card(rank='2', suit='hearts')
...
Card(rank='A', suit='diamonds')
Card(rank='A', suit='hearts')
Card(rank='A', suit='spades')
"""

总而言之，特殊方法是通过内置函数来调用的。