Что такое деление по модулю в python
Python поддерживает все распространенные арифметические операции:
-
+ Сложение двух чисел:
print(6 + 2) # 8
print(6 - 2) # 4
print(6 * 2) # 12
print(6 / 2) # 3.0
print(7 / 2) # 3.5 print(7 // 2) # 3
print(6 ** 2) # Возводим число 6 в степень 2. Результат - 36
print(7 % 2) # Получение остатка от деления числа 7 на 2. Результат - 1
При последовательном использовании нескольких арифметических операций их выполнение производится в соответствии с их приоритетом. В начале выполняются операции с большим приоритетом. Приоритеты операций в порядке убывания приведены в следующей таблице.
Пусть у нас выполняется следующее выражение:
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
Подобно о проблеме можно почитать к документации.
- Вопросы для самопроверки
- Упражнения для самопроверки
% (остаток)
Оператор работает с двумя операндами: делимым и делителем.
Числовые операнды сначала приводятся к общему типу. Операнды могут быть числами с плавающей запятой.
Если второй операнд наверен 0 (нулю), возбуждается ZeroDivisionError
Начиная с +py2.3 оператор не поддерживается комплексными числами. В таких случаях, если применимо, следует получить сначала число с плавающей запятой при помощи функции abs().
Оператор всегда выдаёт результат с тем же знаком, какой имеет его второй операнд (либо нуль). При этом абсолютная величина результата строго меньше абсолютной величены второго операнда.
1 % 2 # 1
1.0 % 2 # 1.0
-1 % 2 # 1
-1 % -2 # -1
2 % 10 # 2
2 % 0 # ZeroDivisionError
На заметку
Похожие функции: divmod() и math.reminder() .
На заметку
Помимо того, что % возвращает остаток от деления для чисел, он же используется для форматирования строк.
Арифметические операторы Python
Что такое оператор и операнды? Это можно объяснить простым примером: 10 + 5 = 15 . В этом выражении 10 и 5 — операнды. Знак + — оператор.
Пусть переменная a = 10 , а переменная b = 5
Оператор | Описание | Пример |
---|---|---|
+ | Добавление — добавляет левый операнд к правому | a + b = 15 |
— | Вычитание — вычитает правый операнд из левого | a — b = 5 |
* | Умножение — умножает левый операнд на правый | a * b = 50 |
/ | Деление — делит левый операнд на правый | a / b = 2 |
% | Деление по модулю — делит левый операнд на правый и возвращает остаток. С помощью него, например, можно проверять числа на четность и нечетность. Если левый операнд меньше правого, то результатом будет левый операнд | a % b = 0 |
** | Возведение в степень | a ** b = 100000 |
// | Целочисленное деление — деление в котором возвращается только целая часть результата. Часть после запятой отбрасывается. | 9 // 2 = 4 9.0 // 2.0 = 4.0 |
©2024 Letpy
Мы используем файлы cookie
Наш сайт использует файлы cookie для улучшения пользовательского опыта, сбора статистики и обеспечения доступа к обучающим материалам. Мы также передаем информацию об использовании вами нашего сайт партерам по социальным сетям, рекламе и аналитике. В свою очередь, наши партнеры могут объединять ее с другой предоставленной вами информацией, или с информацией, которую они собрали в результате использования вами их услуг.
Оператор модуля Python
Операция по модулю — это арифметическая операция, которая находит остаток от деления одного числа на другое. Остаток называется модулем операции.
Например, 5, разделенное на 3, равно 1 с остатком 2, а 8, разделенное на 4, равно 2, с остатком 0.
Оператор модуля Python
В Python оператор по модулю представлен знаком процента ( % ). Синтаксис следующий:
num1 % num2
5 % 4
Если делитель (второй аргумент) равен нулю, возникает ZeroDivisionError :
5 % 0
ZeroDivisionError: integer division or modulo by zero
Оператор по модулю также принимает плавающие числа в качестве аргументов:
6.8 % 3.4
При форматировании строк символ % представляет оператор интерполяции.
Примеры
Один из распространенных случаев использования оператора по модулю — проверка четности или нечетности числа. Если число, деленное на 2, не имеет остатка, то это четное число. В противном случае, если остается 1, то число нечетное:
num = 11 if (num % 2) == 0: print(num, "is even") else: print(num, "is odd")
Если вы запустите приведенный выше код, 11 % 2 оставит остаток 1 и будет выполнен код внутри оператора else :
11 is odd
Вот еще один пример, показывающий, как с помощью оператора по модулю проверить, является ли число простым. Простое число — это целое положительное число, которое без остатка можно разделить только на себя и на 1:
def isPrimeNumber(num): if num 1: return False for i in range(2, num): if (num % i) == 0: return False else: return True
Сначала мы проверяем, является ли число num положительным числом. Затем мы проверяем, делится ли число на другое число в диапазоне от 2 до num без напоминания. Если ни одно из условий не выполняется, число простое.
Оператор по модулю также может использоваться для преобразования единиц измерения. В следующем примере показано, как преобразовать секунды в минуты:
def secondsToMinutes(sec): seconds = sec // 60 minutes = sec % 60 return "%d minutes and %d seconds" % (minutes, seconds) secondsToMinutes(657)
'57 minutes and 10 seconds'
Двойная косая черта ( // ), оператор деления по этажам округляет результат до ближайшего целого числа.
Выводы
В этой статье мы показали вам, как использовать оператор Python по модулю.
Если у вас есть какие-либо вопросы или отзывы, не стесняйтесь оставлять комментарии.