Как вводить нецелые числа в питоне

Работа с числами в Python

В этом материале рассмотрим работу с числами в Python. Установите последнюю версию этого языка программирования и используйте IDE для работы с кодом, например, Visual Studio Code.

В Python достаточно просто работать с числами, ведь сам язык является простым и одновременно мощным. Он поддерживает всего три числовых типа:

• int (целые числа)
• float (числа с плавающей точкой)
• complex (комплексные числа)

Хотя int и float присутствуют в большинстве других языков программирования, наличие типа комплексных чисел — уникальная особенность Python. Теперь рассмотрим в деталях каждый из типов.

Целые и числа с плавающей точкой в Python

В программирование целые числа — это те, что лишены плавающей точкой, например, 1, 10, -1, 0 и так далее. Числа с плавающей точкой — это, например, 1.0, 6.1 и так далее.

Создание int и float чисел

Для создания целого числа нужно присвоить соответствующее значение переменной. Возьмем в качестве примера следующий код:

var1 = 25

Здесь мы присваиваем значение 25 переменной var1 . Важно не использовать одинарные или двойные кавычки при создании чисел, поскольку они отвечают за представление строк. Рассмотрим следующий код.

 
var1 = "25" 
# или 
var1 = '25' 

В этих случаях данные представлены как строки, поэтому не могут быть обработаны так, как требуется. Для создания числа с плавающей точкой, типа float , нужно аналогичным образом присвоить значение переменной.
var1 = 0.001
Здесь также не стоит использовать кавычки.
Проверить тип данных переменной можно с помощью встроенной функции type() . Можете проверить результат выполнения, скопировав этот код в свою IDE.
 
var1 = 1 # создание int 
var2 = 1.10 # создание float 
var3 = "1.10" # создание строки 
print(type(var1)) 
print(type(var2)) 
print(type(var3)) 

В Python также можно создавать крупные числа, но в таком случае нельзя использовать запятые.
 
# создание 1,000,000 
var1 = 1,000,000 # неправильно 

Если попытаться запустить этот код, то интерпретатор Python вернет ошибку. Для разделения значений целого числа используется нижнее подчеркивание. Вот пример корректного объявления.
 
# создание 1,000,000 
var1 = 1_000_000 # правильно 
print(var1) 

Значение выведем с помощью функции print :
1000000
Арифметические операции над целыми и числами с плавающей точкой
Используем такие арифметические операции, как сложение и вычитание, на числах. Для запуска этого кода откройте оболочку Python, введите python или python3 . Терминал должен выглядеть следующим образом:

Сложение
В Python сложение выполняется с помощью оператора + . В терминале Python выполните следующее.
Результатом будет сумма двух чисел, которая выведется в терминале.

Теперь запустим такой код.
>>> 1.0 + 2 3.0
В нем было выполнено сложение целого и числа с плавающей точкой. Можно обратить внимание на то, что результатом также является число с плавающей точкой. Таким образом сложение двух целых чисел дает целое число, но если хотя бы один из операндов является числом с плавающей точкой, то и результат станет такого же типа.
Вычитание
В Python для операции вычитания используется оператор -. Рассмотрим примеры.
>>> 3 - 1 2 >>> 1 - 5 -4 >>> 3.0 - 4.0 -1.0 >>> 3 - 1.0 2.0
Положительные числа получаются в случае вычитания маленького числа из более крупного. Если же из маленького наоборот вычесть большое, то результатом будет отрицательно число. По аналогии с операцией сложения при вычитании если один из операндов является числом с плавающей точкой, то и весь результат будет такого типа.
Умножение
Для умножения в Python применяется оператор * .
>>> 8 * 2 16 >>> 8.0 * 2 16.0 >>> 8.0 * 2.0 16.0
Если перемножить два целых числа, то результатом будет целое число. Если же использовать число с плавающей точкой, то результатом будет также число с плавающей точкой.
Деление
В Python деление выполняется с помощью оператора / .
>>> 3 / 1 3.0 >>> 4 / 2 2.0 >>> 3 / 2 1.5
В отличие от трех предыдущих операций при делении результатом всегда будет число с плавающей точкой. Также нужно помнить о том, что на 0 делить нельзя, иначе Python вернет ошибку ZeroDivisionError . Вот пример такого поведения.
>>> 1 / 0 Traceback (most recent call last): File "", line 1, in ZeroDivisionError: division by zero
Деление без остатка
При обычном делении с использованием оператора / результатом будет точное число с плавающей точкой. Но иногда достаточно получить лишь целую часть операции. Для этого есть операции интегрального деления. Стоит рассмотреть ее на примере.
>>> 2 // 1 2 >>> 4 // 3 1 >>> 5 // 2 2
Результатом такой операции становится частное. Остаток же можно получить с помощью модуля, о котором речь пойдет дальше.
Остаток от деления
Для получения остатка деления двух чисел используется оператор деления по модулю % .
>>> 5 % 2 1 >>> 4 % 2 0 >>> 3 % 2 1 >>> 5 % 3 2
На этих примерах видно, как это работает.
Возведение в степень
Число можно возвести в степень с помощью оператора ** .
>>> 3**2 9 >>> 2**4 16 >>> 3**3 27
Комплексные числа
Комплексные числа — это числа, которые включают мнимую часть. Python поддерживает их «из коробки». Их можно запросто создавать и использовать. Пример:
Как работать с числами с плавающей точкой в Python

К старту курса по Fullstack-разработке на Python делимся решениями классической проблемы неточности чисел с плавающей точкой. В материале вы найдёте примеры работы с функциями и классами, предназначенными специально для решения проблем чисел с плавающей точкой.
Числа с плавающей точкой — быстрый и эффективный способ хранения чисел и работы с ними. Но он связан с рядом трудностей для начинающих и опытных программистов! Вот классический пример:
>>> 0.1 + 0.2 == 0.3 False
Впервые увидев такое, можно растеряться. Такое поведение корректно! Поговорим о том, почему ошибки при операциях над числами с плавающей точкой так распространены, почему они возникают и как с ними справиться в Python.
Компьютер обманывает вас
Вы видели, что 0.1 + 0.2 не равно 0.3, но безумие на этом не заканчивается. Вот ещё пара примеров, сбивающих с толку:
>>> 0.2 + 0.2 + 0.2 == 0.6 False >>> 1.3 + 2.0 == 3.3 False >>> 1.2 + 2.4 + 3.6 == 7.2 False
Проблема касается и сравнения:
>>> 0.1 + 0.2 >> 10.4 + 20.8 > 31.2 True >>> 0.8 - 0.1 > 0.7 True
Что происходит? Когда вы вводите в интерпретатор Python число 0.1, оно сохраняется в памяти как число с плавающей точкой и происходит преобразование. 0.1 — это десятичное число с основанием 10, но числа с плавающей точкой хранятся в двоичной записи. То есть основание 0.1 преобразуется из 10 в 2.
Получающееся двоичное число может недостаточно точно представлять исходное число с основанием 10. 0.1 — один из примеров. Двоичным представлением будет 0.0(0011). То есть 0.1 — это бесконечно повторяющееся десятичное число, записанное с основанием 2. То же происходит, когда в виде десятичного числа с основанием 10 записывается дробь ⅓. Получается бесконечно повторяющееся десятичное число 0.3(3).
Память компьютера конечна, поэтому бесконечно повторяющееся представление двоичной дроби 0.1 округляется до конечной дроби. Её значение зависит от архитектуры компьютера (32- или 64-разрядная).
Увидеть значение с плавающей точкой, которое сохраняется для 0.1, можно с помощью метода .as_integer_ratio(). Представление с плавающей точкой состоит из числителя и знаменателя:
>>> numerator, denominator = (0.1).as_integer_ratio() >>> f"0.1 ≈ / " '0.1 ≈ 3602879701896397 / 36028797018963968'
Чтобы отобразить дробь с точностью до 55 знаков после запятой, используем format():
>>> format(numerator / denominator, ".55f") '0.1000000000000000055511151231257827021181583404541015625'
Так 0.1 округляется до числа чуть больше, чем его истинное значение.

Узнайте больше о числовых методах, подобных .as_integer_ratio(), в моей статье 3 Things You Might Not Know About Numbers in Python («3 факта о числах в Python, которые вы могли не знать»).

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

В числе больше значащих разрядов, чем позволяет плавающая точка.
Это иррациональное число.
Число рациональное, но без конечного двоичного представления.

64-разрядные числа с плавающей точкой имеют 16 или 17 значащих разрядов. Любое число, у которого значащих разрядов больше, округляется. Иррациональные числа, такие как π и e, нельзя представить конечной дробью с целочисленным основанием. И, опять же, иррациональные числа в любом случае округляются при сохранении в виде чисел с плавающей точкой.
В этих двух ситуациях создаётся бесконечный набор чисел, которые нельзя точно представить в виде числа с плавающей точкой. Но вы вряд ли столкнётесь с этими проблемами, не будучи химиком, имеющим дело с крошечными числами, или физиком — с астрономически большими числами.
А как на счёт бесконечных рациональных чисел, например 0.1 с основанием 2? Именно здесь вам встретится большинство связанных с плавающей точкой трудностей и благодаря математике — позволяющей определять, конечная дробь или нет, — вы будете сталкиваться с ошибками представления чаще, чем думаете.
С основанием 10 дробь можно представить как конечную, если её знаменатель — произведение степеней простых множителей 10. Два простых множителя 10 — это 2 и 5, поэтому дроби ½, ¼, ⅕, ⅛ и ⅒ — конечные, а ⅓, ⅐ и ⅑ — нет. У основания 2 только один простой множитель — 2.
Конечные дроби здесь только те, знаменатель которых равен степени числа 2. В результате дроби ⅓, ⅕, ⅙, ⅐, ⅑ и ⅒ — бесконечные, когда представлены в двоичной записи.
Теперь наш первый пример должен стать понятнее. 0.1, 0.2 и 0.3 при преобразовании в числа с плавающей точкой округляются:
>>> # -----------vvvv Display with 17 significant digits >>> format(0.1, ".17g") '0.10000000000000001' >>> format(0.2, ".17g") '0.20000000000000001' >>> format(0.3, ".17g") '0.29999999999999999'
При сложении 0.1 и 0.2 получается число чуть больше 0.3:
>>> 0.1 + 0.2 0.30000000000000004
А поскольку 0.1 + 0.2 чуть больше, чем 0.3, и 0.3 представлено числом, которое чуть меньше 0.3, выражение 0.1 + 0.2 == 0.3 оказывается False.
Об ошибке представления чисел с плавающей точкой должен знать каждый программист на любом языке — и уметь с ней справляться. Она характерна не только для Python. Результат вывода 0.1 + 0.2 на разных языках можно увидеть на сайте с подходящим названием 0.30000000000000004.com.
Как сравнивать числа с плавающей точкой в Python
Как же справляться с ошибками представления чисел с плавающей точкой при сравнении таких чисел в Python? Хитрость заключается в том, чтобы избегать проверки на равенство. Вместо ==, >= или 
>>> import math >>> math.isclose(0.1 + 0.2, 0.3) True
В math.isclose() проверяется, достаточно ли близок первый аргумент ко второму. То есть проверяется расстояние между двумя аргументами. Оно равно абсолютной величине разницы обоих значений:
>>> a = 0.1 + 0.2 >>> b = 0.3 >>> abs(a - b) 5.551115123125783e-17
Если abs(a - b) меньше некоего процента от большего значения a или b, то a считается достаточно близким к b, чтобы считаться «равным» b. Этот процент называется относительной погрешностью и указывается именованным аргументом rel_tol функции math.isclose(), который по умолчанию равен 1e-9.
То есть если abs(a - b) меньше 0.00000001 * max(abs(a), abs(b)), то a и b считаются «близкими» друг к другу. Это гарантирует, что a и b будут приблизительно с девятью знаками после запятой.
Если нужно, можно изменить относительную погрешность:
>>> math.isclose(0.1 + 0.2, 0.3, rel_tol=1e-20) False
Конечно, относительная погрешность зависит от ограничений задачи, но для большинства повседневных приложений стандартной относительной погрешности должно быть достаточно. Проблема возникает, если a или b равно нулю, а rel_tol меньше единицы. Тогда, как бы ни было близко ненулевое значение к нулю, относительной погрешностью гарантируется, что проверка на близость будет неудачной. В качестве запасного варианта здесь применяется абсолютная погрешность:
>>> # Relative check fails! >>> # ---------------vvvv Relative tolerance >>> # ----------------------vvvvv max(0, 1e-10) >>> abs(0 - 1e-10) < 1e-9 * 1e-10 False >>> # Absolute check works! >>> # ---------------vvvv Absolute tolerance >>> abs(0 - 1e-10) < 1e-9 True
В math.isclose() эта проверка выполняется автоматически. Абсолютная погрешность определяется с помощью именованного аргумента abs_tol. Но abs_tol по умолчанию равен 0.0, поэтому придётся задать его вручную, если нужно проверить близость значения к нулю.
В итоге в функции math.isclose() возвращается результат следующего сравнения — с относительными и абсолютными проверками в одном выражении:
abs(a - b) 

math.isclose() появилась в PEP 485 и доступна с Python 3.5.
Когда стоит использовать math.isclose()?
В целом math.isclose() следует применять, сравнивая значения с плавающей точкой. Заменим == на math.isclose():
>>> # Don't do this: >>> 0.1 + 0.2 == 0.3 False >>> # Do this instead: >>> math.isclose(0.1 + 0.2, 0.3) True
>>> a, b, c = 0.1, 0.2, 0.3 >>> # Don't do this: >>> a + b >> # Do this instead: >>> math.isclose(a + b, c) or (a + b < c) True
Есть альтернативы math.isclose(). Если вы работаете с NumPy, можете использовать numpy.allclose() и numpy.isclose():
>>> import numpy as np >>> # Use numpy.allclose() to check if two arrays are equal >>> # to each other within a tolerance. >>> np.allclose([1e10, 1e-7], [1.00001e10, 1e-8]) False >>> np.allclose([1e10, 1e-8], [1.00001e10, 1e-9]) True >>> # Use numpy.isclose() to check if the elements of two arrays >>> # are equal to each other within a tolerance >>> np.isclose([1e10, 1e-7], [1.00001e10, 1e-8]) array([ True, False]) >>> np.isclose([1e10, 1e-8], [1.00001e10, 1e-9]) array([ True, True])
Имейте в виду: стандартные относительные и абсолютные погрешности — не то же самое, что math.isclose(). Стандартная относительная погрешность для numpy.allclose() и numpy.isclose() равна 1e-05, а стандартная абсолютная погрешность — 1e-08.
math.isclose() особенно удобна для модульных тестов, хотя и здесь имеются альтернативы. Во встроенном модуле unittest в Python есть метод unittest.TestCase.assertAlmostEqual().
Но в нём применяется только проверка абсолютной разницы. А это ещё и утверждение, то есть при сбоях возникает ошибка AssertionError, из-за которой оно непригодно для сравнений в бизнес-логике.
Отличная альтернатива math.isclose() для модульного тестирования — это функция pytest.approx() из pytest pytest. Как и в math.isclose(), здесь принимаются два аргумента и возвращается, равны они или нет в пределах некой погрешности:
>>> import pytest >>> 0.1 + 0.2 == pytest.approx(0.3) True
Как и в math.isclose(), в pytest.approx() для задания относительной и абсолютной погрешностей есть именованные аргументы rel_tol и abs_tol. Но стандартные значения различаются. У rel_tol оно 1e-6, а у abs_tol — 1e-12.
Если первые переданные в pytest.approx() два аргумента подобны массиву (то есть это итерируемый объект Python, такой же, как список или кортеж или даже массив NumPy), тогда в pytest.approx() поведение подобно numpy.allclose() и возвращается то, равны эти два массива или нет в пределах погрешностей:
>>> import numpy as np >>> np.array([0.1, 0.2]) + np.array([0.2, 0.4]) == pytest.approx(np.array([0.3, 0.6])) True
Для pytest.approx() сгодятся даже значения словаря:
>>> == pytest.approx() True
Числа с плавающей точкой отлично подходят для работы с числами, когда абсолютная точность не требуется. Они быстры и эффективны с точки зрения потребления памяти. Но, если точность нужна, стоит рассмотреть ряд альтернатив числам с плавающей точкой.
Точные альтернативы числам с плавающей точкой
В Python есть два встроенных числовых типа, которые обеспечивают полную точность в ситуациях, когда числа с плавающей точкой не подходят: Decimal и Fraction.
Тип Decimal
В типе Decimal могут храниться десятичные значения именно с той точностью, какая нужна. По умолчанию в нём сохраняются 28 значащих цифр (это число можно изменить согласно конкретной решаемой задаче):
>>> # Import the Decimal type from the decimal module >>> from decimal import Decimal >>> # Values are represented exactly so no rounding error occurs >>> Decimal("0.1") + Decimal("0.2") == Decimal("0.3") True >>> # By default 28 significant figures are preserved >>> Decimal(1) / Decimal(7) Decimal('0.1428571428571428571428571429') >>> # You can change the significant figures if needed >>> from decimal import getcontext >>> getcontext().prec = 6 # Use 6 significant figures >>> Decimal(1) / Decimal(7) Decimal('0.142857')
Больше узнать о типе Decimal можно в документации Python.
Тип Fraction
Альтернатива числам с плавающей точкой — тип Fraction. В нём могут точно сохраняться рациональные числа. При этом устраняются проблемы с ошибками представления, возникающие в числах с плавающей точкой:
>>> # import the Fraction type from the fractions module >>> from fractions import Fraction >>> # Instantiate a Fraction with a numerator and denominator >>> Fraction(1, 10) Fraction(1, 10) >>> # Values are represented exactly so no rounding error occurs >>> Fraction(1, 10) + Fraction(2, 10) == Fraction(3, 10) True
У типов Fraction и Decimal много преимуществ по сравнению со стандартными значениями с плавающей точкой. Но есть и недостатки: меньшая скорость и повышенное потребление памяти.
Если абсолютная точность не нужна, лучше оставаться с числами с плавающей точкой. А вот в случае с финансовыми и критически важными приложениями эти недостатки типов Fraction и Decimal могут оказаться неприемлемыми.
Заключение
Значения с плавающей точкой — это и благо, и проклятие одновременно. Они обеспечивают быстрые арифметические операции и эффективное потребление памяти за счёт неточного представления. Из этой статьи вы узнали:

Почему числа с плавающей точкой неточны.
Почему ошибка представления с плавающей точкой типична.
Как корректно сравнивать значения с плавающей точкой.
Как точно представлять числа, используя типы Fraction и Decimal.

Узнайте о числах в Python ещё больше. Например, знаете ли вы, что int — не единственный целочисленный тип в Python? Узнайте, какой есть ещё, а также о других малоизвестных фактах о числах в моей статье.
А мы поможем вам прокачать скиллы или с самого начала освоить профессию, востребованную в любое время:

Профессия Fullstack-разработчик на Python
Профессия Data Analyst


 Краткий каталог курсов и профессий
Data Science и Machine Learning

Профессия Data Scientist
Профессия Data Analyst
Курс «Математика для Data Science»
Курс «Математика и Machine Learning для Data Science»
Курс по Data Engineering
Курс «Machine Learning и Deep Learning»
Курс по Machine Learning

Python, веб-разработка

Профессия Fullstack-разработчик на Python
Курс «Python для веб-разработки»
Профессия Frontend-разработчик
Профессия Веб-разработчик

Мобильная разработка

Профессия iOS-разработчик
Профессия Android-разработчик

Java и C#

Профессия Java-разработчик
Профессия QA-инженер на JAVA
Профессия C#-разработчик
Профессия Разработчик игр на Unity

От основ — в глубину

Курс «Алгоритмы и структуры данных»
Профессия C++ разработчик
Профессия Этичный хакер

А также
3 особенности чисел в Python, о которых вы, возможно, не знали
Если вы писали код на Python, то весьма высока вероятность того, что вы, хотя бы в одной из своих программ, пользовались числами. Например, это могли быть целые числа для указания индекса значения в списке, или числа с плавающей точкой, представляющие суммы в некоей валюте.

Но числа в Python — это гораздо больше, чем, собственно, их числовые значения. Поговорим о трёх особенностях чисел в Python, с которыми вы, возможно, не знакомы.
№1: у чисел есть методы
В Python практически всё — это объект. Один из первых объектов, о котором узнаёт тот, кто начинает изучать Python — это str , используемый для представления строк. Возможно, вы сталкивались с использованием методов строк, вроде .lower() , который возвращает новую строку, все символы которой приведены к нижнему регистру:
>>> "HELLO".lower() 'hello'
Числа в Python тоже, как и строки, являются объектами. У них тоже есть методы. Например, целое число можно преобразовать в байтовую строку с помощью метода .to_bytes() :
>>> n = 255 >>> n.to_bytes(length=2, byteorder="big") b'\x00\xff'
Параметр length указывает на количество байт, которые нужно использовать при составлении байтовой строки, а параметр byteorder определяет порядок байт. Например, установка параметра byteorder в значение «big» приводит к возврату байтовой строки, в которой старший байт расположен первым, а установка этого параметра в значение «little» приводит к тому, что первым идёт младший байт.
255 — это максимальное значение, которое может принимать 8-битное целое число. Поэтому в нашем случае при вызове метода .to_bytes() можно без проблем воспользоваться параметром length=1 :
>>> n.to_bytes(length=1, byteorder="big") b'\xff'
А вот если записать в n число 256 и вызвать для него . to_bytes() с параметром length=1 , будет выдана ошибка OverflowError :
>>> n = 256 >>> n.to_bytes(length=1, byteorder="big") Traceback (most recent call last): File "", line 1, in OverflowError: int too big to convert
Преобразовать байтовую строку в целое число можно, воспользовавшись методом .from_bytes() класса int :
>>> int.from_bytes(b'\x06\xc1', byteorder="big") 1729
Методы класса вызывают, используя имя класса, а не его экземпляр. Именно поэтому в предыдущем примере метод .from_bytes() вызывают, обращаясь к int .

Любопытный факт: 1729 — это самое маленькое положительное число, которое можно представить в виде суммы кубов двух положительных чисел двумя способами. Исторический анекдот связывает это число с индийским математиком Сринивасой Рамануджаном, который рассказал о нём своему наставнику Готфри Харолду Харди.
Харди часто навещал Рамануджана, когда тот, умирая, находился в больнице в Патни. Именно в одно из таких посещений произошёл «инцидент» с номером такси. Харди приехал в Патни на такси, воспользовавшись своим излюбленным транспортным средством. Он вошёл в палату, где лежал Рамануджан. Начинать разговор Харди всегда было мучительно трудно, и он произнёс свою первую фразу: «Если не ошибаюсь, то номер такси, на котором я приехал, 1729. Мне кажется, это скучное число». На что Рамануджан тотчас же ответил: «Нет, Харди! О нет! Это очень интересное число. Это самое малое из чисел, представимых в виде суммы двух кубов двумя различными способами».

Один из способов представления числа 1729 в виде суммы двух кубов — это 1 3 + 12 3 . Можете отыскать второй способ?
У чисел с плавающей точкой тоже есть методы. Возможно, самый полезный из них — это .is_integer() . Его используют для проверки того, есть ли у числа с плавающей точкой дробная часть:
>>> n = 2.0 >>> n.is_integer() True >>> n = 3.14 >>> n.is_integer() False
Вот — интересный метод .as_integer_ratio() . Он, вызванный для числа с плавающей точкой, возвращает кортеж, содержащий числитель и знаменатель дроби, представляющей это число:
>>> n.as_integer_ratio() (1, 2)
Правда, из-за ошибки представления чисел с плавающей точкой, иногда этот метод возвращает неожиданные результаты:
>>> n = 0.1 >>> n.as_integer_ratio() (3602879701896397, 36028797018963968)
Если надо — можно вызывать методы на числовых литералах, заключённых в круглые скобки:
>>> (255).to_bytes(length=1, byteorder="big") b'\xff' >>> (3.14).is_integer() False
Если обойтись без скобок — при попытке вызова метода на целочисленном литерале будет выдана ошибка SyntaxError . А вот при вызове метода числового литерала с плавающей точкой отсутствие скобок, что странно, не приведёт к ошибке:
>>> 255.to_bytes(length=1, byteorder="big") File "", line 1 255.to_bytes(length=1, byteorder="big") ^ SyntaxError: invalid syntax >>> 3.14.is_integer() False
Полный список методов числовых Python-типов можно найти в документации.
№2: числа обладают иерархией
В математике числа обладают естественной иерархией. Например, все натуральные числа являются целыми, а все целые числа — рациональными. Все рациональные числа — это вещественные числа, а все вещественные числа — это комплексные числа.
Похожие рассуждения применимы и к представлению чисел в Python. Здесь «числовая башня» выражается через абстрактные типы, содержащиеся в модуле numbers .
Числовая башня
Все числа в Python являются экземплярами класса Number :
>>> from numbers import Number >>> # Целые числа являются наследниками Number >>> isinstance(1729, Number) True >>> # Числа с плавающей точкой являются наследниками Number >>> isinstance(3.14, Number) True >>> # Комплексные числа являются наследниками Number >>> isinstance(1j, Number) True
Если нужно узнать о том, является ли некое Python-значение числовым, но при этом неважно то, каким именно числовым типом оно представлено, воспользуйтесь конструкцией isinstance(value, Number) .
В Python имеется четыре дополнительных абстрактных типа, иерархия которых, начиная с наиболее общего числового типа, выглядит так:

Класс Complex используется для представления комплексных чисел. Тут имеется один встроенный конкретный тип — complex .
Класс Real — это представление вещественных чисел. Его единственный встроенный конкретный тип — float .
Класс Rational представляет рациональные числа. Его единственным встроенным конкретным типом является Fraction .
Класс Integral применяют для представления целых чисел. В нём имеется два встроенных конкретных типа — int и bool .

Так, погодите, а значения типа bool — это разве числа? Да — числа. Можете это проверить, воспользовавшись REPL:
>>> import numbers >>> # Комплексные числа являются наследниками Complex >>> isinstance(1j, numbers.Complex) True >>> # Комплексные числа не являются наследниками Real >>> isinstance(1j, numbers.Real) False >>> # Числа с плавающей точкой являются наследниками Real >>> isinstance(3.14, numbers.Real) True >>> # Числа с плавающей точкой не являются наследниками Rational >>> isinstance(3.14, numbers.Rational) False >>> # Объекты Fractions - это не наследники Rational >>> from fractions import Fraction >>> isinstance(Fraction(1, 2), numbers.Rational) True >>> # Объекты Fractions - это не наследники Integral >>> isinstance(Fraction(1, 2), numbers.Integral) False >>> # Целые числа - это наследники Integral >>> isinstance(1729, numbers.Integral) True >>> # Логические значения - это наследники Integral >>> isinstance(True, numbers.Integral) True >>> True == 1 True >>> False == 0 True
Всё это, на первый взгляд, выглядит вполне нормально. Правда, порядок несколько нарушает то, что значения типа bool являются числами.
Странность Python: так как тип bool относится к классу Integral (на самом деле он — прямой наследник int ), со значениями True и False можно вытворять довольно необычные вещи.
Например, True можно использовать в роли индекса для того чтобы получить второй элемент итерируемого объекта. А если поделить число на False — будет выдана ошибка ZeroDivisionError .
Попробуйте выполнить «False»[True] и 1 / False в REPL!
Но если присмотреться к числовым типам поближе, окажется, что в иерархии Python-чисел имеется пара своеобразных моментов.
Числа типа Decimal не укладываются в иерархию
Как уже было сказано, в «числовой башне» Python есть 4 конкретных числовых типа, соответствующих четырём абстрактным типам: complex , float , Fraction и int . Но в Python имеется и пятый числовой тип, представленный классом Decimal . Этот тип используется для точного представления десятичных чисел и для преодоления ограничений арифметических операций с плавающей точкой.
Можно предположить, что числа типа Decimal являются наследниками Real , но это, на самом деле, не так:
>>> from decimal import Decimal >>> import numbers >>> isinstance(Decimal("3.14159"), numbers.Real) False
Единственный класс, наследником которого является класс Decimal — это Number :
>>> isinstance(Decimal("3.14159"), numbers.Complex) False >>> isinstance(Decimal("3.14159"), numbers.Rational) False >>> isinstance(Decimal("3.14159"), numbers.Integral) False >>> isinstance(Decimal("3.14159"), numbers.Number) True
Логично то, что класс Decimal не является наследником Integral . В некоторой степени смысл есть и в том, что Decimal не является наследником Rational . Но почему Decimal не является наследником Real или Complex ?

Объекты Decimal обладают всеми методами, определёнными в классе Real, но эти объекты не должны регистрироваться в виде наследников Real, так как Decimal-числа не взаимодействуют с двоичными числами с плавающей точкой (например, результат операции Decimal('3.14') + 2.71828 не определён). Но ожидается, что числа, классы которых являются наследниками абстрактного класса Real, способны взаимодействовать друг с другом (то есть — R1+R2 должно вычисляться в том случае, если числа R1 и R2 представлены типами, являющимися наследниками Real).

Получается, что объяснение странностей сводится к особенностям реализации.
Числа с плавающей точкой — странные создания
А вот числа с плавающей точкой, с другой стороны, реализуют абстрактный базовый класс Real . Они используются для представления вещественных чисел. Но, из-за того, что компьютерная память не является неограниченным ресурсом, числа с плавающей точкой — это лишь конечные аппроксимации вещественных чисел. Это приводит к возможности написания «ненормальных» образцов кода вроде такого:
>>> 0.1 + 0.1 + 0.1 == 0.3 False
Числа с плавающей точкой хранятся в памяти в виде двоичных дробей. Это приводит к появлению некоторых проблем. Например, у дроби 1/3 нет конечного десятичного представления (после десятичной точки идёт бесконечное множество троек). А у дроби 1/10 нет конечного представления в виде двоичной дроби.
Другими словами, в компьютере нельзя совершенно точно представить число 0,1 — если только этот компьютер не обладает бесконечной памятью.
Со строго математической точки зрения все числа с плавающей точкой — это рациональные числа, за исключением float(«inf») и float(«nan») . Но программисты используют их в роли аппроксимаций вещественных чисел и воспринимают их, по большей части, как вещественные числа.
Странность Python: float(«nan») — это особое значение с плавающей точкой, представляющее собой «не число». Такие значения часто обозначают как NaN . Но, так как float — это числовой тип, isinstance(float(«nan»), Number) возвращает True .
Получается, что «не числа» — это числа.
В общем, числа с плавающей точкой — странные создания.
№3: набор числовых типов Python можно расширять
Абстрактный числовой базовый тип Python позволяет программисту создавать собственные абстрактные и конкретные числовые типы.
В качестве примера рассмотрим класс ExtendedInteger , который реализует числа в форме a+b√p, где a и b — целые числа, а p — простое число (обратите внимание: класс не обеспечивает то, что число p является простым):
import math import numbers class ExtendedInteger(numbers.Real): def init(self, a, b, p = 2) -> None: self.a = a self.b = b self.p = p self._val = a + (b * math.sqrt(p)) def repr(self): return f"(, , )" def str(self): return f" + √" def trunc(self): return int(self._val) def float(self): return float(self._val) def hash(self): return hash(float(self._val)) def floor(self): return math.floor(self._val) def ceil(self): return math.ceil(self._val) def round(self, ndigits=None): return round(self._val, ndigits=ndigits) def abs(self): return abs(self._val) def floordiv(self, other): return self._val // other def rfloordiv(self, other): return other // self._val def truediv(self, other): return self._val / other def rtruediv(self, other): return other / self._val def mod(self, other): return self._val % other def rmod(self, other): return other % self._val def lt(self, other): return self._val < other def le(self, other): return self._val 

Для того чтобы обеспечить правильность реализации интерфейса Real конкретным типом — нужно создать реализации множества методов, в именах которых есть два символа подчёркивания. Ещё нужно поразмыслить о том, как методы вроде .add() и .mul() взаимодействуют с другими типами, являющимися наследниками Real .

Обратите внимание: вышеприведённый пример не создавался в расчёте на его полноту или абсолютную правильность. Его цель — продемонстрировать читателю возможности работы с числами.

При наличии реализации ExtendedInteger можно заниматься следующими вычислениями:
>>> a = ExtendedInteger(1, 2) >>> b = ExtendedInteger(2, 3) >>> a ExtendedInteger(1, 2, 2) >>> # Проверяем то, что a - это наследник Number >>> isinstance(a, numbers.Number) True >>> # Проверяем то, что a - это наследник Real >>> isinstance(a, numbers.Real) True >>> print(a) 1 + 2√2 >>> a * b ExtendedInteger(14, 7, 2) >>> print(a * b) 14 + 7√2 >>> float(a) 3.8284271247461903
Иерархия числовых типов в Python — довольно гибкая структура. Но, конечно, всегда стоит очень внимательно относиться к реализации типов, являющихся наследниками встроенных абстрактных базовых типов Python. Нужно обеспечить их корректную работу друг с другом.
В документации по Python можно найти несколько советов по реализации собственных типов, которые стоит прочесть тому, кто решит заняться созданием собственных числовых типов. Такому человеку ещё полезно будет ознакомиться с реализацией Fraction .
Итоги
Вот — те три особенности Python-чисел, которые мы здесь обсуждали:

У чисел есть методы, как и у практически всех остальных объектов в Python.
Числа обладают иерархией, даже несмотря на то, что их чёткие взаимоотношения несколько портит наличие типов Decimal и float .
Программисты могут создавать собственные числовые типы, которые вписываются в иерархию числовых типов Python.

Может быть, вы узнали из этого материала не только об этих особенностях чисел, но и ещё о чём-нибудь, что вам пригодится.
О, а приходите к нам работать? ��
Мы в wunderfund.io занимаемся высокочастотной алготорговлей с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.
Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.
Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.
"Случайные" числа в Python – random, randint и randrange
В компьютерных программах нередко требуется эмуляция случайности. Например, при разработке игр. Если в программе имеется некий генератор, то есть производитель, случайного числа, то, используя полученное таким образом число, можно выбирать ту или иную ветку выполнения программы, или произвольный объект из коллекции. Другими словами, главное – сгенерировать число. Эмуляция случайности иного рода основывается на нем.
Мы наверняка не знаем, есть ли в природе случайность, или она нам только кажется из-за ограниченности наших знаний. Мы только знаем, что в программировании настоящей случайности нет. Неоткуда взяться произвольному числу, нельзя запрограммировать его появление из ниоткуда. Можно лишь создать программу, которая в результате применения сложной формулы к "зерну" будет выдавать число, и нам будет казаться, что это число случайно.
"Зерно" – это исходные данные для формулы. Им может быть, например, системное время в миллисекундах, которое постоянно меняется. Следовательно, "зерно" будет постоянно разным. Или программист может задавать его самостоятельно.
Подобную программу (в реальности модуль или функцию) называют генератором псевдослучайных чисел. В состав стандартной библиотеки языка Python входит модуль random . Он содержит множество функций, связанных с эмуляцией случайности (например, "перемешивание" элементов последовательности), а не только функции генерации псевдослучайных чисел.
В этом уроке будут рассмотрены функции random() , randrange() и randint() из модуля random . Обратите внимание, что модуль random содержит одноименную функцию random() . Так бывает.
Чтобы обращаться к функциям, надо импортировать модуль random :
>>> import random
Или импортировать отдельные функции из него:
>>> from random import random, randrange, randint
Функции для получения целых "случайных" чисел – randint() и randrange()
Функции randint() и randrange() генерируют псевдослучайные целые числа. Первая из них наиболее простая и всегда принимает только два аргумента – пределы целочисленного диапазона, из которого выбирается любое число:
>>> random.randint(0, 10) 6
или (если импортировались отдельные функции):
>>> randint(100, 200) 110
В случае randint() обе границы включаются в диапазон, т. е. на языке математики отрезок описывается как [a; b].
Числа могут быть отрицательными:
>>> random.randint(-100, 10) -83 >>> random.randint(-100, -10) -38
Но первое число всегда должно быть меньше или, по-крайней мере, равно второму. То есть a 
Функция randrange() сложнее. Она может принимать один аргумент, два или даже три. Если указан только один, то она возвращает случайное число от 0 до указанного аргумента. Причем сам аргумент в диапазон не входит. На языке математики – это [0; a).
>>> random.randrange(10) 4
>>> randrange(5) 0
Если в randrange() передается два аргумента, то она работает аналогично randint() за одним исключением. Верхняя граница не входит в диапазон, т. е. [a; b).
>>> random.randrange(5, 10) 9 >>> random.randrange(1, 2) 1
Здесь результатом второго вызова всегда будет число 1.
Если в randrange() передается три аргумента, то первые два – это границы диапазона, как в случае с двумя аргументами, а третий – так называемый шаг. Если, например, функция вызывается как randrange(10, 20, 3) , то "случайное" число будет выбираться из чисел 10, 13, 16, 19:
>>> random.randrange(10, 20, 3) 13 >>> random.randrange(10, 20, 3) 19 >>> random.randrange(10, 20, 3) 10
Функция random() – "случайные" вещественные числа
Чтобы получить случайное вещественное число, или, как говорят, число с плавающей точкой, следует использовать функцию random() из одноименного модуля random языка Python. Она не принимает никаких аргументов и возвращает число от 0 до 1, не включая 1:
>>> random.random() 0.17855729241927576 >>> random.random() 0.3310978930421846
>>> random() 0.025328854415995194
Результат содержит много знаков после запятой. Чтобы его округлить, можно воспользоваться встроенной в Python функцией round() :
>>> a = random.random() >>> a 0.8366142721623201 >>> round(a, 2) 0.84 >>> round(random.random(), 3) 0.629
Чтобы получать случайные вещественные числа в иных пределах, отличных от [0; 1), прибегают к математическим приемам. Так если умножить полученное из random() число на любое целое, то получится вещественное в диапазоне от 0 до этого целого, не включая его:
>>> random.random() * 10 2.510618091637596 >>> random.random() * 10 6.977540211221759
Если нижняя граница должна быть отличной от нуля, то число из random() надо умножать на разницу между верхней и нижней границами, после чего прибавить нижнюю:
>>> random.random() * (10 - 4) + 4 9.517280589233597 >>> random.random() * (10 - 4) + 4 6.4429124181215975 >>> random.random() * (10 - 4) + 4 4.9231983600782385
В данном примере число умножается на 6. В результате получается число от 0 до 6. Прибавив 4, получаем число от 4 до 10.
Пример получения случайных чисел от -1 до 1:
>>> random.random() * (1 + 1) - 1 -0.673382618351051 >>> random.random() * (1 + 1) - 1 0.34121487148075924 >>> random.random() * (1 + 1) - 1 -0.988751324713907 >>> random.random() * (1 + 1) - 1 0.44137358363477674
Нижняя граница равна -1. При вычитании получается +. Когда добавляется нижняя граница, то плюс заменяется на минус ( +(-1) = - 1).
Для получения псевдослучайных чисел можно пользоваться исключительно функцией random() . Если требуется получить целое, то всегда можно округлить до него с помощью round() или отбросить дробную часть с помощью int() :
>>> int(random.random() * 100) 61 >>> round(random.random() * 100 - 50) -33
Практическая работа

Используя функцию randrange() получите псевдослучайное четное число в пределах от 6 до 12. Также получите число кратное пяти в пределах от 5 до 100.
Напишите программу, которая запрашивает у пользователя границы диапазона и какое (целое или вещественное) число он хочет получить. Выводит на экран подходящее случайное число.

Примеры решения и дополнительные уроки в pdf-версии курса
X Скрыть Наверх
Python. Введение в программирование
Читать:
Как сделать титры в сони вегас про 13