In questo tutorial imparerai tutto sui diversi tipi di operatori in Python, la loro sintassi e come usarli con esempi.
Video: operatori in Python
Cosa sono gli operatori in Python?
Gli operatori sono simboli speciali in Python che eseguono calcoli aritmetici o logici. Il valore su cui opera l'operatore è chiamato operando.
Per esempio:
>>> 2+3 5
Ecco +l'operatore che esegue l'addizione. 2e 3sono gli operandi ed 5è l'output dell'operazione.
Operatori aritmetici
Gli operatori aritmetici vengono utilizzati per eseguire operazioni matematiche come addizione, sottrazione, moltiplicazione, ecc.
| Operatore | Senso | Esempio |
|---|---|---|
| + | Aggiungi due operandi o più unario | x + y + 2 |
| - | Sottrai l'operando destro dal meno sinistro o unario | x - y- 2 |
| * | Moltiplica due operandi | x * y |
| / | Dividi l'operando sinistro per quello destro (risulta sempre in virgola mobile) | x / y |
| % | Modulo: resto della divisione dell'operando sinistro per quello destro | x% y (resto di x / y) |
| // | Divisione del piano: divisione che si traduce in un numero intero regolato a sinistra nella riga numerica | x // y |
| ** | Esponente: operando sinistro elevato alla potenza di destro | x ** y (x alla potenza y) |
Esempio 1: operatori aritmetici in Python
x = 15 y = 4 # Output: x + y = 19 print('x + y =',x+y) # Output: x - y = 11 print('x - y =',x-y) # Output: x * y = 60 print('x * y =',x*y) # Output: x / y = 3.75 print('x / y =',x/y) # Output: x // y = 3 print('x // y =',x//y) # Output: x ** y = 50625 print('x ** y =',x**y)
Produzione
x + y = 19 x - y = 11 x * y = 60 x / y = 3,75 x // y = 3 x ** y = 50625
Operatori di confronto
Gli operatori di confronto vengono utilizzati per confrontare i valori. Restituisce o Trueo in Falsebase alla condizione.
| Operatore | Senso | Esempio |
|---|---|---|
| > | Maggiore di: vero se l'operando sinistro è maggiore di quello destro | x> y |
| < | Minore di: vero se l'operando sinistro è minore di quello destro | x <y |
| == | Uguale a: vero se entrambi gli operandi sono uguali | x == y |
| ! = | Diverso da: vero se gli operandi non sono uguali | x! = y |
| > = | Maggiore o uguale a - Vero se l'operando sinistro è maggiore o uguale a destra | x> = y |
| <= | Minore o uguale a - Vero se l'operando sinistro è minore o uguale a destra | x <= y |
Esempio 2: operatori di confronto in Python
x = 10 y = 12 # Output: x> y is False print('x> y is',x>y) # Output: x < y is True print('x < y is',x= y is False print('x>= y is',x>=y) # Output: x <= y is True print('x <= y is',x<=y)
Produzione
x> y è False x = y è False x <= y è True
Operatori logici
Gli operatori logici sono i and, or, notoperatori.
| Operatore | Senso | Esempio |
|---|---|---|
| e | Vero se entrambi gli operandi sono veri | x e y |
| o | Vero se uno degli operandi è vero | xo y |
| non | Vero se l'operando è falso (completa l'operando) | non x |
Esempio 3: operatori logici in Python
x = True y = False print('x and y is',x and y) print('x or y is',x or y) print('not x is',not x)
Produzione
xey è False x o y è True non x è False
Ecco la tabella della verità per questi operatori.
Operatori bit per bit
Gli operatori bit per bit agiscono sugli operandi come se fossero stringhe di cifre binarie. Operano poco a poco, da cui il nome.
Ad esempio, 2 è 10in binario e 7 è 111.
Nella tabella seguente: Sia x = 10 ( 0000 1010in binario) ey = 4 ( 0000 0100in binario)
| Operatore | Senso | Esempio |
|---|---|---|
| & | Bitwise AND | x & y = 0 ( 0000 0000) |
| | | OR bit per bit | x | y = 14 ( 0000 1110) |
| ~ | Bitwise NON | ~ x = -11 ( 1111 0101) |
| ^ | Bitwise XOR | x y = 14 ( 0000 1110) |
| >> | Spostamento bit per bit a destra | x >> 2 = 2 ( 0000 0010) |
| << | Spostamento a sinistra bit per bit | x << 2 = 40 (0010 1000) |
Assignment operators
Assignment operators are used in Python to assign values to variables.
a = 5 is a simple assignment operator that assigns the value 5 on the right to the variable a on the left.
There are various compound operators in Python like a += 5 that adds to the variable and later assigns the same. It is equivalent to a = a + 5.
| Operator | Example | Equivalent to |
|---|---|---|
| = | x = 5 | x = 5 |
| += | x += 5 | x = x + 5 |
| -= | x -= 5 | x = x - 5 |
| *= | x *= 5 | x = x * 5 |
| /= | x /= 5 | x = x / 5 |
| %= | x %= 5 | x = x % 5 |
| //= | x //= 5 | x = x // 5 |
| **= | x **= 5 | x = x ** 5 |
| &= | x &= 5 | x = x & 5 |
| |= | x |= 5 | x = x | 5 |
| ^= | x ^= 5 | x = x 5 |
| >>= | x>>= 5 | x = x>> 5 |
| <<= | x <<= 5 | x = x << 5 |
Special operators
Python language offers some special types of operators like the identity operator or the membership operator. They are described below with examples.
Identity operators
is and is not are the identity operators in Python. They are used to check if two values (or variables) are located on the same part of the memory. Two variables that are equal does not imply that they are identical.
| Operator | Meaning | Example |
|---|---|---|
| is | True if the operands are identical (refer to the same object) | x is True |
| is not | True if the operands are not identical (do not refer to the same object) | x is not True |
Example 4: Identity operators in Python
x1 = 5 y1 = 5 x2 = 'Hello' y2 = 'Hello' x3 = (1,2,3) y3 = (1,2,3) # Output: False print(x1 is not y1) # Output: True print(x2 is y2) # Output: False print(x3 is y3)
Output
False True False
Here, we see that x1 and y1 are integers of the same values, so they are equal as well as identical. Same is the case with x2 and y2 (strings).
But x3 and y3 are lists. They are equal but not identical. It is because the interpreter locates them separately in memory although they are equal.
Membership operators
ine not insono gli operatori di appartenenza in Python. Sono usati per verificare se un valore o una variabile si trova in una sequenza (stringa, lista, tupla, insieme e dizionario).
In un dizionario possiamo solo verificare la presenza della chiave, non il valore.
| Operatore | Senso | Esempio |
|---|---|---|
| nel | Vero se viene trovato un valore / una variabile nella sequenza | 5 in x |
| Non in | Vero se il valore / la variabile non viene trovato nella sequenza | 5 non in x |
Esempio # 5: operatori di appartenenza in Python
x = 'Hello world' y = (1:'a',2:'b') # Output: True print('H' in x) # Output: True print('hello' not in x) # Output: True print(1 in y) # Output: False print('a' in y)
Produzione
Vero Vero Vero Falso
Qui 'H'è in x ma 'hello'non è presente in x (ricorda, Python distingue tra maiuscole e minuscole). Allo stesso modo, 1è la chiave ed 'a'è il valore nel dizionario y. Quindi, 'a' in yritorni False.
