目录 | 上一节 (4.2 继承) | 下一节 (4.4 异常)

4.3 特殊方法

可以通过特殊方法（或者称为”魔术”方法（magic method））自定义 Python 行为的各部分。本节介绍特殊方法的思想。此外，还将讨论动态属性访问和绑定方法。

简介

类可以定义特殊方法。特殊方法对于 Python 解释器而言具有特殊的意义。特殊方法总是以双下划线 __ 开头和结尾，例如 __init__。

  1. class Stock(object):
  2.     def __init__(self):
  3.         ...
  4.     def __repr__(self):
  5.         ...

虽然有很多特殊方法，但是我们只研究几个具体的例子。

字符串转换的特殊方法

对象有两种字符串表示形式。

  1. >>> from datetime import date
  2. >>> d = date(2012, 12, 21)
  3. >>> print(d)
  4. 2012-12-21
  5. >>> d
  6. datetime.date(2012, 12, 21)
  7. >>>

str() 函数用于创建格式良好的、可打印的输出：

  1. >>> str(d)
  2. '2012-12-21'
  3. >>>

repr() 函数用于创建详细的、面向程序员的输出。

  1. >>> repr(d)
  2. 'datetime.date(2012, 12, 21)'
  3. >>>

str() 和 repr() 函数都是使用类中定义的特殊方法生成要显示的字符串。

  1. class Date(object):
  2.     def __init__(self, year, month, day):
  3.         self.year = year
  4.         self.month = month
  5.         self.day = day
  7.     # Used with `str()`
  8.     def __str__(self):
  9.         return f'{self.year}-{self.month}-{self.day}'
  11.     # Used with `repr()`
  12.     def __repr__(self):
  13.         return f'Date({self.year},{self.month},{self.day})'

注意：按照惯例，__repr__() 返回一个字符串，当该字符串被传递给 eval() 函数，将会重新创建底层对象（译注：eval(repr(obj)) == obj）。如果不行，则使用某种易于阅读的表现形式。

数学操作的特殊方法

数学运算符涉及的特殊方法如下：

  1. a + b       a.__add__(b)
  2. a - b       a.__sub__(b)
  3. a * b       a.__mul__(b)
  4. a / b       a.__truediv__(b)
  5. a // b      a.__floordiv__(b)
  6. a % b       a.__mod__(b)
  7. a << b      a.__lshift__(b)
  8. a >> b      a.__rshift__(b)
  9. a & b       a.__and__(b)
  10. a | b       a.__or__(b)
  11. a ^ b       a.__xor__(b)
  12. a ** b      a.__pow__(b)
  13. -a          a.__neg__()
  14. ~a          a.__invert__()
  15. abs(a)      a.__abs__()

元素访问的特殊方法

这些是实现容器的特殊方法：

  1. len(x)      x.__len__()
  2. x[a]        x.__getitem__(a)
  3. x[a] = v    x.__setitem__(a,v)
  4. del x[a]    x.__delitem__(a)

你可以在类中使用这些特殊方法。

  1. class Sequence:
  2.     def __len__(self):
  3.         ...
  4.     def __getitem__(self,a):
  5.         ...
  6.     def __setitem__(self,a,v):
  7.         ...
  8.     def __delitem__(self,a):
  9.         ...

方法调用

调用方法有两个步骤。

​ 1、查找：. 运算符

​ 2、方法调用： () 运算符

  1. >>> s = Stock('GOOG',100,490.10)
  2. >>> c = s.cost  # Lookup
  3. >>> c
  4. <bound method Stock.cost of <Stock object at 0x590d0>>
  5. >>> c()         # Method call
  6. 49010.0
  7. >>>

绑定方法

尚未被函数调用运算符 () 调用的方法称为绑定方法（ 译注：bound method，如果直译应该译作“绑定的方法”，但是，就像“类方法”一样，可以省略“的”这个字，译为“绑定方法”，绑定在这里不是动词，而应理解为形容词“绑定的”）。它对自己生成的实例进行操作：

  1. >>> s = Stock('GOOG', 100, 490.10)
  2. >>> s
  3. <Stock object at 0x590d0>
  4. >>> c = s.cost
  5. >>> c
  6. <bound method Stock.cost of <Stock object at 0x590d0>>
  7. >>> c()
  8. 49010.0
  9. >>>

如果使用绑定方法时有些大意，那么容易导致错误。示例：

  1. >>> s = Stock('GOOG', 100, 490.10)
  2. >>> print('Cost : %0.2f' % s.cost)
  3. Traceback (most recent call last):
  4.   File "<stdin>", line 1, in <module>
  5. TypeError: float argument required
  6. >>>

或者：

  1. f = open(filename, 'w')
  2. ...
  3. f.close     # Oops, Didn't do anything at all. `f` still open.

在这两种情形中，错误都是由忘记尾部括号引起的。例如：s.cost() or f.close()。

属性访问

还有一种访问、操作和管理属性的替代方法。

  1. getattr(obj, 'name')          # Same as obj.name
  2. setattr(obj, 'name', value)   # Same as obj.name = value
  3. delattr(obj, 'name')          # Same as del obj.name
  4. hasattr(obj, 'name')          # Tests if attribute exists

示例：

  1. if hasattr(obj, 'x'):
  2.     x = getattr(obj, 'x'):
  3. else:
  4.     x = None

注意： getattr() 函数的默认参数非常有用。

  1. x = getattr(obj, 'x', None)

练习

练习 4.9：更好的输出

请修改 stock.py 文件中定义的 Stock 对象，以便 __repr__() 方法生成更有用的输出。示例：

  1. >>> goog = Stock('GOOG', 100, 490.1)
  2. >>> goog
  3. Stock('GOOG', 100, 490.1)
  4. >>>

修改完成后，请查看读取股票投资组合时会发生什么，以及生成什么样的结果。示例：

  1. >>> import report
  2. >>> portfolio = report.read_portfolio('Data/portfolio.csv')
  3. >>> portfolio
  4. ... see what the output is ...
  5. >>>

练习 4.10：使用 getattr() 的例子

getattr() 是读取属性的另一种机制。可以使用它编写极其灵活的代码。首先，请尝试以下示例：

  1. >>> import stock
  2. >>> s = stock.Stock('GOOG', 100, 490.1)
  3. >>> columns = ['name', 'shares']
  4. >>> for colname in columns:
  5.         print(colname, '=', getattr(s, colname))
  7. name = GOOG
  8. shares = 100
  9. >>>

仔细观察会发现输出数据完全由 columns 变量中列出的属性名决定。

在 tableformat.py 文件中，使用该思想将其扩展为通用函数 print_table()，print_table()打印一个表格，显示用户指定的任意对象的属性。与早期的 print_report() 函数一样，print_table() 方法还应接受一个 TableFormatter 实例来控制输出格式。它们的工作方式如下：

  1. >>> import report
  2. >>> portfolio = report.read_portfolio('Data/portfolio.csv')
  3. >>> from tableformat import create_formatter, print_table
  4. >>> formatter = create_formatter('txt')
  5. >>> print_table(portfolio, ['name','shares'], formatter)
  6.       name     shares
  7. ---------- ----------
  8.         AA        100
  9.        IBM         50
  10.        CAT        150
  11.       MSFT        200
  12.         GE         95
  13.       MSFT         50
  14.        IBM        100
  16. >>> print_table(portfolio, ['name','shares','price'], formatter)
  17.       name     shares      price
  18. ---------- ---------- ----------
  19.         AA        100       32.2
  20.        IBM         50       91.1
  21.        CAT        150      83.44
  22.       MSFT        200      51.23
  23.         GE         95      40.37
  24.       MSFT         50       65.1
  25.        IBM        100      70.44
  26. >>>

目录 | 上一节 (4.2 继承) | 下一节 (4.4 异常)