Что делает %
в расчете? Я не могу понять, что это делает.
Работает ли это, например, процент от расчета: 4% 2
, по-видимому, равно 0. Как?
Оператор% (по модулю) дает остаток от деления первого аргумента на второй. Числовые аргументы сначала преобразуются в общий тип. Аргумент нулевого права поднимает исключение 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.
Несколько не по теме, %
также используется в операциях форматирования строк, таких как % =
, чтобы заменить значения в строку:
>>> x = 'abc_%(key)s_'
>>> x %= {'key':'value'}
>>> x
'abc_value_'
Опять же, не по теме, но это, кажется, небольшая документированная функция, которая заняла у меня некоторое время, чтобы отследить, и я думал, что это связано с вычислением Pythons по модулю, для которого эта страница SO занимает высокое место.
Выражение типа x% y
оценивается как остаток от x & # 247; y
- ну, технически это «модуль» вместо «напоминание», поэтому результаты могут отличаться, если сравнивать с другими языками, где %
является оператором остатка. Есть некоторые тонкие различия (если вас интересуют практические последствия см. Также «Почему Python Integer Division Floors» ниже).
Приоритет такой же, как у операторов /
(разделение) и *
(умножение).
>>> 9 / 2
4
>>> 9 % 2
1
Python gotcha : в зависимости от используемой версии Python, %
также является (устарела) оператор интерполяции строк, так что будьте осторожны, если вы пришли с языка с автоматическим типом кастинга (как PHP или JS) где выражение типа '12 ' % 2 + 3
является законным: в Python это приведет к TypeError: не все аргументы, преобразованные во время форматирования строки
, что, вероятно, будет довольно запутанным для вас.
[обновление для Python 3]
Пользователь n00p комментирует:
9/2 - это 4,5 в питоне. Вы должны выполнить целочисленное деление следующим образом: 9 //2, если вы хотите, чтобы питон сообщал вам, сколько целых объектов осталось после деления (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. Можете ли вы объяснить, почему
-11% 5 = 4
- dahiya_boy
Это странно, верно? Если вы попробуете это в JavaScript:
> -11 % 5
-1
Это связано с тем, что в JavaScript %
является оператором «остаток», а в Python - оператором «модуль» (математика часов).
Вы можете получить объяснение непосредственно из GvR:
Редактировать - dahiya_boy
В Java и iOS -11% 5 = -1
, тогда как в питоне и рубине -11% 5 = 4
.
Ну, половина причины объясняется Пауло Скардин , а остальная часть объяснения здесь ниже
В Java и iOS %
дает остаток, который означает, что если вы разделяете 11% 5 , дает Quotient = 2, а остаток = 1
и - 11% 5 даетQuotient = -2 и остаток = -1
.
Пример кода в быстрой iOS.
Но когда мы говорим о питоне, это дает модуль часов. И его работа с ниже формулой
mod (a, n) = a - {n * Floor (a / n)}
Это значит,
mod (11,5) = 11 - {5 * Этаж (11/5)} = > 11 - {5 * 2}
Итак, mod (11,5) = 1
А также
mod (-11,5) = -11 - 5 * Этаж (11/5) = > -11 - {5 * (-3)}
Итак, mod (-11,5) = 4
Пример кода в питоне 3.0.
Почему Python Integer Division Floors
Сегодня меня попросили (снова) объяснить, почему целочисленное деление в 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
(при условии, что a и b > = 0).
Если вы хотите, чтобы отношения продолжались до отрицательного (сохраняя б положительно) у вас есть два варианта: если вы усекаете q к нулю, r станет отрицательным, так что инвариант изменяется на 0 <= абс(р) & Лт; в противном случае, Вы можете пол Q к отрицательной бесконечности, и инвариант остается 0 <= r < б. [обновление: исправлено в этом пункте]
В математической теории чисел математики всегда предпочитают последний выбор (см., Например,. Википедия). Для Python я сделал такой же выбор, потому что есть некоторые интересные приложения по модулю операции, где знак a неинтересен. Подумайте о том, чтобы взять метку времени POSIX (секунды с начала 1970 года) и превратить ее во время дня. Поскольку в день 24 * 3600 = 86400 секунд, этот расчет составляет просто t% 86400. Но если бы мы выражали время до 1970 года, используя отрицательные числа, правило «усечь к нулю» дало бы бессмысленный результат! Используя правило пола, все работает нормально.
Другие приложения, о которых я думал, это вычисления пиксельных позиций в компьютерной графике. Я уверен, что есть еще.
Для отрицательного b, кстати, все просто переворачивается, и инвариант становится:
0 >= r > b.
Так почему же С не делает это так?? Вероятно, оборудование не делало этого в то время, когда был разработан C. И аппаратное обеспечение, вероятно, не делало этого таким образом, потому что на самом старом аппаратном обеспечении отрицательные числа были представлены как «знак + величина», а не как представление дополнений двух, используемое в наши дни (по крайней мере, для целых чисел). Моим первым компьютером был мэйнфрейм Control Data, и он использовал свое дополнение как для целых чисел, так и для поплавков. Шаблон из 60 означал отрицательный ноль!
Тим Питерс, который знает, где похоронены все скелеты с плавающей запятой Python, выразил некоторое беспокойство по поводу моего желания распространить эти правила на плавающую точку по модулю. Он, вероятно, прав; правило усечения к отрицательному бесконечности может привести к потере точности для x% 1,0, когда x - очень небольшое отрицательное число. Но мне недостаточно разбить целое число по модулю, и // тесно связан с этим.
PS. Обратите внимание, что я использую // вместо / - это синтаксис Python 3, а также разрешено в Python 2 подчеркивать, что вы знаете, что вызываете целочисленное деление. Оператор / в Python 2 неоднозначен, поскольку он возвращает другой результат для двух целочисленных операндов, чем для int и float или двух поплавков. Но это совершенно отдельная история; см. PEP 238.
Автор: Гвидо ван Россум, 9:49 утра
Модуль - это математическая операция, иногда описываемая как «арифметика часов».«Я считаю, что описание его как простого остатка вводит в заблуждение и сбивает с толку, потому что оно маскирует реальную причину, по которой оно так часто используется в информатике. Это действительно используется, чтобы обернуть циклы.
Подумайте о часах: предположим, вы смотрите на часы в «военное» время, где диапазон времени идет от 0:00 до 23,59. Теперь, если вы хотите, чтобы что-то происходило каждый день в полночь, вы бы хотели, чтобы текущее время мод 24 было нулевым:
if (час% 24 == 0):
Вы можете думать о всех часах истории, которые снова и снова оборачиваются вокруг круга по 24 часа, и текущий час дня - это бесконечно длинное число мод 24. Это гораздо более глубокая концепция, чем просто остаток, это математический способ борьбы с циклами, и это очень важно в информатике. Он также используется для обертывания массивов, что позволяет увеличить индекс и использовать модуль для переноса обратно в начало после достижения конца массива.
Python - Основные операторы http://www.tutorialspoint.com/python/python_basic_operators.htm
Модуль - делит левую операнду правой рукой операнд и возвращает остаток
а = 10 и б = 20
б% а = 0
Оператор% 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')
Это, кажется, немного не по теме, но это, безусловно, поможет кому-то.
Также есть полезная встроенная функция, называемая divmod
:
Divmod (а, б)
Возьмите два (не сложных) числа в качестве аргументов и верните пару чисел состоящий из их отношения и остаток при использовании длинного деления.
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
как первая строка исходного кода в каждом исходном файле.
Оператор модуля, он обычно используется для разделения остатков на целых числах, но в Python можно использовать для чисел с плавающей запятой.
http://docs.python.org/reference/expressions.html
Оператор% (по модулю) дает остаток от деления первого аргумента на второй. Числовые аргументы сначала преобразуются в общий тип. Аргумент нулевого права поднимает исключение ZeroDivisionError. Аргументы могут быть числами с плавающей запятой, например,.3,14% 0,7 равно 0,34 (поскольку 3,14 равно 4 * 0,7 + 0,34.) Оператор по модулю всегда дает результат с тем же знаком, что и его второй операнд (или ноль); абсолютное значение результата строго меньше абсолютного значения второго операнда [2].
Это операция по модулю, за исключением случаев, когда это старомодный оператор форматирования строк в стиле C, а не операция по модулю . Смотрите здесь для деталей. Вы увидите много этого в существующем коде.
Знай это
(3+2+1-5) + (4%2) - (1/4) + 6
даже с скобками получается 6,75 вместо 7, если рассчитывается в Python 3.4.
И оператор '/' тоже не так прост для понимания (python2.7): попробуйте...
- 1/4
1 - 1/4
Это немного не по теме, но следует учитывать при оценке приведенного выше выражения :)
как правило, если вы разделите два числа, оно вернет оставшуюся часть:
Возьмем этот пример: === > 10% 3 = ?..... да это 1, почему ?
10/3 = 3 === > 3 * 3 = 9 == > 10 - 9 = 1
Это, как и во многих C-подобных языках, остаток или по модулю операции. См. [документация для числовых типов - int, float, long, complex][1].
[1]: http://docs.python.org/library/stdtypes.html?highlight = Remainder # числовые типы-int-float-long-complex
Модуль - Разделит левую операнду правой рукой операнда и возвращает остаток.
Если это поможет:
1:0> 2%6
=> 2
2:0> 8%6
=> 2
3:0> 2%6 == 8%6
=> true
и так далее...
Мне было трудно легко найти конкретные варианты использования для использования% онлайн, например,. почему разделение дробного модуля или деление отрицательного модуля приводит к ответу, который он делает. Надеюсь, это поможет прояснить подобные вопросы:
Модуль деления в целом:
Разделение модуля возвращает остаток операции математического деления. Это делает это следующим образом:
Скажем, у нас есть дивиденд 5 и делитель 2, будет проведена следующая операция деления (уравненная x):
dividend = 5
divisor = 2
x = 5/2
Первым шагом в расчете модуля является проведение целочисленного деления:
x_int = 5 // 2 (целое деление в питоне использует двойную косую черту)
x_int = 2
Затем выходные данные x_int умножаются на делитель:
x_mult = x_int * делитель x_mult = 4
Наконец, дивиденд вычитается из x_mult
дивиденд - 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
Это по модулю операции 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, потому что мы делаем целочисленную математику здесь.
Оператор% (по модулю) дает остаток от деления первого аргумента на второй. Числовые аргументы сначала преобразуются в общий тип.
3 + 2 + 1 - 5 + 4% 2 - 1/4 + 6 = 7
Это основано на приоритете оператора.
Я обнаружил, что самый простой способ понять оператора модуля (%) - это длинное деление. Это остаток, который может быть полезен при определении числа, которое будет четным или нечетным:
4%2 = 0
2
2|4
-4
0
11%3 = 2
3
3|11
-9
2