Python 数据模型

一摞Python风格的纸牌

 from collections import namedtuple
 from random import choice
 
 #命名元祖
 Card = namedtuple('Card', ['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 = [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('随机选择的扑克牌:', choice(deck))
 
 #选择扑克牌最上面的三张牌
 print('扑克牌上最上面的三张牌:', deck[:3])
 
 #选择大老A
 print('先选择第一张A', deck[12])
 
 #每一个花色有12张牌,可以通过步长来获取
 print('取所有的大老A:', deck[12::13])
 
 #判断成员关系
 print(Card('Q', 'hearts') in deck)
 print(Card('', 'beasts') in deck)
 
 #反向输出结果
 for card in reversed(deck):
     print(card)

以上代码执行的结果为：

扑克牌的长度: 52
随机选择的扑克牌: Card(rank='J', suit='clubs')
扑克牌上最上面的三张牌: [Card(rank='', suit='spades'), Card(rank='', suit='spades'), Card(rank='', suit='spades')]
先选择第一张A Card(rank='A', suit='spades')
取所有的大老A: [Card(rank='A', suit='spades'), Card(rank='A', suit='diamonds'), Card(rank='A', suit='clubs'), Card(rank='A', suit='hearts')]
True
False
Card(rank='A', suit='hearts')
Card(rank='K', suit='hearts')
Card(rank='Q', suit='hearts')
Card(rank='J', suit='hearts')
Card(rank='', suit='hearts')
Card(rank='', suit='hearts')
Card(rank='', suit='hearts')
Card(rank='', suit='hearts')
.......................
.......................

　　那么排序呢？我们按照常规，用点数来判定扑克牌的大小，2 最小、A最大；同时还要加上对花色的判定，黑桃最大、红桃次之、方块再次、梅花最小。下面就是按照这个规则来给扑克牌排序的函数，梅花 2 的大小是 0，黑桃 A 是 51：

 #牌颜色的权重
 suit_values = dict(spades=3, hearts=2, diamonds=1, clubs=0)
 
 def spades_high(card):
     #获取2.....A的索引的值
     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)

以上代码执行的结果为：

Card(rank='', suit='clubs')
Card(rank='', suit='diamonds')
Card(rank='', suit='hearts')
... (46 cards ommitted)
Card(rank='A', suit='diamonds')
Card(rank='A', suit='hearts')
Card(rank='A', suit='spades')

如何使用特殊方法

模拟数值类型

利用特殊方法，可以让自定义对象通过加号“+”（或是别的运算符）进行运算

们来实现一个二维向量（vector）类，这里的向量就是欧几里得几何中常用的概念，常在数学和物理中使用的那个

一个二维向量加法的例子，Vector(2,4) + Vextor(2,1) =Vector(4,5)

一个简单的二维向量类

 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})'.format(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, 4)
 v2 = Vector(2, 1)
 
 #向量v1 + v2的结果
 print('v1 + v2的和:', v1+v2)
 
 #向量v abs的结果
 v = Vector(3, 4)
 print('v abs的结果:', abs(v))
 
 #向量的惩罚
 print('v 的标量乘法abs的结果:', abs(v * 3))

以上代码执行的结果为：

v1 + v2的和: Vector(4, 5)
v abs的结果: 5.0
v 的标量乘法abs的结果: 15.0

字符串表示形式

　　Python 有一个内置的函数叫 repr，它能把一个对象用字符串的形式表达出来以便辨认，这就是“字符串表示形式”。repr 就是通过 __repr__这个特殊方法来得到一个对象的字符串表示形式的。如果没有实现__repr__，当我们在控制台里打印一个向量的实例时，得到的字符串可能会是 <Vector object at 0x10e100070>。　

　　交互式控制台和调试程序（debugger）用 repr 函数来获取字符串表示形式；在老的使用 % 符号的字符串格式中，这个函数返回的结果用来代替 %r 所代表的对象；同样，str.format 函数所用到的新式字符串格式化语法（https://docs.python.org/2/library/string.html#format-stringsyntax）也是利用了 repr()，才把 !r 字段变成字符串。

　　__repr__ 所返回的字符串应该准确、无歧义，并且尽可能表达出如何用代码创建出这个被打印的对象。因此这里使用了类似调用对象构造器的表达形式（比如 Vector(3, 4) 就是个例子）

　　__repr__ 和 __str__ 的区别在于，后者是在 str() 函数被使用，或是在用 print 函数打印一个对象的时候才被调用的，并且它返回的字符串对终端用户更友好。如果你只想实现这两个特殊方法中的一个，__repr__ 是更好的选择，因为如果一个对象没有 __str__ 函数，而 Python 又需要调用它的时候，解释器会用 __repr__ 作为替代。

算术运算符

　　通过 __add__ 和 __mul__，示例向量类带来了 + 和 * 这两个算术运算符。值得注意的是，这两个方法的返回值都是新创建的向量对象，被操作的两个向量（self 或 other）还是原封不动，代码里只是读取了它们的值而已。中缀运算符的基本原则就是不改变操作对象，而是产出一个新的值。

自定义的布尔值

　　尽管 Python 里有 bool 类型，但实际上任何对象都可以用于需要布尔值的上下文中（比如 if 或 while 语句，或者 and、or 和 not 运算符）。为了判定一个值 x 为真还是为假，Python 会调用 bool(x)，这个函数只能返回 True 或者 False。

　　默认情况下，我们自己定义的类的实例总被认为是真的，除非这个类对 __bool__ 或者 __len__ 函数有自己的实现。bool(x) 的背后是调x.__bool__() 的结果；如果不存在 __bool__ 方法，那么 bool(x) 会尝试调用 x.__len__()。若返回 0，则 bool 会返回 False；否则返回True。

　　我们对 __bool__ 的实现很简单，如果一个向量的模是 0，那么就返回False，其他情况则返回 True。因为 __bool__ 函数的返回类型应该是布尔型，所以我们通过 bool(abs(self)) 把模值变成了布尔值。

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

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

　　它不那么易读，却能省掉从 abs 到 __abs__ 到平方再到平方根这些中间步骤。通过 bool 把返回类型显式转换为布尔值是为了符合__bool__ 对返回值的规定，因为 or 运算符可能会返回 x 或者 y本身的值：若 x 的值等价于真，则 or 返回 x 的值；否则返回 y 的值。

特殊方法一览

跟运算符无关的特殊方法

类别	方法名
字符串字/字节序列表示形式	__repr__、__str__、__format__、__bytes__
数值转换	__abs__、__bool__、__complex__、__int__、__float__、__hash__、__index__
集合模拟	_len__、__getitem__、__setitem__、__delitem__、__contains__
迭代枚举	__iter__、__reversed__、__next__
可调用模拟	__call__
上下文管理	__enter__、__exit__
实例的创建和销毁	__new__、__init__、__del__
属性管理	__getattr__、__getattribute__、__setattr__、__delattr__、__dir__
属性描述符	__get__、__set__、__delete__
跟类相关的服务	__prepare__、__instancecheck__、__subclasscheck__

跟运算符相关的特殊方法

类别	方法名
一元运算符	__neg__ -、__pos__ +、__abs__ abs()
众多比较运算符	__lt__ <、__le__ <=、__eq__ ==、__ne__ !=、__gt__ >、__ge__ >=
算数运算符	__add__ +、__sub__ -、__mul__ *、__truediv__ /、__floordiv__ //、__mod__ %、  __divmod__divmod()、__pow__ ** 或pow()、__round__ round()
反向算术运算符	__radd__、__rsub__、__rmul__、__rtruediv__、__rfloordiv__、__rmod__、__rdivmod__
增量赋值算术运算符	__iadd__、__isub__、__imul__、__itruediv__、__ifloordiv__、__imod__、__ipow__
位运算符	__invert__ ~、__lshift__ <<、__rshift__ >>、__and__ &、__or__ |、__xor__ ^
反向位运算符	__rlshift__、__rrshift__、__rand__、__rxor__、__ror__
增量赋值为运算符	__ilshift__、__irshift__、__iand__、__ixor__、__ior__