{% raw %}

Python 魔术方法

原文： http://zetcode.com/python/magicmethods/

Python 魔术方法教程描述了什么是 Python 魔术方法，并说明了如何使用它们。 在本教程中，我们介绍了一些常见的魔术方法。

Python 魔术方法

Python 魔术方法是为我们的自定义类添加功能的特殊方法。 它们被双下划线包围（例如__add __()）。

Python 中有许多魔术方法。 它们中的大多数用于非常特殊的情况。 我们将提到一些更流行的方法。

__add__方法

__add__()方法用于实现加法运算。 在 Python 中，数字不是原始字面值，而是对象。 num + 4表达式等效于num.__add__(4)。

add_dict.py

  1. #!/usr/bin/env python
  3. class MyDict(dict):
  5.     def __add__(self, other):
  7.         self.update(other)
  8.         return MyDict(self)
  10. a = MyDict({'de': 'Germany'})
  11. b = MyDict({'sk': 'Slovakia'})
  13. print(a + b)

在示例中，我们有一个自定义字典，该字典使用__add__()实现加法运算。

  1. class MyDict(dict):
  3. def __add__(self, other):
  5.     self.update(other)
  6.     return MyDict(self)

自定义字典继承自内置dict。 __add__()方法与update()方法添加两个字典，并返回新创建的字典。

  1. a = MyDict({'de': 'Germany'})
  2. b = MyDict({'sk': 'Slovakia'})

我们创建两个简单的字典。

  1. print(a + b)

我们添加两个字典。

  1. $ ./add_dict.py
  2. {'de': 'Germany', 'sk': 'Slovakia'}

这是输出。

__init__和__str__方法

__init__()方法用于初始化对象。 此方法用于实现对象的构造器。 __str__()提供了对象可读的输出。

init_str.py

  1. #!/usr/bin/env python
  3. class Person:
  5.     def __init__(self, name, occupation):
  7.         self.name = name
  8.         self.occupation = occupation
  10.     def __str__(self):
  12.         return f'{self.name} is a {self.occupation}'
  14. p = Person('John Doe', 'gardener')
  15. print(p)

在示例中，我们有一个Person类，具有两个属性：name和occupation。

  1. def __init__(self, name, occupation):
  3.     self.name = name
  4.     self.occupation = occupation

在__init__()方法中，我们将实例变量设置为传递给构造器的值。

  1. def __str__(self):
  3.     return f'{self.name} is a {self.occupation}'

__str__()方法可以很好地输出对象。

  1. $ ./init_str.py
  2. John Doe is a gardener

这是输出。

__repr__方法

__repr__()方法由内置函数repr()调用。 当它求值返回对象的表达式时，在 Python shell 上使用它。

__str__()用于提供对象的人类可读版本，__repr__()用于提供对象的完整表示。 后者的输出也更适合开发者。

如果缺少__str__()实现，则将__repr__()方法用作后备。

  1. def __repr__(self):
  2.     return '<{0}.{1} object at {2}>'.format(
  3.       self.__module__, type(self).__name__, hex(id(self)))

对象的__repr__()方法的默认实现类似于上面的代码。

repr_ex.py

  1. #!/usr/bin/env python
  3. class Person:
  5.     def __init__(self, name, occupation):
  7.         self.name = name
  8.         self.occupation = occupation
  10.     def __str__(self):
  12.         return f'{self.name} is a {self.occupation}'
  14.     def __repr__(self):
  16.         return f'Person{{name: {self.name}, occupation: {self.occupation}}}'
  18. p = Person('John Doe', 'gardener')
  20. print(p)
  21. print(repr(p))

该示例实现了__str__()和__repr__()方法。

  1. $ ./repr_ex.py
  2. John Doe is a gardener
  3. Person{name: John Doe, occupation: gardener}

这是输出。

__len__和__getitem__方法

__len__()方法返回容器的长度。 当我们在对象上使用内置的len()方法时，将调用该方法。 __getitem__()方法定义项目访问（[]）运算符。

french_deck.py

  1. #!/usr/bin/env python
  3. import collections
  4. from random import choice
  6. Card = collections.namedtuple('Card', ['suit', 'rank'])
  8. class FrenchDeck:
  10.     ranks = [str(i) for i in range(2, 11)] + list('JQKA')
  11.     suits = ["heart", "clubs", "spades", "diamond"]
  13.     def __init__(self):
  14.         self.total = [Card(suit, rank)
  15.                            for suit in self.suits for rank in self.ranks]
  17.     def __len__(self):
  18.         return len(self.total)
  20.     def __getitem__(self, index):
  21.         return self.total[index]
  23. deck = FrenchDeck()
  25. print(deck[0])
  26. print(len(deck))
  27. print(choice(deck))

该方法用于实现法语卡片组。

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

我们使用一个命名的元组来定义一个Card类。 namedtuple是用于创建元组类的工厂功能。 每张卡都有一套西装和一个等级。

  1. def __len__(self):
  2.     return len(self.total)

__len__()方法返回卡座（52）中的卡数。

  1. def __getitem__(self, index):
  2.     return self.total[index]

__getitem__()实现索引操作。

  1. print(deck[0])

我们得到卡组的第一张牌。 这称为__getitem__()。

  1. print(len(deck))

这将调用__len__()方法。

  1. $ ./french_deck.py
  2. Card(suit='heart', rank='2')
  3. 52
  4. Card(suit='diamond', rank='A')

这是输出。

__int__和__index__方法

调用__int__()方法以实现内置的int()函数。 当在切片表达式中使用对象以及内置的hex()，oct()和bin()函数时，__index__()方法将类型转换为int。

char_ex.py

  1. #!/usr/bin/env python
  3. class Char:
  5.     def __init__(self, val):
  6.         self.val = val
  8.     def __int__(self):
  9.         return ord(self.val)
  11.     def __index__(self):
  12.         return ord(self.val)
  14. c1 = Char('a')
  16. print(int(c1))
  17. print(hex(c1))
  18. print(bin(c1))
  19. print(oct(c1))

在示例中，我们创建一个自定义的Char类，该类实现了int()，hex()，bin()和oct()函数。

  1. ./char_ex.py
  2. 97
  3. 0x61
  4. 0b1100001
  5. 0o141

这是输出。

__eq __，__ lt__和__gt__方法

__eq__()实现了==运算符。 __lt__()实现了<运算符，__gt__()实现了>运算符。

pouch.py

  1. #!/usr/bin/env python
  3. import collections
  5. Coin = collections.namedtuple('coin', ['rank'])
  7. # a gold coin equals to two silver and six bronze coins
  9. class Pouch:
  11.     def __init__(self):
  12.         self.bag = []
  14.     def add(self, coin):
  16.         self.bag.append(coin)
  18.     def __eq__(self, other):
  20.         val1, val2 = self.__evaluate(other)
  22.         if val1 == val2:
  23.             return True
  24.         else:
  25.             return False
  27.     def __lt__(self, other):
  29.         val1, val2 = self.__evaluate(other)
  31.         if val1 < val2:
  32.             return True
  33.         else:
  34.             return False
  36.     def __gt__(self, other):
  38.         val1, val2 = self.__evaluate(other)
  40.         if val1 > val2:
  41.             return True
  42.         else:
  43.             return False
  45.     def __str__(self):
  47.         return str(self.bag)
  49.     def __evaluate(self, other):
  51.         val1 = 0
  52.         val2 = 0
  54.         for coin in self.bag:
  56.             if coin.rank == 'g':
  57.                 val1 += 6
  59.             if coin.rank == 's':
  60.                 val1 += 3
  62.             if coin.rank == 'b':
  63.                 val1 += 1
  65.         for coin in other.bag:
  67.             if coin.rank == 'g':
  68.                 val2 += 6
  70.             if coin.rank == 's':
  71.                 val2 += 3
  73.             if coin.rank == 'b':
  74.                 val2 += 1
  76.         return val1, val2
  78. pouch1 = Pouch()
  80. pouch1.add(Coin('g'))
  81. pouch1.add(Coin('g'))
  82. pouch1.add(Coin('s'))
  84. pouch2 = Pouch()
  86. pouch2.add(Coin('g'))
  87. pouch2.add(Coin('s'))
  88. pouch2.add(Coin('s'))
  89. pouch2.add(Coin('b'))
  90. pouch2.add(Coin('b'))
  91. pouch2.add(Coin('b'))
  93. print(pouch1)
  94. print(pouch2)
  96. if pouch1 == pouch2:
  97.     print('Pouches have equal value')
  99. elif pouch1 > pouch2:
  100.     print('Pouch 1 is more valueable than Pouch 2')
  101. else:
  102.     print('Pouch 2 is more valueable than Pouch 1')

我们有一个可以容纳金，银和青铜硬币的小袋。 一枚金币等于两个银币和六个铜币。 在示例中，我们使用 Python 魔术方法为pouch对象实现了三个比较运算符。

  1. def __eq__(self, other):
  3.     val1, val2 = self.__evaluate(other)
  5.     if val1 == val2:
  6.         return True
  7.     else:
  8.         return False

在__eq__()方法中，我们首先求值两个小袋的值。 然后我们比较它们并返回布尔结果。

  1. def __evaluate(self, other):
  3.     val1 = 0
  4.     val2 = 0
  6.     for coin in self.bag:
  8.         if coin.rank == 'g':
  9.             val1 += 6
  11.         if coin.rank == 's':
  12.             val1 += 3
  14.         if coin.rank == 'b':
  15.             val1 += 1
  17.     for coin in other.bag:
  19.         if coin.rank == 'g':
  20.             val2 += 6
  22.         if coin.rank == 's':
  23.             val2 += 3
  25.         if coin.rank == 'b':
  26.             val2 += 1
  28.     return val1, val2

__evaluate()方法计算两个袋的值。 它穿过小袋的硬币，并根据硬币的等级增加一个值。

  1. pouch1 = Pouch()
  3. pouch1.add(Coin('g'))
  4. pouch1.add(Coin('g'))
  5. pouch1.add(Coin('s'))

我们创建第一个袋，并在其中添加三个硬币。

  1. if pouch1 == pouch2:
  2.     print('Pouches have equal value')
  4. elif pouch1 > pouch2:
  5.     print('Pouch 1 is more valueable than Pouch 2')
  6. else:
  7.     print('Pouch 2 is more valueable than Pouch 1')

我们将小袋与比较运算符进行比较。

2D 向量示例

在下面的示例中，我们介绍了几种其他魔术方法，包括__sub__()，__mul__()和__abs__()。

vector.py

  1. #!/usr/bin/env python
  3. import math
  5. class Vec2D:
  7.     def __init__(self, x, y):
  9.         self.x = x
  10.         self.y = y
  12.     def __add__(self, other):
  13.         return Vec2D(self.x + other.x, self.y + other.y)
  15.     def __sub__(self, other):
  16.         return Vec2D(self.x - other.x, self.y - other.y)
  18.     def __mul__(self, other):
  19.         return self.x * other.x + self.y * other.y
  21.     def __abs__(self):
  22.         return math.sqrt(self.x ** 2 + self.y ** 2)
  24.     def __eq__(self, other):
  25.         return self.x == other.x and self.y == other.y
  27.     def __str__(self):
  28.         return f'({self.x}, {self.y})'
  30.     def __ne__(self, other):
  31.         return not self.__eq__(other)  
  33. u = Vec2D(0, 1)
  34. v = Vec2D(2, 3)
  35. w = Vec2D(-1, 1)
  37. a = u + v
  38. print(a)
  40. print(a == w)
  42. a = u - v
  43. print(a)
  45. a = u * v
  47. print(a)
  48. print(abs(u))
  49. print(u == v)
  50. print(u != v)

在示例中，我们有一个Vec2D类。 我们可以比较，加，减和乘向量。 我们还可以计算向量的长度。

  1. $ ./vector.py
  2. (2, 4)
  3. False
  4. (-2, -2)
  5. 3
  6. 1.0
  7. False 
  8. True

这是输出。

在本教程中，我们使用了 Python 魔术方法。

您可能也对以下相关教程感兴趣： Python 字符串， Python Jinja 教程和 Python 教程，或列出所有 Python 教程 。

{% endraw %}