cosa significano questi operatori (**, ^,%, //)? - Python?

Question

diversi dagli operatori standard +, -, * e /; ma cosa significa questo (**, ^, %, //)?

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

Come circa l'operatore ^?

>>> 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%m restituisce un normale modulo resto, ma solo se m < x, perché è così? Cosa fa %?

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

Come circa l'operatore //? Che cosa fa?

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

Answer 1

• **: elevamento
• ^: esclusivo o (bit)
• %: modulo
• //: dividere con esito integrale (scarti resto)

Answer 2

È sono corretti che ** è il pow funzione.

^ è bit XOR bit.

% è infatti l'operazione di modulo, ma si noti che per i numeri positivi, x % m = x ogni volta m > x. Questo deriva dalla definizione di modulo. (Inoltre, Python specifica x % m per avere il segno di m.)

// è un'operazione di divisione che restituisce un numero intero scartando il resto. Questa è la forma standard di divisione che utilizza lo / nella maggior parte dei linguaggi di programmazione. Tuttavia, Python ha modificato il comportamento di / per eseguire la divisione in virgola mobile anche se gli argomenti sono numeri interi. L'operatore // stato introdotto in Python 2.6 e Python 3 per fornire un operatore integer divisione che si comportasse costantemente tra Python 2 e Python 3. Ciò significa:

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

Per ulteriori dettagli, vedere questa domanda: Division in Python 2.7. and 3.3

Answer 3

È possibile trovare tutti questi operatori nello Python language reference, anche se è necessario scorrere un po 'per trovarli tutti. Come hanno risposto altre risposte:

• L'operatore ** esegue l'esponenziazione. a ** b è a elevato alla potenza b.Lo stesso simbolo ** viene utilizzato anche nell'argomento delle funzioni e nelle notazioni di chiamata, con un significato diverso (passando e ricevendo argomenti di parole chiave arbitrarie).
• L'operatore ^ fa un xor binario. a^b restituirà un valore con solo i bit impostati in a o in b ma non entrambe. Questo è semplice!
• Il % operatore è in gran parte per trovare il modulo di due numeri interi. a % b restituisce il resto dopo aver diviso a per b. A differenza degli operatori modulo in alcuni altri linguaggi di programmazione (come C), in un modulo Python avrà lo stesso segno di b, piuttosto che lo stesso segno di a. Lo stesso operatore viene utilizzato anche per lo stile "vecchia" di formattazione di stringhe, così a % b può restituire una stringa se a è una stringa di formato e b è un valore (o tupla di valori) che può essere inserito in a.
• L'operatore fa // versione di Python di divisione intera. La divisione integer di Python non è esattamente la stessa della divisione intera offerta da altri linguaggi (come C), poiché va verso l'infinito negativo, piuttosto che verso lo zero. Insieme all'operatore modulo, puoi dire che a == (a // b)*b + (a % b). In Python 2, la divisione floor è il comportamento predefinito quando si dividono due numeri interi (utilizzando l'operatore di divisione normale /). Dato che questo può essere inaspettato (specialmente quando non sei schizzinoso su quali tipi di numeri ottieni come argomenti per una funzione), Python 3 è cambiato per rendere "vera" (virgola mobile) la divisione per la divisione che verrebbe arrotondata altrimenti, e farà la divisione "floor" solo quando richiesto esplicitamente. (Puoi anche ottenere il nuovo comportamento in Python 2 inserendo from __future__ import division nella parte superiore dei tuoi file. Lo consiglio vivamente!)