Деление в Python
Python — популярный высокоуровневый язык программирования. Он обладает большим набором инструментов, имеет динамическую типизацию и используется для решения любых видов задач.
Деление в Python разделяется на три вида: обычное, целочисленное и взятие остатка. Программисту не нужно заботиться о типах операндов, Python сам определяет их и приводит результат к нужному виду. Как это делается, разберемся в этой статье.
Оператор деления
Деление в Python обозначается косой чертой «/». Примечательно, что результат в консоле всегда приводится к типу «float», даже если оба операнда были целочисленного типа, об этом свидетельствует появление «.0» у полученного значения.
Это появилось в 3-ей версии Python, ранее результатом деления целых чисел было только целое число, чтобы получить дробный результат, программисты явно указывали одному из операндов тип «float», в противном случае дробная часть просто отбрасывалась.
Важно понимать, что деление в Python, как и другие операции, работает медленнее, чем в более низкоуровневых языках программирования. Это связано с высоким уровнем автоматизации и абстракции, из-за динамической типизации интерпретатор вынужден приводить числа к дробному типу «float», который требует большего количества памяти.
Деление в представлении человека отличается от его представления в компьютере. Компьютер устроен так, что все арифметические операции могут выполняться только через сложение. Это значит, что быстрее всего выполняется сложение, затем вычитание, где необходимо менять знак операндов, умножение, где число складывается много раз. Деление выполняется дольше всех, потому что помимо многократно повторяющейся операции сложения необходимо также менять знак операндов, что требует больше памяти и действий.
print(int(1) / int(2)) print(5 / 5) print(1 / 3) 0.5 1.0 0.3333333333333333
Из примера видно, что не смотря на то, что во всех случаях операция была между целыми числами, результатом деления в Python 3 является вещественное число. В первом случае мы даже специально использовали приведение к типу int.
Дополнительно хотелось бы отметить, что если точности типа данных float не достаточно, можно воспользоваться библиотекой decimal. В частности мы её использовали при написании программы «калькулятор» в отдельной статье.
Деление без остатка
Чтобы выполнить деление на цело в Python, можно воспользоваться целочисленным делением. В этом случае результатом будет целое число, без остатка. Целочисленное деление в Python обозначается двумя косыми чертами «//».
В отличие от других языков программирования Python позволяет результату целочисленного деления быть как целым (int), так и дробным (float) числом. В обоих случаях дробная часть отбрасывается и получается число с окончанием «.0».
Примеры нахождения целой части от деления:
print(5 // 2) print(0 // 2) print(1234 // 5.0) 2 0 246.0
В первых двух случаях деление осуществлялось между целыми числами. Поэтому в результате было получено целое число. В третьем примере одно из чисел вещественное. В этом случае в результате получаем так же вещественное число (типа float), после запятой у которого 0.
Остаток
Для получения остатка от деления в Python 3 используется операция, обозначающаяся символом процента «%». Остаток — это оставшаяся после целочисленного деления часть числа. Операция взятия остатка используется для решения различных видов задач.
print(10 % 3) print(5 % 10) print(5 % 0.25) 1 5 0.0
Определение остатка от деления очень часто используется в программах для нахождения, допустим, чётных чисел. Или, например, если обработка данных выполняется в цикле, и нужно выводить в консоль сообщение о ходе обработки не каждый раз, а на каждой 10-ой итерации.
Вот пример вывода чётных чисел из списка в консоль:
example_list = [3, 7, 2, 8, 1, 12] for value in example_list: if value % 2 == 0: print(value) 2 8 12
Проблемы чисел с плавающей точкой
Компьютер устроен так, что на аппаратном уровне понимает только две цифры: один и ноль. Из-за этого при делении и других операциях с дробями часто возникают проблемы. Например, 1/10 в двоичном представлении является неправильной бесконечной дробью. Её нельзя написать полностью, поэтому приходится округлять, а выбор значения при округлении ограничен нулем и единицей.
Что говорить о делении, если ошибки возникают и при операции сложения. Если сложить число «0.1» с самим собой четырнадцать раз, то получиться 1.400…01. Откуда взялась эта единица? Она появилась при переводе числа из двоичного вида в десятичный.
a = 0.1 for i in range(13): a += 0.1 print(a) 1.4000000000000001
Более технически сложное деление приводит к подобным неточностям гораздо чаще. Обычно Python округляет результат так, что пользователь не замечает этой проблемы, но если получается достаточно длинное число, то проблема проявляется.
Деление комплексных чисел
Комплексные числа — это числа вида «a + b·i». Они занимают наивысшую ступень в иерархии чисел, арифметические операции над ними существенно отличаются от операций над обычными числами.
Деление комплексного числа на обычное меняет лишь длину радиус вектора, но не его направление.
print((5 + 8j) / 2) (2.5+4j)
Сокращенные операции деления
Чтобы упростить жизнь программистов, разработчики Python включили в язык «сокращенные операции». Их используют если надо выполнить операцию над переменной и полученный результат записать в эту же переменную. То, что записывается в длинной форме, можно записать в более короткой по следующим правилам:
| Полная форма | Краткая форма | |
| Деление | a = a / b | a /= b |
| Целая часть | a = a // b | a //=b |
| Остаток | a = a % b | a %= b |
a = 245 a %= 17 print(a) 7
Деление на ноль
Если попробовать в Python выполнить деление на 0, то мы получим исключение ZeroDivisionError.
Исключение следует обрабатывать, это можно сделать так:
try: print(24 / 0) except Exception as e: print(e) division by zero
Но в этом случае мы обрабатываем все исключения. Зачастую так делать не совсем корректно. Мы знаем, что в нашем коде возможно деление на 0 и, чтобы отловить именно эту ошибку, следует заменить except Exception as e: на except ZeroDivisionError as e: .
Но можно и проверять перед выполнением операции, что делитель не равен 0. Например так:
a = 14 b = None if a == 0: print('делитель равен нулю!') else: b = 345/a print('Операция выполнена, результат = ' + str(b)) Операция выполнена, результат = 24.642857142857142
Как найти остаток от деления в питоне
Пусть у нас выполняется следующее выражение:
number = 3 + 4 * 5 ** 2 + 7 print(number) # 110
Здесь начале выполняется возведение в степень (5 ** 2) как операция с большим приоритетом, далее результат умножается на 4 (25 * 4), затем происходит сложение (3 + 100) и далее опять идет сложение (103 + 7).
Чтобы переопределить порядок операций, можно использовать скобки:
number = (3 + 4) * (5 ** 2 + 7) print(number) # 224
Следует отметить, что в арифметических операциях могут принимать участие как целые, так и дробные числа. Если в одной операции участвует целое число (int) и число с плавающей точкой (float), то целое число приводится к типу float.
Арифметические операции с присвоением
Ряд специальных операций позволяют использовать присвоить результат операции первому операнду:
- += Присвоение результата сложения
- -= Присвоение результата вычитания
- *= Присвоение результата умножения
- /= Присвоение результата от деления
- //= Присвоение результата целочисленного деления
- **= Присвоение степени числа
- %= Присвоение остатка от деления
number = 10 number += 5 print(number) # 15 number -= 3 print(number) # 12 number *= 4 print(number) # 48
Округление и функция round
При операциях с числами типа float надо учитывать, что результат операций с ними может быть не совсем точным. Например:
first_number = 2.0001 second_number = 5 third_number = first_number / second_number print(third_number) # 0.40002000000000004
В данном случае мы ожидаем получить число 0.40002, однако в конце через ряд нулей появляется еще какая-то четверка. Или еще одно выражение:
print(2.0001 + 0.1) # 2.1001000000000003
В случае выше для округления результата мы можем использовать встроенную функцию round() :
first_number = 2.0001 second_number = 0.1 third_number = first_number + second_number print(round(third_number)) # 2
В функцию round() передается число, которое надо округлить. Если в функцию передается одно число, как в примере выше, то оно округляется до целого.
Функция round() также может принимать второе число, которое указывает, сколько знаков после запятой должно содержать получаемое число:
first_number = 2.0001 second_number = 0.1 third_number = first_number + second_number print(round(third_number, 4)) # 2.1001
В данном случае число third_number округляется до 4 знаков после запятой.
Если в функцию передается только одно значение — только округляемое число, оно округляется то ближайшего целого
# округление до целого числа print(round(2.49)) # 2 - округление до ближайшего целого 2 print(round(2.51)) # 3
Однако если округляемая часть равна одинаково удалена от двух целых чисел, то округление идет к ближайшему четному:
print(round(2.5)) # 2 - ближайшее четное print(round(3.5)) # 4 - ближайшее четное
Округление производится до ближайшего кратного 10 в степени минус округляемая часть:
# округление до двух знаков после запятой print(round(2.554, 2)) # 2.55 print(round(2.5551, 2)) # 2.56 print(round(2.554999, 2)) # 2.55 print(round(2.499, 2)) # 2.5
Однако следует учитывать, что функция round() не идеальный инструмент. Например, выше при округление до целых чисел применяется правило, согласно которому, если округляемая часть одинаково удалена от двух значений, то округление производится до ближайшего четного значения. В Python в связи с тем, что десятичная часть числа не может быть точно представлена в виде числа float, то это может приводить к некоторым не совсем ожидаемым результатам. Например:
# округление до двух знаков после запятой print(round(2.545, 2)) # 2.54 print(round(2.555, 2)) # 2.56 - округление до четного print(round(2.565, 2)) # 2.56 print(round(2.575, 2)) # 2.58 print(round(2.655, 2)) # 2.65 - округление не до четного print(round(2.665, 2)) # 2.67 print(round(2.675, 2)) # 2.67
Подобно о проблеме можно почитать к документации.
Остаток от деления
python mathematics
Сегодня при решении задач на Python столкнулся как мне показалось с очень трудной задачей, которую я никак не мог решить в рамках пройденной темы. Публикую условие задачи
Дано число n. С начала суток прошло n минут. Определите, сколько часов и минут будут показывать электронные часы в этот момент. Программа должна вывести два числа: количество часов (от 0 до 23) и количество минут (от 0 до 59). Учтите, что число n может быть больше, чем количество минут в сутках.
Я написал простенький код
n = int(input()) # Присваеваем переменной n функцию input(), которая будет получать значение минут hours = int(n//60) # Присваеваем переменной hours целое частное от деления заданных минут на 60 получая значение часов minutes = init(n%60) # Присваеваем переменной minutes остаток от деления заданных минут на 60 получая значение минут print(hours, minutes) # Функцией print() выводим на экран значения hours и minutes Данное значение в 150 минут программка показала правильно выдав значение 2 часа и 30 минут. Но вот с остальными тестовыми данными ее ждал провал. Во первых она не показывала 00 часов, а вместо это выдавала 24 часа. Ну и во вторых если ей давалось исходное значение больше \( 24*60 \) минут то мои написанные часы могли показать и 30 часов 5 минут и так далее. Естественно это была ошибка и код не работал как следует. Я не понимал как заставить их правильно считать часы, в голову лезли лишь условные операторы, но по теме я их еще не проходил. Тогда я подсмотрел решение, оно оказалось очень простым.
Остаток от деления большего числа на меньшее
С остатком от деления большего числа на меньшее у меня проблем не было, я прекрасно представлял себе как это работает. Возьмем для примера 5 вкусных апельсинов как на фото и разделим их на пятерых друзей, важное условие чтобы каждый получил целый апельсин. Тут все просто \( 5/5=1 \) апельсин на человека, при этом у нас не остается апельсинов, так как мы все раздали. Т.е. остаток у нас 0. А если бы нам нужно было поделить 5 апельсинов на двоих, сохраняя при этом условие, что каждый должен получить только целые апельсины. \( 5/2=2 \) целых апельсина, и \( 5-2*2=1 \) апельсин в остатке. (Если ты это читаешь, то я уже знаю, что если бы мне пришлось делить апельсины с тобой, то тебе бы дасталось 5, а мне 0 и при этом считалось бы поровну.)
Остаток от деления меньшего числа на большее
Когда полез гуглить и обнаружилось, что это материал третьего класса математики стало стыдно. То ли я забыл этот материал, то ли сказывается то, что давно не занимался, то ли я вообще этого не знал. Мысленно обратимся снова к апельсинам. Теперь нужно поделить 5 апельсинов на 10 человек! Как? Поделить каждый апельсин пополам и каждому раздать половинку. \( 5/(1/2)/10=1 \) как показывает пример каждый получает по 1/2, т.е. половине апельсина. Но! По нашему условию каждый то должен был получить обязательно по целому апельсину, а никак не по половине. Так как разделить 5 апельсинов на 10 человек, чтобы каждый получил целый апельсин? Правильно, никак. Каждый получает 0 апельсинов, а в остатке у нас остается так же 5 апельсинов. Теперь зная это уже можно поменять код для получения часа:
hours = int(n//60%24) # n // 60 - делим заданное количество минут на 60 минут, выполняем целочисленное деление, чтобы получить количество целых часов без дробной части # получаем остаток от деления полученного количества часов n // 60 на 24 (количество часов в сутках) Как работает код. Допустим нужно определить какое время покажут часы когда с начала суток пройдет 8952 часа. 1. \( 8952/60=149,2 \) но мы выполняем целочисленное деление и соответственно результатом будет просто 149 2. \( 149/24 \) нам нужен остаток от деления, нацело не делится, получается 6 целых и \( 149-24 * 6=5 \) остаток. Т.е. получается часовая стрелка сделает 6 полных оборотов, т.е. пройдет 6 суток и еще 5 часов. На часах будет 5 часов. Теперь найдем сколько покажут минут наши часы, для этого нам нужен остаток от деления данных минут на 60.Мы уже находили целое число от деления, подставив его найдем остаток \( 8952-149 * 60=12 \) минут. Весь код будет выглядеть так:
n = int(input()) hours = int(n//60%24) minutes = int(n%60) print(hours, minutes) Что произойдет если количества заданных минут при пересчете на часы будет меньше 24? Будет как раз таки нахождение остатка от деления меньшего числа на большее, которое я не знал и которое сбило меня с толку. Т.е. Возьмем на входе 150 минут. Целочисленное деление 150 на 60 даёт нам 2 часа. Теперь находим остаток от деления 2 на 24, как и в случае с апельсинами остаток останется 2, так как мы не можем цело поделить 2 на 24. В условии есть еще что программа должа определять часы от 0 до 23, а минуты от 0 до 59. Вы наверное уже догадались почему в результате у нас никак не может получится 24 часа или 60 минут. Поясняю. Берем значение в 1440 минут. Находим целочисленное от деления 1440 на 60, оно равно 24. Далее вычисляем остаток от деления 24 на 24, он получается равным 0, как и в случае когда мы 5 апельсинов делили на 5 человек, мы отдали все и у нас ничего не осталось. Поэтому наши часы покажут 0 вместо 24. Только при таком образном представление до меня дошло как решаются подобные задачи и как применяется остаток от деления.
Кому интересно, задачки я решаю тут
Опубликованно April 11th, 2018 by Aziz Madazimov
Поделитесь, если Вам понравилось!
Вам так же может понравиться:
Остаток от деления в Java и Python
Решаю одну и ту же простую задачу на Python и Java. Алгоритм идентичен, но результаты почему-то разные. Причина нашлась: в решении использую «%» (остаток от деления) и, если первая переменная имеет отрицательное значение, то почему-то результаты разнятся:
print(-1 % 109) #Python. System.out.println(-1 % 109); //Java. Вывод: -1 Объясните, пожалуйста, почему разные результаты?
Отслеживать
задан 11 янв 2022 в 21:12
133 1 1 серебряный знак 9 9 бронзовых знаков
Разная реализация нахождения остатка для отрицательных аргументов зависит от конкретного языка. Оба результата правильны. Какой результат вам нужен?
11 янв 2022 в 21:42
В вике есть статья, рассматривающая эту тему (в ней есть таблица про знак остатка в разных языках)
11 янв 2022 в 21:46
Спасибо за ответ! Мне нужен был именно положительный остаток, как в Python. Решение найдено с использованием Math.floorMod()