Что такое деление по модулю в python

Осваиваем Python: математические операции

В этом руководстве мы будем работать с двумя типами данных в Python – целыми числами ( integer) и числами с плавающей точкой ( floats) :

В этой статье будут описаны операции с числовыми типами данных в Python.

Математические операторы Python 3

Оператор – это символ, которая обозначает операцию. Например, в математике знак плюса или + – это оператор сложения.

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

Ниже представлена таблица с кратким обзором математических операторов, доступных в Python.

Сумма в питоне и разность в питоне

В Python операторы суммы и разности выполняют те же операции, что и в математике. Поэтому вы можете использовать этот язык программирования как калькулятор.

Рассмотрим некоторые примеры. Начнём с целых чисел:

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

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

Прибавление работает аналогично и с числами с плавающей запятой:

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

Унарные арифметические операции Python

Унарное математическое выражение состоит из одного элемента. Знаки плюса и минуса в питоне могут быть использованы как единичный оператор, чтобы вернуть тождественное значение (+) или сменить знак числа (-).

Знак плюса означает тождественное значение. Мы можем использовать его с положительными значениями:

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

При использовании с отрицательным значением знак плюса возвращает то же отрицательное значение.

Минус (в отличие от знака плюса) изменяет знак числа. Поэтому при передаче положительного числа мы получим отрицательное значение:

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

Умножение и деление в питоне

Оператор, которые мы будем использовать в Python для умножения «*», а для деления «/». Пример умножения двух чисел с плавающей точкой в Python:

Когда вы выполняете деление в Python 3, частное всегда будет числом с плавающей точкой, даже если вы используете два целых числа:

Это одно из наиболее существенных отличий Python 2 от Python 3. В Python 3 результатом будет дробное число. Поэтому, когда вы используете оператора «/» для деления 11 на 2, возвращено будет 5.5. В Python 2 возвращаемое значение деления 11 / 2 было 5.

Целочисленное деление python 3 использует оператор «//». Выражение 100 // 40 вернёт значение 2.

Деление с остатком Python

Оператор % используется для деления по модулю, и возвращает остаток от деления, а не частное. Это полезно, например, для нахождения множителей числа.

Деление по модулю Python (с остатком) — пример:

В этом примере 85 делится на 15. Результат – 5 с остатком 10. Значение 10 выводится, поскольку оператор возвращает остаток от деления.

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

В приведенном выше примере 36.0 делится на 6.0 без остатка, поэтому возвращается значение 0.0.

Возведение в степень Python

Оператор «**» в Python используется для возведения числа, расположенного слева от оператора в степень, указанную справа. То есть, в выражении 5 ** 3, число 5 возводится в третью степень.

В математике часто используется выражение 5³. То есть 5 умножается на себя три раза. В Python мы получим тот же результат (125) выполнив 5 ** 3 или 5 * 5 * 5.

Пример с переменными:

Возведение числа с плавающей точкой 52.25 в степень 7 с помощью оператора ** приводит к выводу большого числа с плавающей точкой.

Приоритет операторов

Операторы Python выполняются в порядке приоритета. Посмотрим на следующее выражение:

Операторы присваивания Python

Оператор «=» присваивает значение, расположенное справа, переменной слева. Например, v = 23 присваивает значение числа 23 переменной v.

В программировании часто используют составные операторы присваивания. Они соединяют арифметический оператор с оператором «=». Поэтому для сложения мы используем оператор «+» с оператором «=», чтобы получить составной оператор «+=». Пример:

Составные операторы присваивания часто используются в циклах for:

В Python предусмотрен составной оператор присваивания для каждой арифметической операции:

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

Заключение

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

Пожалуйста, опубликуйте свои комментарии по текущей теме материала. Мы крайне благодарны вам за ваши комментарии, подписки, лайки, дизлайки, отклики!

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

Источник

Базовые математические операции в Python

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

Но не всё так страшно. Да, понимание математики на высоком уровне помогает стать высококвалифицированным программистом, но оно не является для этого обязательным условием. Тем не менее базовые вещи знать придётся. А в основе всех мощных математических инструментов лежат простые и понятные операции.

Сложение (+)

И самая простая и понятная из них — сложение. Никаких «подводных камней»: берём два или более чисел, пишем между ними знак » + » и присваиваем результат выражения переменной (или сразу выводим сумму на экран):

x = 5 y = 3 z = x + y print(z) > 8

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

q = 4.5 w = 2.5 e = 2.5 r = 0.5 print(q + w + e + r) > 10.0

Вообще говоря, если хотя бы одно из слагаемых — число вещественное, то вещественным будет и весь результат.

num1 = 10 num2 = 15 num3 = 10.0 sum = num1 + num2 + num3 print(sum) > 35.0 print(type(sum)) >

Вычитание (-)

Вычитание – это обратная операция сложению. Оператором выступает знак «-«:

Умножение (*)

Как и две предыдущие операции, умножение в Python не таит в себе никаких скрытых или неочевидных особенностей. Умножаем два или более чисел при помощи оператора «звёздочка» ( * ):

Деление (/)

Сложение, вычитание и умножение тривиальны, а вот с делением не всё так просто. В Python существует три вида деления и столько же разных операторов. Начнём с истинного деления, за которое отвечает оператор » / «. Его главным отличием является то, что, вне зависимости от типов операндов, будет возвращен вещественный результат ( float ).

print(8/2) > 4.0 # делимое и делитель — int числа, а частое — float print(type(8/2)) > print(8/3) > 2.6666666666666665

Этот вид деления наиболее близок к обычному и знакомому нам математическому. И здесь тоже нельзя делить на ноль:

print(8/0) > ZeroDivisionError: division by zero

💁 Немного истории. В старых версиях Питон оператор «/» выполнял операцию классического деления: т.е. он делил целочисленно и усекал дробную часть в том случае, когда делимое и делитель были целыми. Если же операнды принадлежали к множеству вещественных чисел, то проводилось деление с сохранением дробной части, и результат был float.

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

Целочисленное деление (//)

print(15//2) # видно, что результат округлился в меньшую сторону > 7 # и остался целочисленным, поскольку и делимое, и делитель — int числа print(type(15//2)) >

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

print(15//3.1) > 4.0 print(type(15//3.1)) >

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

На ноль всё ещё нельзя делить:

print(15//0) > ZeroDivisionError: integer division or modulo by zero

Остаток от деления (%)

Остаток от деления ещё называют делением по модулю. Оператор » % » сначала делит, а затем возвращает остаток.

print(21 % 3) > 0 print(21 % 5) > 1 print(21 % 0) > ZeroDivisionError: integer division or modulo by zero

Остаток может не быть целочисленным:

print(21.3 % 3) > 0.3000000000000007

Но вся прелесть данного оператора заключается не в возвращаемом им значении остатка.

Главная фишка деления по модулю в том, что с его помощью легко проверяется факт делимости одного числа на другое

А отсюда вытекают и проверки на чётность/нечётность:

import random def parity_check(num): «»» функция, проверяющая четность числа. Любое четное число делится на 2 без остатка. «»» if num % 2 == 0: return ‘Число чётное’ else: return ‘Число нечётное’ # сгенерируем случайное число и проверим работу функции rnum = random.randint(0, 100) print(rnum) print(parity_check(rnum)) > 62 > Число чётное

💭 Проверка числа на чётность/нечётность будет часто встречаться в вашей работе.

Возведение в степень (**)

Нетипичный оператор для большинства других языков программирования. Тем он и удобен. Парная «звёздочка» ( ** ) выполняет классическое математическое возведение числа «a» в степень «b»:

a = 2 b = 10 print(a ** b) > 1024

И показатель степени, и основание могут быть отрицательными:

# степень 0.5 аналогична квадратному корню a = 100 b = 0.5 print(a ** b) > 10.0 a = 0.5 b = 2 print(a ** b) > 0.25

Операндов у возведения в степень также может быть несколько. В таком случае, оператор » ** » работает, как право-ассоциативный (т.е. операции выполняются справа-налево):

print(2 ** 2 ** 3) # Сначала выполняется 2 ** 3, а затем уже 2 ** 8. > 256

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

Источник

Python Modulo — оператор %

Оператор модуля Python (%) используется для получения остатка от деления. Операция по модулю поддерживается для целых чисел и чисел с плавающей запятой.

Если и «a», и «b» являются целыми числами, то остаток также является целым числом. Если одно из них является числом с плавающей запятой, результатом также будет число с плавающей запятой.

Пример оператора модуля Python

Давайте посмотрим на несколько примеров оператора по модулю.

1. По модулю с целыми числами

2. По модулю с поплавком

3. Модульное с пользовательским вводом.

Когда мы получаем данные, введенные пользователем, они имеют форму строки. Мы используем встроенную функцию float() для преобразования их в числа с плавающей запятой. Вот почему остаток равен 1,0, а не 1.

4. Пример ZeroDivisionError

5. По модулю с отрицательными числами

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

6. Python Modulo math.fmod()

Поведение оператора% с отрицательными числами отличается от поведения библиотеки C. Если вы хотите, чтобы операция по модулю велась как программирование на C, вам следует использовать функцию fmod() математического модуля. Это рекомендуемая функция для получения чисел с плавающей запятой по модулю.

Перегрузка оператора по модулю

Мы можем перегрузить оператор по модулю, реализовав __mod__() в нашем определении класса.

Коротко о проблемах арифметики с плавающей запятой

Мы используем двоичный формат для хранения значений в компьютерах. Что касается дробей, в большинстве случаев мы не можем представить их в точности как двоичные дроби. Например, 1/3 не может быть представлена в точном двоичном формате, и это всегда будет приблизительное значение.

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

На выходе должно быть 0, потому что 3,2 * 3 равно 9,6. Но значения долей с плавающей запятой не представлены точно, и приближение вызывает эту ошибку. Это тоже видно из этого примера.

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

Источник

Операторы Python

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

Оператор в Python — это символ, который выполняет операцию над одним или несколькими операндами.
Операндом выступает переменная или значение, над которыми проводится операция.

Введение в операторы Python

Операторы Python бывают 7 типов:

Арифметические операторы Python

Этот тип включает операторы для проведения базовых арифметических операций.

Сложение (+)

Складывает значение по обе стороны оператора.
Пример:

Вычитание (-)

Вычитает значение правой стороны из значения в левой.
Пример:

Умножение (*)

Перемножает значения с обеих сторон оператора.
Пример:

Деление (/)

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

Возведение в степень (**)

Возводит первое число в степень второго.
Пример:

Деление без остатка (//)

Выполняет деление и возвращает целочисленное значение частного, убирая цифры после десятичной точки.
Пример:

Деление по модулю (остаток от деления) (%)

Выполняет деление и возвращает значение остатка.
Пример:

Операторы сравнения

Операторы сравнения в Python проводят сравнение операндов. Они сообщают, является ли один из них больше второго, меньше, равным или и то и то.

Меньше (

Этот оператор проверяет, является ли значение слева меньше, чем правое.
Пример:

Больше (>)

Проверяет, является ли значение слева больше правого.

Пример:

Меньше или равно (

Проверяет, является ли левая часть меньше или равной правой.
Пример:

Больше или равно (>=)

Проверяет, является ли левая часть больше или равной правой.
Пример:

Равно (==)

Не равно (!=)

Проверяет, не равно ли значение слева правому. Оператор <> выполняет ту же задачу, но его убрали в Python 3.

Операторы присваивания

Оператор присваивания присваивает значение переменной. Он может манипулировать значением до присваивания. Есть 8 операторов присваивания: 1 простой и 7 с использованием арифметических операторов.

Присваивание (=)

Присваивает значение справа левой части. Стоит обратить внимание, что == используется для сравнения, а = — для присваивания.
Пример:

Сложение и присваивание (+=)

То же касается и все остальных операторов присваивания.
Пример:

Вычитание и присваивание (-=)

Вычитает значение справа из левого и присваивает его выражению слева.
Пример:

Деление и присваивание (/=)

Делит значение слева на правое. Затем присваивает его выражению слева.
Пример:

Умножение и присваивание (*=)

Перемножает значения обеих сторон. Затем присваивает правое левому.
Пример:

Деление по модулю и присваивание (%=)

Выполняет деление по модулю для обеих частей. Результат присваивает левой части.
Пример:

Возведение в степень и присваивание (**=)

Выполняет возведение левой части в степень значения правой части. Затем присваивает значение левой части.
Пример:

Деление с остатком и присваивание (//=)

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

Это один из важных операторов Python

Логические операторы Python

Это союзы, которые позволяют объединять по несколько условий. В Python есть всего три оператора: and (и), or (или) и not (не).

И (and)

Если условия с двух сторон оператора and истинны, тогда все выражение целиком считается истинным.
Пример:

Или (or)

Выражение ложно, если оба операнда с двух сторон ложные. Если хотя бы одно из них истинное, то и все выражение истинно.
Пример:

Не (not)

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

Нет в (not in)

Этот оператор проверяет, НЕ является ли значение членом последовательности.
Пример:

Операторы тождественности

Эти операторы проверяют, являются ли операнды одинаковыми (занимают ли они одну и ту же позицию в памяти).

Это (is)

Это не (is not)

Битовые операторы Python

Эти операторы работают над операндами бит за битом.

Бинарное И (&)

Бинарное ИЛИ (|)

Проводит побитовую операцию or на двух значениях. Здесь or для 10 (2) и 11 (3) возвращает 11 (3).
Пример:

Бинарное ИЛИ НЕТ (^)

Проводит побитовую операцию xor (исключающее или) на двух значениях. Здесь результатом ИЛИ НЕ для 10 (2) и 11 (3) будет 01 (1).
Пример:

Инвертирующий оператор (

Бинарный сдвиг влево (

Бинарный сдвиг вправо (>>)

Выводы

В этом уроке были рассмотрены все 7 типов операторов Python. Для каждого был предложен пример в IDE. Для понимания особенностей работы операторов нужно продолжать с ними работать, использовать в условных конструкциях и объединять.

Источник

Деление по модулю в практике Python или как использовать оператор %

Python поддерживает широкий спектр арифметических операторов, которые вы можете использовать при работе с числами в вашем коде. Одним из этих операторов является оператор деления по модулю ( % ), который возвращает остаток от деления двух чисел.

В этом уроке вы узнаете:

Об операторе деления по модуля иногда забывают. Но хорошее понимание этого оператора даст вам бесценный инструмент в своём арсенале инструментов Python.

В этом уроке:

Деление по модулю в математике ↑

Классический пример модульной арифметики — двенадцать часов. Двенадцатичасовые часы имеют фиксированный набор значений от 1 до 12. При подсчете двенадцатичасовых часов вы считаете до модуля 12, а затем возвращаетесь к 1. Двенадцатичасовые часы можно классифицировать как «modulo 12», иногда сокращается до «mod 12».

Оператор деление по модулю используется, когда вы хотите сравнить число с модулем и получить эквивалентное число, ограниченное диапазоном модуля.

Если подумать, 17 и 5 эквивалентны в контексте mod 12. Если бы вы посмотрели на часовую стрелку в 5:00 и 17:00, она была бы в том же положении. В модульной арифметике есть уравнение, описывающее эту взаимосвязь:

Это уравнение гласит: «a и b равны по модулю n». Это означает, что a и b эквивалентны по модулю n, поскольку они имеют одинаковый остаток при делении на n. В приведенном выше уравнении n — это модуль как для a, так и для b. Используя значения 17 и 5 из предыдущих, уравнение будет выглядеть так:

Это гласит: «17 и 5 равны по модулю 12». 17 и 5 имеют одинаковый остаток 5 при делении на 12. Таким образом, в модуле 12 числа 17 и 5 эквивалентны.

Подтвердить это можно с помощью деления:

Обе операции имеют одинаковый остаток 5, поэтому они эквивалентны по модулю 12.

Основы работы с операторами деления модуля Python ↑

Оператор деления по модулю, как и другие арифметические операторы, может использоваться с числовыми типами int и float. Как вы увидите позже, его также можно использовать с другими типами, такими как math.fmod(), decimal.Decimal и вашими собственными классами.

Оператор деления по модулю с int ↑

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

Будь осторожен! Как и в случае с оператором деления ( / ), Python вернет ошибку ZeroDivisionError, если вы попытаетесь использовать оператор по модулю с делителем 0:

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

Оператор деления по модулю чисел плавающей точкой (float) ↑

Альтернативой использованию числа с плавающей запятой с оператором по модулю является использование math.fmod() для выполнения операций по модулю над значениями с плавающей запятой:

В следующем разделе вы более подробно исследуете использование оператора по модулю с отрицательными операндами.

Как и другие арифметические операторы, оператор по модулю и math.fmod() могут столкнуться с проблемами округления и точности при работе с арифметикой с плавающей запятой:

Если для вашего приложения важно поддерживать точность с плавающей запятой, вы можете использовать оператор по модулю с decimal.Decimal. Вы рассмотрите это позже.

Оператор деления по модулю с отрицательным операндом ↑

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

Как выясняется из, способ, которым компьютеры определяют результат операции деления по модулю с отрицательным операндом, оставляет неоднозначность относительно того, должен ли остаток принимать знак делимого (число, которое делится) или знак делителя (число, на которое делится делимое). Разные языки программирования обрабатывают это по-разному.

Например, в JavaScript остаток примет знак делимого:

Остаток в этом примере, 2, положительный, поскольку он принимает знак делимого, 8. В Python и других языках вместо этого остаток принимает знак делителя:

Это уравнение состоит из трех переменных:

Здесь вы можете увидеть, как такой язык, как JavaScript, получает остаток 2. Python и другие языки, в которых остаток принимает знак делителя, используют следующее уравнение:

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

Оператор деления по модулю и divmod() ↑

Python имеет встроенную функцию divmod(), которая внутренне использует оператор по модулю. divmod() принимает два параметра и возвращает кортеж, содержащий результаты деления этажа и по модулю с использованием предоставленных параметров.

Ниже приведен пример использования divmod() с 37 и 5:

Вы можете видеть, что divmod(37, 5) возвращает кортеж (7, 2). 7 — это результат деления полов на 37 и 5. 2 — результат 37 по модулю 5.

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

Приоритет оператора деления по модулю ↑

Как и другие операторы Python, для оператора деления по модулю существуют определенные правила, которые определяют его приоритет при оценке выражений. Оператор деления по модулю ( % ) имеет тот же уровень приоритета, что и операторы умножения ( * ), деления ( / ) и деления пола ( // ).

Взгляните на пример приоритета оператора деления по модулю ниже:

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

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

В этом примере сначала вычисляется (12 – 9), затем 4 * 10 и, наконец, 40 % 3, что равно 1.

Оператор деления по модулю Python на практике ↑

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

Как проверить, четное или нечетное число ↑

В этом разделе вы увидите, как с помощью оператора по модулю определить, четное или нечетное число. Используя оператор по модулю с модулем 2, вы можете проверить любое число, чтобы узнать, делится ли оно без остатка на 2. Если оно делится без остатка, то это четное число.

Здесь num % 2 будет равно 0, если num четное, и 1, если num нечетное. Проверка против 0 вернет логическое значение True или False в зависимости от того, является ли число четным или нет.

Проверка на нечетные числа очень похожа. Чтобы проверить нечетное число, вы инвертируете проверку равенства:

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

Вы можете понять, почему, в следующих примерах:

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

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

Как запускать код с определенными интервалами в цикле ↑

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

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

Как видите, список имен разделен на три строки, максимум по три имени в каждой строке. по умолчанию модуль равен 3, но вы можете указать любое число:

Не вдаваясь в подробности, синтаксис: — ^ 15 предписывает print () выполнять следующие действия:

Теперь, когда имя напечатано в строке, взгляните на основную часть split_names_into_rows() :

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

Приведенный выше код — это только один пример. Использование шаблона index % modulus == 0 позволяет запускать другой код через определенные промежутки времени в ваших циклах. В следующем разделе вы немного углубитесь в эту концепцию и рассмотрите циклическую итерацию.

Как создать циклическую итерацию ↑

Циклическая итерация описывает тип итерации, которая сбрасывается при достижении определенной точки. Как правило, этот тип итерации используется для ограничения индекса итерации определенным диапазоном.

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

В приведенном выше коде используется бесконечный цикл для рисования повторяющейся формы звезды. После каждых шести итераций он меняет цвет пера. Размер пера увеличивается с каждой итерацией, пока i не сбрасывается обратно в 0. Если вы запустите код, вы должны получить что-то похожее на это:

Важные части этого кода выделены ниже:

Вы можете увидеть шаги итерации ниже для более подробного пояснения:

Как конвертировать единицы измерения ↑

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

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

Вот пример используемой функции:

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

Вы можете увидеть, как это работает, ниже:

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

Ниже операторы деления без остатка и по модулю были заменены на divmod() :

Как видите, divmod(total_inches, 12) возвращает кортеж, который распакован в футы и дюймы.

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

Вы получите тот же результат, но теперь код более лаконичен. Вы также можете обновить convert_minutes_to_days() :

Использование divmod() необязательно для всех ситуаций, но здесь имеет смысл, поскольку при расчетах преобразования единиц используется как деление этажа, так и модуль.

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

Как определить, является ли число простым числом ↑

В следующем примере вы увидите, как можно использовать оператор Python по модулю, чтобы проверить, является ли число простым. Простое число — это любое число, которое содержит только два делителя: 1 и само себя. Некоторые примеры простых чисел: 2, 3, 5, 7, 23, 29, 59, 83 и 97.

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

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

Углубившись в код, вы увидите, что он начинается с проверки, меньше ли num 2. Простые числа могут быть только больше или равны 2. Если num меньше 2, то выполнение функции не требуется. Он просто напечатает сообщение и сделает возврат:

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

Вот основная часть функции:

Здесь есть что распаковать, так что давайте рассмотрим это шаг за шагом.

Внутри цикла while оператор по модулю проверяет, делится ли num без остатка на i :

После завершения цикла while код проверяет, не были ли найдены какие-либо дополнительные факторы:

Если в списке factors существует более одного кортежа, то num не может быть простым числом. Для непростых чисел коэффициенты распечатываются. Для простых чисел функция печатает сообщение о том, что num является простым числом.

Как реализовать шифрование ↑

Оператор деления по модулю в Python может использоваться для создания шифров. Шифр એ — это тип алгоритма для выполнения шифрования и дешифрования входных данных, обычно текста. В этом разделе вы познакомитесь с двумя шифрами: шифр Цезаря и шифр Виженера.

Шифр Цезаря

Шифр Цезаря работает, взяв зашифровываемую букву и сдвинув ее на определенное количество позиций влево или вправо в алфавите. Какая бы буква ни была в этой позиции, используется как зашифрованный символ. Это же значение сдвига применяется ко всем символам в строке.

Например, если смена была 5, затем A сдвинется на пять букв вверх, чтобы стать F, B станет G и так далее. Ниже вы можете увидеть процесс шифрования текста REALPYTHON со сдвигом 5:

В результате получается шифр WJFQUDYMTS.

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

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

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

Затем функция определяет три переменные для хранения символов ASCII нижнего регистра, символов ASCII верхнего регистра и результатов шифрования или дешифрования:

Наконец, caesar_cipher() перебирает отдельные символы в тексте и выполняет следующие действия для каждого символа:

После завершения цикла перебора текстового значения возвращается результат:

Вот еще раз полный код:

Теперь запустите код в Python REPL, используя текст meetMeAtOurHideOutAtTwo со сдвигом 10 :

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

Шифр Виженера

Шифр Виженера એ — это полиалфавитный шифр подстановки. Для шифрования он использует разные шифры Цезаря для каждой буквы входящего текста. Шифр Виженера использует ключевое слово, чтобы определить, какой шифр Цезаря следует использовать для поиска буквы шифра.

Вы можете увидеть пример процесса шифрования на следующем изображении. В этом примере вводимый текст REALPYTHON зашифрован с использованием ключевого слова MODULO:

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

Ниже представлена ​​реализация шифра Виженера. Как вы увидите, оператор деления по модулю используется в функции дважды:

Вы могли заметить, что подпись для vigenere_cipher() очень похожа на caesar_cipher() из предыдущего раздела:

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

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

Взгляните на эти шаги в приведенном ниже коде:

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

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

index % 26 гарантирует, что индекс символа не превышает 25, таким образом гарантируя, что он остается внутри алфавита. С помощью этого индекса зашифрованный или дешифрованный символ выбирается из верхнего регистра и добавляется к результатам.

Вот еще раз полный код шифра Виженера:

Теперь запустите его в Python REPL:

Хорошо! Теперь у вас есть рабочий шифр Виженера для шифрования текстовых строк.

Расширенные возможности оператора деления по модулю Python ↑

Использование оператора деления по модулю Python с decimal.Decimal ↑

Вот несколько примеров использования целых чисел с decimal.Decimal и оператором по модулю:

Вот некоторые числа с плавающей запятой, используемые с decimal.Decimal и оператором деления по модулю:

Как видно из приведенных выше примеров, работа с decimal.Decimal и оператором деления по модулю аналогична работе с другими числовыми типами. Вам просто нужно иметь в виду, как он определяет знак результата при работе с отрицательным операндом.

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

Использование оператора деления по модулю Python с настраиваемыми классами ↑

Сейчас, если вы помните из приведенного выше раздела о преобразовании единиц, convert_minutes_to_day() использовал оператор Python деления по модулю для преобразования total_mins в дни, часы и минуты. Теперь вы реализуете модифицированную версию этого метода, чтобы увидеть, как можно использовать свой собственный класс с оператором деления по модулю:

Если вы загрузите этот модуль в Python REPL, вы можете использовать его следующим образом:

Вот полный код после изменений:

Теперь, вызвав код в Python REPL, вы увидите, что он намного лаконичнее:

Заключение ↑

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

В этом уроке вы узнали, как:

Благодаря знаниям, полученным в этом уроке, теперь вы сможете с большим успехом начать использовать оператор деления по модулю в своем собственном коде. Удачного питонинга!

Опубликовано Вадим В. Костерин

ст. преп. кафедры ЦЭиИТ. Автор более 130 научных и учебно-методических работ. Лауреат ВДНХ (серебряная медаль). Посмотреть больше записей

Источник