Operatorn % (modulo) ger återstoden från divisionen av det första argumentet med det andra. De numeriska argumenten konverteras först till en gemensam typ. Ett högerargument som är noll ger upphov till undantaget ZeroDivisionError. Argumenten kan vara flyttalstal, t.ex. 3,14%0,7 är lika med 0,34 (eftersom 3,14 är lika med 4*0,7 + 0,34). Modulo-operatorn ger alltid ett resultat med samma tecken som den andra operanden (eller noll); resultatets absoluta värde är strikt mindre än det absoluta värdet av den andra operanden [2].

Taget från http://docs.python.org/reference/expressions.html

Exempel 1: 6%2 utvärderas till 0 eftersom det inte finns någon rest om 6 divideras med 2 ( 3 gånger ).

Exempel 2: **Exempel: 7%2 utvärderas till 1 eftersom det finns en rest på 1 när 7 divideras med 2 ( 3 gånger ).

Så för att sammanfatta det, så returnerar den återstoden av en divisionsoperation, eller 0 om det inte finns någon återstoden. Så 6%2 betyder att man hittar resten av 6 dividerat med 2.

Ett uttryck som x % y utvärderar resten av x ÷ y - tekniskt sett är det "modulus" istället för "reminder" så resultatet kan bli annorlunda om du jämför med andra språk där % är restoperatorn. [Det finns några subtila skillnader] (https://rob.conery.io/2018/08/21/mod-and-remainder-are-not-the-same/) (om du är intresserad av de praktiska konsekvenserna se även "Why Python's Integer Division Floors" nedan). Precedensen är densamma som operatörerna / (division) och * (multiplikation).

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

• 9 dividerat med 2 är lika med 4.
• 4 gånger 2 är 8
• 9 minus 8 är 1 - återstoden. Python gotcha: Beroende på vilken Python-version du använder är % också den (föråldrade) stränginterpolationsoperatorn, så se upp om du kommer från ett språk med automatisk typbrytning (som PHP eller JS) där ett uttryck som '12' % 2 + 3 är lagligt: i Python kommer det att resultera i TypeError: not all arguments converted during string formatting, vilket troligen kommer att vara ganska förvirrande för dig. [uppdatering för Python 3] Användarens n00p-kommentarer:

  9/2 är 4,5 i Python. Du måste göra en heltalsdivision på följande sätt: 9//2 om du vill att Python ska berätta hur många hela objekt som återstår efter division(4). För att vara exakt, helhetsdivision brukade vara standard i Python 2 (tänk på att det här svaret är äldre än min pojke som redan går i skolan och på den tiden 2.x var mainstream):

$ 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

I modern Python ger 9 / 2 verkligen 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

[uppdatering] Användaren dahiya_boy frågade i kommentarsessionen: Kan du förklara varför -11 % 5 = 4 - dahiya_boy Detta är konstigt, eller hur? Om du provar detta i JavaScript:

> -11 % 5
-1

Detta beror på att % i JavaScript är operatorn "rest" medan det i Python är operatorn "modulus" (klockmatematik).
Du kan få [förklaringen direkt från GvR] (http://python-history.blogspot.com/2010/08/why-pythons-integer-division-floors.html):

Redigera - dahiya_boy I Java och iOS -11 % 5 = -1 medan i python och ruby -11 % 5 = 4. Hälften av orsaken förklaras av Paulo Scardine, och resten av förklaringen finns här nedan. I Java och iOS ger % återstoden, dvs. om du dividerar 11 % 5 får du Kvot = 2 och återstoden = 1 och -11 % 5 ger Kvot = -2 och återstoden = -1. Exempel på kod i swift iOS. [![ange bildbeskrivning här][1]]][1][1] Men när vi talar om i python ger den klockmodul. Och det fungerar med nedanstående formel mod(a,n) = a - {n Floor(a/n)}. Det betyder, mod(11,5) = 11 - {5 Floor(11/5)} => 11 - {5 2}. Så,mod(11,5) = 1. Och mod(-11,5) = -11 - 5 Floor(11/5) => -11 - {5 * (-3)}`. Så,mod(-11,5) = 4`. Exempel på kod i python 3.0. [![ange bildbeskrivning här][2]]][2][2]

Varför Python's helhetsdivisionsgolv?

Jag blev idag ombedd (igen) att förklara varför heltalsdivision i Python returnerar resultatet i golvet i stället för att trunka mot noll som i C.

För positiva tal är det ingen överraskning:

>>> 5//2
2

Men om en av operanderna är negativ blir resultatet golvat, dvs. avrundat från noll (mot negativ oändlighet):

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

Detta stör en del människor, men det finns ett bra matematiskt skäl. Helhetsdivisionen (//) och dess syskon, modulooperationen (%), går ihop och uppfyller ett trevligt matematiskt förhållande (alla variabler är heltal):

a/b = q with remainder r

så att

b*q + r = a and 0  (förutsatt att a och b är >= 0).
>
> Om du vill att förhållandet ska sträcka sig till negativa a (med b positivt) har du två val: om du trunker q mot noll kommer r att bli negativt, så att invarianten ändras till 0  I matematisk talteori föredrar matematiker alltid det senare alternativet (se t.ex. [Wikipedia][3]). För Python gjorde jag samma val eftersom det finns en del intressanta tillämpningar av modulo-operationen där tecknet på a är ointressant. Tänk på att ta en POSIX-tidsstämpel (sekunder sedan början av 1970) och omvandla den till klockslag. Eftersom det finns 24*3600 = 86400 sekunder på en dag är denna beräkning helt enkelt t % 86400. Men om vi skulle uttrycka tider före 1970 med hjälp av negativa tal skulle "truncate towards zero" regeln ge ett meningslöst resultat! Om vi använder golvregeln blir allting bra.
>
> Andra tillämpningar som jag har tänkt på är beräkningar av pixelpositioner i datorgrafik. Jag är säker på att det finns fler.
>
> För negativt b, förresten, vänds allting bara om, och invarianten blir:

0 >= r > b.

> Så varför gör inte C det på detta sätt? Troligen gjorde hårdvaran inte detta när C utformades. Och hårdvaran gjorde förmodligen inte det på detta sätt eftersom negativa tal i den äldsta hårdvaran representerades som "tecken + magnitud" snarare än den tvåkomplementsrepresentation som används idag (åtminstone för heltal). Min första dator var en stordator från Control Data och den använde ett komplement för heltal och även för flyttal. Ett mönster med 60 ettor betydde negativ nolla!
>
> Tim Peters, som vet var alla Pythons skelett med flytande punkter ligger begravda, har uttryckt en viss oro över min önskan att utvidga dessa regler till att omfatta modulo med flytande punkter. Han har förmodligen rätt; truncate-towards-negative-infinity-regeln kan orsaka precisionsförlust för x%1.0 när x är ett mycket litet negativt tal. Men det räcker inte för mig för att bryta heltalsmodulo, och // är nära kopplat till detta.
>
> PS. Observera att jag använder // i stället för / -- detta är Python 3 syntax, och även tillåtet i Python 2 för att betona att du vet att du åberopar heltalsdivision. Operatorn / i Python 2 är tvetydig, eftersom den ger ett annat resultat för två heltalsoperander än för en int och en float eller två floats. Men det är en helt annan historia; se PEP 238.
>
> Skrivet av Guido van Rossum kl. 9:49
  [1]: https://i.stack.imgur.com/33rAl.png
  [2]: https://i.stack.imgur.com/A9Q0C.png
  [3]: https://en.wikipedia.org/wiki/Modulo_operation

Modulusoperatorn används vanligtvis för restdivision av heltal, men i Python kan den användas för flyttalstal.

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

Operatören % (modulo) ger resten av divisionen av det första argumentet med det andra. De numeriska argumenten konverteras först till en gemensam typ. Ett högerargument som är noll ger upphov till undantaget ZeroDivisionError. Argumenten kan vara flyttalstal, t.ex. 3,14%0,7 är lika med 0,34 (eftersom 3,14 är lika med 4*0,7 + 0,34). Modulo-operatorn ger alltid ett resultat med samma tecken som den andra operanden (eller noll); resultatets absoluta värde är strikt mindre än det absoluta värdet av den andra operanden [2].