In Python ci sono tutti gli operatori cui linguaggi come il C o Java ci hanno abituati. Come in C, indici fra parentesi quadre si usano per accedere a singoli elementi di sequenze. Si possono pero' usare gli indici anche per estrarre sezioni delle sequenze (slicing). Le parentesi quadre sono a tutti gli effetti operatori, e, quando si creano classi,se ne puo' fare l'override. Alcuni operatori usati per i numeri sono ridefiniti per le sequenze, in modo da fare, su queste, operazioni particolari. Le stringhe hanno un operatore di formattazione, che si comporta in modo analogo alla funzione printf del C.
In Python 3 la divisione fra 2 interi fornisce un numero float. In Python 2 invece forniva un intero, troncando il risultato; in Python 3, per avere un risultato troncato, si usa l'operatore di divisione intera: '//' , sia su interi che float.
Operazioni fra interi danno interi, se uno dei 2 operandi e' un float viene prodotto un float; Python in questi casi fa conversioni automatiche.
| Operatore | Funzione | Esempi |
|---|---|---|
| ** | Elevamento a potenza | a**3 ; anche funzione pow(x,y) |
| * | Moltiplicazione | a*b ; 3*2 => 6 |
| / | Divisione | a/b ; 5/2 => 2.5 |
| // | Divisione intera | a//b ; 5//2.0 => 1.0 |
| % | Resto | a%b ; 5/2. => 1.0 |
| + | Addizione | a+b ; 2+5 => 7 |
| - | Sottrazione | a-b ; 2-5 => -3 |
Questi operatori hanno significato diverso se applicati ad oggetti diversi, ad esemio l'addizione si usa anche per concatenare stringhe, o sequenze.
Questi operatori agiscono sui numeri seguendo una logica binaria e cambiano i singoli bit delle variabili. Questi operatori sono definiti per interi con segno o booleani. Per come sono rappresentati i numeri negativi (complemento a 2), l'operatore '~' cambia segno agli interi e sottrae 1. Il complemento a 2 ha infatti i numeri negativi con il primo bit a sinistra che vale 1, ed ottiene numeri negativi invertendo i bit e sommando 1.
| Operatore | Funzione | Esempi |
|---|---|---|
| << | shift a sinistra | a<<1 ; 8<<1 fornisce 16 |
| >> | shift a destra | a>>1 ; 8>>1 fornisce 4 |
| & | or sui bit | a&b ; 2&1 fornisce 0 |
| | | and sui bit | a|b ; 2|1 fornisce 3 |
| ^ | or esclusivo | a^b ; 2^3 fornisce 1 |
| ~ | inverte i bit | ~a ; ~0 fornisce -1 |
In Python ci sono diversi operatori di assegnazione; ogni operazione numerica puo' essere combinata con una assegnazione, per modificare una variabile e riassegnarla a se stessa.
| Operatore | Funzione | Esempi |
|---|---|---|
| = | assegna riferimento | a=3 |
| *= | moltiplica ed assegna | a*=3 ; equivale ad a=a*3 |
| /= | divide ed assegna | a/=3 ; equivale ad a=a/3 |
| += | somma ed assegna | a+=3 ; equivale ad a=a+3 |
| -= | sottrae ed assegna | a-=3 ; equivale ad a=a-3 |
| //= | divisione intera ed assegna | a//=3 ; equivale ad a=a//3 |
| %= | resto ed assegna | a%=3 ; equivale ad a=a%3 |
| **= | potenza e assegna | a**=3;equivale ad a=a**3 |
| &= | or bitwise ed assegna | a&=1 ; equivale ad a=a&1 |
| |= | and bitwise ed assegna | a|=1 ; equivale ad a=a|1 |
| ^= | not bitwise ed assegna | a^=3 ; equivale ad a=^a |
| >>= | bit right shift ed assegna | a>>=3 ; equivale ad a=a>>3 |
| <<= | bit left shift ed assegna | a<<=3 ; equivale ad a=a<<3 |
L'assegnazione si comporta in modo diverso per oggetti mutabili e non mutabili; a=3 crea un oggetto immutabile "3" ed una reference "a", che punta ad esso; se riassegno la reference: a=3 ; b=a ; a=4 , Python, dopo aver creato una nuova reference "b" che punt a: "3", crea l'oggetto: "4" e riassegna la reference "a" all'oggetto "4". Il valore di "b" continua a valere 3. Se invece ho un oggetto mutabile, come una lista, nell'istruzione: a=[3] ; b=a ; a=[4] , la riassegnazione: b=a crea una reference "b", che punta anche lei a [3]. La lista e' unica, se la modifico tramite il riferimento a (a=[4] ) vedo modificato anche b.
In Python si possono fare assegnazioni multiple, ma il numero di oggetti a sinistra e destra deve essere lo stesso:
| Operazione | Commento |
|---|---|
| a,b = b,a | scambio dei valori di a e b |
| a,b,c=1,2,3 | assegna i numeri, in sequenza alle 3 variabili |
| a=1,2,3 | a diventa una tupla di 3 oggetti |
| c,d,e=a | funziona se a e' una tupla o lista di 3 oggetti |
| a,b=1 | provoca errore |
| a=b=3 | sia a che b sono riferimenti all'oggetto '3' |
In python 3 si possono fare assegnazioni multiple, di parti di un oggetto mettendo il resto in una lista:
a,*b = 1,2,3,4 # in b finisce la lista [2,3,4] a,*b, c = 1,2,3,4 # in b finisce la lista [2,3] , 4 va in c
Restituiscono uno degli argomenti.
| Operatore | Significato | Esempio |
|---|---|---|
| or | or logico | x or y |
| and | and logico | x and y |
| not | negazione | not x |
L'operatore "not" restituisce True o False a seconda di x .
Gli operatori "and" ed "or" restituiscono uno degli argomenti non, semplicemente, False o True.
x or y Vale x se x e' True, altrimenti valuta y e restituisce y x and y Vale x se x e' False, altrimenti valuta y e restituisce y x or y or z restituisce il primo vero (o l'ultimo) x and y and z restituisce il primo falso (o l'ultimo)
Restituiscono : True o False
| Operatore | Funzione | Esempi |
|---|---|---|
| > | maggiore | a > b |
| < | minore | a < b |
| <= | minore od eguale | a <= b |
| >= | maggiore od eguale | a >=b |
| == | eguale | a == b |
| != | diverso | b != b |
Si puo' controllare se una variabile e' in un intervallo con la sintassi compatta del tipo: 1 < a < 3
In Python 2 c'era anche l'operatore "<>" con lo stesso significato di "!="
L'operatore "in" restituisce True o False a seconda che un oggetto faccia parte di una sequenza, dizionario o set, l'operatore "is" controlla se due riferimenti puntano allo stesso oggetto.
| Operatore | Funzione | Esempi |
|---|---|---|
| in | vero se x compare in s | x in s |
| not in | vero se x non compare in s | x not in s |
| is | vero se x ed y sono lo stesso oggetto | x is y |
| is not | vero se non sono lo stesso oggetto | x is not y |
Questi separatori li abbiamo gia' visti nella descrizione della sintassi di Python. Alcuni si comportano come veri e propri operatori, ad esempio '[]' per gli indici delle sequenze oppure '()' per le chiamate a funzioni.
| separatore | Funzione |
|---|---|
| ( ) | racchiudono elementi di una tupla, chiama funzione |
| [ ] | racchiudono elementi di una lista, indici di sequenze |
| { } | racchiudono elementi di un dizionario o set |
| ; | separano istruzioni sulla stessa linea |
| ` ` | trasformano una variabile in una stringa (solo Python 2) |
| " " | racchiudono stringhe ( anche contenenti apici singoli ) |
| ' ' | racchiudono stringhe ( anche contenenti apici doppi ) |
Queste funzioni effettuano conversioni fra diversi tipi di variabili, o effettuano operazioni particolari, non sono proprio operatori, ma le elenco qui per completezza.
| Operatore | Funzione | Esempi |
|---|---|---|
| abs(x) | Valore assoluto | abs(-3) produce: 3 |
| divmod(x,y) | divisione e resto | divmod(5,2) produce: (2, 1) |
| int(x) | muta in intero (tronca) | int('3'), int(3.2) producono : 3 |
| float(x) | muta in float | a='3' ; float(a) produce: 3.0 |
| complex(r,i) | crea numero complesso | complex(3,2) produce: (3+2j) |
| c.conjugate() | complesso coniugato | (3+2j).conjugate() da: (3-2j) |
| round(x,n) | arrotonda, a n decimali | round(3.12345,2) da: 3.12 |
| bin(x) | rappresentazione binaria | bin(2) da: '0b10' |
| oct(x) | rappresentazione ottale | oct(8) da: '0o10' |
| hex(x) | rappresentazione esadecimale | hex(16) da: '0x10' |
| str(x) | muta in stringa | str(2.345) da: 2.345 |
| repr(x) | rappresenta oggetto come stringa | simile ad str |
Molte altre funzioni che operano sui numeri sono nel pacchetto "math", dedicato alle funzioni matematiche, ad esempio:
math.trunc(x) : tronca ad interi math.floor(x) : approssima all'intero piu' piccolo math.ceil(x) : approssima all'intero piu' grande
Sono sequenze, e quindi con elementi identificati da indice intero fra parentesi quadre, le liste, le tuple, i byte, i bytearray. Alle sequenze si applicano gli operatori della tabella seguente. Alcuni operatori, come +, assumono significato particolare se applicati a sequenze (si dice che per le classi delle sequenze si fa l'overloading dell'operatore).
Le operazioni che ottengono sottoinsiemi di sequenze sono dette di 'slicing', in italiano e' si trova l'orribile traduzione 'affettamento' ; ma 'sottosequenza' o 'sezione della sequenza' sarebbe una traduzione piu' decente. Indici negativi partono dal fondo della sequenza. Vedremo meglio le sequenze quando si tratteranno le stringhe e le liste.
| Operatore | Funzione | Esempi |
|---|---|---|
| in | vero se x compare in s | x in s |
| not in | vero se x non compare in s | x not in s |
| s + t | concatena sequenze | [1,2]+[4,5] da:[1,2,4,5] |
| s * n | ripete la sequenza | [1,2]*3 da: [1,2,1,2,1,2] |
| s[i] | elemento numero i | |
| s[i:j] | elementi da i a j, j escluso | |
| s[i:j:k] | da i a j con passo k | |
| len(s) | numero elementi nella sequenza | |
| min(s) | minimo elemento nella sequenza | |
| max(s) | massimo elemento nella sequenza | |
| s.count(x) | conta quante volte x e' nella sequenza | |
| s.index(x,i,j) | posizione di x nella sequenza, cercando fra posizioni i e j | |
| map(f,s) | applica la funzione f alla sequenza producendo una lista | |
Le liste ed i bytearray, come sequenze mutabili hanno anche tutte le operazioni per fare modifiche alla sequenza
| Operazione | Effetto |
|---|---|
| s[i] = x | modifica elemento i della sequenza |
| s[i:j] = t | modifica elementi da i a j (j escluso) |
| del s[i:j:k] | elimina elementi, gli indici dei restanti elementi cambiano |
| s.append(x) | aggiunge elemento in fondo, come: s[len(s):len(s)] = t |
| s.clear() | come del s[:] , svuota la sequenza |
| ss=s.copy() | fa una copia della sequenza s |
| s.insert(i, x) | come s[i:i]=[x], gli elementi seguenti cambiano di indice |
| s.pop(i) | estrae l'elemento i e lo elimina, pop() estrae l'ultimo |
| s.remove(x) | elimina il primo elemento di valore x che trova |
| s.reverse() | ribalta la sequenza |
| s.sort() | ordina la sequenza, modificandola |
La sintassi dell'operatore e':
'stringa di formattazione' % (tupla di valori)
La stringa di formattazione contiene dei "placeholder", simboli che vengono sostituiti dai valori della tupla, nell'ordine. Questi "placeholder" iniziano con il carattere: % ed indicano il formato con cui il valore viene rappresentato
Nella tabella alcuni esempi di questi "placeholders"
| Rappresentazione valore | ||
|---|---|---|
| %s | come stringa (usa funzione str()) | |
| %r | come stringa (usa funzione repr() | |
| %10s | stringa, occupa minimo 10 spazi | |
| %-10s | 10 spazi, ma allineato a sinistra | |
| %c | singolo carattere | |
| %5.1f | float in 5 spazi, una cifra decimale | |
| %5d | decimale, in 5 spazi | |
| %i | intero | |
| %08i | intero, in 8 spazi, ma spazi iniziali con degli zeri | |
Esempi:
a='%s %s %.2f' % (42,'stringa',1/3.0) produce: '42 stringa 0.33' a='%10d %-10s'%(12.3,'AAA') produce: ' 12 AAA '
Come nel linguaggio C, sono possibili sostituzioni complesse, in modo da creare stringhe che siano adatte a stampe di tabelle etc.
Esempio:
x=3 '%2d %3d %4d' % (x, x*x, x*x*x) produce: 3 9 27 %2d indica decimale con spazio per 2 cifre, %3d, con 3 cifre.
Si puo' anche usare un dizionario per le variabili da formattare:
template = '%(motto)s, %(pork)s and %(food)s' template % dict(motto='spam', pork='ham', food='eggs') produce: 'spam, ham and eggs'
Per formattare le stringhe python3 introduce la funzione "format()", python 3.6 le "f-string", che vedremo dopo.
La precedenza degli operatori e' nella lista seguente: da quelli con precedenza maggiore a quelli con precedenza minore:
creazione dizionari: { }
creazione liste []
creazione tuple( ) ,
funzioni , slicing, indici
riferimenti ad attributi di oggetti
esponente: **
operatori "unary" : +x, -x , ~x
operatori numerici: / // % * - +
operatori sui bit: << >> & ^ |
operatori logici: == != <> < <= > >=
Operatori di appartenenza: is in
operatori logici: not and or
generazione funzioni lambda (che vedremo dopo)
Nell'uso interattivo possono essere utili le funzioni dir ed help. La funzione dir: dir(oggetto) mostra gli operatori ed i membri dell'oggetto. La funzione help: help(oggetto.funzione) mostra cosa fa una funzione, in pratica stampa il suo docstring. La funzione vars(oggetto) mostra il dizionario delle variabili definite in un oggetto.