《流畅的Python》第一章 自学笔记

第一章：Python数据模型

目录

1.1  一摞Python风格的纸牌

1.2  如何使用特殊方法

1.3  特殊方法一览 

1.4  为什么len不是普通方法

1.1  一摞Python风格的纸牌

       首先可以通过 pyhon 内置的 collections 库的 namedtuple 函数（这是一个工厂函数）构建一个带字段名的 tuple。

       具名函数 namedtuple 的实例和普通元组 tuple 消耗的内存一样多 (因为字段名都被保存在对应的类中) 但却更具可读性 (namedtuple 使 tuple 变成自文档，根据字段名很容易理解用途)，令代码更易维护；

       同时，namedtuple 不用命名空间字典 (namespace dictionary) __dict__ 来存放/维护实例属性，故比普通 dict 更加轻量和快速。但注意，具名元组 namedtuple 继承自 tuple ，其中的属性均不可变。

# 一个Python风格的纸牌
import collections

# 使用collection.namedtuple构建一个简单的类来表示一个纸牌
Card = collections.namedtuple('Card', ['rank', 'suit'])
# 通过实例化可以轻松得到一个实例对象
beer_card = Card('7', 'diamonds')
print(beer_card) # Card(rank='7', suit='diamonds')

       接着创建一个“法式纸牌”类：

# 纸牌类（法式纸牌）
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 suit in self.suits
                                        for rank in self.ranks]

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

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

       实例化纸牌，可以对纸牌进行一系列的操作：

# 实例化
deck = FrenchDeck()
print(len(deck))

# 抽取一张特定的纸牌
print(deck[0])

# 随机抽取一张纸牌
from random import choice
print(choice(deck))

# deck类自动支持切片操作
print(deck[:3])
print(deck[12::13])

# 仅仅实现了 __getitem__方法，这一摞牌就变成可迭代的了
for card in deck:
    print(card)

# 也可以做到反向迭代
for card in reversed(deck):
    print(card)

# 也可以用 in 等运算符
print(Card('Q', 'hearts') in deck)  # True
print(Card('7', 'beasts') in deck)  # False

# 排序 (spades>hearts>diamonds>clubs, 2最小, A最大)
suit_values = dict(spades=3, hearts=2, diamonds=1, clubs=0)

def spades_high(card):
    rank_value = FrenchDeck.ranks.index(card.rank)
    return rank_value * len(suit_values) + suit_values[card.suit]

for card in sorted(deck, key=spades_high):
    print(card)
    
print(len(suit_values))

所以通过实现特殊方法来利用 Python 数据类型的三个好处：

1.作为你的类的用户，他们不必去记住标准操作的各式名称（“怎么得到元素的总数？是 .size() 还是 .length() 还是别的什么？”），直接用 len()就好了。

2.可以更加方便地利用 Python 的标准库，比如 random.choice 函数，从而不用重新发明轮子。

3.这样产生的是一个可迭代对象，许多运算符可以对我们的类进行操作。

1.2  如何使用特殊方法

       特殊方法是给 Python 解释器调用的，不需要自己调用。

       在执行 len(my_object)的时候，如果 my_object 是一个自定义类的对象，那么 Python 会自己去调用其中由你实现的 __len__方法。

       如果（调用的对象）是 Python 内置的类型（list，str等），那么 CPython 会抄个近路， __len__ 实际上会直接返回 PyVarObject 里的 ob_size 属性。 PyVarObject 是表示内存中长度可变的内置对象的 C 语言结构体。直接读取这个值比调用一个方法要快很多。

       很多时候特殊方法的调用时隐式的。通常代码无需直接使用特殊方法。除非有大量元编程的存在，直接调用特殊方法的频率应该远远低于实现他们的次数。唯一例外的可能是__init__方法，代码里可能经常会用到，目的是在自己的子类 __init__ 方法中调用超类的构造器。

       通过内置的函数来使用特殊方法是最好的选择。这些内置函数不仅会调用特殊方法，通常还会提供额外的好处。而且对于内置的类来说，它们的速度更快。

       不要自己想当然的随意添加特殊方法，比如 __foo__ 之类的，因为虽然现在这个名字没有被 Python 内部使用，以后就不一定了。

1.2.1  模拟数值类型

       利用特殊方法，可以让自定义对象通过运算符进行运算。

       首先定义一个简单的二维向量类：

from math import hypot

class Vector:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def __repr__(self):
        return 'Vector(%r, %r)' % (self.x, self.y)

    def __abs__(self):
        return hypot(self.x, self.y)

    def __bool__(self):
        return bool(abs(self))

    def __add__(self, other):
        x = self.x + other.x
        y = self.y + other.y
        return Vector(x, y)

    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)

       类的实例化和运算操作演示：

v1 = Vector(2, 1)
v2 = Vector(2, 4)
print(v1 + v2)  # Vector(4, 5)

v = Vector(3, 4)
print(abs(v))  # 5.0
print(v*3)  # Vector(9, 12)

       虽然代码里有6个特殊方法，但除了__init__，这些方法并不会在这个类自身的代码中使用。一般只有 Python 的解释器会频繁地直接调用这些方法。

1.2.2  字符串表示形式

       repr 通过 __repr__ 这个特殊方法来得到一个对象的字符串表示形式。repr 可以把一个对象用字符串的形式表达出来以便辨认。

       在 __repr__ 的实现种。我们用到了 %r 来获取对象各个属性的标准字符串表示形式。这是一个好习惯，它暗示了一个关键：Vector(1, 2) 和Vector('1', '2')是不一样的。如果是后者的话，在 __abs__ 和 __bool__处会报错。此外，1.2.4节定义的 __bool__ 不会报错。

       __repr__ 所返回的字符应该准确、无歧义，并且尽可能表达出如何用代码创建出这个被打印的对象。因此这里使用了类似调用对象构造器的表达形式。

       如果一个对象没有 __str__ 函数， 而 Python 又需要调用它的时候，解释器会用 __repr__ 作为替代。

1.2.3  算数运算符

       例中的 __add__ 和 __mul__ 的返回值都是新创建的向量对象。被操作的两个向量还是原封不动，代码里只是读取了它们的值而已。中缀运算符的基本原则就是不改变操作对象，而是产出一个新的值。示例只实现了数字做乘数、向量做被乘数的运算，乘法的交换律被忽略了。后续会解决这个问题。

1.2.4  自定义的布尔值

       通过 bool(abs(self)) 可以把模值变成布尔值。

       如果想让 Vector.__bool__ 更高效，可以采用这种实现。

def __bool__(self):
    return bool(self.x or self.y)

1.3  特殊方法一览 

1.4  为什么len不是普通方法

       “实用胜于纯粹”，但同时“不能让特例特殊到开始破坏既定规则”。