Деление в Python

Сегодня поговорим об одной из основных встроенных возможностей языка Python — о делении. Разберём, как и что можно и нельзя делить и какие вообще есть виды деления.

Зачем в программировании математика

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

Если учить математику до программирования, хуже точно не станет. Работа с большим количеством абстрактных вещей иногда вводит разработчика-новичка в ступор, а математика заранее подготовит мозги к тому, что некоторые вещи нельзя ни потрогать, ни увидеть, ни услышать — даже представить их часто невозможно.

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

Язык Python и его встроенные возможности

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

Есть три типа чисел.

Int — целые положительные и отрицательные числа и ноль.

По умолчанию Python распознаёт все числа в десятичной системе, но ещё умеет работать в двоичной, восьмеричной и шестнадцатеричной. Для этого нужно поставить перед числом соответствующее обозначение — 0b для двоичной системы, 0o для восьмеричной и 0x для шестнадцатеричной. Выглядит так:

# бинарный (двоичный) формат
b = 0b11011000 

# восьмеричный
o = 0o12 

# шестнадцатеричный
h = 0x12 

В десятичной системе можно разделять разряды числа нижним подчёркиванием. Тогда можно сразу видеть разряды:

x = 1_987_654_000

Float — вещественные положительные и отрицательные числа с плавающей точкой. Float-числа могут быть указаны в обычном виде или через научную нотацию с использованием буквы e или E, что указывает на умножение на 10 в определённой степени. 

Если записывать числа через научную нотацию, точка может менять своё место, то есть «плавать»: 1.234567e4 — это то же самое, что 1,234567 × 10^4, или 12345,67. 

Другие примеры:

# обычный ввод
f = 1.5

# ввод с разделением разрядов
f = 12_345.678_999

# запись в научной нотации
# такая запись означает 2 * 10 в 400-й степени:
f = 2e400

Complex — комплексные числа, которые получаются по такой формуле:

c = a + b*i

Что входит в формулу:

Оператор деления и операнды

Деление в Python делит одно число на другое и выдаёт результат. Всё как в школе.

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

Вот какие термины нам ещё понадобятся, чтобы дальше было проще:

Обычное деление

Начнём с обычного, классического деления. В Python оно ещё называется «истинное».

Обычное деление обозначается одной косой чертой:

# определяем две переменные
x = 99
y = 11
# выводим на экран результат деления
print(x / y)

В результате в консоли получим:

9.0

Обратите внимание, что мы получили число формата float. Так работает обычное деление — результатом всегда будет вещественное число.

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

# определяем две переменные
x = 1
y = 10
# сохраняем в третью переменную результат деления
z = x / y
# выводим на экран результат деления
# с точностью 30 знаков после запятой
print(f"{z:.30f}")

В консоли после запуска получаем:

0.100000000000000005551115123126

Так происходит потому, что числа с точкой сохраняются по стандарту IEEE 754, который использует формат двоичных чисел для хранения данных. Но не все десятичные дроби могут быть сохранены в двоичном формате точно — только те, которые представляют собой сумму степеней двойки. Например, 1/2, 1/4, 1/8 будут записаны в памяти точно. А остальные дроби компьютер сохраняет как их приближённые значения, которые немного отличаются от реальных.

Целочисленное деление

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

Оператор целочисленного деления обозначается двумя косыми линиями:

# определяем две переменные
x = 1234
y = 100
# выводим на экран результат деления
print(x // y)

В консоли получаем:

12

Когда компьютер будет выполнять эту операцию, сохранит только целое количество делителей, а остаток отбросит. Результат сохраняется в формате int, если все операнды тоже относятся к этому типу, и в формате float — если хотя бы один из них тоже типа float.

До появления Python версии 3 истинное деление / работало как целочисленное: остаток отбрасывался, а результат сохранялся в формате int. Но такое деление могло приводить к неожиданным результатам и зависело от типов операндов. Поэтому сейчас для разных типов делений используются разные операторы.

Деление по модулю для нахождения остатка

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

В предыдущем примере мы могли понять, сколько целых рублей получится из 1 234 копеек:

# определяем две переменные
x = 1234
y = 100
# выводим на экран результат деления — получится 12
print(x // y)

Делением по модулю мы выясним, сколько копеек у нас останется после размена:

# определяем две переменные
x = 1234
y = 100
# выводим на экран результат деления
print(x % y)

Результат в консоли:

34

Этим можно воспользоваться, например, для проверки чётности и нечётности числа:

# объявляем число
num = 12345

# если оно делится на 2 без остатка, то число чётное
if num % 2 == 0:
   print('Число чётное')
# если не делится без остатка, то нечётное
else:
   print('Число нечётное')

В примере выше мы для простоты сами задаём число, но в реальной программе будем получать его в результате каких-то предыдущих действий. Например, его может вводить пользователь.

Как и при целочисленном делении, результат деления по модулю может быть дробным числом с плавающей точкой, если делимое — число типа float.

Проверка на чётность позволяет чередовать действия и фильтровать данные. Например, можно сделать так, чтобы чётные задачи из списка уходили одному человеку, а нечётные — другому. Но на этом полезные действия этой операции не заканчиваются, всё ограничивается только фантазией и опытом.

Деление на ноль

В обычной математике на ноль делить нельзя. В программировании, как правило, тоже.

В Python ни один тип деления не разрешает деление на ноль. При попытке подставить вместо делителя ноль в консоли получим ошибку:

ZeroDivisionError: division by zero

После этого выполнение программы остановится.

Можно заранее предусмотреть неправильный ввод, чтобы программа продолжала работать. Это можно сделать через блок try except, когда скрипт пробует выполнить команду, а если что-то идёт не так, то действует по заданному сценарию.

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

numbers = [10, 5, 0, 8]
divider = 0

for num in numbers:
    try:
        result = num / divider
        print(f"Результат деления {num} на {divider}: {result}")
    except ZeroDivisionError:
        print(f"Ошибка: деление {num} на {divider} невозможно (деление на ноль).")

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

Приоритет математических операций на Python

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

Для программирования это работает так же:

Пример: получаем отдельно цифры большого числа

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

На входе мы попросим пользователя ввести трёхзначное число. После этого программа разберёт его по разрядам: выдаст отдельно сотни, десятки и единицы.

Сначала посмотрим на код, а потом разберём его.

# Получение трёхзначного числа от пользователя
num = int(input("Введите трёхзначное число: "))

# Получение сотен, десятков и единиц
# Целочисленное деление на 100
hundreds = num // 100
# Сначала делим на 10, затем берём остаток от деления на 10      
tens = (num // 10) % 10
# Остаток от деления на 10     
units = num % 10             

# Вывод цифр
print(f"Сотни: {hundreds}")
print(f"Десятки: {tens}")
print(f"Единицы: {units}")

Вот как это работает:

Где ещё применяется деление

Деление — стандартная операция, которая часто используется в важных процедурах:

Что дальше

В следующий раз разберём другие привычные операции в Python — посмотрим, как они работают, какие там есть тонкости и как это можно применить в коде.