fractions — Rational numbers¶
The fractions module provides support for rational number arithmetic.
A Fraction instance can be constructed from a pair of integers, from another rational number, or from a string.
class fractions. Fraction ( numerator = 0 , denominator = 1 ) ¶ class fractions. Fraction ( other_fraction ) class fractions. Fraction ( float ) class fractions. Fraction ( decimal ) class fractions. Fraction ( string )
The first version requires that numerator and denominator are instances of numbers.Rational and returns a new Fraction instance with value numerator/denominator . If denominator is 0 , it raises a ZeroDivisionError . The second version requires that other_fraction is an instance of numbers.Rational and returns a Fraction instance with the same value. The next two versions accept either a float or a decimal.Decimal instance, and return a Fraction instance with exactly the same value. Note that due to the usual issues with binary floating-point (see Floating Point Arithmetic: Issues and Limitations ), the argument to Fraction(1.1) is not exactly equal to 11/10, and so Fraction(1.1) does not return Fraction(11, 10) as one might expect. (But see the documentation for the limit_denominator() method below.) The last version of the constructor expects a string or unicode instance. The usual form for this instance is:
[sign] numerator ['/' denominator]
where the optional sign may be either ‘+’ or ‘-’ and numerator and denominator (if present) are strings of decimal digits (underscores may be used to delimit digits as with integral literals in code). In addition, any string that represents a finite value and is accepted by the float constructor is also accepted by the Fraction constructor. In either form the input string may also have leading and/or trailing whitespace. Here are some examples:
>>> 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)
The Fraction class inherits from the abstract base class numbers.Rational , and implements all of the methods and operations from that class. Fraction instances are hashable , and should be treated as immutable. In addition, Fraction has the following properties and methods:
Changed in version 3.2: The Fraction constructor now accepts float and decimal.Decimal instances.
Changed in version 3.9: The math.gcd() function is now used to normalize the numerator and denominator. math.gcd() always return a int type. Previously, the GCD type depended on numerator and denominator.
Changed in version 3.11: Underscores are now permitted when creating a Fraction instance from a string, following PEP 515 rules.
Changed in version 3.11: Fraction implements __int__ now to satisfy typing.SupportsInt instance checks.
Numerator of the Fraction in lowest term.
Denominator of the Fraction in lowest term.
Return a tuple of two integers, whose ratio is equal to the Fraction and with a positive denominator.
Alternative constructor which only accepts instances of float or numbers.Integral . Beware that Fraction.from_float(0.3) is not the same value as Fraction(3, 10) .
From Python 3.2 onwards, you can also construct a Fraction instance directly from a float .
Alternative constructor which only accepts instances of decimal.Decimal or numbers.Integral .
From Python 3.2 onwards, you can also construct a Fraction instance directly from a decimal.Decimal instance.
Finds and returns the closest 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(355, 113)
or for recovering a rational number that’s represented as a float:
>>> from math import pi, cos >>> Fraction(cos(pi/3)) Fraction(4503599627370497, 9007199254740992) >>> Fraction(cos(pi/3)).limit_denominator() Fraction(1, 2) >>> Fraction(1.1).limit_denominator() Fraction(11, 10)
>>> from math import floor >>> floor(Fraction(355, 113)) 3
Returns the least int >= self . This method can also be accessed through the math.ceil() function.
__round__ ( ) ¶ __round__ ( ndigits )
The first version returns the nearest 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. This method can also be accessed through the round() function.
The abstract base classes making up the numeric tower.
Модуль Fraction в Python: примеры создания дробей
Модуль Fraction в Python используется для работы с арифметикой рациональных чисел. Этот модуль позволяет нам создавать дробные экземпляры целых чисел, чисел с плавающей запятой, десятичных чисел и строк.
Что такое дробный экземпляр?
Дробные экземпляры могут быть созданы с использованием пары целых чисел, строки или другого рационального числа. Они являются хешируемыми и должны рассматриваться как изменяемые.
Как создать дробь?
Модуль Fraction в Python предоставляет следующие встроенные функции, которые используются для создания дроби. Давайте разберемся в следующих способах создания дроби.
- class fractions.Function(numerator = 0, denominator = 1): – Этот метод по умолчанию присваивает числителю значение 0 и знаменателю 1. Если знаменатель равен 0, это вызовет ошибку Zerodivision. Давайте разберемся в следующем примере.
from fractions import Fraction print(Fraction(10, 37)) # returns Fraction(11, 35) print(Fraction(11, 18)) # returns Fraction(5, 9) print(Fraction()) # returns Fraction(0, 1)
- class fractions.Fraction(other_fraction): этот метод принимает экземпляр other_fraction числа. Он возвращает рациональные и дробные экземпляры с одинаковым значением.
- class fractions.Fraction(float): – этот метод принимает значение с плавающей запятой и возвращает тот же экземпляр значения дроби.
from fractions import Fraction print(Fraction(1/12))
6004799503160661/72057594037927936
- class fractions.Fraction(decimal): этот метод принимает десятичный экземпляр и возвращает экземпляр с тем же значением. Давайте разберемся в следующем примере.
from fractions import Fraction print(Fraction('2.26')) - class fractions.Fraction(string): этот метод принимает строку или Unicode в качестве аргумента и возвращает экземпляр с тем же значением.
from fractions import Fraction print(Fraction('7/25')) print(Fraction('1.23')) print(Fraction('3/5')) print(Fraction('1.414213 \t\n')) 7/25 123/100 3/5 1414213/1000000
- limit_denominator(max_denominator = 1000000) – используется для нахождения приближения к заданному числу с плавающей запятой. Возвращает заданную дробь self, знаменатель которой равен max_denominator. Разберем в следующих примерах.
from fractions import Fraction print(Fraction('3.14159265358979323846')) print(Fraction('3.14159265358979323846').limit_denominator(10000)) print(Fraction('3.14159265358979323846').limit_denominator(100)) print(Fraction('3.14159265358979323846').limit_denominator(10)) print(Fraction(125, 50).numerator) print(Fraction(125, 50).denominator) 157079632679489661923/50000000000000000000 355/113 311/99 22/7 5 2
Пример – 2: Выполнение математической операции с дробным числом.
from fractions import Fraction print(Fraction(56, 12) + Fraction(18, 25)) print(Fraction(5, 2) / Fraction(12, 10)) print(Fraction(16, 15) * Fraction(26, 39)) print(Fraction(18, 5) * Fraction(15, 36)) print(Fraction(22, 5) ** Fraction(6, 10))
404/75 25/12 32/45 3/2 2.4326050606703427
Заключение
В этом руководстве мы обсудили модуль Fraction и несколько его важных методов. Эти методы можно использовать в проектах сложных математических вычислений и машинного обучения.
Рациональные числа. Класс Fraction
Рациональное число – это число, которое можно представить в виде рациональной дроби m/n , где m , n соответственно числитель и знаменатель которые имеют целочисленное значение. Например, в дроби 5/6 значение m = 5, значение n = 6.
В языке программирования Python для работы с рациональными числами предлагается класс Fraction . В классе соответствующим образом представлены числитель m и знаменатель n . В классе Fraction автоматически осуществляется упрощение дроби (например, 9/18 => 1/2).
Чтобы использовать возможности класса Fraction нужно предварительно подключить модуль fractions
from fractions import Fraction
2. Создание объекта класса Fraction
Объект класса Fraction можно создать одним из двух способов.
Способ 1. С помощью конструктора, который содержит целочисленные значения числителя и знаменателя.
a = Fraction(5, 6) # a = 5/6 - рациональное число b = Fraction(8, 12) # b = 2/3 - рациональное число
В вышеприведенном примере в строке
значение числителя 8 и знаменателя 12 переменной b будет автоматически упрощено к виду 2/3. То есть, числитель в классе равен 2, знаменатель равен 3.
Способ 2. С помощью конструктора, который получает строку с вещественным значением.
a = Fraction('1.33') # a = 133/100 b = Fraction('3.719') # b = 3719/1000 c = Fraction('-1.5') # c = -3/2 d = Fraction('3.7') + Fraction('5.2') # d = 89/10
3. Операции над рациональными числами. Примеры
Над объектами класса Fraction можно выполнять следующие арифметические операции:
# Рациональные числа from fractions import Fraction a = Fraction(5, 6) + Fraction(3, 2) # a = 7/3 b = a - Fraction(3, 5) # b = 26/15 c = b * Fraction(101, 202) # c = 13/15 d = c / b # d = 1/2 e = d % a # e = 1/2
Операция возведения в степень числа типа Fraction возвращает вещественный результат
f = Fraction(1,2)**Fraction(1,2) # f = 0.7071067811865476 4. Преимущества применения рациональных чисел. Пример
Как известно, операции с вещественными числами имеют ограничение точности, которая зависит от возможностей аппаратных средств реализующих математику вещественных чисел. По сравнению с вещественными числами рациональные числа обеспечивают
Пример. В примере демонстрируется потеря точности для выражения 0.2+0.2+0.2-0.4.
# Рациональные числа, преимущества применения from fractions import Fraction a = 0.2+0.2+0.2-0.4 # a = 0.20000000000000007 - точность теряется b = Fraction('0.2')+Fraction('0.2')+Fraction('0.2')-Fraction('0.4') # b = 1/5 print('a = ', a) print('b = ', b)
Результат работы программы
a = 0.20000000000000007 b = 1/5
5. Метод as_integer_ratio() . Пример
Метод as_integer_ratio() возвращает числитель и знаменатель, который соответствует заданному числу. Общая форма вызова метода
(real_number).as_integer_ratio()
Метод используется для поддержки преобразования в рациональные числа.
# метод as_integer_ratio from fractions import Fraction # преобразование в дробное число a = (3.5).as_integer_ratio() # a = (7, 2) b = (11.7).as_integer_ratio() # b = (3293257227514675, 281474976710656) # преобразование в тип Fraction a = 8.5 c = Fraction(*a.as_integer_ratio()) # c = 17/2
В вышеприведенном примере символ * означает синтаксис распаковывания кортежа на отдельные аргументы.
6. Метод Fraction.from_float() . Пример
Метод from_float() класса Fraction позволяет получить числитель и знаменатель вещественного числа также как и метод as_integer_ratio() .
# метод from_float класса Fraction from fractions import Fraction y = Fraction.from_float(2.25) # y = 9/4 x = 3.8 # тип float y = Fraction.from_float(x) # y = 4278419646001971/1125899906842624 x = -8.75 y = Fraction.from_float(x) # y = -35/4
7. Метод float() . Пример
Метод float() может получать объекты типа Fraction в качестве аргументов. Метод возвращает число типа float .
# метод float() класса Fraction from fractions import Fraction # аргумент - переменная вещественного типа x = Fraction(11, 4) y = float(x) # y = 2.75 # аргумент - число y = float(Fraction(7,6)) # y = 1.1666666666666667