Ответ 1

Оператор% (modulo) дает остаток от деления первого аргумента на второй. Числовые аргументы сначала преобразуются в общий тип. Аргумент zero right вызывает исключение ZeroDivisionError. Аргументами могут быть числа с плавающей запятой, например, 3,14% 0,7 равно 0,34 (поскольку 3,14 равно 4 * 0,7 + 0,34.) Оператор по модулю всегда дает результат с тем же знаком, что и его второй операнд (или нуль); абсолютное значение результата строго меньше абсолютного значения второго операнда [2].

Взято из http://docs.python.org/reference/expressions.html

Пример 1: 6%2 оценивается как 0, потому что нет остатка, если 6 делится на 2 (3 раза).

Пример 2: 7%2 оценивается как 1, потому что остаток 1, когда 7 делится на 2 (3 раза).

Итак, чтобы суммировать это, он возвращает оставшуюся часть операции деления или 0, если нет остатка. Таким образом, 6%2 означает найти оставшуюся часть 6, деленную на 2.

Ответ 2

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

>>> x = 'abc_%(key)s_'
>>> x %= {'key':'value'}
>>> x 
'abc_value_'

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

Ответ 3

Выражение, подобное x % y, оценивает остаток от x ÷ y - технически это "модуль" вместо "напоминание", поэтому результаты могут отличаться, если вы сравниваете с другими языками, где % является оператором остатка. Есть некоторые тонкие различия (если вас интересуют практические последствия, см. также "Почему этажи Python Integer Divisionors")?

Приоритет такой же, как у операторов / (деление) и * (умножение).

>>> 9 / 2
4
>>> 9 % 2
1

• 9, деленное на 2, равно 4.
• 4 раза 2 - 8
• 9 минус 8 равно 1 - остаток.

Python получил: в зависимости от используемой версии Python % также является (устаревшим) оператором интерполяции строк, поэтому следите, если вы пришли из языка с автоматическим приведением типов (например, PHP или JS), где выражение типа '12' % 2 + 3 является допустимым: в Python это приведет к TypeError: not all arguments converted during string formatting, что, вероятно, будет довольно запутанным для вас.

[обновление для Python 3]

Пользователь n00p комментирует:

9/2 - это 4,5 в питоне. Вы должны выполнить целочисленное деление следующим образом: 9//2, если вы хотите, чтобы python сообщал вам, сколько всего объектов осталось после деления (4).

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

$ python2.7
Python 2.7.10 (default, Oct  6 2017, 22:29:07)
[GCC 4.2.1 Compatible Apple LLVM 9.0.0 (clang-900.0.31)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 9 / 2
4
>>> 9 // 2
4
>>> 9 % 2
1

В современном Python 9 / 2 результаты 4.5 действительно:

$ python3.6
Python 3.6.1 (default, Apr 27 2017, 00:15:59)
[GCC 4.2.1 Compatible Apple LLVM 8.1.0 (clang-802.0.42)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 9 / 2
4.5
>>> 9 // 2
4
>>> 9 % 2
1

[обновление]

Пользователь dahiya_boy спросил в комментарии:

Q. Can you please explain why -11 % 5 = 4 - dahiya_boy

Это странно, правда? Если вы попробуете это в JavaScript:

> -11 % 5
-1

Это потому, что в JavaScript % является оператором "остатка", в то время как в Python это оператор "модуля" (тактовой математики).

Вы можете получить объяснение непосредственно из GvR:

Edit - dahiya_boy

В Java и iOS -11 % 5 = -1, тогда как в python и ruby -11 % 5 = 4.

Ну, половина причины объясняется Пауло Скардином, а остальное объяснение здесь ниже

В Java и iOS % дает остаток, который означает, что при делении 11% 5 дает Quotient = 2 and remainder = 1, а -11% 5 дает Quotient = -2 and remainder = -1.

Пример кода в быстрой iOS.

Но когда мы говорим о Python, он дает модуль часов. И его работа с формулой ниже

mod(a,n) = a - {n * Floor(a/n)}

Это значит,

mod(11,5) = 11 - {5 * Floor(11/5)} => 11 - {5 * 2}

Итак, mod(11,5) = 1

И

mod(-11,5) = -11 - 5 * Floor(11/5) => -11 - {5 * (-3)}

Итак, mod(-11,5) = 4

Пример кода в Python 3.0.

Почему Python Integer Divisionors Этажи

Сегодня меня (снова) попросили объяснить, почему целочисленное деление в Python возвращает пол результата вместо усечения до нуля, как C.

Для положительных чисел нет ничего удивительного:

>>> 5//2
2

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

>>> -5//2
-3
>>> 5//-2
-3

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

a/b = q with remainder r

такой, что

b*q + r = a and 0 <= r < b

(assuming a и b are >= 0).

Если вы хотите, чтобы отношение расширялось до отрицательного значения a (при сохранении положительного значения b), у вас есть два варианта: если вы укоротите q до нуля, r станет отрицательным, так что инвариант изменится на 0 & lt; = abs (r) & Lt; в противном случае вы можете перейти q к отрицательной бесконечности, и инвариант останется 0 & lt; = r & lt; б. [обновление: исправил этот пункт]

В математической теории чисел математики всегда предпочитают последний вариант (см., Например, Википедия). Для Python я сделал такой же выбор, потому что есть некоторые интересные приложения операции по модулю, где знак а неинтересен. Подумайте о том, чтобы взять метку времени POSIX (секунды с начала 1970 года) и перевести ее на время суток. Поскольку в день 24 * 3600 = 86400 секунд, это вычисление просто t% 86400. Но если бы мы выражали время до 1970 года с использованием отрицательных чисел, правило "обрезать до нуля" дало бы бессмысленный результат! Используя правило пола, все работает отлично.

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

Кстати, для отрицательного b все просто переворачивается, и инвариант становится следующим:

0 >= r > b.

Так почему же C не делает это таким образом? Вероятно, аппаратное обеспечение не делало этого во время разработки C. И аппаратное обеспечение, вероятно, не делало этого таким образом, потому что в самом старом аппаратном обеспечении отрицательные числа были представлены как "знак + величина", а не как представление с двумя дополнениями, используемое в наши дни (по крайней мере для целых чисел). Моим первым компьютером был мэйнфрейм Control Data, и он использовал одно дополнение для целых чисел, а также для чисел с плавающей точкой. Образец из 60 означал отрицательный ноль!

Тим Питерс, который знает, где похоронены все скелеты Python с плавающей точкой, выразил некоторую обеспокоенность по поводу моего желания распространить эти правила на модули с плавающей точкой. Он наверное прав; Правило усечения к отрицательной бесконечности может привести к потере точности для x% 1.0, когда x - очень маленькое отрицательное число. Но этого недостаточно для того, чтобы разбить целое число по модулю, и//тесно связано с этим.

PS. Обратите внимание, что я использую//вместо / - это синтаксис Python 3, а также разрешено в Python 2 подчеркнуть, что вы знаете, что вызываете целочисленное деление. Оператор/в Python 2 неоднозначен, так как он возвращает другой результат для двух целочисленных операндов, чем для целого и с плавающей точкой или двух с плавающей точкой. Но это совершенно отдельная история; см. PEP 238.

Отправленный Гвидо ван Россумом в 9:49

Ответ 4

Модуль - это математическая операция, которую иногда называют "арифметикой часов". Я считаю, что описание его просто как остатка вводит в заблуждение и вводит в заблуждение, поскольку оно скрывает реальную причину, по которой он так часто используется в информатике. Это действительно используется, чтобы обернуть вокруг циклов.

Подумайте о часах. Предположим, вы смотрите на часы в "военное" время, где диапазон времени колеблется от 0:00 до 23,59. Теперь, если вы хотите, чтобы что-то происходило каждый день в полночь, вы бы хотели, чтобы текущее время мод 24 было равно нулю:

если (час% 24 == 0):

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

Ответ 5

Python - Основные операторы
http://www.tutorialspoint.com/python/python_basic_operators.htm

Модуль - делит левый операнд на правый операнд и возвращает остаток

а = 10 и б = 20

б% а = 0

Ответ 6

В большинстве языков% используется для модуля. Python не является исключением.

Ответ 7

Оператор% Modulo также можно использовать для печати строк (как в C), как это определено в Google https://developers.google.com/edu/python/strings.

      # % operator
  text = "%d little pigs come out or I'll %s and %s and %s" % (3, 'huff', 'puff', 'blow down')

Это кажется немного не по теме, но это, безусловно, поможет кому-то.

Ответ 8

Кроме того, есть полезная встроенная функция divmod:

divmod (a, b)

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

Ответ 9

x % y вычисляет остаток от деления x деленного на y где частным является целое число. Остаток имеет знак y.

На Python 3 расчет дает 6.75; это потому, что / делает истинное деление, а не целочисленное деление, как (по умолчанию) в Python 2. В Python 2 1/4 дает 0, а результат округляется в меньшую сторону.

Целочисленное деление может быть выполнено и на Python 3, с помощью оператора //, поэтому, чтобы получить 7 в результате, вы можете выполнить:

3 + 2 + 1 - 5 + 4 % 2 - 1 // 4 + 6

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

from __future__ import division

в качестве первой строки исходного кода в каждом исходном файле.

Ответ 10

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

http://docs.python.org/reference/expressions.html

Оператор% (modulo) дает остаток от деления первого аргумента на второй. Числовые аргументы сначала преобразуются в общий тип. Аргумент zero right вызывает исключение ZeroDivisionError. Аргументами могут быть числа с плавающей запятой, например, 3,14% 0,7 равно 0,34 (поскольку 3,14 равно 4 * 0,7 + 0,34.) Оператор по модулю всегда дает результат с тем же знаком, что и его второй операнд (или нуль); абсолютное значение результата строго меньше абсолютного значения второго операнда [2].

Ответ 11

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

Ответ 12

Помните, что

(3+2+1-5) + (4%2) - (1/4) + 6

даже если скобки приводят к 6.75 вместо 7, если рассчитывается в Python 3.4.

И оператор '/' также не так понятен (python2.7): try...

- 1/4

1 - 1/4

Здесь немного не по теме, но следует учитывать при оценке выражения:)

Ответ 13

Это, как и во многих C-подобных языках, операция останова или по модулю. См. Документацию для числовых типов - int, float, long, complex.

Ответ 14

Модуль - Делит левый операнд правой рукой и возвращает остаток.

Если это помогает:

1:0> 2%6
=> 2
2:0> 8%6
=> 2
3:0> 2%6 == 8%6
=> true

... и т.д.

Ответ 15

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

Модуль в целом:

Деление по модулю возвращает остальную часть операции математического деления. Это делается следующим образом:

Скажем, что мы имеем дивиденд 5 и делитель 2, следующая операция деления будет (приравнивается к x):

dividend = 5
divisor = 2

x = 5/2 

• Первым шагом в вычислении модуля является проведение целочисленного деления:

  x_int = 5//2 (целочисленное деление в python использует двойную косую черту)

  x_int = 2

• Затем вывод x_int умножается на делитель:

  x_mult = x_int * делитель x_mult = 4

• Наконец, дивиденд вычитается из x_mult

  divend - x_mult = 1

• Таким образом, операция модуля возвращает 1:

  5% 2 = 1

Применение для применения модуля к доле

Example: 2 % 5 

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

dividend = 2 
divisor = 5

Целочисленное деление приводит к 0, тогда как; поэтому, когда выполняется шаг 3 выше, значение дивиденда переносится (вычитается из нуля):

dividend - 0 = 2  —> 2 % 5 = 2 

Применение для применения модуля к отрицательному

Наступает разделение полов, в котором значение целочисленного деления округляется до наименьшего целочисленного значения:

import math 

x = -1.1
math.floor(-1.1) = -2 

y = 1.1
math.floor = 1

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

Применение вышеприведенных шагов в отношении следующих дивидендов и делителей иллюстрирует концепцию модуля:

dividend: -5 
divisor: 2 

Шаг 1: применить целочисленное деление

x_int = -5 // 2  = -3

Шаг 2: Умножьте результат целочисленного деления на делитель

x_mult = x_int * 2 = -6

Шаг 3: вычтите дивиденд из умноженной переменной, обратите внимание на двойной отрицательный.

dividend - x_mult = -5 -(-6) = 1

Таким образом:

-5 % 2 = 1

Ответ 16

Оператор% (modulo) дает остаток от деления первого аргумента на второй. Числовые аргументы сначала преобразуются в общий тип.

3 + 2 + 1 - 5 + 4% 2 - 1/4 + 6 = 7

Это основано на приоритете оператора.

Ответ 17

% modulo. 3 % 2 = 1, 4 % 2 = 0

/ является (целочисленным в этом случае) делением, поэтому:

3 + 2 + 1 - 5 + 4 % 2 - 1 / 4 + 6
1 + 4%2 - 1/4 + 6
1 + 0 - 0 + 6
7

Ответ 18

Это модульная операция http://en.wikipedia.org/wiki/Modulo_operation

http://docs.python.org/reference/expressions.html

Итак, с порядком операций, который работает

(3 + 2 + 1-5) + (4% 2) - (1/4) + 6

(1) + (0) - (0) + 6

7

1/4 = 0, потому что здесь мы делаем целочисленную математику.

Ответ 19

Я обнаружил, что самый простой способ понять оператор модуля (%) - это длинное деление. Это остаток и может быть полезен при определении числа, чтобы быть четным или нечетным:

4%2 = 0

  2
2|4
 -4
  0


11%3 = 2

  3
3|11
 -9
  2

Ответ 20

обычно, если вы разделите два числа, он вернет остаток от него:

Возьмите этот пример:===> 10% 3 =?..... да, это 1, Почему?

10/3 = 3 ===> 3 * 3 = 9 ==> 10 - 9 = 1