Какой результат% в Python?

https://stackoverflow.com/questions/4432208

09-10-2019
|

Вопрос

Что это % В расчете? Я не могу работать, что это делает.

Работает ли он проценты расчета, например: 4 % 2 по-видимому, равно 0. Как?

Решение

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

Взято из http://docs.ython.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, для которого это так называется страница.

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

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

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

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

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

Обновление для Python 3

Пользователь N00P Комментарии:

9/2 - 4.5 в Python. Вы должны сделать целое дивизию, как так: 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

В современном питоне 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 тогда как в Python и Ruby -11 % 5 = 4.

Хорошо половина причины объясняется Paulo Shardine., и остальное объяснение ниже здесь

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

Образец кода в SWIFT IOS.

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

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

Меня спросили (опять же), чтобы объяснить, почему целочисленное разделение в 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 are> = 0).

Если вы хотите, чтобы отношения были продлены для отрицательного A (хранения B положительных), у вас есть два варианта: если вы обретете q к нулю, R станет отрицательным, так что инвариантные изменения в 0 <= ABS (R) <в противном случае, вы Может пол q к негативной бесконечности, а инвариант остается 0 <= r <b. [Обновление: Исправлено этот пункт

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

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

Для отрицательного B, кстати, все просто переворачивает, а инвариант становится:

0 >= r > b.

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

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

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

Опубликовано Guido Van Rossum в 9:49

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

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

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

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

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

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

A = 10 и B = 20

b% a = 0

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

% 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 (a, b)

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

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.ython.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

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

Это, как у многих C-подобных языков, остаток или модуль операции. Увидеть Документация для числовых типов - int, float, длинный, сложный.

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

Если это поможет:

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 (целочисленное разделение в Python использует двойную косулью)

X_INT = 2.
Далее вывод X_INT умножается на Divisor:

x_mult = x_int * divisor 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

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

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

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

% является модуль. 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

Это модульная работаhttp://en.wikipedia.org/wiki/modulo_operation.

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

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

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

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

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

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

Как правило, если вы разделите два числа, он вернет оставшуюся часть:

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

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

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow