mirror of https://github.com/python/cpython
91 lines
3.0 KiB
ReStructuredText
91 lines
3.0 KiB
ReStructuredText
|
|
:mod:`fractions` --- Rational numbers
|
|
=====================================
|
|
|
|
.. module:: fractions
|
|
:synopsis: Rational numbers.
|
|
.. moduleauthor:: Jeffrey Yasskin <jyasskin at gmail.com>
|
|
.. sectionauthor:: Jeffrey Yasskin <jyasskin at gmail.com>
|
|
|
|
|
|
The :mod:`fractions` module defines an immutable, infinite-precision
|
|
Rational number class.
|
|
|
|
|
|
.. class:: Fraction(numerator=0, denominator=1)
|
|
Fraction(other_fraction)
|
|
Fraction(string)
|
|
|
|
The first version requires that *numerator* and *denominator* are
|
|
instances of :class:`numbers.Integral` and returns a new
|
|
``Fraction`` representing ``numerator/denominator``. If
|
|
*denominator* is :const:`0`, raises a :exc:`ZeroDivisionError`. The
|
|
second version requires that *other_fraction* is an instance of
|
|
:class:`numbers.Fraction` and returns an instance of
|
|
:class:`Rational` with the same value. The third version expects a
|
|
string of the form ``[-+]?[0-9]+(/[0-9]+)?``, optionally surrounded
|
|
by spaces.
|
|
|
|
Implements all of the methods and operations from
|
|
:class:`numbers.Rational` and is immutable and hashable.
|
|
|
|
|
|
.. method:: from_float(flt)
|
|
|
|
This classmethod constructs a :class:`Fraction` representing the exact
|
|
value of *flt*, which must be a :class:`float`. Beware that
|
|
``Fraction.from_float(0.3)`` is not the same value as ``Rational(3, 10)``
|
|
|
|
|
|
.. method:: from_decimal(dec)
|
|
|
|
This classmethod constructs a :class:`Fraction` representing the exact
|
|
value of *dec*, which must be a :class:`decimal.Decimal`.
|
|
|
|
|
|
.. method:: limit_denominator(max_denominator=1000000)
|
|
|
|
Finds and returns the closest :class:`Fraction` to ``self`` that has
|
|
denominator at most max_denominator. This method is useful for finding
|
|
rational approximations to a given floating-point number:
|
|
|
|
>>> from fractions import Fraction
|
|
>>> Fraction('3.1415926535897932').limit_denominator(1000)
|
|
Fraction(355L, 113L)
|
|
|
|
or for recovering a rational number that's represented as a float:
|
|
|
|
>>> from math import pi, cos
|
|
>>> Fraction.from_float(cos(pi/3))
|
|
Fraction(4503599627370497L, 9007199254740992L)
|
|
>>> Fraction.from_float(cos(pi/3)).limit_denominator()
|
|
Fraction(1L, 2L)
|
|
|
|
|
|
.. method:: __floor__()
|
|
|
|
Returns the greatest :class:`int` ``<= self``. Will be accessible through
|
|
:func:`math.floor` in Py3k.
|
|
|
|
|
|
.. method:: __ceil__()
|
|
|
|
Returns the least :class:`int` ``>= self``. Will be accessible through
|
|
:func:`math.ceil` in Py3k.
|
|
|
|
|
|
.. method:: __round__()
|
|
__round__(ndigits)
|
|
|
|
The first version returns the nearest :class:`int` to ``self``, rounding
|
|
half to even. The second version rounds ``self`` to the nearest multiple
|
|
of ``Fraction(1, 10**ndigits)`` (logically, if ``ndigits`` is negative),
|
|
again rounding half toward even. Will be accessible through :func:`round`
|
|
in Py3k.
|
|
|
|
|
|
.. seealso::
|
|
|
|
Module :mod:`numbers`
|
|
The abstract base classes making up the numeric tower.
|