Python 中的数字到底是什么？

规范
本 PEP 规定了一组抽象基类（Abstract Base Class），并提出了一个实现某些方法的通用策

略。它使用了来自于PEP 3119的术语，但是该层次结构旨在对特定类集的任何系统方法都有意

义。

标准库中的类型检查应该使用这些类，而不是具体的内置类型。

数值类
我们从 Number 类开始，它是人们想象的数字类型的模糊概念。此类仅用于重载；它不提供任

何操作。

class Number(metaclass=ABCMeta): pass
大多数复数（complex number）的实现都是可散列的，但是如果你需要依赖它，则必须明确地

检查：此层次结构支持可变的数。

class Complex(Number):
“”"Complex defines the operations that work on the builtin complex type.

In short, those are: conversion to complex, bool(), .real, .imag,
+, -, *, /, **, abs(), .conjugate(), ==, and !=.

If it is given heterogenous arguments, and doesn't have special
knowledge about them, it should fall back to the builtin complex
type as described below.
"""

@abstractmethod
def __complex__(self):
    """Return a builtin complex instance."""

def __bool__(self):
    """True if self != 0."""
    return self != 0

@abstractproperty
def real(self):
    """Retrieve the real component of this number.

    This should subclass Real.
    """
    raise NotImplementedError

@abstractproperty
def imag(self):
    """Retrieve the real component of this number.

    This should subclass Real.
    """
    raise NotImplementedError

@abstractmethod
def __add__(self, other):
    raise NotImplementedError

@abstractmethod
def __radd__(self, other):
    raise NotImplementedError

@abstractmethod
def __neg__(self):
    raise NotImplementedError

def __pos__(self):
    """Coerces self to whatever class defines the method."""
    raise NotImplementedError

def __sub__(self, other):
    return self + -other

def __rsub__(self, other):
    return -self + other

@abstractmethod
def __mul__(self, other):
    raise NotImplementedError

@abstractmethod
def __rmul__(self, other):
    raise NotImplementedError

@abstractmethod
def __div__(self, other):
    """a/b; should promote to float or complex when necessary."""
    raise NotImplementedError

@abstractmethod
def __rdiv__(self, other):
    raise NotImplementedError

@abstractmethod
def __pow__(self, exponent):
    """a**b; should promote to float or complex when necessary."""
    raise NotImplementedError

@abstractmethod
def __rpow__(self, base):
    raise NotImplementedError

@abstractmethod
def __abs__(self):
    """Returns the Real distance from 0."""
    raise NotImplementedError

@abstractmethod
def conjugate(self):
    """(x+y*i).conjugate() returns (x-y*i)."""
    raise NotImplementedError

@abstractmethod
def __eq__(self, other):
    raise NotImplementedError

# __ne__ is inherited from object and negates whatever __eq__ does.

Real抽象基类表示在实数轴上的值，并且支持内置的float的操作。实数（Real number）是完

全有序的，除了 NaN（本 PEP 基本上不考虑它）。

class Real(Complex):
“”"To Complex, Real adds the operations that work on real numbers.

In short, those are: conversion to float, trunc(), math.floor(),
math.ceil(), round(), divmod(), //, %, <, <=, >, and >=.

Real also provides defaults for some of the derived operations.
"""

# XXX What to do about the __int__ implementation that's
# currently present on float?  Get rid of it?

@abstractmethod
def __float__(self):
    """Any Real can be converted to a native float object."""
    raise NotImplementedError

@abstractmethod
def __trunc__(self):
    """Truncates self to an Integral.

    Returns an Integral i such that:
      * i>=0 iff self>0;
      * abs(i) <= abs(self);
      * for any Integral j satisfying the first two conditions,
        abs(i) >= abs(j) [i.e. i has "maximal" abs among those].
    i.e. "truncate towards 0".
    """
    raise NotImplementedError

@abstractmethod
def __floor__(self):
    """Finds the greatest Integral <= self."""
    raise NotImplementedError

@abstractmethod
def __ceil__(self):
    """Finds the least Integral >= self."""
    raise NotImplementedError

@abstractmethod
def __round__(self, ndigits:Integral=None):
    """Rounds self to ndigits decimal places, defaulting to 0.

    If ndigits is omitted or None, returns an Integral,
    otherwise returns a Real, preferably of the same type as
    self. Types may choose which direction to round half. For
    example, float rounds half toward even.

    """
    raise NotImplementedError

def __divmod__(self, other):
    """The pair (self // other, self % other).

    Sometimes this can be computed faster than the pair of
    operations.
    """
    return (self // other, self % other)

def __rdivmod__(self, other):
    """The pair (self // other, self % other).

    Sometimes this can be computed faster than the pair of
    operations.
    """
    return (other // self, other % self)

@abstractmethod
def __floordiv__(self, other):
    """The floor() of self/other. Integral."""
    raise NotImplementedError

@abstractmethod
def __rfloordiv__(self, other):
    """The floor() of other/self."""
    raise NotImplementedError

@abstractmethod
def __mod__(self, other):
    """self % other

    See
    https://mail.python.org/pipermail/python-3000/2006-May/001735.html
    and consider using "self/other - trunc(self/other)"
    instead if you're worried about round-off errors.
    """
    raise NotImplementedError

@abstractmethod
def __rmod__(self, other):
    """other % self"""
    raise NotImplementedError

@abstractmethod
def __lt__(self, other):
    """< on Reals defines a total ordering, except perhaps for NaN."""
    raise NotImplementedError

@abstractmethod
def __le__(self, other):
    raise NotImplementedError

# __gt__ and __ge__ are automatically done by reversing the arguments.
# (But __le__ is not computed as the opposite of __gt__!)

# Concrete implementations of Complex abstract methods.
# Subclasses may override these, but don't have to.

def __complex__(self):
    return complex(float(self))

@property
def real(self):
    return +self

@property
def imag(self):
    return 0

def conjugate(self):
    """Conjugate is a no-op for Reals."""
    return +self

我们应该整理 Demo/classes/Rat.py，并把它提升为 Rational.py 加入标准库。然后它将实现

有理数（Rational）抽象基类。

class Rational(Real, Exact):
“”".numerator and .denominator should be in lowest terms."""

@abstractproperty
def numerator(self):
    raise NotImplementedError

@abstractproperty
def denominator(self):
    raise NotImplementedError

# Concrete implementation of Real's conversion to float.
# (This invokes Integer.__div__().)

def __float__(self):
    return self.numerator / self.denominator

最后是整数类：

class Integral(Rational):
“”“Integral adds a conversion to int and the bit-string operations.”""

@abstractmethod
def __int__(self):
    raise NotImplementedError

def __index__(self):
    """__index__() exists because float has __int__()."""
    return int(self)

def __lshift__(self, other):
    return int(self) << int(other)

def __rlshift__(self, other):
    return int(other) << int(self)

def __rshift__(self, other):
    return int(self) >> int(other)

def __rrshift__(self, other):
    return int(other) >> int(self)

def __and__(self, other):
    return int(self) & int(other)

def __rand__(self, other):
    return int(other) & int(self)

def __xor__(self, other):
    return int(self) ^ int(other)

def __rxor__(self, other):
    return int(other) ^ int(self)

def __or__(self, other):
    return int(self) | int(other)

def __ror__(self, other):
    return int(other) | int(self)

def __invert__(self):
    return ~int(self)

# Concrete implementations of Rational and Real abstract methods.
def __float__(self):
    """float(self) == float(int(self))"""
    return float(int(self))

@property
def numerator(self):
    """Integers are their own numerators."""
    return +self

@property
def denominator(self):
    """Integers have a denominator of 1."""
    return 1

运算及__magic__方法的变更
为了支持从 float 到 int（确切地说，从 Real 到 Integral）的精度收缩，我们提出了以下

新的 magic 方法，可以从相应的库函数中调用。所有这些方法都返回 Intergral 而不是

Real。

trunc(self)：在新的内置 trunc(x) 里调用，它返回从 0 到 x 之间的最接近 x 的

Integral。
floor(self)：在 math.floor(x) 里调用，返回最大的 Integral <= x。
ceil(self)：在 math.ceil(x) 里调用，返回最小的 Integral > = x。
round(self)：在 round(x) 里调用，返回最接近 x 的 Integral ，根据选定的类型作四

舍五入。浮点数将从 3.0 版本起改为向偶数端四舍五入。（译注：round(2.5) 等于 2，

round(3.5) 等于 4）。它还有一个带两参数的版本__round__(self, ndigits)，被 round(x,

ndigits) 调用，但返回的是一个 Real。
在 2.6 版本中，math.floor、math.ceil 和 round 将继续返回浮点数。

float 的 int() 转换等效于 trunc()。一般而言，int() 的转换首先会尝试__int__()，如果

找不到，再尝试__trunc__()。

complex.{divmod, mod, floordiv, int, float} 也消失了。提供一个好的错误消息来帮

助困惑的搬运工会很好，但更重要的是不出现在 help(complex) 中。

给类型实现者的说明
实现者应该注意使相等的数字相等，并将它们散列为相同的值。如果实数有两个不同的扩展，

这可能会变得微妙。例如，一个复数类型可以像这样合理地实现 hash()：

def hash(self):
return hash(complex(self))
但应注意所有超出了内置复数范围或精度的值。

添加更多数字抽象基类
当然，数字还可能有更多的抽象基类，如果排除了添加这些数字的可能性，这会是一个糟糕的

等级体系。你可以使用以下方法在 Complex 和 Real 之间添加MyFoo：

class MyFoo(Complex): …
MyFoo.register(Real)
实现算术运算
我们希望实现算术运算，使得在混合模式的运算时，要么调用者知道如何处理两种参数类型，

要么将两者都转换为最接近的内置类型，并以此进行操作。

对于 Integral 的子类型，这意味着__add__和__radd__应该被定义为：

class MyIntegral(Integral):

def __add__(self, other):
    if isinstance(other, MyIntegral):
        return do_my_adding_stuff(self, other)
    elif isinstance(other, OtherTypeIKnowAbout):
        return do_my_other_adding_stuff(self, other)
    else:
        return NotImplemented

def __radd__(self, other):
    if isinstance(other, MyIntegral):
        return do_my_adding_stuff(other, self)
    elif isinstance(other, OtherTypeIKnowAbout):
        return do_my_other_adding_stuff(other, self)
    elif isinstance(other, Integral):
        return int(other) + int(self)
    elif isinstance(other, Real):
        return float(other) + float(self)
    elif isinstance(other, Complex):
        return complex(other) + complex(self)
    else:
        return NotImplemented
         亚马逊测评 www.yisuping.com