Operatoren % (modulo) giver resten af divisionen af det første argument med det andet. De numeriske argumenter konverteres først til en fælles type. Et højre nul-argument giver anledning til undtagelsen ZeroDivisionError. Argumenterne kan være tal med flydende komma, f.eks. 3,14%0,7 er lig med 0,34 (da 3,14 er lig med 4*0,7 + 0,34.) Modulo-operatoren giver altid et resultat med samme fortegn som den anden operand (eller nul); resultatets absolutte værdi er strengt taget mindre end den absolutte værdi af den anden operand [2].

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

Eksempel 1: 6%2 evalueres til 0, fordi der ikke er nogen rest, hvis 6 divideres med 2 ( 3 gange ).

Eksempel 2: 7%2 evalueres til 1, fordi der er en rest på 1, når 7 divideres med 2 ( 3 gange ).

Så for at opsummere det, returnerer den resten af en divisionsoperation, eller 0 hvis der ikke er nogen rest. Så 6%2 betyder at finde resten af 6 divideret med 2.

Et udtryk som x % y evaluerer til resten af x ÷ y - teknisk set er det dog "modulus" i stedet for "rest" så resultaterne kan være anderledes, hvis du sammenligner med andre sprog, hvor % er restoperatoren. [Der er nogle subtile forskelle] (https://rob.conery.io/2018/08/21/mod-and-remainder-are-not-the-same/) (hvis du er interesseret i de praktiske konsekvenser, se også "Why Python's Integer Division Floors" bellow). Præcedens er den samme som operatorer / (division) og * (multiplikation).

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

• 9 divideret med 2 er lig med 4.
• 4 gange 2 er 8
• 9 minus 8 er 1 - restbeløbet. Python gotcha: afhængigt af hvilken Python-version du bruger, er % også den (forældede) string-interpolationsoperator, så pas på, hvis du kommer fra et sprog med automatisk type casting (som PHP eller JS), hvor et udtryk som '12' % 2 + 3 er lovligt: i Python vil det resultere i TypeError: not all arguments converted during string formatting, hvilket sandsynligvis vil være ret forvirrende for dig. [opdatering til Python 3] Bruger n00p kommentarer:

  9/2 er 4.5 i python. Du skal lave heltalsdivision på denne måde: 9//2, hvis du vil have python til at fortælle dig, hvor mange hele objekter der er tilbage efter division(4). For at være helt præcis, så plejede heltalsdivision at være standard i Python 2 (husk, dette svar er ældre end min dreng, der allerede går i skole og på det tidspunkt 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 moderne Python 9 / 2 resulterer 4.5 faktisk:

$ 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

[opdatering] Bruger dahiya_boy spurgte i kommentarsessionen: Kan du venligst forklare hvorfor -11 % 5 = 4 - dahiya_boy Det er da underligt, ikke? Hvis du prøver dette i JavaScript:

> -11 % 5
-1

Det skyldes, at % i JavaScript er operatoren "rest" mens det i Python er operatoren "modulus" (urmatematik).
Du kan få forklaringen direkte fra GvR:

Rediger - dahiya_boy I Java og iOS er -11 % 5 = -1, mens det i python og ruby er -11 % 5 = 4. Godt halvdelen af årsagen er forklaret af Paulo Scardine, og resten af forklaringen er nedenfor her I Java og iOS giver % resten, dvs. hvis du dividerer 11 % 5 giver det Kvotient = 2 og resten = 1 og -11 % 5 giver Kvotient = -2 og resten = -1. Eksempel på kode i swift iOS. [![indtast billedbeskrivelse her][1]]][1] Men når vi taler om i python giver det clock modulus. Og dens arbejde med nedenstå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` Og `mod(-11,5) = -11 - 5 * Floor(11/5) => -11 - {5 * (-3)} Så mod(-11,5) = 4 Eksempel på kode i python 3.0. [![indtast billedbeskrivelse her][2]]][2]

Hvorfor Python's Integer Division Floors

Jeg blev i dag (igen) bedt om at forklare, hvorfor heltalsdivision i Python returnerer gulvet af resultatet i stedet for at afkortes mod nul som i C.

For positive tal er der ingen overraskelse:

>>> 5//2
2

Men hvis en af operanderne er negativ, bliver resultatet afrundet, dvs. afrundet væk fra nul (mod negativ uendelighed):

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

Dette forstyrrer nogle mennesker, men der er en god matematisk grund til det. Heltalsdivisionsoperationen (//) og dens søskende, modulo-operationen (%), går sammen og opfylder et fint matematisk forhold (alle variabler er heltal):

a/b = q with remainder r

således at

b*q + r = a and 0  (under forudsætning af at a og b er >= 0).
>
> Hvis du ønsker, at forholdet skal udvides til at gælde for negativ a (idet b forbliver positiv), har du to muligheder: Hvis du afkorter q mod nul, bliver r negativ, så invarianten ændres til 0  I matematisk talteori foretrækker matematikere altid det sidste valg (se f.eks. [Wikipedia][3]). I Python har jeg truffet det samme valg, fordi der er nogle interessante anvendelser af modulo-operationen, hvor tegnet på a er uinteressant. Overvej at tage et POSIX-tidsstempel (sekunder siden starten af 1970) og omdanne det til klokkeslæt. Da der er 24*3600 = 86400 sekunder i en dag, er denne beregning simpelthen t % 86400. Men hvis vi skulle udtrykke tider før 1970 ved hjælp af negative tal, ville "truncate towards zero" reglen give et meningsløst resultat! Ved at bruge gulvreglen går det hele fint.
>
> Andre anvendelser, som jeg har tænkt på, er beregninger af pixelpositioner i computergrafik. Jeg er sikker på, at der er flere.
>
> For negativ b, i øvrigt, alting bare flips, og den invariant bliver:

0 >= r > b.

> Så hvorfor gør C det ikke på denne måde? Sandsynligvis gjorde hardwaren det ikke på det tidspunkt, hvor C blev designet. Og hardwaren gjorde det sandsynligvis ikke på denne måde, fordi negative tal i den ældste hardware blev repræsenteret som "tegn + størrelse" i stedet for den tokomplementrepræsentation, der anvendes i dag (i det mindste for hele tal). Min første computer var en Control Data-mainframe, og den brugte et komplement til hele tal og også til floats. Et mønster på 60 enere betød negativt nul!
>
> Tim Peters, som ved hvor alle Pythons skelet til flydende komma er begravet, har udtrykt en vis bekymring over mit ønske om at udvide disse regler til at omfatte modulo til flydende komma. Han har sikkert ret; truncate-towards-negative-infinity-reglen kan medføre præcisionstab for x%1.0, når x er et meget lille negativt tal. Men det er for mig ikke nok til at bryde heltalsmodulo, og // er tæt koblet til det.
>
> PS. Bemærk at jeg bruger // i stedet for / -- det er Python 3 syntaks, og også tilladt i Python 2 for at understrege at man ved at man påkalder heltalsdivision. Operatoren / i Python 2 er tvetydig, da den returnerer et andet resultat for to heltalsoperander end for en int og en float eller to floats. Men det'er en helt anden historie; se PEP 238.
>
> Indsendt af 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

Modulus-operatoren bruges typisk til restdivision af hele tal, men i Python kan den også bruges til flydende tal.

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

Operatoren % (modulo) giver resten af divisionen af det første argument med det andet. De numeriske argumenter konverteres først til en fælles type. Et højre nul-argument giver anledning til undtagelsen ZeroDivisionError. Argumenterne kan være tal med flydende komma, f.eks. 3,14%0,7 er lig med 0,34 (da 3,14 er lig med 4*0,7 + 0,34.) Modulo-operatoren giver altid et resultat med samme fortegn som den anden operand (eller nul); resultatets absolutte værdi er strengt taget mindre end den absolutte værdi af den anden operand [2].