Числа

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

Целые числа

Целые числа в Python представлены типом int (от англ. integer – целое число). Они широко используются в математике и программировании для представления количественных величин, порядковых номеров и многого другого.

Создать переменную целочисленного типа очень просто: достаточно присвоить ей целое числовое значение:

students = 40
age = 29

Системы счисления

По умолчанию целые числа в Python интерпретируются как десятичные (используются цифры 0-9). Однако с помощью специальных префиксов можно задавать целые числа в других системах счисления.

Используем специальные префиксы и создадим целые числа в двоичной, восьмеричной и шестнадцатеричной системах счисления:

binary_number = 0b101101
octal_number = 0o173
hexadecimal_number = 0xA9

А теперь воспользуемся функциями перевода в двоичную, восьмеричную и шестнадцатеричную системы счисления для преобразования числа 24:

print(bin(24)) 
# Вывод: 0b11000
print(oct(24))
# Вывод: 0o30
print(hex(24)) 
# Вывод: 0x18

При этом функции bin(), oct() и hex() возвращают строки, которые начинаются с одного из префиксов, обозначающих систему счисления (0b, 0o, 0x):

print(type(bin(42)))
# Вывод: <class 'str'>

Преобразование в целое число

В целое число можно преобразовать как строку, содержащую число, так и число с плавающей точкой, то есть вещественное число с дробной частью. Для этого в Python предназначена функция int().

Отсутствие пробелов в base=10 не является ошибкой или опечаткой. Согласно PEP 8, при присваивании значения параметру функции не следует ставить пробелы до и после знака =. Поэтому если base является параметром функции, пробелы не ставятся, но если вы создаёте переменную с именем base, то вокруг оператора присваивания должно быть по одному пробелу.

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

number = int("224")
print(number + 1)
# Вывод: 225
print(type(number))  
# Вывод: <class 'int'>

Если строку нельзя преобразовать в целое число, то это приведёт к ошибке ValueError:

number = int("Число 457")
# Ошибка: ValueError: invalid literal for int() with base 10: 'Число 457'

При этом знак «минус» у отрицательных чисел обрабатывается корректно:

number = int("-65")
print(type(number))  
# Вывод: <class 'int'>

Если строка содержит число в другой системе счисления, необходимо указывать её основание с помощью параметра base. Однако строка с таким числом не должна содержать префикс системы счисления:

print(int("11101001", base=2)) 
# Вывод: 233
print(int("723", base=8))
# Вывод: 467
print(int("A37", base=16)) 
# Вывод: 2615

Если строка с числом содержит префикс (например, 0b101), то параметр base не указывается, иначе это приведет к ошибке ValueError:

print(int(0b100101)) 
# Вывод: 37
print(int(0o272))  
# Вывод: 186
print(int(0x102B)) 
# Вывод: 4139

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

print(int(1.2)) 
# Вывод: 1
print(int(72.9)) 
# Вывод: 72

Неограниченность диапазона целых чисел

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

n = 78446744073709551615

Для улучшения читаемости больших чисел в коде можно использовать символ подчеркивания (_) в качестве разделителя тысяч (или любой другой группы разрядов). Python игнорирует эти подчеркивания при интерпретации числа:

n = 78_446_744_073_709_551_615
print(n) 
# Вывод: 78446744073709551615

Числа с плавающей точкой

Числа с плавающей точкой в Python – это вещественные числа, имеющие дробную часть. Они представлены типом данных float (от англ. floating-point arithmetic – арифметика с плавающей точкой).

Создать переменную типа float можно, присвоив ей число с десятичной точкой:

score = 0.54

Даже целое число можно представить в виде числа с плавающей точкой, добавив значимый ноль после точки:

weight = 68.0

Такой ноль не влияет на значение числа, но указывает на определенную точность его представления.

Плавающая точка

Название «число с плавающей точкой» связано с особым способом хранения дробных значений в памяти компьютера. В отличие от целых чисел, где позиция каждой цифры фиксирована (например, в числе 123, цифра 2 всегда означает число 20), в числах с плавающей точкой десятичная точка может «плавать» или перемещаться.

Представьте, что вы хотите записать очень большое число, например, приблизительную скорость света в метрах в секунду (300 000 000), или очень маленькое число, например, заряд электрона в кулонах (0.00000000000000000016).

Если бы компьютер хранил эти числа так, как мы их пишем, потребовалось бы очень много места для нулей. Вместо этого, числа с плавающей точкой хранятся в виде двух основных компонентов:

• Мантисса – это значащая часть числа, содержит само число без учета его порядка (количества нулей).
• Порядок – это число, которое указывает, насколько сильно нужно «сдвинуть» десятичную точку в мантиссе. По сути, это степень числа 10 (или 2 для компьютеров), на которую умножается мантисса.

Тогда число 300 000 000 может быть записано как 3 × 10⁸, а число 0.00000000000000000016 как 1.6 × 10⁻¹⁹, где числа 3 и 1.6 – мантиссы, а числа 8 и -19 – порядки. Такая запись числа называют экспоненциальной, а порядок или степень числа 10 называют экспонентой.

Однако при неизменной мантиссе, например, 3, можно представить и другие числа – 0.0003 как 3 × 10^-4 или 3000000 как 3 × 10⁶. То есть «плавающая точка» означает, что положение десятичной точки не фиксировано, а определяется порядком. Такой подход позволяет компьютерам эффективно хранить такие числа и выполнять вычисления над ними.

Преобразование в число с плавающей точкой

Как и в целое число, в число с плавающей точкой можно преобразовать строку, содержащую число, или целое число. Для этого предназначена функция float().

Переведём несколько чисел из строкового типа в тип числа с плавающей точкой:

print(float("2.57")) 
# Вывод: 2.57
print(float("-12.5679")) 
# Вывод: -12.5679

Целые числа так же можно преобразовать в вещественные:

print(float(2)) 
# Вывод: 2.0
print(float(10)) 
# Вывод: 10.0

В таком случае к числу просто будет добавлен значимый ноль.

Экспоненциальная запись чисел с плавающей точкой

В Python числа с плавающей точкой можно представлять в виде экспоненциальной записи. Для этого используется символ экспоненты e (или E), означающий «умножить на 10 в степени».

Например, рассмотрим следующие переменные:

point = 0.0000000014
radius = 2100000000

Экспоненциальная запись сделает их значения более наглядными, так как позволит сразу оценить размер числа и количество нулей:

point = 1.4e-9
radius = 2.1e9

Такая запись чисел в Python включает в себя следующие части:

• Мантисса – десятичное число, например, 4 или 2.1.
• Символ экспоненты – e или E.
• Порядок или показатель степени – целое число, указывающее степень, в которую возводится число 10, например, 9 или -9.

Поэтому число 1.4e-9 означает 1.4 × 10⁻⁹, а число 2.1e9 – это 2.1 × 10⁹.

Точность вычислений с плавающей точкой

Хотя числа с плавающей точкой удобны для представления широкого диапазона значений, они имеют свою специфику, связанную с точностью. Из-за того, что компьютеры хранят эти числа в двоичной системе (основание 2), а не в десятичной (основание 10), не все десятичные дроби могут быть представлены с достаточной точностью.

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

print(0.1 + 0.2)
# Вывод: 0.30000000000000004

Здесь мы ожидаем увидеть число 0.3, но из-за особенностей вычислений с плавающей точкой мы видим число 0.30000000000000004.

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

Примеры

Пример 1. Управление данными в системе учета товаров

В системе инвентаризации товары имеют уникальные идентификаторы, которые должны быть переведены в различные форматы, например, для печати штрихкода или этикеток:

# ID товара в десятичной системе счисления
product_id_decimal = 65535
print("Десятичный код товара:", product_id_decimal)
 
# Переведём ID товара в двоичный формат для штрихкода
binary_code_str = bin(product_id_decimal)
print("Двоичный код товара:", binary_code_str)
 
# Переведём ID товара в шестнадцатеричный формат для печати этикеток
hex_representation = hex(product_id_decimal)
print(f"Шестнадцатеричный код товара:", hex_representation)

Вывод:

Десятичный код товара: 65535
Двоичный код товара: 0b1111111111111111
Шестнадцатеричный код товара: 0xffff
Очень большой инвентарный номер: 987654321098765432109876543210

Пример 2. Анализ научных данных

В научных исследованиях часто приходится работать с очень большими или очень маленькими числами, такими как расстояние до звезд или размеры молекул, которые более наглядны в экспоненциальной записи:

# Приблизительное расстояние до Проксима Центавра в метрах
star_distance = 4.011e16  # 4.011 x 10^16 метров
print("Расстояние до Проксимы Центавра (м):", star_distance)
 
# Приблизительный диаметр молекулы воды в метрах
water_diameter = 2.75e-10 # 2.75 x 10^-10 метров
print("Диаметр молекулы воды (м):", water_diameter)
 
# Преобразуем числа с плавающей точкой в целочисленный тип
star_distance_int = int(star_distance)  # Дробная часть отбрасывается
print("Расстояние до Проксимы Центавра (м, целое число):", star_distance_int)
water_diameter_int = int(water_diameter)
print("Диаметр молекулы воды (м, целое число):", water_diameter_int)

Вывод:

Расстояние до Проксимы Центавра (м): 4.011e+16
Диаметр молекулы воды (м): 2.75e-10
Расстояние до Проксимы Центавра (м, целое число): 40110000000000000
Диаметр молекулы воды (м, целое число): 0

Итоги

• Python поддерживает различные числовые типы данных: целые числа, числа с плавающей точкой (дробные) и комплексные числа.
• Целые числа по умолчанию представлены в десятичной системе счисления, но их можно задавать в двоичной, восьмеричной и шестнадцатеричной системах счисления. Функции bin(), oct() и hex() преобразуют десятичные числа в строки соответствующей системы.
• Диапазон целых чисел в Python практически неограничен и зависит от доступной памяти.
• Числа с плавающей точкой хранятся в компьютере в виде мантиссы и порядка. Мантисса представляет собой значение числа, а порядок – степень, в которую возводится основание системы счисления (обычно 2 для компьютеров).
• Числа с плавающей точкой могут испытывать проблемы с точностью из-за способа их представления в компьютере.
• Числа с плавающей точкой можно записывать в экспоненциальной форме с помощью символа e (или E), означающего «умножить на 10 в степени».
• Функция int() преобразует другое число или строку в целое число.
• Функция float() преобразует другое число или строку в число с плавающей точкой.

Задания для самопроверки

1. Каким типом данных представлены результаты перевода числа из десятичной системы счисления в другую с помощью функций bin(), oct() и hex()?

2. Что будет выведено на экран в результате выполнения данного кода?

print(int(12.1))
print(int(9.99))

12
9

3. Какому типу данных соответствуют дробные числа?

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

x = 12000000000
y = 0.00000071

x = 1.2e+10
y = 7.1e-7

5. Что делает функция float()?