关于Python的资料市面上非常多，好的其实并不太多。
个人认为，基础的，下面的都还算可以
进阶的更少，《流畅的Python》应该算一个。
加上，自己也很久没有耐心的看完一本书了
鉴于以上2点，2023-9-26开始在这里跟大家一起重读下这本书
文中
引用是书籍正文的内容
自己会加一些理解，示例，限于水平难免有不对的地方，请大神看到帮忙斧正。
内容上会同时参考书籍的第一版(纸质,中文)和第二版(电子档,全英文)
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可以说是对魔术方法的详解
示例代码
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
更多的细节可以自己再深入了解，不再赘述，浅尝止之
再来看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__() 的旧式序列迭代协议
关于纸牌的排序
假定我们的顺序是这样的
那怎样来输出呢?
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个部分内容
dict(spades=3, hearts=2, diamonds=1, clubs=0) 这个就简单其中数学是关键，另外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__方法，洗牌功能就不是问题了