Python fractions模块 —— 分数相关函数

本文主要是介绍Python fractions模块 —— 分数相关函数，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

这是一简单的模块，搞不懂python为什么不把它并入math模块？

>>> import fractions
>>> fractions.__all__
['Fraction', 'gcd']
>>> fractions.gcd(12,18)

Warning (from warnings module):
  File "<pyshell#2>", line 1
DeprecationWarning: fractions.gcd() is deprecated. Use math.gcd() instead.
6
>>> fractions.gcd(14,6)
2
>>> import math
>>> math.gcd(14,6)
2
>>> 

一共就俩，其中一个最大公约数函数gcd()还不推荐使用，用math中的gcd替代。

fractions模块中的类Fraction

class Fraction(numbers.Rational)
 |  Fraction(numerator=0, denominator=None, *, _normalize=True)
 |  
 |  This class implements rational numbers.
 |  
 |  In the two-argument form of the constructor, Fraction(8, 6) will
 |  produce a rational number equivalent to 4/3. Both arguments must
 |  be Rational. The numerator defaults to 0 and the denominator
 |  defaults to 1 so that Fraction(3) == 3 and Fraction() == 0.
 |  
 |  Fractions can also be constructed from:
 |  
 |    - numeric strings similar to those accepted by the
 |      float constructor (for example, '-2.3' or '1e10')
 |  
 |    - strings of the form '123/456'
 |  
 |    - float and Decimal instances
 |  
 |    - other Rational instances (including integers)
 |  
 |  Method resolution order:
 |      Fraction
 |      numbers.Rational
 |      numbers.Real
 |      numbers.Complex
 |      numbers.Number
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __abs__(a)
 |      abs(a)
 |  
 |  __add__(a, b)
 |      a + b
 |  
 |  __bool__(a)
 |      a != 0
 |  
 |  __ceil__(a)
 |      math.ceil(a)
 |  
 |  __copy__(self)
 |  
 |  __deepcopy__(self, memo)
 |  
 |  __divmod__(a, b)
 |      (a // b, a % b)
 |  
 |  __eq__(a, b)
 |      a == b
 |  
 |  __floor__(a)
 |      math.floor(a)
 |  
 |  __floordiv__(a, b)
 |      a // b
 |  
 |  __ge__(a, b)
 |      a >= b
 |  
 |  __gt__(a, b)
 |      a > b
 |  
 |  __hash__(self)
 |      hash(self)
 |  
 |  __le__(a, b)
 |      a <= b
 |  
 |  __lt__(a, b)
 |      a < b
 |  
 |  __mod__(a, b)
 |      a % b
 |  
 |  __mul__(a, b)
 |      a * b
 |  
 |  __neg__(a)
 |      -a
 |  
 |  __pos__(a)
 |      +a: Coerces a subclass instance to Fraction
 |  
 |  __pow__(a, b)
 |      a ** b
 |      
 |      If b is not an integer, the result will be a float or complex
 |      since roots are generally irrational. If b is an integer, the
 |      result will be rational.
 |  
 |  __radd__(b, a)
 |      a + b
 |  
 |  __rdivmod__(b, a)
 |      (a // b, a % b)
 |  
 |  __reduce__(self)
 |      Helper for pickle.
 |  
 |  __repr__(self)
 |      repr(self)
 |  
 |  __rfloordiv__(b, a)
 |      a // b
 |  
 |  __rmod__(b, a)
 |      a % b
 |  
 |  __rmul__(b, a)
 |      a * b
 |  
 |  __round__(self, ndigits=None)
 |      round(self, ndigits)
 |      
 |      Rounds half toward even.
 |  
 |  __rpow__(b, a)
 |      a ** b
 |  
 |  __rsub__(b, a)
 |      a - b
 |  
 |  __rtruediv__(b, a)
 |      a / b
 |  
 |  __str__(self)
 |      str(self)
 |  
 |  __sub__(a, b)
 |      a - b
 |  
 |  __truediv__(a, b)
 |      a / b
 |  
 |  __trunc__(a)
 |      trunc(a)
 |  
 |  as_integer_ratio(self)
 |      Return the integer ratio as a tuple.
 |      
 |      Return a tuple of two integers, whose ratio is equal to the
 |      Fraction and with a positive denominator.
 |  
 |  limit_denominator(self, max_denominator=1000000)
 |      Closest Fraction to self with denominator at most max_denominator.
 |      
 |      >>> Fraction('3.141592653589793').limit_denominator(10)
 |      Fraction(22, 7)
 |      >>> Fraction('3.141592653589793').limit_denominator(100)
 |      Fraction(311, 99)
 |      >>> Fraction(4321, 8765).limit_denominator(10000)
 |      Fraction(4321, 8765)
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_decimal(dec) from abc.ABCMeta
 |      Converts a finite Decimal instance to a rational number, exactly.
 |  
 |  from_float(f) from abc.ABCMeta
 |      Converts a finite float to a rational number, exactly.
 |      
 |      Beware that Fraction.from_float(0.3) != Fraction(3, 10).
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  __new__(cls, numerator=0, denominator=None, *, _normalize=True)
 |      Constructs a Rational.
 |      
 |      Takes a string like '3/2' or '1.5', another Rational instance, a
 |      numerator/denominator pair, or a float.
 |      
 |      Examples
 |      --------
 |      
 |      >>> Fraction(10, -8)
 |      Fraction(-5, 4)
 |      >>> Fraction(Fraction(1, 7), 5)
 |      Fraction(1, 35)
 |      >>> Fraction(Fraction(1, 7), Fraction(2, 3))
 |      Fraction(3, 14)
 |      >>> Fraction('314')
 |      Fraction(314, 1)
 |      >>> Fraction('-35/4')
 |      Fraction(-35, 4)
 |      >>> Fraction('3.1415') # conversion from numeric string
 |      Fraction(6283, 2000)
 |      >>> Fraction('-47e-2') # string may include a decimal exponent
 |      Fraction(-47, 100)
 |      >>> Fraction(1.47)  # direct construction from float (exact conversion)
 |      Fraction(6620291452234629, 4503599627370496)
 |      >>> Fraction(2.25)
 |      Fraction(9, 4)
 |      >>> Fraction(Decimal('1.47'))
 |      Fraction(147, 100)
 |  
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |  
 |  denominator
 |  
 |  numerator
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __abstractmethods__ = frozenset()
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from numbers.Rational:
 |  
 |  __float__(self)
 |      float(self) = self.numerator / self.denominator
 |      
 |      It's important that this conversion use the integer's "true"
 |      division rather than casting one side to float before dividing
 |      so that ratios of huge integers convert without overflowing.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from numbers.Real:
 |  
 |  __complex__(self)
 |      complex(self) == complex(float(self), 0)
 |  
 |  conjugate(self)
 |      Conjugate is a no-op for Reals.
 |  
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from numbers.Real:
 |  
 |  imag
 |      Real numbers have no imaginary component.
 |  
 |  real
 |      Real numbers are their real component.

函数实例在上述帮助中有......混一篇凑凑数 ^_^

这篇关于Python fractions模块 —— 分数相关函数的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！