>>> 'Go Bears!'[3]
'B'
>>> 'Go Bears!'.__getitem__(3)
'B'

Callable 对象。在 Python 中，函数是一等对象，因此它们可以作为数据传递，并且具有与任何其他对象一样的属性。Python 还允许我们通过包含 __call__ 方法来定义可以像函数一样“调用”的对象。使用此方法，我们可以定义一个行为类似于高阶函数的类。

>>> def make_adder(n):def adder(k):return n + kreturn adder

>>> add_three = make_adder(3)
>>> add_three(4)
7

>>> class Adder(object):def __init__(self, n):self.n = ndef __call__(self, k):return self.n + k

>>> add_three_obj = Adder(3)
>>> add_three_obj(4)
7

复数可以用两种几乎等效的方式表示：矩形形式（实部和虚部）和极坐标形式（大小和角度）。有时矩形形式更合适，有时极性形式更合适。事实上，完全可以想象一个系统，其中复数以两种方式表示，并且用于作复数的函数与任何一种表示形式一起工作。我们在下面实现这样的系统。顺便说一句，我们正在开发一个对复数执行算术运算的系统，作为使用泛型运算的程序的一个简单但不切实际的示例。复数类型实际上内置于 Python 中，但在此示例中，我们将实现自己的类型。

>>> class Number:def __add__(self, other):return self.add(other)def __mul__(self, other):return self.mul(other)

>>> class Complex(Number):def add(self, other):return ComplexRI(self.real + other.real, self.imag + other.imag)def mul(self, other):magnitude = self.magnitude * other.magnitudereturn ComplexMA(magnitude, self.angle + other.angle)

• ComplexRI constructs a complex number from real and imaginary parts.
  ComplexRI 从实部和虚部构造一个复数。
• ComplexMA constructs a complex number from a magnitude and angle.
  ComplexMA 从大小和角度构造一个复数。

>>> from math import atan2
>>> class ComplexRI(Complex):def __init__(self, real, imag):self.real = realself.imag = imag@propertydef magnitude(self):return (self.real ** 2 + self.imag ** 2) ** 0.5@propertydef angle(self):return atan2(self.imag, self.real)def __repr__(self):return 'ComplexRI({0:g}, {1:g})'.format(self.real, self.imag)

Python 具有一个简单的功能，用于从零参数函数动态计算属性。@property 修饰器允许在没有 call 表达式语法（表达式后面的括号）的情况下调用函数。ComplexRI 类存储 real 和 imag 属性，并按需计算大小和角度。

同样，ComplexMA 类存储 magnitude 和 angle，但每当查找这些属性时，都会计算 real 和 imag。

>>> from math import sin, cos, pi
>>> class ComplexMA(Complex):def __init__(self, magnitude, angle):self.magnitude = magnitudeself.angle = angle@propertydef real(self):return self.magnitude * cos(self.angle)@propertydef imag(self):return self.magnitude * sin(self.angle)def __repr__(self):return 'ComplexMA({0:g}, {1:g} * pi)'.format(self.magnitude, self.angle/pi)

>>> ma = ComplexMA(2, pi/2)
>>> ma.imag
2.0
>>> ma.angle = pi
>>> ma.real
-2.0

>>> from fractions import gcd
>>> class Rational(Number):def __init__(self, numer, denom):g = gcd(numer, denom)self.numer = numer // gself.denom = denom // gdef __repr__(self):return 'Rational({0}, {1})'.format(self.numer, self.denom)def add(self, other):nx, dx = self.numer, self.denomny, dy = other.numer, other.denomreturn Rational(nx * dy + ny * dx, dx * dy)def mul(self, other):numer = self.numer * other.numerdenom = self.denom * other.denomreturn Rational(numer, denom)

>>> from math import pi
>>> ComplexRI(1, 2) + ComplexMA(2, pi/2)
ComplexRI(1, 4)
>>> ComplexRI(0, 1) * ComplexRI(0, 1)
ComplexMA(1, 1 * pi)
能够直接用运算符进行操作的原因是在number class中，就已经进行了__add__ , __mul__的运算符重载

>>> c = ComplexRI(1, 1)
>>> isinstance(c, ComplexRI)
True
>>> isinstance(c, Complex)
True
>>> isinstance(c, ComplexMA)
False

>>> def is_real(c):"""Return whether c is a real number with no imaginary part."""if isinstance(c, ComplexRI):return c.imag == 0elif isinstance(c, ComplexMA):return c.angle % pi == 0

>>> is_real(ComplexRI(1, 1))
False
>>> is_real(ComplexMA(2, pi))
True

>>> Rational.type_tag = 'rat'
>>> Complex.type_tag = 'com'
>>> Rational(2, 5).type_tag == Rational(1, 2).type_tag
True
>>> ComplexRI(1, 1).type_tag == ComplexMA(2, pi/2).type_tag
True
>>> Rational(2, 5).type_tag == ComplexRI(1, 1).type_tag
False

>>> def add_complex_and_rational(c, r):return ComplexRI(c.real + r.numer/r.denom, c.imag)