Detailed explanation of how to make Python support fraction types (using the standard library fractions module)

Recently I encountered fraction processing at work. I searched for relevant information and found that it can be implemented using the Fraction class. So the following article mainly introduces to you the relevant information about using the standard library fractions module to make Python support fraction types. In the article The introduction through sample code is very detailed, friends in need can refer to it.

Preface

You may not need to deal with fractions very often, but when you do, Python’s Fraction class will give you a lot of help . This article will give you a detailed introduction to the use of the standard library fractions module to enable Python to support fraction types, and share it for your reference and study. I won’t say much below, let’s take a look at the detailed introduction:

fractions module

fractions module provides support for fraction types.

Fraction class

This class is the core of the fractions module. It inherits the numbers.Rational class and implements all methods of this class.

The constructor is not complicated:

class fractions.Fraction(numerator=0, denominator=1) 
class fractions.Fraction(int|float|str|Decimal|Fraction)

You can provide both the numerator and the denominator to the constructor for instantiating the Fraction class. But both must be of int type or numbers.Rational type at the same time, otherwise a type error will be thrown. When the denominator is 0, an exception ZeropisionError will be thrown during initialization.

If only one parameter is provided, the above five types can be used for initialization. When initialized with a string, the fractions module uses built-in regular expression matching. When initializing with floating point numbers or Decimal, the fractions module will call as_integer_ratio() internally.

The following code example is from the official documentation and shows various ways to instantiate Fraction:

>>> from fractions import Fraction
>>> Fraction(16, -10)
Fraction(-8, 5)
>>> Fraction(123)
Fraction(123, 1)
>>> Fraction()
Fraction(0, 1)
>>> Fraction('3/7')
Fraction(3, 7)
>>> Fraction(' -3/7 ')
Fraction(-3, 7)
>>> Fraction('1.414213 \t\n')
Fraction(1414213, 1000000)
>>> Fraction('-.125')
Fraction(-1, 8)
>>> Fraction('7e-6')
Fraction(7, 1000000)
>>> Fraction(2.25)
Fraction(9, 4)
>>> Fraction(1.1)
Fraction(2476979795053773, 2251799813685248)
>>> from decimal import Decimal
>>> Fraction(Decimal('1.1'))
Fraction(11, 10)

Limit denominator

##fractions.Fraction.limit_denominator(max_denominator=1000000)

Sometimes floating point numbers or Decimal are used as initialization of Fraction instances The data may encounter problems with rounding errors, such as the example above where

Fraction(11, 10) is not returned when calling Fraction(1.1). At this time, the Fraction class provides an instance method limit_denominator() to reduce this error. This method was originally intended to obtain an approximate value by limiting the denominator, but it actually makes the result more accurate when rounding errors occur, such as the following example:

>>> from fractions import Fraction
>>> Fraction(1.1)
Fraction(2476979795053773, 2251799813685248)
>>> Fraction(1.1).limit_denominator()
Fraction(11, 10)

will Fraction is used for arithmetic operations, relational operations and various other operations

As mentioned above, the Fraction class inherits the

numbers.Rational class and implements all methods of this class. Therefore, the Fraction class actually overloads many special functions so that its instances can be directly used for various arithmetic operations.

Not only supports arithmetic operations, the Fraction class also supports relational operations, pickle modules, copy modules and hash value calculations.

>>> from fractions import Fraction
>>> x = Fraction(1, 2)
>>> y = Fraction(1, 3)
>>> x + y
Fraction(5, 6)
>>> x - y
Fraction(1, 6)
>>> x * y
Fraction(1, 6)
>>> x / y
Fraction(3, 2)
>>> x ** 2
Fraction(1, 4)
>>> -x
Fraction(-1, 2)
>>> abs(x)
Fraction(1, 2)
>>> round(x)
0
>>> import math
>>> math.floor(x)
0
>>> math.ceil(x)
1
>>> x == y
False
>>> x > y
True

Other functions

fractions.Fraction.from_float(flt) 
fractions.Fraction.from_decimal(dec)

In Python3.2 Previously, the Fraction class did not support obtaining instances by passing floating point numbers and Decimals into the constructor. Instead, the above two class methods are provided to generate instances by calling the class methods. These two class methods still exist in the current version (Python 3.6.1).

fractions.gcd(a, b)

is used to calculate the greatest common divisor. This function was abandoned after Python 3.5, and the official recommendation is to use

math.gcd() .

Summary

There is nothing to summarize... I can only say that Python is too convenient... By the way, this blog is actually a dig. I've been stuck for a long time. I didn't understand part of the source code before, so I haven't posted it yet. Haha, the following series of standard library learning will continue to be updated!

The above is the detailed content of Detailed explanation of how to make Python support fraction types (using the standard library fractions module). For more information, please follow other related articles on the PHP Chinese website!