Python作为一种多范式语言，它的很多语言特性都能从其他语言上找到参照，但是Python依然形成了一套自己的“Python 风格”（Pythonic）。这种Pythonic风格完全体现在 Python 的数据模型上，而数据模型中的元接口（指那些名字以两个下划线开头，以两个下划线结尾的特殊方法，例如 __getitem__），就是编写地道的Python代码的秘密所在。这种基于元接口实现的设计模式，也叫鸭子类型（duck typing）。

鸭子类型指的是对象的类型无关紧要，只要实现了特定的接口即可。忽略对象的真正类型，转而关注对象有没有实现所需的方法、签名和语义。Python的数据模型都支持鸭子类型，鸭子类型也是地道Python编程鼓励的风格，所以如果觉得自己想创建新的抽象基类，先试着通过常规的鸭子类型来解决问题。

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

 

得益于 Python 数据模型，自定义类的行为可以像内置类型那样自然。实现如此自然的行为，靠的不是继承，而是元接口。Python给类设计了大量的元接口，具体请参看Python 语言参考手册中的“Data Model”章节。下面是一些类的元接口的展示。

  1. """
  2.     >>> v1 = Vector2d(3, 4)
  4.     通过元接口__iter__支持拆包
  5.     >>> x, y = v1
  6.     >>> x, y
  7.     (3.0, 4.0)
  9.     通过元接口__repr__支持字面量表示和repr函数
  10.     >>> v1
  11.     Vector2d(3.0, 4.0)
  12.     >>> v1_clone = eval(repr(v1))
  13.     >>> v1 == v1_clone
  14.     True
  16.     通过元接口__str__支持print函数
  17.     >>> print(v1)
  18.     (3.0, 4.0)
  20.     通过元接口__bytes__支持bytes函数
  21.     >>> octets = bytes(v1)
  22.     >>> octets
  23.     b\'d\\x00\\x00\\x00\\x00\\x00\\x00\\x08@\\x00\\x00\\x00\\x00\\x00\\x00\\x10@\'
  25.     通过元接口__abs__支持abs函数
  26.     >>> abs(v1)
  27.     5.0
  29.     通过元接口__bool__支持bool函数
  30.     >>> bool(v1), bool(Vector2d(0, 0))
  31.     (True, False)
  33.     通过property支持可读属性
  34.     >>> v1.x, v1.y
  35.     (3.0, 4.0)
  36.     >>> v1.x = 123
  37.     Traceback (most recent call last):
  38.       ...
  39.     AttributeError: can\'t set attribute
  41.     通过__hash__支持对象可散列，支持dict、set等函数
  42.     >>> hash(v1)
  43.     7
  44.     >>> set(v1)
  45.     {3.0, 4.0}
  46.     >>> {v1: \'point1\'}
  47.     {Vector2d(3.0, 4.0): \'point1\'}
  49. """
  50.  
  51. from array import array
  52. import math
  54. class Vector2d:
  55.     typecode = \'d\'
  56.  
  57.     def __init__(self, x, y):
  58.         self.__x = float(x) 
  59.         self.__y = float(y)
  61.     @property
  62.     def x(self):
  63.         return self.__x
  65.     @property
  66.     def y(self):
  67.         return self.__y
  68.  
  69.     def __iter__(self):
  70.         return (i for i in (self.x, self.y))
  72.     def __repr__(self):
  73.         class_name = type(self).__name__
  74.         return \'{}({!r}, {!r})\'.format(class_name, *self)
  76.     def __str__(self):
  77.         return str(tuple(self))
  79.     def __bytes__(self):
  80.         return (bytes([ord(self.typecode)]) +
  81.                 bytes(array(self.typecode, self)))
  83.     def __eq__(self, other):
  84.         return tuple(self) == tuple(other)
  86.     def __hash__(self):
  87.         return hash(self.x) ^ hash(self.y)
  89.     def __abs__(self):
  90.         return math.hypot(self.x, self.y)
  92.     def __bool__(self):
  93.         return bool(abs(self))

 Python中一切皆对象，函数也不例外，而且Python中的函数还是一等对象。函数可以理解为一种可调用对象语法糖。

可调用对象的元接口是__call__。如果一个类定义了 __call__ 方法，那么它的实例可以作为函数调用。示例如下。

  1. """
  2. >>> pickcard = Cards(range(52))
  3. >>> pickcard()
  4. 51
  5. >>> pickcard()
  6. 50
  7. >>> callable(pickcard)
  8. True
  9. """
  10. class Cards:
  11.     def __init__(self, items):
  12.         self._items = list(items)
  14.     def __call__(self):
  15.         return self._items.pop()

 

Python 的序列数据模型的元接口很多，但是对象只需要实现 __len__ 和 __getitem__ 两个方法，就能用在绝大部分期待序列的地方，如迭代，[]运算符、切片、for i in 等操作。示例如下：

  1. """
  2. >>> poker = Poker()
  4. 支持len运算
  5. >>> len(poker)
  6. 52
  8. 支持[]运算
  9. >>> poker[0]
  10. Card(rank=\'2\', suit=\'spades\')
  11. >>> poker[-1]
  12. Card(rank=\'A\', suit=\'hearts\')
  14. 支持切片运算
  15. >>> poker[12::13]
  16. [Card(rank=\'A\', suit=\'spades\'), Card(rank=\'A\', suit=\'diamonds\'), Card(rank=\'A\', suit=\'clubs\'), Card(rank=\'A\', suit=\'hearts\')]
  18. 支持 for i in 运算
  19. >>> for card in poker: print(card)  # doctest: +ELLIPSIS
  20. ...
  21. Card(rank=\'2\', suit=\'spades\')
  22. Card(rank=\'3\', suit=\'spades\')
  23. Card(rank=\'4\', suit=\'spades\')
  24. ...
  26. 支持 in 运算
  27. >>> Card(\'7\', \'hearts\') in poker
  28. True
  30. """
  31.  
  32. import collections
  34. Card = collections.namedtuple(\'Card\', [\'rank\', \'suit\'])
  35. class Poker:
  36.     ranks = [str(n) for n in range(2, 11)] + list(\'JQKA\')
  37.     suits = \'spades diamonds clubs hearts\'.split()
  38.     def __init__(self):
  39.         self._cards = [Card(rank, suit) for suit in self.suits
  40.                                         for rank in self.ranks]
  41.     def __len__(self):
  42.         return len(self._cards)
  43.     def __getitem__(self, position):
  44.         return self._cards[position] 

从测试用例上可以看出它具有序列所有特性，即便它是 object 的子类也无妨。因为它的行为像序列，那我们就可以说它是序列。

 Python中，可迭代对象的元接口是__iter__。迭代器可以从可迭代的对象中获取，__iter__和__next__是它的2个主要的元接口。__iter__ 方法使对象支持迭代，__next__ 方法返回序列中的下一个元素。如果没有元素了，那么抛出 StopIteration 异常。

迭代器可以迭代，但是可迭代的对象不是迭代器，也一定不能是自身的迭代器。也就是说，可迭代的对象必须实现 __iter__ 方法，但不能实现 __next__ 方法。

只要实现__iter__接口的对象，就是迭代鸭子类型，自然就支持所有的迭代运算。示例如下：

  1. """
  2. >>> s = Sentence(\'hello world\')
  3. >>> s
  4. Sentence(\'hello world\')
  6. 支持迭代list运算
  7. >>> list(s)
  8. [\'hello\', \'world\']
  10. 获取迭代器
  11. >>> it = iter(s)
  13. 支持迭代器next运算
  14. >>> next(it)
  15. \'hello\'
  16. >>> next(it)
  17. \'world\'
  18. >>> next(it)
  19. Traceback (most recent call last):
  20.   ...
  21. StopIteration
  23. 支持迭代for运算
  24. >>> for w in s: print(w)
  25. hello
  26. world
  27. """
  28.  
  29. import re
  30. import reprlib
  32. RE_WORD = re.compile(\'\w+\')
  34. class Sentence:
  36.     def __init__(self, text):
  37.         self.text = text
  39.     def __repr__(self):
  40.         return \'Sentence(%s)\' % reprlib.repr(self.text)
  42.     def __iter__(self):
  43.         word_iter = RE_WORD.finditer(self.text)  
  44.         return SentenceIter(word_iter)  
  45.  
  46.  
  47. class SentenceIter():
  49.     def __init__(self, word_iter):
  50.         self.word_iter = word_iter  
  51.  
  52.     def __next__(self):
  53.         match = next(self.word_iter)  
  54.         return match.group()  
  55.  
  56.     def __iter__(self):
  57.         return self

上面这个例子中，可迭代对象Sentence通过定义迭代器SentenceIter的方式实现。更Pythonic的做法是通过生成器yield来实现。下面是一个示例，能通过上面的所有测试用例，但代码更加精简。

  1. RE_WORD = re.compile(\'\w+\')
  3. class Sentence:
  5.     def __init__(self, text):
  6.         self.text = text 
  8.     def __repr__(self):
  9.         return \'Sentence(%s)\' % reprlib.repr(self.text)
  11.     def __iter__(self):
  12.         for match in RE_WORD.finditer(self.text):
  13.             yield match.group()  

 Python的with关键字是上下文管理器语法糖，上下文管理器协议包含 __enter__ 和 __exit__ 两个方法。with 语句开始运行时，会在上下文管理器对象上调用 __enter__ 方法。with 语句运行结束后，会在上下文管理器对象上调用 __exit__ 方法，以此扮演 finally 子句的角色。可以看出，上下文管理器简化了 try/finally 模式。下面是一个示例。

  1. """
  2. ReversePrint对象的上下文管理，进入with块后，标准输出反序打印，
  3. 退出with块后，标准输出恢复正常状态。
  4. >>> with ReversePrint() as what:
  5. ...      print(\'Hello world!\')
  6. !dlrow olleH
  7. >>> print(\'Hello world!\') 
  8. Hello world!
  10. """
  11.  
  12. class ReversePrint:
  14.     def __enter__(self):
  15.         import sys
  16.         self.original_write = sys.stdout.write
  17.         sys.stdout.write = self.reverse_write
  18.         return \'JABBERWOCKY\'
  19.  
  20.     def reverse_write(self, text):
  21.         self.original_write(text[::-1])
  23.     def __exit__(self, exc_type, exc_value, traceback):
  24.         import sys
  25.         sys.stdout.write = self.original_write
  26.         if exc_type is ZeroDivisionError:
  27.             print(\'Please DO NOT divide by zero!\')
  28.             return True

 

版权声明：本文为wahaha02原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/wahaha02/p/10254049.html