Модуль fractions позволяет выполнять арифметические действия над рациональными числами, что в некоторых ситуациях бывает чрезвычайно удобно.
Создание обыкновенных дробей
Способов создания экземпляров рациональных чисел, довольно много поэтому мы разделим их на группы.
Самый простой способ создать обыкновенную дробь – указать числитель ( numerator ) и знаменатель ( denominator ):
Если указанные числитель и знаменатель имеют общие делители, то перед созданием рационального числа они будут сокращены:
В качестве числителя и (или) знаменателя могут быть указаны другие дроби:
Целое и вещественное число, так же можно преобразовать в обыкновенную дробь:
А вот комплексные числа приведут к ошибке:
Но мнимой и действительной частью комплексного числа, могут быть указаны рациональные числа:
Так же любая десятичная дробь модуля Decimal может быть преобразована в обыкновенную дробь:
Ну и напоследок, любая строка, которая может быть преобразована в любое допустимое число, так же может быть использована для получения обыкновенных дробей:
Математические операции над рациональными числами
Все арифметические операторы поддерживают вычисления с рациональными числами:
Однако арифметические операторы не способны к действиям над типами ‘Fraction’ и ‘decimal.Decimal’ в одном выражении:
Функции модуля math способны принимать рациональные числа в качестве аргументов, так как последние, по сути, могут быть просто преобразованы к вещественным числам:
Fraction — aтрибуты и методы
Как можно заметить, из-за хранения чисел с плавающей точкой в двоичном представлении Fraction.from_float(0.6) вовсе не равно Fraction(6, 10) :
Данный метод позволяет получать как рациональные приближения, так и восстанавливать рациональные значения по их неточному представлению в виде чисел с плавающей точкой:
Ну и учитывая что, все функции модуля math могут обрабатывать обыкновенные дроби, то воспользоваться данным методом можно и так:
Возвращает НОД(a, b). Знак результата зависит от знака b, если b не равен \(0\), в противном случае знак результата равен знаку a. Возвращает \(0\), только если a и b оба равны \(0\):
# Дробные числа
Числа бывают целыми и дробными. Для десятичных дробей, или чисел с плавающей запятой, в Python есть специальный тип данных — float (от англ. floating point, «плавающая точка»).
Дробные числа, как и целые, преобразуют к строкам вызовом функции str() :
Такой похожий код — и такой разный результат! Превратив числа в строки, мы получили один из IP-адресов серверов.
Можно и наоборот. Преобразуем строки в числа функцией float() :
Также можно сделать несколько преобразований в одной строчке. Попробуем сначала сделать дробь целым числом, а затем преобразовать ее в строку:
Что значит «плавающая запятая» и куда она плывет? Грубо говоря, дробные числа называются «числами с плавающей запятой», потому что запятая «плавает» по числу, когда его представляют в виде произведения значащей части и степени.
Например, число 3,14159 можно записать следующим образом:
В англоязычной литературе запятая называется точкой, floating point, потому что принято писать десятичные дроби через точку.
# Упражнения
Очеловечим Виту. Пусть она округляет точные значения так, как это делают люди. Точное значение — дробь — хранится в переменной temperature_exact (англ. exact, «точный»). Выведите на экран строку вида За окном 39.3 градусов Цельсия. Это почти 40 Вита должна взять точное значение, отбросить знаки после запятой, добавить единицу и сообщить примерное значение, округлённое «вверх» — до ближайшего большего целого числа. Его Вита сохраняет в переменной temperature_approx(от англ. approximate, «примерный»). При другом значении temperature_exact должна изменяться и возвращаемая строка.
# Упражнения tkinter
Создайте оконное приложение «Вита», в которое выводятся данные о температуре. Пусть она округляет точные значения так, как это делают люди. Точное значение — дробь — хранится в переменной temperature_exact (англ. exact, «точный»). Выведите на экран строку вида За окном 17.3 градусов Цельсия. Это почти 18 Вита должна взять точное значение, отбросить знаки после запятой, добавить единицу и сообщить примерное значение, округлённое «вверх» — до ближайшего большего целого числа. Его Вита сохраняет в переменной temperature_approx (от англ. approximate, «примерный»). При другом значении temperature_exact должна изменяться и возвращаемая строка.
Модули Decimal и Fraction в Python
О принципах работы Decimal и Fraction и пойдет речь в данном обзоре.
Для чего нужен модуль Decimal?
Некоторые пользователи задаются вопросом, зачем нам нужен модуль для выполнения простейшей арифметики с десятичными числами, когда мы вполне можем сделать то же самое с помощью чисел с плавающей точкой ?♂️?
Перед тем, как мы ответим на данный вопрос, мы хотим, чтобы вы сами посчитали в Python, какой результат будет в данном примере: 0.1+0.2? Вы будете удивлены, когда узнаете, что правильный ответ — это не 0,3, а 0,30000000000000004.
Чтобы понять, почему в расчетах возникла ошибка, попробуйте представить 1/3 в десятичной форме. Тогда вы заметите, что число на самом деле не заканчивается в базе 10. Так как все числа должны быть каким-то образом представлены, при их сохранении в консоли делается несколько приближений, что и приводит к ошибкам.
Cпециально для читателей-гуманитариев, у нас есть объяснение принципов работы модулей Питона: «Она на долю секунды отвела взгляд» и «Она отвела взгляд на короткое время» — чувствуете разницу?
Чтобы получить точные результаты, подобные тем, к которым мы привыкли при выполнении расчетов вручную, нам нужно что-то, что поддерживает быструю, точно округленную, десятичную арифметику с плавающей запятой, и модуль Decimal отлично справляется с этой задачей. Теперь, когда мы разобрались с теорией, переходим к принципам работы десятичного модуля.
Модуль Decimal
Синтаксис
С помощью Decimal вы можете создавать десятичные числа.
Decimal обеспечивает поддержку правильного округления десятичной арифметики с плавающей точкой.
>>> from decimal import Decimal >>> number1 = Decimal(«0.1») >>> number2 = Decimal(«0.7») >>> print(number1 + number2) 0.8
Контекст
Базовые параметры Decimal можно посмотреть в его контексте, выполнив функцию getcontext() :
>>> from decimal import getcontext >>> getcontext() Context(prec=3, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[Inexact, Rounded], traps=[InvalidOperation, DivisionByZero, Overflow])
Точность
Контекстом в Deciaml можно управлять, устанавливая свои значения. Например, для того, чтобы управлять точностью Decimal, необходимо изменить параметр контекста prec (от англ. precision — точность):
>>> from decimal import Decimal, getcontext >>> getcontext().prec = 2 >>> print(Decimal(‘4.34’) / 4) 1.1 >>> getcontext().prec = 3 >>> print(Decimal(‘4.34’) / 4) 1.08
Округление
>>> from decimal import Decimal >>> getcontext().prec = 4 # установим точность округление >>> number = Decimal(«2.1234123») >>> print(number.quantize(Decimal(‘1.000’))) 2.123 # округление до 3 чисел в дробной части >>> print(number.quantize(Decimal(‘1.00’))) 2.12 # округление до 2 чисел в дробной части >>> print(number.quantize(Decimal(‘1.0’))) 2.1 # округление до 1 числа в дробной части
>>> print(number.quantize(Decimal(‘1.000’))) Traceback (most recent call last): File «
«, line 1, in print(number.quantize(Decimal(‘1.00’))) decimal.InvalidOperation: [ ]
Чтобы избежать ее, необходимо поменять точность округления, как было сделано в примере выше:
>> getcontext().prec = 4 >>> print(number.quantize(Decimal(‘1.000’))) 2.123
Помимо первого параметра, quantize() принимает в качестве второго параметра стратегию округления:
Помните, что как округление, так и точность вступают в игру только во время арифметических операций, а не при создании самих десятичных дробей
Полезные методы Decimal
Итак, вот некоторые полезные методы для работы с десятичными числами в Decimal:
? Полный список методов Decimal описан в официальной документации
Модуль Fraction
Этот модуль пригодится в тех случаях, когда вам необходимо выполнить вычисления с дробями, или когда результат должен быть выражен в формате дроби.
>>> from fractions import Fraction as frac >>> print(Fraction(33.33)) 2345390243441541/70368744177664 >>> print(Fraction(‘33.33’)) 3333/100
Модуль Fraction особенно полезен, потому что он автоматически уменьшает дробь. Выглядит это вот так:
>>> Fraction(153, 272) Fraction(9, 16)
>>> Fraction(1, 2) + Fraction(3, 4) Fraction(5, 4)
Теперь давайте попробуем возвести дробь в степень:
>>> Fraction(1, 8) ** Fraction(1, 2) 0.3535533905932738
Когда использовать Decimal и Fraction?
Потребность в максимальной точности расчетов на практике чаще всего возникает в отраслях и ситуациях, где некорректно выбранная точность расчетов может обернуться серьезными финансовыми потерями:
Таким образом, этих двух модулей должно быть достаточно, чтобы помочь вам выполнять общие операции как с десятичными, так и с дробными числами. Как мы уже говорили, вы можете использовать эти модули вместе с математическим модулем для вычисления значения всех видов математических функций в желаемом формате.
Модуль Decimal незаменим, если нужно считать деньги: с его помощью вы сможете подсчитать точную сумму, вплоть до копеек.
Fraction считает просто и честно: любители онлайн-игр приспособили его для подсчетов в игровой математике.
Модуль дробей в Python
Модуль дробей Python позволяет пользователю эффективно управлять вычислениями, связанными с дробями. Этот модуль позволяет нам создавать дроби из целых чисел, чисел с плавающей запятой, десятичных чисел и строк.
Он поддерживает арифметические операции с рациональными числами.
1. Импорт модуля фракций:
2. Создайте экземпляр класса дроби:
Есть несколько способов создать экземпляр класса дроби. Ниже приведены некоторые способы:
Пример: создание экземпляра путем передачи числителя и знаменателя
Пример: создание с поплавком
Пример: создать экземпляр с десятичным числом
Пример: создать экземпляр строки
Создание дробей
Выполнение арифметических операций над дробями
В следующем примере объясняются различные математические операции с дробями.
Экземпляры фракций
Экземпляр Fraction — это дробь, состоящая из пары целых чисел, рациональных чисел или строки. Дроби являются хешируемыми и неизменяемыми, поэтому их значения нельзя изменить после создания.
class fractions.Fraction (числитель = 0, знаменатель = 1): требует, чтобы числитель и знаменатель были числами. В качестве выходных данных возвращается дробное значение = (числитель / знаменатель), значения по умолчанию — 0. Если знаменатель = 0, возникает ошибка деления.
Функции математического модуля
Функции математического модуля можно смешивать с дробным представлением. В приведенном ниже примере показано одно такое представление.
Округление дробей
Есть возможность округлить дроби на количество цифр, которое пользователь хочет в знаменателе.
Числа
Числа в языке Python представлены тремя встроенными типами: целые ( int ), вещественные ( float ) и комплексные ( comlex ), а так же двумя типами чисел, которые предоставляет его стандартная библиотека: десятичные дроби неограниченной точности ( Decimal ) и обыкновенные дроби ( Float ).
Числовой тип данных устроен очень просто и интуитивно понятно. Однако, если чисел в вашей работе очень много, то узнать о них будет, по крайней мере, не лишним.
Помимо этого, числа встроенных типов (int, float и complex) относятся к немутирующим (неизменяемым) объектам, т.е. объектам чья структура не может быть изменена напрямую. Нельзя изменить какую-нибудь цифру существующего числа, нельзя расставить его цифры в обратном порядке. То что кажется изменением числа, на самом деле таковым не является. Например:
Вроде бы мы создали объект-число со значением \(1\), а затем изменили его значение на \(0\). Но если это так, то id объекта (его адрес в памяти) не должен меняться, а он меняется:
Как видим, изменения объекта не произошло, старый объект исчез и появился новый. Эту информацию трудно назвать «очень полезной», но она нужна для понимания «внутренней кухни» языка. Например того, что все в этом языке, включая числа, является объектом. Или того, что числа, действительно хранятся в памяти компьютера, и живут в этой памяти по каким-то своим правилам. Но вся эта внутренняя кухня является заботой самого Python. В основном, мы пишем код, даже не задумываясь о ее существовании, лишь иногда, очень редко вмешиваясь в ее работу.
Ну и последнее, что я могу сказать о встроенных числовых типах, так это то, что результат всегда преобразуется к более общему типу если это необходимо. Например, если частное двух целых чисел (int) не является целым числом, то оно будет преобразовано к вещественному типу (float):
А если результат не может быть выражен типами int и float, то он будет преобразован к типу complex. Так что если вдруг будете вычислять корни четной степени из отрицательных чисел, не ждите ошибки:
Еще мы могли бы рассмотреть как устроено хеширование чисел, или как устроены их классы. Но такие тонкости настолько редко требуются на практике, что я о них ни разу не слышал (что и не мудрено, я ведь сельский учитель ?). А к тому моменту, когда вам вдруг это потребуется вы и сами без труда сможете со всем разобраться. Давайте рассмотрим каждый тип чисел в отдельности.
Целые числа (int)
Все дело в том, что данная функция для трех аргументов реализована, как алгоритм быстрого возведения в степень по модулю, что на порядки быстрее чем эквивалентная команда:
Поддержка длинной арифметики может показаться излишней, но на самом деле, есть целая куча подразделов математики (например, комбинаторика, теория графов, теория чисел, криптография и т.д.) где ее наличие «под рукой» может сильно облегчить вычисления и даже способствовать вашему самообразованию. Чем, по вашему, изучение отличается от заучивания? Верно, тем что вы сами все проверяете и подвергаете критике.
Вещественные числа (float)
Наверное, было бы правильнее называть эти числа числами с плавающей точкой нежели вещественными, но в принципе, с определенной натяжкой, можно сказать, что это, как бы одно и тоже. Давайте разберемся почему.
В качестве примера возьмем число \(\sqrt<2>\), которое является вещественным потому что мы никогда не сможем выразить его с помощью обыкновенной дроби. А если мы все-таки извлечем корень из двойки, то обнаружим, что это бесконечная десятичная дробь. Но вычислив этот корень на Python:
мы увидим, что никакой бесконечной дробью и не пахнет. Python вернул только начало этой дроби, а все остальное отбросил, т.е. он вернул число с плавающей точкой, которое как бы и соответствует вещественному числу, но с определенной погрешностью.
На самом деле, работая с числами с плавающей точкой, мы очень часто подразумеваем числа вещественные, например вот такое число \(\sqrt[77]<7>\), его мы увидим в виде конечной десятичной дроби:
А число \(7^<-77>\) в виде мантисы \(8.461569363277291\) (опять же конечной десятичной дроби) и порядка \(-66\):
Кстати, можно было бы подумать, что 8.461569363277291*10**(-66) вернет результат идентичный предыдущему, но:
Отличие настолько незначительное, что для нас оно становится абсолютно неважным. Возможно, поэтому числа типа float в Python все чаще называют вещественными, а не числами с плавающей точкой. Возможно, потому что так короче, хотя и не так как кажется:
А может, потому что в нашей стране все меньше инженеров и прочих физиков-ядерщиков, для которых «какие-то» погрешности принципиально важны. Незнаю.
В общем важно то, что тип float это тип чисел с погрешностью, чисел с ограниченной точностью. И этой точности нам более чем достаточно. Но существуют исключения из правил – ситуации, в которых и пятый и даже миллионный знак после запятой может оказаться очень важен. А бывают даже такие ситуации, когда мы вообще не можем пользоваться десятичными дробями (вещественными числами).
Комплексные числа (complex)
Единственная область где могут пригодиться комплексные числа – это наука, как теоретическая, так и прикладная. Причем, если понаблюдать за теоретиками, то можно заметить, что они, вполне себе, обходятся бумагой и ручкой, а вот прикладники часто, очень часто что-то считают на компьютерах. Причем, комплексные числа нет-нет да появятся, то тут то там. В принципе, раз это надо только ученым, то пусть сами и выкручиваются – они же умные. «Хм. ну так-то я и есть ученый и как бы даже математик» подумал (наверное) создатель языка Гвидо Ван Россум и добавил в Python комплексные числа.
Раз поддерживаются комплексные числа, следовательно, поддерживаются и математические операции над комплексными числами, так что если вам вдруг понадобится вычислить, значение какой нибудь комлексной функции, например такой:
при \(z=1+1j\), то знайте – в этом нет ничего сложного:
Десятичные дроби (Decimal)
Числа данного типа позволяют производить вычисления над десятичными дробями с заданной точностью. Возможно, вы сразу задались вопросом: «А разве типом float мы обойтись не можем? Ведь это как бы и десятичные дроби, а погрешности при вычислениях с ними, настолько ничтожны, что мы можем вообще не обращать на них внимания.» Чтож, вполне обоснованное замечание, но давайте посмотрим вот на такой пример:
Должно получиться ровно \(0.4\) а получилось \(0.39999999999999997\). Конечно, как вы сказали: на такую погрешность можно вообще не обращать внимания, но как минимум, такой результат сложения кажется странным сам по себе. Ну в самом деле, разве это так трудно правильно сложить? Дело в том, что компьютер использует двоичную арифметику, над числами в двоичном представлении, а конечная десятичная дробь, в двоичном представлении может оказаться бесконечной, бесконечный «хвост» которой и отбрасывается при вычислениях, что в свою очередь и приводит к таким «ничтожным» погрешностям.
Но, как говорится «Дьявол кроется в мелочах» Очень неприятным последствием таких «ничтожно-маленьких» погрешностей является то, что вы не можете точно проверить истинность равенства:
Потому что с точки зрения компьютера:
А в финансовой и бухгалтерской среде подобные логические проверки выполняются постоянно.
Вторым неприятным последствием становится то, что погрешности имеют свойство накопления. Расмотрим простой пример:
Потребность в повышенной точности, возникает очень редко, но возникает неспроста. Именно эту потребность и призваны удовлетворить числа типа Decimal. Этот тип не является встроенным, а предоставляется модулем Decimal из стандартной библиотеки Python:
Причем точность может быть настолько большой, насколько позволяет мощность компьютера. Допустим, мы хотим видеть результат с точностью \(80\) знаков после запятой (хотя можем увидеть и \(1000\)), вот они:
Хотелось бы думать, что такая точность доступна абсолютно для всех математических операций и функций, например таких как всякие синусы, косинусы или даже Γ, Β, G, K функции и прочая экзотика. Но нет, слишком хорошо – тоже не хорошо. К тому же все эти и другие функции могут быть получены с помощью базовых математических операций, которые модулем Decimal прекрасно поддерживаются, например:
Обыкновенные дроби (Fraction)
Честно говоря без чисел типа Fraction можно легко обойтись, но из примера видно, что данный модуль выполнил сокращение числителя и знаменателя автоматически, что довольно любопытно и наводит на вопрос «А где бы мне это могло пригодиться?». Самый очевидный ответ – числовые ряды и пределы. Для примера рассмотрим ряд Лейбница, который сходится к \(\pi/4\) (правда медленно. ооочень медленно сходится):
Или посмотреть на поведение вот такого предела:
который тоже можно выразить с помощью чисел типа fractions:
Мы можем проделать тоже самое, полагаясь только на встроенные типы чисел, но результат будет не так приятен глазу: