Wat betekenen deze operatoren (** , ^ , %, //)?

Anders dan de standaard operators +, -, *en /; maar wat betekenen deze (**, ^, %, //) ?

>>> 9+float(2) # addition
11.0
>>> 9-float(2) # subtraction
7.0
>>> 9*float(2) # multiplication
18.0
>>> 9/float(2) # division
4.5
>>>
>>> 9**float(2) # This looks like a square, (i.e. power 2) 
81.0
>>> 9**float(3) # So ** is equivalent to `math.pow(x,p)` ?
729.0

Hoe zit het met de operator ^?

>>> 9^int(2) # What is `^` in `x^u` , it only allows `int` for `u`
11
>>> 9^int(3)
10
>>> 9^int(4)
13
>>> 9^int(5)
12
>>> 9^int(6)
15
>>> 9^int(7)
14
>>> 9^int(8)
1
>>> 9^int(9)
0
>>> 9^int(10)
3
>>> 9^int(11)
2
>>> 9^int(12)
5

%in x%mretourneert een normale restmodulus, maar alleen als m < x, waarom is dat zo? Wat doet %?

>>> 9%float(2)
1.0
>>> 9%float(3)
0.0
>>> 9%float(4)
1.0
>>> 9%float(5)
4.0
>>> 9%float(6)
3.0
>>> 9%float(7)
2.0
>>> 9%float(8)
1.0
>>> 9%float(9)
0.0
>>> 9%float(10)
9.0
>>> 9%float(11)
9.0
>>> 9%float(12)
9.0

Hoe zit het met de operator //? wat doet het?

>>> 9//float(2)
4.0
>>> 9//float(3)
3.0
>>> 9//float(4)
2.0
>>> 9//float(5)
1.0
>>> 9//float(6)
1.0
>>> 9//float(7)
1.0
>>> 9//float(8)
1.0
>>> 9//float(9)
1.0
>>> 9//float(1)
9.0
>>> 9//float(0.5)
18.0

Antwoord 1, autoriteit 100%

• **: machtsverheffing
• ^: exclusief-of (bitsgewijs)
• %: modulus
• //: delen met integraal resultaat (rest weggooien)

Antwoord 2, autoriteit 29%

Je kunt al deze operators echter vinden in de Python-taalreferentieje zult een beetje moeten scrollen om ze allemaal te vinden. Zoals andere antwoorden al hebben gezegd:

• De operator **voert machtsverheffen uit. a ** bis atot de macht bverheven. Hetzelfde **-symbool wordt ook gebruikt in functieargumenten en aanroepnotaties, met een andere betekenis (willekeurige trefwoordargumenten doorgeven en ontvangen).
• De operator ^doet een binaire xor. a ^ bretourneert een waarde met alleen de bits die zijn ingesteld in aof in b, maar niet beide. Deze is eenvoudig!
• De %operator is meestal om de modulus van twee gehele getallen te vinden. a % bRetourneert het restant na het delen van adoor b. In tegenstelling tot de Modulus-operators in een aantal andere programmeertalen (zoals C), heeft een modulus in Python een modulus hetzelfde teken als b, in plaats van hetzelfde bord als a. Dezelfde operator wordt ook gebruikt voor de “oude” stijl van string-opmaak, dus a % bkan een string retourneren als aeen indelingsreeks is en bis een waarde (of tuple van waarden) die in akan worden ingevoegd.
• De //Operator doet Python’s versie van Integer Division. Python’s Integer-divisie is niet precies hetzelfde als de integer-divisie die wordt aangeboden door een aantal andere talen (zoals C), omdat het rondet naar negatieve oneindigheid, in plaats van naar nul. Samen met de Modulus-operator kunt u zeggen dat a == (a // b)*b + (a % b). In Python 2 is Floor Division het standaardgedrag wanneer u twee gehele getallen verdeelt (met behulp van de normale divisie-exploitant /). Aangezien dit onverwacht kan zijn (vooral als u niet kieskeurig bent over welke soorten nummers u als argumenten voor een functie krijgt), is Python 3 gewijzigd om “True” (drijvend punt) divisie de norm voor divisie te maken die zou worden afgesloten Anders, en het zal alleen “vloer” divisie doen wanneer expliciet wordt gevraagd. (Je kunt ook het nieuwe gedrag in Python 2 krijgen door from __future__ import divisionbovenaan je bestanden te plaatsen. Ik raad het ten zeerste aan!)

Antwoord 3, Autoriteit 8%

U klopt dat **de stroomfunctie is.

^is bitwise XOR.

%is inderdaad de modulusbewerking, maar noteer dat voor positieve cijfers, x % m = xwanneer m > x. Dit volgt uit de definitie van modulus. (Bovendien specificeert Python x % mom het teken van mte hebben.)

//is een divisiebewerking die een geheel getal retourneert door het restant te verwijderen. Dit is de standaardvorm van divisie met behulp van de /in de meeste programmeertalen. Python 3 veranderde het gedrag van /om drijvende divisie uit te voeren, zelfs als de argumenten geheel getallen zijn . De operator //werd geïntroduceerd in Python 2.6 en Python 3 om een ​​integer-divisie-operator te verschaffen die zich consequent zou gedragen tussen Python 2 en Python 3. Dit betekent:

| context                                | `/` behavior   | `//` behavior |
---------------------------------------------------------------------------
| floating-point arguments, Python 2 & 3 | float division | int divison   |
---------------------------------------------------------------------------
| integer arguments, python 2            | int division   | int division  |
---------------------------------------------------------------------------
| integer arguments, python 3            | float division | int division  |

Zie deze vraag voor meer informatie: Divisie in Python 2.7. en 3.3