L’operatore tricheco di Python: l’espressione di assegnazione (Tutorial)

Che cos’è l’operatore tricheco di Python

L’ espressione di assegnazione, che usa l’operatore :=, è simile alla più comune istruzione di assegnazione, che usa l’operatore =. C’è però una distinzione importante tra le due.

Una statement è un’unità di codice che esegue un’azione. Un’ espressione è uno statement che può essere valutato a un valore. Quindi, un’espressione restituisce un valore, mentre gli statement che non sono espressioni non restituiscono alcun valore.

La REPL di Python (Read, Evaluate, Print, and Loop) mostra il valore di un’espressione non appena viene valutata. Nessun valore viene invece mostrato quando si esegue uno statement che non è un’espressione:

>>> import random  # Not an expression
>>> 10 * 2  # An expression
20

Lo statement import non è valutato ad alcun valore. Invece, 10 * 2 è un’espressione che si valuta in un valore.

L’istruzione di assegnazione, che usa l’operatore =, assegna un oggetto a una variabile o a un altro riferimento, ma non restituisce il valore. L’espressione di assegnazione, o operatore tricheco, compie la stessa azione dell’istruzione di assegnazione ma in più restituisce l’oggetto:

>>> value = 10  # Assignment statement
>>> value
10
>>> (value := 20)  # Assignment expression
20

Nota che l’istruzione di assegnazione non restituisce il valore, a differenza dell’espressione di assegnazione. Di conseguenza, un’espressione di assegnazione combina diverse operazioni:

1. Valuta l’espressione alla destra dell’operatore :=.
2. Assegna questo valore a un nome di variabile.
3. Restituisce il valore.

Le parentesi sono una sintassi obbligatoria quando si usa l’espressione di assegnazione al posto dell’istruzione di assegnazione, come in questo esempio, per ridurre l’ambiguità. Più avanti nel tutorial trovi altri dettagli sui requisiti sintattici dell’operatore tricheco.

Un’espressione di assegnazione può essere usata ovunque in Python si possano usare espressioni. Vediamo un esempio:

print(f"The number is {(value := 50)}")
print(value)

The number is 50
50

Il nome di variabile value è definito all’interno della f-string nella prima riga. Tuttavia, l’intero viene anche restituito direttamente alle parentesi graffe nella f-string. Le parentesi graffe nelle f-string devono contenere un’espressione, ecco perché non si può usare un’istruzione di assegnazione.

Casi d’uso dell’operatore tricheco di Python

Due casi d’uso comuni dell’operatore tricheco sono semplificare e ottimizzare il codice.

Semplificare il codice

Un uso tipico dell’operatore tricheco è semplificare il codice quando normalmente una variabile andrebbe definita prima di essere usata, ad esempio in alcune istruzioni condizionali. Considera il seguente ciclo while:

import random
value = random.randint(1, 20)
while value < 18:
    print(value)
    value = random.randint(1, 20)

7
5
1
11
12
1
9

Questo codice esegue il blocco while finché il valore casuale generato è minore di 18. La variabile value deve essere definita prima del ciclo while così da poter essere usata nell’istruzione while. Un nuovo numero casuale viene assegnato a value alla fine del blocco while.

L’espressione di assegnazione := può essere usata per ridurre le righe di codice e per chiamare la funzione random.randint() in un unico punto del programma:

import random
while (value := random.randint(1, 20)) < 18:
    print(value)

1
9
2
4
9
15
11

A ogni nuova iterazione del ciclo while viene generato un nuovo numero casuale e assegnato a value.

Ottimizzare il codice

Vediamo un altro esempio con le list comprehension. Considera il seguente codice, che filtra una lista di stringhe contenenti date e crea una lista di datetime.datetime oggetti contenenti solo le date di un dato anno:

from datetime import datetime
def format_date(date_str):
    return datetime.strptime(date_str, "%Y-%m-%d")
dates = ["2024-01-01", "2022-12-31", "2024-06-15", "2023-08-23", "2024-11-30"]
formatted_dates = [
    format_date(date)
    for date in dates
    if format_date(date).year == 2024
]
print(formatted_dates)

[datetime.datetime(2024, 1, 1, 0, 0), datetime.datetime(2024, 6, 15, 0, 0), datetime.datetime(2024, 11, 30, 0, 0)]

La funzione format_date() accetta una stringa con una data nel formato yyyy-mm-dd e restituisce un oggetto datetime.datetime. Uno degli attributi di datetime.datetime è .year, che contiene il componente anno della data.

Nella lista finale sono incluse solo le tre date del 2024, che sono anche oggetti datetime.datetime invece che stringhe. La list comprehension include una clausola if, che chiama format_date(). Tuttavia, format_date() è chiamata anche nella prima espressione della list comprehension, che genera i valori da aggiungere alla lista. Chiamare due volte la funzione con lo stesso argomento è inefficiente, soprattutto se la funzione è un collo di bottiglia per le prestazioni del programma.

Una possibilità per evitare la doppia chiamata è invocare la funzione e assegnarne il risultato a una variabile prima di usarla. Tuttavia, questo non si può fare con un’istruzione di assegnazione continuando a usare una list comprehension. Questa soluzione richiede un ciclo for standard:

from datetime import datetime
def format_date(date_str):
    return datetime.strptime(date_str, "%Y-%m-%d")
dates = ["2024-01-01", "2022-12-31", "2024-06-15", "2023-08-23", "2024-11-30"]
formatted_dates = []
for date in dates:
    formatted_date = format_date(date)
    if formatted_date.year == 2024:
        formatted_dates.append(formatted_date)
print(formatted_dates)

[datetime.datetime(2024, 1, 1, 0, 0), datetime.datetime(2024, 6, 15, 0, 0), datetime.datetime(2024, 11, 30, 0, 0)]

L’operatore tricheco offre un’alternativa compatibile con una list comprehension, dato che la data formattata restituita dalla funzione può essere assegnata a un nome di variabile e restituita nella stessa espressione:

from datetime import datetime
def format_date(date_str):
    return datetime.strptime(date_str, "%Y-%m-%d")
dates = ["2024-01-01", "2022-12-31", "2024-06-15", "2023-08-23", "2024-11-30"]
formatted_dates = [
    formatted_date
    for date in dates
    if (formatted_date := format_date(date)).year == 2024
]
print(formatted_dates)

[datetime.datetime(2024, 1, 1, 0, 0), datetime.datetime(2024, 6, 15, 0, 0), datetime.datetime(2024, 11, 30, 0, 0)]

L’espressione di assegnazione nella list comprehension è l’espressione tra parentesi, (formatted_date := format_date(date)). Questa espressione chiama la funzione format_date(), assegna il suo valore alla variabile formatted_date e restituisce il valore. Poiché l’espressione di assegnazione si valuta in un oggetto datetime.datetime, il codice accede all’attributo .year, che viene confrontato con 2024 usando l’operatore di uguaglianza.

La clausola if nella list comprehension viene eseguita prima dell’espressione che genera il valore da memorizzare nella lista. Perciò, l’operatore tricheco è usato nella clausola if e la variabile definita da questa espressione di assegnazione è usata come prima espressione nella list comprehension.

La controversia sull’operatore tricheco di Python

L’espressione di assegnazione non è amata da tutti i programmatori Python. Alcuni la vedono come un modo per semplificare il codice, altri ritengono che lo renda meno leggibile e preferiscono soluzioni più lunghe. La leggibilità è soggettiva, quindi le opinioni divergono sul fatto che l’operatore tricheco renda il codice più o meno chiaro.

L’ultimo esempio nella sezione precedente mostra i compromessi necessari. Senza l’operatore tricheco, in quell’esempio il codice deve prima inizializzare una lista vuota e poi aggiungervi valori in un ciclo for. Questa soluzione è più lunga e meno efficiente rispetto alle list comprehension, che sono ottimizzate per questo compito.

Tuttavia, per alcuni programmatori la soluzione con il ciclo for standard può essere più leggibile, soprattutto se le prestazioni non sono un problema, e quindi preferiscono scrivere più codice piuttosto che usare l’operatore tricheco.

Molte guide di stile del codice raccomandano ancora di evitare l’espressione di assegnazione o di usarla con parsimonia.

Operatore tricheco di Python: regole di sintassi

È comune imbattersi in errori di sintassi quando si inizia a esplorare l’operatore tricheco, a causa delle sue regole sintattiche.

Per evitare confusione tra l’istruzione di assegnazione = e l’espressione di assegnazione :=, non esiste alcuna situazione in cui entrambe le opzioni siano sintatticamente valide. Per questo motivo, spesso è necessario racchiudere l’espressione di assegnazione tra parentesi:

(value := 20)  # Valid
value := 20  # Invalid (SyntaxError)

L’obbligo di includere l’espressione di assegnazione tra parentesi in questo caso è l’opposto del requisito dell’istruzione di assegnazione, che non può essere inclusa tra parentesi.

Tuttavia, l’espressione di assegnazione non richiede sempre le parentesi:

import random
if value := random.randint(0, 3):
    print(f"{value} is greater than 0")

1 is greater than 0

L’espressione di assegnazione nell’istruzione if genera un numero casuale tra 0 e 3 e lo assegna alla variabile value. Gli interi 1, 2 e 3 sono truthy, e il codice nel blocco if verrà eseguito quando vengono generati questi valori. Tuttavia, quando random.randint() restituisce 0, che è falsy, il blocco if non viene eseguito.

L’istruzione di assegnazione non è valida dopo una keyword if. Quindi, in questa situazione non c’è confusione e le parentesi non sono richieste.

Questo esempio evidenzia anche un altro punto chiave sull’espressione di assegnazione. L’ambito della variabile assegnata segue le normali regole LEGB. Pertanto, in questo esempio la variabile value è disponibile ovunque nello scope globale:

import random
if value := random.randint(0, 3):
    print(f"{value} is greater than 0")
   
print(value)

2 is greater than 0
2

Se un’espressione di assegnazione è usata all’interno della definizione di una funzione, la variabile sarà disponibile solo localmente nella funzione. Questo è lo stesso comportamento delle variabili create con un’istruzione di assegnazione.

Questo esempio può essere modificato per mostrare un’altra potenziale insidia quando si usa l’operatore tricheco. Cambiamo il codice includendo un operatore di confronto nell’istruzione if:

import random
if value := random.randint(0, 3) < 2:
    print(f"{value} is less than 2")

True is less than 2

L’output suggerisce il problema: value è il booleano True invece di un intero. L’operatore tricheco ha la precedenza più bassa tra tutti gli operatori, e solo la virgola ha precedenza più bassa. Pertanto, l’operatore minore di < viene valutato per primo e il suo output è assegnato a value. Per gestire questa situazione servono le parentesi:

import random
if (value := random.randint(0, 3)) < 2:
    print(f"{value} is less than 2")

0 is less than 2

Ora l’espressione di assegnazione è valutata per prima poiché le parentesi hanno la precedenza più alta. Il numero restituito da random.randint() viene assegnato a value e usato come primo operando dell’operatore minore di.

A differenza dell’istruzione di assegnazione, l’operatore tricheco può assegnare valori solo a nomi di variabile e non può essere usato per assegnare valori a indici o attributi:

(name := "James")  # Valid
points = {"James": 10, "Mary": 20}
(points["Sarah"] := 30)  # Invalid
class Article:
    pass
article = Article()
(article.title := "The Walrus Operator")  # Invalid

Non è possibile assegnare un valore usando un indice o a un attributo con l’operatore tricheco.

Conclusione

L’espressione di assegnazione, che usa la sintassi := ed è spesso chiamata operatore tricheco, è un’aggiunta relativamente recente a Python. L’istruzione di assegnazione, che usa l’operatore =, è il modo più comune di assegnare un valore a un nome di variabile.

Tuttavia, l’operatore tricheco estende questa operazione restituendo anche il valore assegnato, il che rende l’assegnazione un’espressione. Di conseguenza, puoi usare l’espressione di assegnazione ovunque tu possa usare altre espressioni in Python.

La comunità Python è però divisa sull’utilità e la leggibilità dell’operatore tricheco. Per questo motivo, l’espressione di assegnazione non è usata così spesso come altre novità di Python. È utile sapere come usarlo, ma non esagerare!