Wat doet de %
in een berekening? Ik kan er maar niet achter komen wat het doet.
Werkt het een percentage van de berekening uit, bijvoorbeeld: 4 % 2
is blijkbaar gelijk aan 0. Hoe?
De % (modulo) operator geeft de rest van de deling van het eerste argument door het tweede. De numerieke argumenten worden eerst geconverteerd naar een gemeenschappelijk type. Een nulrechts argument leidt tot de exception ZeroDivisionError. De argumenten kunnen drijvende komma getallen zijn, bv. 3.14%0.7 is gelijk aan 0.34 (aangezien 3.14 gelijk is aan 4*0.7 + 0.34.) De modulo-operator geeft altijd een resultaat met hetzelfde teken als zijn tweede operand (of nul); de absolute waarde van het resultaat is strikt kleiner dan de absolute waarde van de tweede operand [2].
Overgenomen van http://docs.python.org/reference/expressions.html
Voorbeeld 1:
6%2
evalueert naar 0
omdat er'geen rest is als 6 gedeeld wordt door 2 ( 3 keer ).
Voorbeeld 2: 7%2
evalueert naar 1
omdat er'een rest van 1
is als 7 wordt gedeeld door 2 ( 3 keer ).
Dus om dat samen te vatten, het geeft de rest van een delingsoperatie terug, of 0
als er geen rest is. Dus 6%2
betekent dat je de rest vindt van 6 gedeeld door 2.
Een uitdrukking als x % y
evalueert naar de rest van x ÷ y
- wel, technisch gezien is het "modulus" in plaats van "reminder" dus de resultaten kunnen anders zijn als je vergelijkt met andere talen waar %
de rest-operator is. Er zijn enkele subtiele verschillen (als u geïnteresseerd bent in de praktische gevolgen zie ook "Why Python's Integer Division Floors" hieronder).
De voorrang is hetzelfde als bij de operatoren /
(deling) en *
(vermenigvuldiging).
>>> 9 / 2
4
>>> 9 % 2
1
%
ook de (deprecated) string interpolation operator, dus kijk uit als je uit een taal komt met automatische type casting (zoals PHP of JS) waar een expressie als '12' % 2 + 3
legaal is: in Python zal het resulteren in TypeError: not all arguments converted during string formatting
wat waarschijnlijk behoorlijk verwarrend zal zijn voor je.
[update voor Python 3]
Gebruiker n00p commentaar:9/2 is 4.5 in python. Je moet integer delen als volgt doen: 9//2 als je wilt dat python je vertelt hoeveel hele objecten er overblijven na deling(4). Om precies te zijn, integer division was vroeger de standaard in Python 2 (let wel, dit antwoord is ouder dan mijn jongen die al op school zit en in de tijd dat 2.x mainstream waren):
$ 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
In moderne Python resulteert 9 / 2
inderdaad in 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
[update] Gebruiker dahiya_boy vroeg in de commentaarsessie:
Q. Kunt u alstublieft uitleggen waarom
-11 % 5 = 4
- dahiya_boy Dit is raar, toch? Als je dit in JavaScript probeert:
> -11 % 5
-1
%
de "rest" operator is terwijl het in Python de "modulus" (klok wiskunde) operator is.Edit - dahiya_boy In Java en iOS
-11 % 5 = -1
terwijl in python en ruby-11 % 5 = 4
. Nou de helft van de reden wordt uitgelegd door de Paulo Scardine, en de rest van de uitleg is hier onder In Java en iOS,%
geeft de rest, dat betekent als je deelt 11 % 5 geeftQuotient = 2 en rest = 1
en -11 % 5 geeftQuotient = -2 en rest = -1
. Voorbeeldcode in swift iOS. [![Voer hier de beschrijving van de afbeelding in][1]][1] Maar als we het hebben over in python geeft het clock modulus. En het werkt met onderstaande formulemod(a,n) = a - {n * Floor(a/n)}
Dat betekent,mod(11,5) = 11 - {5 * Floor(11/5)} => 11 - {5 * 2}
Dus,mod(11,5) = 1
Enmod(-11,5) = -11 - 5 * Floor(11/5) => -11 - {5 * (-3)}
Dus,mod(-11,5) = 4
Steekproefcode in python 3.0. [![vul hier de beschrijving van de afbeelding in][2]][2]Waarom Python's Integer Division Floors
Ik werd vandaag (weer) gevraagd om uit te leggen waarom integer division in Python de floor van het resultaat retourneert in plaats van truncating naar nul zoals in C.
Voor positieve getallen is er'geen verrassing:
>>> 5//2
2
Maar als een van de operanden negatief is, wordt het resultaat gevloerd, d.w.z. van nul weg afgerond (naar negatieve oneindigheid):
>>> -5//2
-3
>>> 5//-2
-3
Dit stoort sommige mensen, maar er is een goede wiskundige reden voor. De gehele delingsoperatie (//) en zijn broer of zus, de modulo operatie (%), gaan samen en voldoen aan een mooie wiskundige relatie (alle variabelen zijn gehele getallen):
a/b = q with remainder r
zo dat
b*q + r = a and 0 <= r < b
(ervan uitgaande dat a en b >= 0 zijn).
Als je de relatie wilt uitbreiden voor negatieve a (waarbij b positief blijft), heb je twee keuzes: als je q afknot naar nul, wordt r negatief, zodat de invariant verandert in 0 <= abs(r) < anders kun je q afknotten naar negatieve oneindigheid, en blijft de invariant 0 <= r < b. [update: deze alinea gerepareerd].
In de mathematische getaltheorie geven wiskundigen altijd de voorkeur aan de laatste keuze (zie bijv. [Wikipedia][3]). Voor Python heb ik dezelfde keuze gemaakt omdat er een aantal interessante toepassingen van de modulo operatie zijn waarbij het teken van a oninteressant is. Neem nu een POSIX tijdstempel (seconden sinds het begin van 1970) en verander het in de tijd van de dag. Aangezien er 24*3600 = 86400 seconden in een dag zitten, is deze berekening eenvoudig t % 86400. Maar als we de tijd vóór 1970 zouden uitdrukken in negatieve getallen, dan zou de "truncate towards zero" regel een nietszeggend resultaat geven! Met de bodemregel komt het allemaal goed.
Andere toepassingen die ik'heb bedacht zijn berekeningen van pixelposities in computergraphics. Ik'ben er zeker van dat er meer zijn.
Voor negatieve b, trouwens, draait alles gewoon om, en de invariant wordt:
0 >= r > b.
Dus waarom doet C het niet op deze manier? Waarschijnlijk deed de hardware dit niet op het moment dat C werd ontworpen. En de hardware deed het waarschijnlijk niet op deze manier omdat in de oudste hardware negatieve getallen werden weergegeven als "teken + magnitude" in plaats van de twee's complement weergave die tegenwoordig wordt gebruikt (althans voor gehele getallen). Mijn eerste computer was een Control Data mainframe en die gebruikte one's complement voor gehele getallen en ook voor vlottende getallen. Een patroon van 60 enen betekende een negatieve nul!
Tim Peters, die weet waar alle Python's floating point skeletten zijn begraven, heeft enige bezorgdheid geuit over mijn wens om deze regels uit te breiden naar floating point modulo. Hij'heeft waarschijnlijk gelijk; de truncate-towards-negative-infinity regel kan precisieverlies veroorzaken voor x%1.0 wanneer x een heel klein negatief getal is. Maar dat'is voor mij niet genoeg om integer modulo te doorbreken, en // is daar nauw aan gekoppeld.
PS. Merk op dat ik // gebruik in plaats van / -- dit is Python 3 syntaxis, en ook toegestaan in Python 2 om te benadrukken dat je weet dat je een beroep doet op integer division. De / operator in Python 2 is ambigu, omdat het een ander resultaat geeft voor twee gehele operanden dan voor een int en een float of twee floats. Maar dat'is een heel ander verhaal; zie PEP 238.
Gepost door Guido van Rossum om 9:49 AM
Modulus operator, wordt meestal gebruikt voor restdelingen op gehele getallen, maar kan in Python ook gebruikt worden voor drijvende komma getallen.
http://docs.python.org/reference/expressions.html
De % (modulo) operator geeft de rest van de deling van het eerste argument door het tweede. De numerieke argumenten worden eerst geconverteerd naar een gemeenschappelijk type. Een nulrechts argument leidt tot de exception ZeroDivisionError. De argumenten kunnen drijvende komma getallen zijn, bv. 3.14%0.7 is gelijk aan 0.34 (aangezien 3.14 gelijk is aan 4*0.7 + 0.34.) De modulo-operator geeft altijd een resultaat met hetzelfde teken als zijn tweede operand (of nul); de absolute waarde van het resultaat is strikt kleiner dan de absolute waarde van de tweede operand [2].