Operatori in Python

Proprio come in matematica, i linguaggi di programmazione come Python hanno gli operatori. Puoi pensarli come funzioni estremamente semplici alla base dell’informatica. Sono le operazioni più elementari a cui si può ridurre un programma. Sono conoscenze essenziali per qualsiasi aspirante Data Scientist o Software Engineer.

In questo tutorial imparerai

• I diversi tipi di operatori: Aritmetici, Di assegnazione, Di confronto e Logici
• Overloading degli operatori
• Precedenza
• Associatività

Se vuoi approfondire le basi del linguaggio di programmazione Python, dai un’occhiata al nostro corso gratuito Intro to Python for Data Science.

Operatori aritmetici

Probabilmente li conosci già, perché provengono dalla matematica di base.

Gli operatori aritmetici sono addizione (+), sottrazione (-), moltiplicazione (*), divisione (/), esponenziazione (**), divisione intera (//) e modulo (%). I primi quattro sono piuttosto semplici; sono addizione, sottrazione, moltiplicazione e divisione, e probabilmente ti sono già familiari.

# Addition
print(5 + 2)

# Subtraction
print(5 - 2)

# Multiplication
print(5 * 2)

# Division
print(5 / 2)

7
3
10
2.5

Gli altri tre sono un po’ più complicati. L’operatore di esponenziazione significa "elevato alla potenza di". Per esempio, 2 ** 3 significa che 2 è moltiplicato per sé stesso 3 volte, quindi 2 ** 3 equivale a 2 * 2 * 2, che fa 8.

La divisione intera è come la divisione normale, tranne per il fatto che il risultato viene sempre arrotondato per difetto. Nell’esempio qui sotto, 5 è diviso per 2, il che dà 2.5. Ma poiché è una divisione intera, 2.5 viene arrotondato a 2.

Infine, il modulo è il resto della divisione. Nel caso di 5%2, il numero 2 sta in 5 solo due volte, il che significa che il resto è 1.

# Exponent
print(5 ** 2)
# This is the same as 5 * 5

# Floor Division
print(5 // 2)

# Modulus
print(5 % 2)

25
2
1

In Python, l’operatore di addizione può anche essere usato per concatenare stringhe. Questo significa che verranno unite in un’unica stringa, per esempio:

firstName = "Théo"

introduction = "Hi, my name is " + firstName + "."

print(introduction)

Hi, my name is Théo.

Operatori di assegnazione

Se hai un po’ di esperienza di programmazione, avrai certamente già usato gli operatori di assegnazione. Assegnano un certo valore a una variabile. Il più usato è =. Per usarlo, digita semplicemente il nome della variabile a cui vuoi assegnare un nuovo valore, il = e il valore da assegnare. Per esempio, se vuoi assegnare il valore 100 alla variabile balance, puoi fare così:

balance = 100
print(balance)

100

Se vuoi incrementare il valore di balance di 10, puoi usare balance += 10. È equivalente a balance = balance + 10, ma è molto più breve.

balance += 10
print(balance)

110

Lo stesso vale per -=: balance -= 10 è uguale a balance = balance - 10:

print(balance)
balance -= 10
print(balance)

110
100

Gli altri operatori di assegnazione funzionano esattamente allo stesso modo. Sono:

• *=
• /=
• **=
• //=
• %=

Operatori di confronto

Puoi usare gli operatori di confronto per, indovina un po’, confrontare i valori delle variabili. Restituiscono sempre un valore booleano, cioè True o False. Ce ne sono sei:

• Uguale: ==
• Diverso: !=
• Maggiore di: >
• Minore di: <
• Maggiore o uguale a: >=
• Minore o uguale a: <=

Ecco alcuni esempi di confronto:

a = 3
b = 5

print(a == b) # Equal
print(a != b) # Not equal
print(a > b) # Greater than
print(a < b) # Less than
print(a >= b) # Greater than or equal to
print(a <= b) # Less than or equal to

False
True
False
True
False
True

== e != possono anche essere usati per confrontare stringhe invece di numeri. Gli altri operatori non sono compatibili con le stringhe, dato che una stringa non può davvero essere maggiore di un’altra stringa.

print("Hello" == "World")
print("Python" != "R")

False
True

Operatori logici

Potresti già conoscerli! In logica, sono chiamati connettivi logici. Sono anche molto usati nel linguaggio naturale. Sono: and, or e not.

and restituisce True solo se entrambi gli operandi (i due oggetti booleani che stai confrontando) sono True. Per esempio:

print(True and True)
print(True and False)
print(False and False)

True
False
False

Per capire il comportamento di questo operatore logico, puoi usare una tavola di verità:

or è True ogni volta che almeno uno degli operandi è True.

print(True and True)
print(True and False)

True
False

Nota che funzionano anche con più di due operandi, per esempio:

print(True and True and True and True)
print(True and True and True and False)
print(False or False or False or False)
print(False or False or False or True)

True
False
False
True

not restituisce l’opposto del suo operando, quindi True se viene passato False e viceversa.

print(not True)

False

Overloading degli operatori

Ricorda che prima hai visto come + possa essere usato per sommare numeri, ma anche per concatenare, o combinare, stringhe. Quindi + funziona in modo diverso a seconda del tipo di oggetto su cui lo usi. Ma non è sempre così. A volte, l’operatore con cui stai lavorando non supporta il tipo di oggetto su cui vuoi usarlo.

Ecco un esempio. Diciamo che hai due oggetti Dog, ozzy e filou. Appartengono alla classe Dog qui sotto. Puoi pensare alla classe come a un modello di come devono essere fatti gli oggetti e come devono comportarsi. In questo caso, gli oggetti Dog hanno un nome, un’età e un’altezza. Dopo aver definito la classe, puoi istanziare gli oggetti. Uno è Ozzy, di 3 anni e alto 30 centimetri. L’altro è Filou, ha 5 anni ed è alto 65 centimetri.

Questo esempio usa il concetto di programmazione orientata agli oggetti. Se vuoi saperne di più, leggi il nostro tutorial su Programmazione orientata agli oggetti in Python

Supponiamo che tu voglia confrontare i due cani con il maggiore di: >. Questo non funzionerà. Otterrai un errore che dice '>' not supported between instances of 'Dog' and 'Dog'. Significa che > non sa come confrontare oggetti della classe Dog.

class Dog:

    def __init__(self, name, age, height):  
        self.name = name
        self.age = age
        self.height = height

ozzy = Dog("Ozzy", 3, 30)
filou = Dog("Filou", 5, 65)

print(filou > ozzy)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-96-428069ab24cc> in <module>()
      9 filou = Dog("Filou", 5, 65)
     10
---> 11 print(filou > ozzy)


TypeError: '>' not supported between instances of 'Dog' and 'Dog'

Per fortuna, con l’overloading degli operatori puoi definire il comportamento dell’operatore quando viene chiamato su oggetti Dog. In questo caso, deve essere definito un metodo chiamato __gt__, che significa "maggiore di", e che accetta due argomenti. Poiché vogliamo confrontare i cani in base alla loro altezza, il metodo restituisce self.height > other.height.

class Dog:

    def __init__(self, name, age, height):  
        self.name = name
        self.age = age
        self.height = height

    def __gt__(self,other):
        return self.height > other.height

ozzy = Dog("Ozzy", 3, 30)
filou = Dog("Filou", 5, 65)

print(filou > ozzy)
print(ozzy > filou)

True
False

Precedenza

Quando combini molti operatori, le cose possono diventare confuse. Guarda l’esempio qui sotto:

a = 2
b = 3
c = 9

a ** b > 5 and c - a // b >= 9 or b ** 2 == c

True

Come fai a sapere quale verrà eseguito per primo? Come dovresti leggere una riga di codice con molti di questi simboli? Viene eseguito da sinistra a destra o c’è un ordine specifico?

Qui entra in gioco la precedenza. Gli operatori Python vengono eseguiti in un ordine molto specifico, e alcuni hanno priorità su altri.

Nella tabella seguente puoi vedere la precedenza degli operatori, in ordine dall’alto verso il basso. Queste regole sono le stesse in matematica, dove alcuni calcoli in una formula devono essere eseguiti prima di altri.

Associatività

Hai visto che la precedenza conta! Ma che dire di quelli che sono allo stesso livello di precedenza, come moltiplicazione e divisione? Vengono eseguiti nello stesso momento? No. *, \, % e \\ vengono eseguiti da sinistra a destra, mentre ** viene eseguito da destra a sinistra. Questo si chiama associatività.

Guarda il seguente esempio. In questo caso, gli operatori verranno eseguiti da sinistra a destra e l’output è 3.

print(5 * 2 // 3)

3

Aggiungendo però le parentesi, puoi cambiare l’ordine di esecuzione degli operatori. Questa è l’associatività, che funziona allo stesso modo della matematica. Qualsiasi cosa sia tra parentesi viene calcolata per prima. In questo caso, verrà eseguita prima la divisione intera, seguita dalla moltiplicazione.

print(5 * (2 // 3))

Conclusione

Ora sai cosa sono gli operatori, come usarli e come funzionano. Hai anche imparato a conoscere overloading, precedenza e associatività. Sei sulla buona strada per diventare un maestro di Python! Se vuoi imparare ancora di più, dai un’occhiata al nostro corso Intermediate Python for Data Science.