《流畅的Python》 读书笔记 230926

写在最前面的话

缘由

关于Python的资料市面上非常多，好的其实并不太多。

个人认为，基础的，下面的都还算可以

1. B站小甲鱼
2. 黑马的视频
3. 刘江的博客
4. 廖雪峰的Python课程

进阶的更少，《流畅的Python》应该算一个。

加上，自己也很久没有耐心的看完一本书了

鉴于以上2点，2023-9-26开始在这里跟大家一起重读下这本书

注意事项

文中

引用是书籍正文的内容

自己会加一些理解，示例，限于水平难免有不对的地方，请大神看到帮忙斧正。

内容上会同时参考书籍的第一版(纸质,中文)和第二版(电子档,全英文)

第一章 Python数据模型

Python 最好的品质之一是一致性

如果你带着来自其他面向对象语言的经验进入 Python 的世界，会对 len(collection)

而不是 collection.len() 写法觉得不适

如Java中

String s = "hello";
System.out.println(s.length()); // 5

如Javascript中是

var s="hello";
console.log(s.length); // 5

Python中对str类型求长度是

len('hello')

str虽然有很多的方法，但并没有直接求长度的，虽然是有的。

s = 'hello'
print(s.__len__())

Python这样设计：len(obj)而不是obj.len())

它所代表的庞大的设计思想，是形成我们通常说的“Python 风格”（Pythonic）的关键

这种设计思想完全体现在 Python 的数据模型上，而数据模型所描述的API，为使用最地道的语言特性来构建你自己的对象提供了工具

数据模型其实是对 Python 框架的描述，它规范了这门语言自身构建模块的接口，这些模块包括但不限于序列、迭代器、函数、类和上下文管理器。

obj[key] 的背后就是 getitem 方法

userinfo = {'username':'wuxianfeng'}
print(userinfo['username']) # wuxianfeng
print(userinfo.__getitem__('username')) # wuxianfeng

这些特殊方法名能让你自己的对象实现和支持以下的语言构架，并与之交互：

• 迭代

• 集合类

• 属性访问

• 运算符重载

• 函数和方法的调用

• 对象的创建和销毁

• 字符串表示形式和格式化

• 管理上下文（即 with 块）

是的，不光是len(),dict[key]等，很多实现的背后都是魔术方法在发挥着作用

但是，我们一般都只是用表面的形式，不会直接去用魔术方法(除了__init__)；还要一种情况就是自定义对象，你如果善用魔术方法，能起到很好的Pythonic效果。

魔术方法（magic method）是特殊方法的昵称

特殊方法也叫双下方法（dunder method）

关于魔术方法：Python官网其实是非常详细的进行了说明的

以3.9为例: https://docs.python.org/zh-cn/3.9/reference/datamodel.html#special-method-names

我在知乎的另外一篇文章中也做了一些归类: https://zhuanlan.zhihu.com/p/656429071

其实流畅的Python可以说是对魔术方法的详解

1.1 一摞Python风格的纸牌

示例代码

import collections

Card = collections.namedtuple('Card', ['rank', 'suit'])
class FrenchDeck:
    ranks = [str(n) for n in range(2, 11)] + list('JQKA') # 这是 23456789 10 JQKA 构成的列表
    suits = 'spades diamonds clubs hearts'.split() #这是4个花色
    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]

看完代码你知道它在做什么吗？怎么做到的呢？让我们来逐一解开.... 其实很多初学者学完一遍基础是看不懂这个代码的，就是因为基础的书籍基本不会去讲这些，但其实这些是Python的思想(这个词，想了很久，说核心感觉有点大了，说原理，也不太对)

逐行解释

---

collections 是标准库的重要组成，其中有很多值得大家去掌握的API，比如defaultdict OrderedDict等等

---

第二行用了collections.namedtuple 顾名思义：命名元组

自 Python 2.6开始，namedtuple 就加入到 Python 里，用以构建只有少数属性但是没有方法的对象

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

这句话的意思其实是定义了一个类，名为Card，有2个属性rank 和 suit，需要你初始化的时候提供，有点像这样

Class Card:
    def __init__(self,rank,suit):
        pass

但作为namedtuple，有个非常重要的特性就是它像元组，因此你可以去用下标访问它

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

card1 = Card('10','spades')
print(card1[0]) # 10
print(card1[1]) # spades

namedtuple的定义是这样的

def namedtuple(typename, field_names, *, rename=False, defaults=None, module=None):
	pass

• typename: 类名
• field_names: 字段名，可以是['x', 'y'] 可以是'x y'，也可以是'x,y'
• rename:如果元素名称中含有python的关键字，则必须设置为rename=True
• defaults: 默认值

更多的细节可以自己再深入了解，不再赘述，浅尝止之

---

再来看FrenchDeck类的实现

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]

第2行：ranks = [str(n) for n in range(2, 11)] + list('JQKA') 构建了牌的大小的列表，值是str类型，2-A

第3行：suits = 'spades diamonds clubs hearts'.split() 就是4个花色

第4-6行：初始化的时候构成了52张牌，黑红金方2-A

用了双重列表推导式，举个例子

[i+j for i in '1234' for j in 'abcd']
['1a', '1b', '1c', '1d', '2a', '2b', '2c', '2d', '3a', '3b', '3c', '3d', '4a', '4b', '4c', '4d']

第7-8行：定义了魔术方法__len__，就是你在执行len()的时候会调用的，给你一个返回值，其实可以看得出来就是52

第9-10行：定义了魔术方法__getitem__，就是你在执行card[position]的时候给你的具体的牌

    frenchdeck = FrenchDeck()  # 新建一副牌
    print('一共有多少张:',len(frenchdeck)) # 52
    print('第1张牌是:',frenchdeck[0]) # 黑桃2
    print('第5张牌是:',frenchdeck[4]) # 黑桃6
    print('最后一张牌是:',frenchdeck[-1]) # 方块A

如果这个时候开始游戏，你要随便发一张牌给一个玩家

你可以用random.choice，而不需要自己去在这个类上实现随机的方法

通过目前的代码，你可以看到__len()__其实是事实上的标准获取对象长度的方法，所有的类都可以定义它，那么python就可以用len(obj)来看长度，不像有的语言，有的是size，有的是length，有的是len，千奇百怪，python统一了。

而__getitem__可不光是你可以下标去取牌这么简单

由于你的代码是把position给了self._cards

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

你已经可以用切片操作了，甚至还可以进行迭代操作(仅仅实现了__getitem__)，比如这样

    print('前3张牌:',frenchdeck[:3])  #切片
    print('4张A:',frenchdeck[12::13]) #切片
    print('正着数--->') #迭代
    for card in frenchdeck:
        print(card,end=' ')
    print('倒着数--->') #反向迭代
    for card in frenchdeck[::-1]:
        print(card,end=' ')

迭代通常是隐式的，譬如说一个集合类型没有实现 contains 方法，那么 in 运算符就会按顺序做一次迭代搜索。于是，in 运算符可以用在我们的 FrenchDeck 类上，因为它是可迭代的

测试代码

    frenchdeck = FrenchDeck()
    card1 = Card('2','hearts')
    card2 = Card('11','clubs')
    print(card1 in frenchdeck) # T
    print(card2 in frenchdeck) # F

关于__contains__，Python 官方对此的描述: https://docs.python.org/zh-cn/3.9/reference/datamodel.html

object.__contains__(self, item)
调用此方法以实现成员检测运算符。如果 item 是 self 的成员则应返回真，否则返回假。对于映射类型，此检测应基于映射的键而不是值或者键值对。

对于未定义 __contains__() 的对象，成员检测将首先尝试通过 __iter__() 进行迭代，然后再使用 __getitem__() 的旧式序列迭代协议

---

关于纸牌的排序

假定我们的顺序是这样的

1. 2最小，A最大
2. 黑桃>红桃>方块>草花

那怎样来输出呢?

    frenchdeck = FrenchDeck()
    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(frenchdeck,key=spades_high,reverse=True): # 从大 到小 ， 改为False或不写就是小->大
        print(card)

蛮多基础薄弱的人不知道为何这样是能做到的

这里其实涉及3个部分内容

1. dict的另外一种创建方式dict(spades=3, hearts=2, diamonds=1, clubs=0) 这个就简单
2. sorted用法
3. 数学

其中数学是关键，另外2个都是用来实现数学思想的

原始顺序
■2<2<2<2<
■3<3<3<3<
...
■A<A<A<A
你可以构造的序列，应该做一个转化
0<1<2<3
4<5<6<7
...

如何得到的呢?其实这是一个小学级别的数学题，但的确很多人那道题都未必做得出来，更遑论要自己构思了，所以数学好编程应该是轻松的，但编程好，数学可能是不太擅长的，因为你可能只是个API调用侠或者...

■2<2<2<2
0<1<2<3

■3<3<3<3
4<5<6<7

2就对应0(正好是牌大小的索引)，+ 花色所占的位序 (构建一个dict，存储对应关系)

来看核心代码

        rank_value = FrenchDeck.ranks.index(card.rank)
    # 得到的是 比如 2 在2-A这个列表中的索引 0
    # 同理 3的话得到是1
        return rank_value * len(suit_values) + suit_values[card.suit]
    # 最终的返回
    # 大小对应的索引(如2索引0)*4(花色的种类,在当前纸牌是固定的) + 花色对应的值(黑桃3红桃2梅花1方块0)
    # 黑桃2--> 2的索引0*4 + 3 == 3
    # 方块6--> 6的索引4*4 + 0 == 16

我不是个数学老师，所以未必能教的会啦，你自己再琢磨琢磨

最后的总结

虽然 FrenchDeck 隐式地继承了 object 类，但功能却不是继承而来的。我们通过数据模型和一些合成来实现这些功能。通过实现 __len__ 和__getitem__这两个特殊方法，FrenchDeck就跟一个 Python 自有的序列数据类型一样，可以体现出 Python 的核心语言特性（例如迭代和切片）。同时这个类还可以用于标准库中诸如 random.choice、reversed 和 sorted 这些函数。另外，对合成的运用使得__len__和__getitem__的具体实现可以代理给 self._cards 这个 Python 列表（即 list 对象

引申

按照目前的设计，FrenchDeck 是不能洗牌的，因为这摞牌是不可变的（immu-table）：卡牌和它们的位置都是固定的，除非我们破坏这个类的封装性，直接对 _cards 进行操作。第 11 章会讲到，其实只需要一行代码来实现__setitem__ 方法，洗牌功能就不是问题了