About
Swaroop C H is 29 years of age. He is a coder and startupper. He has previously worked at Yahoo!, Adobe, his own startup and Infibeam.
Views
Support
Personal tools
COLLECTION
Collection
Python it:Operatori ed espressioni
From Notes
Contents |
Introduzione
Molte istruzioni (linee logiche) contengono delle espressioni. Un semplice esempio di espressione è 2 + 3. Ogni espressione può essere scomposta in operatori ed operandi.
Gli operatori sono funzioni che svolgono una particolare azione e sono rappresentate da simboli come il + o da parole chiave. Gli operatori richiedono dati su cui operare; tali dati sono chiamati operandi. In questo caso, 2 e 3 costituiscono gli operandi.
Operatori
Segue una breve panoramica sugli operatori e sul loro uso.
Gli esempi forniti possono essere direttamente provati nella shell interattiva. Per esempio, per valutare l´espressione 2 + 3, si usa direttamente l´interprete interattivo di comandi di Python:
>>> 2 + 3 5 >>> 3 * 5 15 >>>
|
Operatore |
Nome |
Spiegazione |
Esempi |
|---|---|---|---|
|
+ |
Più |
Somma due oggetti |
3 + 5 restituisce 8. 'a' + 'b' restituisce 'ab'. |
|
- |
Meno |
Ritorna un numero negativo oppure la differenza tra i due operandi |
-5.2 restituisce un numero negativo. 50 - 24 restituisce 26. |
|
* |
Moltiplicazione |
Rende il prodotto dei due operandi oppure ripete una stringa n volte. |
2 * 3 restituisce 6. 'la' * 3 restituisce 'lalala'. |
|
** |
Elevamento a potenza |
Ritorna x elevato alla potenza y |
3 ** 4 restituisce 81 (p.e. 3 * 3 * 3 * 3) |
|
/ |
Divisione |
Divide x per y |
4 / 3 restituisce 1.3333333333333333. |
|
// |
Arrotondamento di una divisione |
Restituisce l´arrotondamento per difetto di una divisione |
4 // 3 restituisce 1. |
|
% |
Modulo |
Restituisce il resto del quoziente tra i due operandi |
8 % 3 restituisce 2. -25.5 % 2.25 restituisce 1.5. |
|
<< |
Shift a sinistra |
Sposta a sinistra i bit del primo operando del numero di posizioni specificato dal secondo operando ( Si ricordi che ogni numero è rappresentato in memoria da una sequenza di bit 0 e 1 ). |
2 << 2 restituisce 8. 2 nel codice binario è rappresentato da 10. Operare uno spostamento a sinistra di 2 bit restituisce 1000 la rappresentazione binaria del numero decimale 8. |
|
>> |
Shift a destra |
Sposta a destra i bit del primo operando del numero di posizioni specificato dal secondo operando. |
11 >> 1 restituisce 5. 11 viene rappresentato in binario dal numero 1011. Operare uno spostamento a destra di 1 bit restituisce il numero binario 101, il cui equivalente decimale è il numero 5. |
|
& |
Operatore binario AND |
Esegue un AND logico tra ogni corrispondente bit dei due operandi. |
5 & 3 restituisce 1. |
|
| |
Operatore binario OR |
Esegue un OR logico tra ogni corrispondente bit dei due operandi. |
5 | 3 restituisce 7 |
|
^ |
Operatore binario XOR |
Esegue uno XOR logico tra ogni corrispondente bit dei due operandi. |
5 ^ 3 restituisce 6 |
|
~ |
Inversione binaria |
L'inversione binaria di x è -(x+1) |
~5 restituisce -6. |
|
< |
Minore di |
Restituisce True se il primo operando è minore del secondo. Tutti gli operatori di comparazione restituiscono True se il confronto è vero, False in caso contrario. Da notare che il nome del valore restituito inizia con la lettera maiuscola. |
5 < 3 restituisce False e 3 < 5 restituisce True. I confronti comparativi possono essere valutati in cascata: 3 < 5 < 7 restituisce True. |
|
> |
Maggiore di |
Restituisce True se il primo operando è maggiore del secondo. |
5 > 3 restituisce True. Se entrambi gli operandi sono numerici, vengono prima convertiti in un tipo comune. Altrimenti il confronto risulterebbe sempre False. |
|
<= |
Minore o uguale a |
Restituisce True se il primo operando è minore o uguale al secondo. |
x = 3; y = 6; x <= y restituisce True. |
|
>= |
Maggiore o uguale a |
Restituisce True se il primo operando è maggiore o uguale al secondo. |
x = 4; y = 3; x >= 3 restituisce True. |
|
== |
Uguale a |
Confronta se i due operandi sono uguali |
x = 2; y = 2; x == y restituisce True. x = 'str'; y = 'stR'; x == y restituisce False. x = 'str'; y = 'str'; x == y restituisce True. |
|
!= |
Diverso da |
Confronta se i due operandi sono diversi |
x = 2; y = 3; x != y rstituisce True. |
|
not |
NOT booleano |
Se x è True, restituisce False. Se x è False, restituisce True. |
x = True; not x restituisce False. |
|
and |
AND booleano |
x and y restituiscono False se x è False, altrimenti viene restituita la valutazione booleana di y |
x = False; y = True; x and y restituisce False dato che x è False. In questo caso il Python non valuta y sapendo che il valore risultante dell´espressione sarà comunque False (x è False). Questo procedimento valutativo si chiama valutazione di corto-circuito. |
|
or |
OR booleano |
Se x è True, restituisce True, altrimenti viene restituita la valutazione booleana di y |
x = True; y = False; x or y restituisce True. Anche in questo caso si parla di valutazione di corto-circuito. |
Scorciatoia per operazione matematiche e di assegnamento
E' comune eseguire operazioni matematiche su una variable e riassegnare alla stessa il risultato dell'operazione, quello che segue è una scoriatoia per espressioni di questo tipo.
E' possibile scrivere:
a = 2; a = a * 3
così come:
a = 2; a *= 3
Notare che var = var operazione espressione diventa var operazione= espressione.
Precedenza tra gli operatori
Nel caso si abbia un´espressione del tipo 2 + 3 * 4, verrà valutata prima la somma od il prodotto? La scuola insegna che deve essere prima svolto il prodotto; l´operatore del prodotto (*) ha precedenza sull´operatore di addizione (+).
La tabella che segue riporta le precedenze che Python attribuisce agli operatori matematici, ordinata da quello a priorità più bassa a quello a più alta. Ciò significa che, in una data espressione, Python prima valuterà gli operatori posti in fondo alla tabella, per poi passare a valutare quelli in cima.
La tabella presa dal Python reference manual è fornita per completezza. Tuttavia, si raccomanda l´ uso di parentesi per il raggruppamento logico degli operatori e degli operandi e per specificare in modo esplicito le precedenze, rendendo al tempo stesso il programma più leggibile. Si veda Cambiare l'ordine della valutazione di seguito.
|
Operatore |
Descrizione |
|---|---|
|
lambda |
Espressione Lambda |
|
or |
OR booleano |
|
and |
AND booleano |
|
not x |
NOT booleano |
|
in, not in |
Test di appartenenza |
|
is, is not |
Test di identità |
|
<, <=, >, >=, !=, == |
Comparatori |
|
| |
OR binario |
|
^ |
XOR binario |
|
& |
AND binario |
|
<<, >> |
Shift |
|
+, - |
Addizione e sottrazione |
|
*, /, //, % |
Moltiplicazione, divisione, arrotondamento e resto |
|
+x, -x |
Positivo, negativo |
|
~x |
NOT binario |
|
** |
Elevazione a potenza |
|
x.attribute |
Riferimento ad un attributo |
|
x[index] |
Subscription |
|
x[index1:index2] |
Affettamento |
|
f(arguments ...) |
Chiamata a funzione |
|
(expressions, ...) |
Visualizzare tuple |
|
[expressions, ...] |
Visualizzare liste |
|
{key:datum, ...} |
Visualizzare dizionari |
Cambiare l'ordine di valutazione
Per rendere le espressioni più leggibili, si possono usare le parentesi. Per esempio 2 + (3 * 4) è sicuramente più comprensibile di 2 + 3 * 4 che richiede la conoscenza sulla precedenza degli operatori. Come con qualsiasi altra cosa, le parentesi dovrebbero venire usate in modo ragionevole (senza abusarne) e non dovrebbero essere ridondanti (come in 2 + (3 + 4)).
Un valore aggiunto con l'uso delle parentesi è che aiutano a cambiare l'ordine di valutazione. Per esempio, se in un'espressione si vuole che un'addizione venga valutata prima di una moltiplicazione , si può scrivere qualcosa come (2 + 3) * 4.
Associatività
Gli operatori vengono di solito associati da sinistra a destra, e gli operatori con la stessa precedenza vengono valutati da sinistra a destra. Per esempio: 2 + 3 + 4 viene valutata come (2 + 3) + 4. Alcuni operatori, come operatori di assegnamento, hanno una associatività da destra a sinistra, come in a = b = c viene trattato come a = (b = c).
Espressioni
Esempio:
#!/usr/bin/python # Filename: expression.py base = 5 altezza = 2 area = base * altezza print('L\'area è', area) print('Il perimetro è', 2 * (base + altezza))
Output:
$ python expression.py L'area è 10 Il perimetro è 14
Funzionamento
La base e l'altezza di un rettangolo vengono memorizzate in variabili con il loro nome. Queste vengono usate per calcolare l'area ed il perimetro del rettangolo con l'aiuto di un'espressione. Il risultato dell'espressione base * altezza viene memorizzato nella variabile area e stampato usando l'istruzione print. Nel secondo caso, si usa direttamente il valore dell'espressione 2 * (base + altezza) con l'istruzione print.
Si noti anche come Python stampa l'output in modo semplice. Anche se non viene specificato uno spazio tra 'L'area è' e la variabile area, Python lo inserisce automaticamente rendendo sia l'output che il programma più leggibile (dato che non ci si deve preoccupare degli spazi nell'output). Questo è un esempio di come Python rende semplice la vita dei programmatori.
Sommario
In questo capitolo è stato trattato l'uso di operatori, operandi ed espressioni i quali compongono i blocchi di base di ogni programma. Il prossimo capitolo tratterà come utilizzarli nei programmi attraverso l'uso di istruzioni.
Please add your comments by clicking on the 'Discussion' link in the left sidebar.