Класс Fraction модуля fractions

Курс по стандартной библиотеке: https://stepik.org/a/259466?utm_source=proproprogs

Рассмотренный на прошлых занятиях класс Decimal позволяет повысить точность вычислений, но все же имеет очевидные ограничения, связанные с невозможностью представления некоторых дробей конечными десятичными дробями. Например, простая математическая формула:

на уровне объектов класса Decimal не выдаст точного значения один:

res = Decimal('1') / Decimal('3') * Decimal('3')
print(res)  # 0.9999999999999999999999999999

во многом из-за невозможности точно описать дробь 1/3 в виде вещественного значения (конечной десятичной дробью).

Для решения подобных задач был предложен специальный класс Fraction, который способен описывать любые обыкновенные дроби без потери информации. Например, злополучную дробь 1/3 можно определить следующим образом:

from fractions import Fraction
 
a = Fraction(1, 3)
b = Fraction('1/3')
c = Fraction(3, 9)
d = Fraction('5/15')

Во всех случаях будет создан объект класса Fraction для представления дроби 1/3. То есть, здесь числитель и знаменатель дроби хранятся отдельно в виде целых чисел. Обратите внимание, что две последние дроби 3/9 = 5/15 = 1/3 сокращаются до дроби 1/3. И это всегда так. Класс Fraction содержит наименьшие (по модулю) целые значения числителя и знаменателя.

Теперь, если умножить какое-либо из этих чисел на три:

res = a * 3  # Fraction(1, 1)

то получим объект класса Fraction с дробью 1/1 = 1. В результате, благодаря использованию обыкновенных дробей вместо вещественных чисел, имеем возможность точного вычисления итогового результата. В этом главная особенность и преимущество чисел класса Fraction. При этом каждый такой объект содержит два полезных свойства для получения значений числителя и знаменателя:

b.numerator  # 1 – числитель
b.denominator  # 3 – знаменатель

Либо можно воспользоваться методом as_integer_ratio() для извлечения тех же данных в виде кортежа:

b.as_integer_ratio()  # (1, 3)

Зная эти величины, всегда можно число типа Fraction перевести в число типа float или Decimal. Или использовать стандартные функции приведения типов:

bf = float(b)  # 0.3333333333333333
bi = int(b)  # 0 (выделение целой части)
bs = str(b)  # '1/3'
bool(b)  # True
b0 = Fraction(0)
bool(b0)  # False

Как видите, с объектами класса Fraction возможны любые стандартные преобразования.

Создание объектов класса Fraction

Давайте теперь посмотрим на способы создания объектов (чисел) класса Fraction. В общем случае это можно делать так:

a1 = Fraction(5, 6)  # Fraction(5, 6)
a2 = Fraction(3, 6)  # Fraction(1, 2)
a3 = Fraction(-3, 6)  # Fraction(-1, 2)
a4 = Fraction(-3, -6)  # Fraction(1, 2)
a5 = Fraction(5)  # Fraction(5, 1)
a6 = Fraction(1.5)  # Fraction(3, 2)
a7 = Fraction('1/2')  # Fraction(1, 2)
a8 = Fraction('0.756')  # Fraction(189, 250)
a9 = Fraction('-2.3')  # Fraction(-23, 10)
a10 = Fraction('2e-3')  # Fraction(1, 500)

То есть, можно прописывать или два целых числа (числитель, знаменатель), или одно целое число (числитель), тогда знаменатель будет равен 1, или вещественное значение, которое будет преобразовано в обыкновенную дробь, или передавать строки с числами в разных форматах. Также мы можем создавать числа Fraction на основе чисел Decimal следующим образом:

d = Decimal('5.47')
a11 = Fraction(d)  # Fraction(547, 100)

Все это вполне допустимые операции.

Обратите внимание, что вещественные числа лучше явно не прописывать при создании объектов Fraction. Например, команда:

Fraction(0.1)  # Fraction(3602879701896397, 36028797018963968)

создаст очень странную дробь. И все из-за неточного представления числа 0.1 в памяти компьютера. А вот если эту же команду прописать с использованием строкового значения числа:

Fraction('0.1')  # Fraction(1, 10)

то получим вполне ожидаемый результат. Поэтому вместо вещественных чисел старайтесь всегда использовать их строковые аналоги.

Арифметические операции с числами класса Fraction

Обыкновенные дроби, представленные классом Fraction, можно складывать, вычитать, умножать и делить. Делаются все эти операции согласно общим правилам математики. Рассмотрим их на простых примерах.

Пусть имеются две дроби 1/2 и 1/3:

from fractions import Fraction
 
a = Fraction(1, 2)
b = Fraction('1/3')

После их сложения, получим:

c = a + b  # Fraction(5, 6)

Действительно, согласно школьной математике, имеем:

Обратите внимание, что дроби в классе Fraction всегда автоматически приводятся к наименьшему знаменателю. Например, сложение следующих двух дробей:

a = Fraction('3/4')
b = Fraction('4/8')  
c = a + b  # Fraction(5, 4)

в действительности описывает такое сложение:

Несмотря на то, что дробь b определена как 4/8, она автоматически сокращается до 1/2 (представляется с наименьшим знаменателем).

Операция вычитания работает по аналогии, т.к. это по сути сложение положительной и отрицательной дробей. Например:

a = Fraction('3/4')
b = Fraction('7/8')
c = a - b  # Fraction(-1, 8)
d = b - a  # Fraction(1, 8)

Следующая операция умножения дробей записывается в виде:

a = Fraction('3/4')
b = Fraction('1/3')
c = a * b  # Fraction(1, 4)

и вычисляется следующим образом:

Наконец, деление записывается так:

a = Fraction('3/4')
b = Fraction('2/3')
c = a / b  # Fraction(9, 8)
d = b / a  # Fraction(8, 9)

Согласно правилам математики эти дроби вычисляются следующим образом:

Помимо базовых арифметических операций с числами класса Fraction можно выполнять и некоторые дополнительные:

a ** 2  # Fraction(9, 16)
a // b  # 1
a += b  # Fraction(17, 12)
b *= 5  # Fraction(10, 3)
a - 7  # Fraction(-67, 12)

Обратите внимание, что объекты класса Fraction можно вычислять совместно с целыми числами. А вот с дробными float дроби преобразуются в конечные десятичные и результат получается в виде десятичных дробей:

b + 0.5  # 3.8333333333333335

Соответственно, имеем погрешности в представлении таких чисел. Поэтому при выполнении арифметических операций над обыкновенными дробями не следует использовать вещественные числа типа float.

Операции сравнения

Помимо арифметических операций числа класса Fraction поддерживают все стандартные операции сравнения. Пусть, например, заданы три следующие дроби:

a = Fraction('0.5')
b = Fraction('2/4')
c = Fraction('3/4')

Тогда операции сравнения с ними вернут следующие результаты:

a == b  # True
a == c  # False
b != c  # True
a < c  # True
a <= b  # True
c > a + b  # False
c >= a  # True

Обратите внимание, что дроби a и b равны между собой, т.к. это одна и та же дробь 1/2. Результат работы всех остальных операций вполне очевиден.

Курс по стандартной библиотеке: https://stepik.org/a/259466?utm_source=proproprogs

Видео по теме

#1. Тип данных complex

#2. Множество frozenset

#3. Перечисления (enum). Класс Enum

#4. Классы IntEnum и StrEnum

#5. Именованные кортежи namedtuple модуля collections

#6. Словарь defaultdict модуля collections

#7. Упорядоченный словарь OrderedDict

#8. Класс Counter модуля collections

#9. Класс ChainMap модуля collections

#10. Функции pprint() и pformat(). Класс PrettyPrinter

#11. Очереди типов FIFO и LIFO

#12. Очередь deque модуля collections

#13. Класс Queue модуля queue

#14. Классы LifoQueue и PriorityQueue модуля queue

#15. Понятие кучи (heap). Модуль heapq

#16. Класс array. Методы класса array

#17. Модуль bisect - сортировка в моменте

#18. Функции copy() и deepcopy() модуля copy

#19. Магические методы __copy__() и __deepcopy__()

#20. Декораторы partial и partialmethod модуля functools

#21. Функция update_wrapper() и декоратор wraps

#22. Декоратор lru_cache модуля functools

#23. Функция reduce() модуля functools

#24. Декоратор singledispatch модуля functools

#25. Модуль abc (Abstract Base Classes)

#26. Модуль itertools. Функция chain()

#27. Функции zip_longest(), islice() и tee()

#28. Комбинаторные функции модуля itertools

#29. Функции фильтрации из модуля itertools

#30. Функции-генераторы модуля itertools

#31. Функции groupby() и starmap() модуля itertools

#32. Функции модуля operator. Классы itemgetter и attrgetter

#33. Функция methodcaller() модуля operator

#34. Функции модуля time. Функции time() и ctime()

#35. Функции monotonic(), perf_counter() и process_time()

#36. Функции localtime(), gmtime(), mktime(), strftime() и strptime()

#37. Модуль datetime. Классы time и date

#38. Арифметика дат. Класс timedelta

#39. Класс datetime модуля datetime

#40. Модуль calendar. Основные функции, классы и методы

#41. Модуль math (часть 1)

#42. Модуль math (часть 2)

#43. Модуль math (часть 3)

#44. Класс Decimal для точного представления вещественных чисел

#45. Методы класса Decimal

#46. Функции с числами Decimal. Глобальный и локальный контексты

#47. Класс Fraction модуля fractions

#48. Стандартные функции с объектами класса Fraction

#49. Модуль random стандартной библиотеки

#50. Введение в модуль statistics

#51. Вычисление дисперсий и ковариаций с помощью модуля statistics

#52. Введение в модуль re. Символьные классы

#53. Квантификаторы регулярных выражений

#54. Группировка и сохранение в регулярных выражениях

#55. Опережающие (lookahead) проверки. Флаги

#56. Ретроспективные (lookbehind) проверки

#57. Объект Match. Методы search(), finditer() и findall()

#58. Методы match(), split(), sub(), subn(), compile()

#59. Функции модуля os.path для анализа файловых маршрутов

#60. Дополнительные функции модуля os.path

#61. Классы PurePosixPath и PureWindowsPath модуля pathlib

#62. Классы PosixPath и WindowsPath модуля pathlib