L’istru­zio­ne if-else in Python è una ra­mi­fi­ca­zio­ne con­di­zio­na­le e quindi una struttura di controllo di base. L’uso di una ra­mi­fi­ca­zio­ne consente di seguire percorsi di codice diversi a seconda di una con­di­zio­ne ri­scon­tra­ta in fase di ese­cu­zio­ne. Vi spie­ghia­mo come funziona e come si usa if-else in Python.

Cer­ti­fi­ca­to SSL
Proteggi il tuo sito con un cer­ti­fi­ca­to SSL

Evita che venga vi­sua­liz­za­ta un'al­ler­ta nella barra degli indirizzi e ottieni la fiducia dei clienti con un sito crit­to­gra­fa­to tramite SSL.

Che cos’è un’istru­zio­ne if-else?

L’istru­zio­ne if-else è una ra­mi­fi­ca­zio­ne con­di­zio­na­le. Si può pensare che sia come un in­ter­rut­to­re: a seconda dell’elemento di com­mu­ta­zio­ne, viene seguito solo uno dei due percorsi possibili. Python è un lin­guag­gio in­ter­pre­ta­to; l’in­ter­pre­te legge le righe del codice sorgente dall’alto verso il basso. Nel caso più semplice, si ottiene un flusso di programma stret­ta­men­te lineare: tutte le righe vengono lette, in­ter­pre­ta­te ed eseguite una dopo l’altra.

Seguendo questo schema semplice, tuttavia, non è possibile rea­liz­za­re programmi complessi. È solo at­tra­ver­so l’uso di strutture di controllo che si ottiene la va­ria­bi­li­tà del codice eseguito, richiesta nell’uso pratico. Una ra­mi­fi­ca­zio­ne consente l’ese­cu­zio­ne con­di­zio­na­le di alcune parti di codice. In par­ti­co­la­re, i cicli for in Python e i cicli while in Python sono uti­liz­za­ti come ulteriori strutture di controllo, che con­sen­to­no l’ese­cu­zio­ne ripetuta di parti di codice.

Consiglio

Imparate a scrivere nel codice Python con il nostro tutorial su Python!

Come funziona if-else in Python?

In generale, l’istru­zio­ne if-else in Python si comporta in modo simile a quello co­no­sciu­to in altri linguaggi. Tuttavia, esistono alcune pe­cu­lia­ri­tà spe­ci­fi­che di Python. Vediamo in dettaglio come funziona l’istru­zio­ne if-else in Python e come si comporta rispetto ad altri linguaggi.

Sintassi generale dell’istru­zio­ne if-else in Python

La sintassi generale dell’istru­zio­ne if-else in Python può essere espressa di­ret­ta­men­te nel codice Python. Definiamo una con­di­zio­ne e nel corpo dell’istru­zio­ne if, ad esempio, spe­ci­fi­chia­mo una chiamata di funzione come percorso di codice da seguire quando la con­di­zio­ne diventa vera. Inoltre, nel corpo dell’istru­zio­ne else, definiamo un percorso di codice che verrà seguito in caso contrario, ovvero nel caso in cui la con­di­zio­ne non diventi mai vera:

if condition:
    if_body()
else:
    else_body()

La con­di­zio­ne definita può essere vera (True) o falsa (False). Vi chiariamo meglio il modello inserendo il Literal True o False di­ret­ta­men­te come con­di­zio­ne. Il risultato è un flusso di programma statico in cui è garantito che solo uno dei due percorsi verrà seguito:

if False:
    # questo codice non verrà mai eseguito
    if_body()
else:
    else_body()
if True:
    if_body()
else:
    # questo codice non verrà mai eseguito
    else_body()

Na­tu­ral­men­te, questo schema non è pratico, ma serve solo per chiarire meglio il concetto. Invece di un valore statico vero/falso, viene uti­liz­za­ta un’espres­sio­ne come con­di­zio­ne. L’espres­sio­ne viene valutata in fase di ese­cu­zio­ne del programma. In questo caso si parla di “va­lu­ta­zio­ne” dell’espres­sio­ne. Quando l’espres­sio­ne viene valutata, si ottiene un valore di verità. A seconda che il valore di verità sia True o False, il programma si dirama in una direzione o nell’altra.

È im­por­tan­te capire che la parte else è fa­col­ta­ti­va. Il codice nel corpo dell’istru­zio­ne else viene eseguito solo se la con­di­zio­ne non è valida. Tuttavia, ciò non è as­so­lu­ta­men­te ne­ces­sa­rio. Spesso è suf­fi­cien­te una di­chia­ra­zio­ne if in­di­pen­den­te:

if condition:
    if_body()

Una piccola nota sulla no­men­cla­tu­ra: abbiamo usato i termini “istru­zio­ne” ed “espres­sio­ne” senza spiegarli. È im­por­tan­te capire cosa si intende con questi termini, visto che sono uti­liz­za­ti in tutti i linguaggi di pro­gram­ma­zio­ne. Di seguito vi ri­por­tia­mo il si­gni­fi­ca­to dei termini:

Termine Equi­va­len­te in inglese Spie­ga­zio­ne
Istru­zio­ne/Di­chia­ra­zio­ne Statement Azione che viene eseguita; di solito influenza il corso del programma
Espres­sio­ne Ex­pres­sion Termine che re­sti­tui­sce un valore quando viene valutato

In­ter­ro­ga­re più con­di­zio­ni esclusive con l’istru­zio­ne elif in Python

Oltre alla ben nota istru­zio­ne if-else, in Python esiste anche l’istru­zio­ne elif. Un’istru­zio­ne if è fa­col­ta­ti­va­men­te seguita da diverse istru­zio­ni elif, seguite da un blocco else opzionale. Un’istru­zio­ne elif viene eseguita solo se nessuna delle con­di­zio­ni pre­ce­den­ti è diventata vera. Questo ga­ran­ti­sce che venga seguito un solo percorso di codice definito:

if condition:
    if_body()
elif other_condition:
    elif_body()
elif another_condition:
    another_elif_body()
else:
    else_body()

Di seguito trovate le regole per costruire una ra­mi­fi­ca­zio­ne con­ca­te­na­ta if-elif-else:

Istru­zio­ne di ra­mi­fi­ca­zio­ne Quantità nella com­bi­na­zio­ne
if Proprio una
elif Zero o più
else Zero o una

Come si usa if-else in Python?

L’istru­zio­ne if-else è una fun­zio­na­li­tà di base in Python come in altri linguaggi. Na­tu­ral­men­te, gli usi sono mol­te­pli­ci. Vi mostriamo degli esempi comuni, comprese le migliori pratiche e gli anti-pattern.

Uso corretto della con­di­zio­ne if in Python

Vediamo in­nan­zi­tut­to come funziona la con­di­zio­ne di un’istru­zio­ne di ra­mi­fi­ca­zio­ne. La con­di­zio­ne viene in­ter­pre­ta­ta come un’espres­sio­ne booleana che valuta uno dei valori di verità True o False. Non è quindi ne­ces­sa­rio ve­ri­fi­ca­re espli­ci­ta­men­te l’ugua­glian­za con un letterale booleano:

if expression == True:
    ...

Anche se la cor­ri­spon­den­za esplicita con True non è un vero errore, il codice appare poco pro­fes­sio­na­le. I pro­gram­ma­to­ri esperti scrivono invece:

if expression:
    ...

Ana­liz­zia­mo l’anti-pattern con un esempio. Sup­po­nia­mo che una funzione is_odd() re­sti­tui­sca True per un numero se questo è dispari. Al­tri­men­ti, la funzione is_odd re­sti­tui­sce False. Uti­liz­zia­mo la funzione all’interno di un’istru­zio­ne if e pro­du­cia­mo un testo cor­ri­spon­den­te:

if is_odd(number) == True:
    print("The number is odd.")

Im­ma­gi­nia­mo cosa succede quando si passa dalla ra­mi­fi­ca­zio­ne con un numero dispari. In primo luogo, l’espres­sio­ne “is_odd(number) == True” è valutata come “True == True”. Quest’ultimo, a sua volta, viene valutato come “True”; il corpo dell’istru­zio­ne if viene eseguito. È più sensato usare il valore booleano re­sti­tui­to dalla funzione is_odd di­ret­ta­men­te come con­di­zio­ne:

if is_odd(number):
    print("The number is odd.")

Ese­cu­zio­ne di codice opzionale con di­chia­ra­zio­ne if in Python

Im­ma­gi­nia­mo la seguente si­tua­zio­ne: abbiamo un blocco di codice con de­ter­mi­na­te funzioni. Le righe vengono eseguite una dopo l’altra. Tuttavia, una parte del codice non deve essere eseguita sempre, ma solo quando una con­di­zio­ne è vera. Per im­ple­men­ta­re questo schema, abbiamo bisogno solo di un’istru­zio­ne if. Qui viene mostrato l’esempio di un processo classico di re­gi­stra­zio­ne dell’utente:

def register_user(user_data, do_newsletter_signup = False):
    # create user account
    user_account = create_account(user_data)
    # sign up for newsletter — only if requested by user
    if do_newsletter_signup:
        signup_newsletter(user_account)
    # send confirmation mail
    send_confirmation_mail(user_account)

Di­stin­gue­re due casi distinti con l’istru­zio­ne if-else in Python

Spesso i programmi devono di­stin­gue­re tra due casi che si escludono a vicenda. Se è lo­gi­ca­men­te ovvio che non possono esistere altri casi, ha senso uti­liz­za­re un’istru­zio­ne if-else. Ad esempio, ve­ri­fi­chia­mo se una persona ha raggiunto una certa età e forniamo un risultato adeguato a seconda dei casi:

def is_of_age(person, age_limit = 18):
    if person.age >= age_limit:
        print("You're old enough")
    else:
        print("Sorry, wait some more")

Di­stin­gue­re più casi esclusivi con le istru­zio­ni elif in Python

Se si vogliono di­stin­gue­re più di due casi mu­tua­men­te esclusivi, entrano in gioco le di­chia­ra­zio­ni elif con­ca­te­na­te. Un else finale viene uti­liz­za­to per rilevare le va­ria­zio­ni sco­no­sciu­te. As­se­gnia­mo i nomi dei Paesi ai codici cor­ri­spon­den­ti:

def get_country_from_code(country_code):
    if country_code == 'DE':
        country = "Deutschland"
    elif country_code == 'ES':
        country = "España"
    elif country_code == 'FR':
        country = "France"
    elif country_code == 'GB':
        country = "Great Britain"
    elif country_code == 'IT':
        country = "Italia"
    else:
        country = None
    return country

Se la catena elif è all’interno di una funzione, a volte è meglio uti­liz­za­re più di­chia­ra­zio­ni if in­di­pen­den­ti. In questo modo ci ri­spar­mia­mo l’as­se­gna­zio­ne nel corpo dell’istru­zio­ne elif. Con l’istru­zio­ne return, usciamo dalla funzione se una delle con­di­zio­ni diventa vera. Al posto dell’else finale, viene uti­liz­za­ta per ultima un’istru­zio­ne return, che viene raggiunta solo se nessuna delle con­di­zio­ni è vera:

def get_country_from_code(country_code):
    if country_code == 'DE':
        return "Deutschland"
    if country_code == 'ES':
        return "España"
    if country_code == 'FR':
        return "France"
    if country_code == 'GB':
        return "Great Britain"
    if country_code == 'IT':
        return "Italia"
    return None

Le di­chia­ra­zio­ni elif con­ca­te­na­te sono un modello ben noto nei linguaggi più datati. In Python, spesso è più diretto usare un “Dic­tio­na­ry Lookup”, ossia cercare su un di­zio­na­rio. Definiamo di­ret­ta­men­te l’as­se­gna­zio­ne dei codici ai nomi dei Paesi ed estraiamo il nome in base al codice. Al posto dell’istru­zio­ne finale else, uti­liz­zia­mo il metodo in­cor­po­ra­to get, che accetta un valore pre­de­fi­ni­to come secondo parametro:

def get_country_from_code(country_code):
    countries = {
        'DE': "Deutschland",
        'ES': "España",
        'FR': "France",
        'GB': "Great Britain",
        'IT': "Italia",
    }
    country = countries.get(country_code, None)
    return country

Utilizzo dell’istru­zio­ne if in Python per ve­ri­fi­ca­re se un oggetto contiene dati

Python è un lin­guag­gio dinamico e non tipizzato. Invece delle variabili, i tipi sono legati ai valori. A seconda dell’uso, possono ve­ri­fi­car­si con­ver­sio­ni implicite tra tipi. Nel contesto delle espres­sio­ni booleane, si parla anche di “truthy” e “falsy” come esten­sio­ne dei valori di verità True e False.

Ciò significa che la con­di­zio­ne di un’istru­zio­ne if in Python non deve essere valutata espli­ci­ta­men­te come True o False. Piuttosto, i valori di altri tipi possono essere usati come con­di­zio­ni. Questi vengono in­ter­pre­ta­ti come valori booleani in base a de­ter­mi­na­te regole.

Citazione

“Any object can be tested for truth value, for use in an if or while condition or as operand of the Boolean ope­ra­tions […]

[...] An object is con­si­de­red true unless its class defines either a __bool__() method that returns False or a __len__() method that returns zero [...]” – Fonte: https://docs.python.org/3/library/stdtypes.html#truth-value-testing

Tra­du­zio­ne: “È possibile ve­ri­fi­ca­re il valore di verità di qualsiasi oggetto per uti­liz­zar­lo in un’istru­zio­ne if o while o in una delle ope­ra­zio­ni booleane [...]

[...] Un oggetto è valutato vero a meno che non definisca un metodo __bool__() che re­sti­tui­sce False o un metodo __len__() che re­sti­tui­sce zero [...]” (tradotto da IONOS).

Uti­liz­zia­mo questo schema per ve­ri­fi­ca­re se un oggetto contiene dati. Poiché il testo seguente è vuoto, viene re­sti­tui­to un messaggio cor­ri­spon­den­te:

text = ''
if not text:
    print("No text given")

I seguenti oggetti vengono valutati come False in un contesto booleano e sono pertanto definiti “falsy”:

Oggetto Spie­ga­zio­ne
False, None Costanti che sono False in base alla de­fi­ni­zio­ne
0, 0.0, Decimal(0), Fraction(0, 1), ecc. Numero che rap­pre­sen­ta lo zero
‘‘, (), [], {}, set(), range(0), ecc. Sequenza o insieme vuoti

Un altro esempio con una lista vuota:

books_in_library = []
if not books_in_library:
    print("Library is empty")

Tutti gli altri oggetti vengono valutati come True

number = 42
if number:
    print("Number exists")

Im­ple­men­ta­re un in­ter­rut­to­re binario con if-else in Python

Un’istru­zio­ne if-else viene uti­liz­za­ta anche per andare avanti e indietro tra due stati esclusivi. Il principio è simile a quello di un in­ter­rut­to­re della luce e viene chiamato “toggle” in inglese. Definiamo una funzione che alterna lo stato di una luce:

def toggle_light(light):
    if light == 'on':
        return 'off'
    else:
        return 'on'

Forse avrete già notato che è ancora più facile. Se lo stato non è rap­pre­sen­ta­to come una stringa ma come un valore booleano, è possibile ri­nun­cia­re com­ple­ta­men­te all’istru­zio­ne if. Si utilizza invece l’operatore logico NOT per invertire il valore booleano:

def toggle(boolean):
    return not boolean

Uso di Early Return per risolvere le di­chia­ra­zio­ni if annidate in Python

In pratica, è comune eseguire un certo codice quando diverse con­di­zio­ni diventano vere allo stesso tempo. Questo porta ra­pi­da­men­te a di­chia­ra­zio­ni if annidate per i pro­gram­ma­to­ri inesperti. Tuttavia, questo non è un buon com­por­ta­men­to da seguire. Infatti, le ra­mi­fi­ca­zio­ni annidate in pro­fon­di­tà sono difficili da tenere sotto controllo e da gestire.

Facciamo un esempio: scriviamo una funzione che re­sti­tui­sca la di­chia­ra­zio­ne se una persona può votare. Per prima cosa con­trol­lia­mo se la persona ha un documento d’identità. Poi ve­ri­fi­chia­mo se la persona ha già raggiunto l’età per votare. Una prima im­ple­men­ta­zio­ne della funzione contiene di­chia­ra­zio­ni if annidate:

def person_may_vote(person, voting_age = 18):
    if person.has_id():
        if person.get_age() >= voting_age:
            return True

Un problema immediato di questa im­ple­men­ta­zio­ne è che più con­di­zio­ni vengono ve­ri­fi­ca­te, più il codice più im­por­tan­te viene indentato. Per risolvere le di­chia­ra­zio­ni if annidate, si utilizza so­li­ta­men­te l’istru­zio­ne “Early Return”. Quindi, all’inizio della funzione con­trol­lia­mo se le singole con­di­zio­ni sono sod­di­sfat­te. Se una con­di­zio­ne non è sod­di­sfat­ta, in­ter­rom­pia­mo e usciamo dalla funzione uti­liz­zan­do l’istru­zio­ne return.

Ri­for­mu­lia­mo la nostra funzione per uti­liz­za­re le istru­zio­ni Early Return. Spesso ciò richiede l’in­ver­sio­ne delle con­di­zio­ni pre­ce­den­te­men­te definite. In questo caso è utile la com­pren­sio­ne degli operatori booleani in Python. Se non si applica nessuna delle con­di­zio­ni negative, viene eseguito il codice ef­fet­ti­va­men­te in­te­res­san­te:

def person_may_vote(person, voting_age = 18):
    if not person.has_id():
        return False
    if person.age < voting_age:
        return False
    # if we made it here, the person may vote
    return True

Uso degli operatori logici per sem­pli­fi­ca­re e so­sti­tui­re le istru­zio­ni if in Python

Come abbiamo già visto, spesso è ne­ces­sa­rio con­trol­la­re che si ve­ri­fi­chi­no più con­di­zio­ni. Nella maggior parte dei casi, è su­bot­ti­ma­le uti­liz­za­re di­chia­ra­zio­ni if annidate per ve­ri­fi­ca­re più con­di­zio­ni. Esa­mi­nia­mo il codice di esempio che determina se una persona può votare:

if has_id(person):
    if is_adult(person):
        print("You may vote")

Le con­di­zio­ni con­ca­te­na­te possono essere rap­pre­sen­ta­te nel modo migliore uti­liz­zan­do gli operatori logici. Poiché vogliamo ve­ri­fi­ca­re se entrambe le con­di­zio­ni sono valide allo stesso tempo, uti­liz­zia­mo l’operatore logico AND. In questo modo abbiamo bisogno di una sola di­chia­ra­zio­ne if:

if has_id(person) and is_adult(person):
    print("You may vote")

Qui di seguito trovate gli operatori logici di base in Python:

Operatore logico Si­gni­fi­ca­to Sintassi Python Altri linguaggi    
E L’espres­sio­ne è vera se tutti gli operandi sono veri; re­sti­tui­sce l’ultimo operando valutato. and &&    
O L’espres­sio­ne è vera se almeno uno degli operandi è vero; re­sti­tui­sce l’ultimo operando valutato. or      
NON Inverte il valore dell’espres­sio­ne. not !    

Vediamo un esempio: im­ma­gi­nia­mo che un/una utente possa spe­ci­fi­ca­re una valuta per un calcolo fi­nan­zia­rio. Per fa­ci­li­tar­ne l’uso, la scelta dovrebbe essere fa­col­ta­ti­va. Se l’utente non seleziona una valuta, il valore pre­de­fi­ni­to è EUR. Il codice seguente traccia questo principio:

# user made no currency choice
currency = None
...
# further down in the program flow
if not currency:
    # set default if value missing
    currency = 'EUR'

Uti­liz­zan­do l’operatore logico OR, l’istru­zio­ne if può essere risolta. Ri­scri­via­mo il codice; quando viene eseguito, la variabile currency contiene il valore “EUR”:

# user made no currency choice
currency = None
...
# further down in the program flow
# set default if value missing
currency = currency or 'EUR'

Cosa succede esat­ta­men­te qui? Nell’ultima riga, viene assegnato un nuovo valore alla variabile “currency”. A tal fine, viene valutata prima l’espres­sio­ne “currency or 'EUR'” sul lato destro del segno di uguale. L’operatore logico OR valuta in­nan­zi­tut­to l’espres­sio­ne di sinistra, in questo caso “currency”. Poiché nell’esempio contiene “None” ed è quindi “falsy”, l’espres­sio­ne corretta “EUR” viene valutata e uti­liz­za­ta come valore di ritorno per l’as­se­gna­zio­ne.

L’operatore con­di­zio­na­le if-else in Python

Oltre alla ra­mi­fi­ca­zio­ne con­di­zio­na­le, c’è un altro uso delle parole chiave if-else in Python. È l’operatore con­di­zio­na­le, noto anche come operatore “ternario”, molto usato per di­stin­gue­re tra due possibili valori nelle as­se­gna­zio­ni.

Vediamo prima un esempio che utilizza l’istru­zio­ne if-else in Python. Il codice seguente imposta Celsius o Fah­ren­heit come unità di misura della tem­pe­ra­tu­ra, a seconda del sistema di misura se­le­zio­na­to:

if system == 'metric':
    unit = 'C'
else:
    unit = 'F'

Uti­liz­zan­do l’operatore con­di­zio­na­le, il codice può essere sem­pli­fi­ca­to in una singola as­se­gna­zio­ne:

unit = 'C' if system == 'metric' else 'F'

Come svela il nome, l’operatore ternario accetta tre operandi: i due valori possibili e un’espres­sio­ne come con­di­zio­ne.

Operatore Spie­ga­zio­ne Esempio
Unario L’operatore accetta un operando. not boolean_operand
Binario L’operatore accetta due operandi. left_operand + right_operand
Ternario L’operatore accetta tre operandi. some_value if condition else other_value

So­sti­tu­zio­ne di if-else in Python con l’istru­zio­ne match-case

Con il rilascio della versione 3.10 di Python, è stata in­tro­dot­ta l’istru­zio­ne match-case. All’inizio ricorda l’istru­zio­ne switch-case di altri linguaggi. In questo caso, si usa switch-case per spezzare i costrutti if-elif-else di grandi di­men­sio­ni.

Noto per essere soggetto a errori, switch-case non è mai esistito in Python. Piuttosto, l’istru­zio­ne match-case in Python è una fun­zio­na­li­tà per lo “Struc­tu­ral Pattern Matching” (in italiano: “cor­ri­spon­den­za strut­tu­ra­le dei modelli”) basata su linguaggi fun­zio­na­li come Haskell. La sua utilità va ben oltre quella dello switch-case.

Il­lu­stria­mo il principio di match-case con un esempio: im­ma­gi­nia­mo di voler elaborare dati di persone in formati diversi. Una persona può essere rap­pre­sen­ta­ta come un singolo nome o come un di­zio­na­rio con nome ed even­tual­men­te età o come una tupla di nome e cognome. Inoltre, vogliamo gestire il nome esatto “Jack” in modo par­ti­co­la­re:

# the name 'Jack'
person1 = 'Jack'
# just a name
person2 = 'John'
# name and age in a dict
person3 = {'name': 'Jim', 'age': 42}
# name in a dict, but no age
person4 = {'name': 'Walter', 'email': 'walter.white@example.com'}
# tuple of first and last name
person5 = ('Walther', 'White')

Vediamo in­nan­zi­tut­to una funzione che saluta una persona in uno dei formati. Uti­liz­zia­mo una catena if-elif-else e la funzione isin­stan­ce per di­stin­gue­re i diversi formati. Inoltre, vengono uti­liz­za­te con­di­zio­ni con­ca­te­na­te con l’operatore AND e un’istru­zio­ne if-else annidata. Il codice finale non sembra par­ti­co­lar­men­te chiaro:

def greet_person(person):
    if isinstance(person, str):
        if person == 'Jack':
            print('Jack himself has arrived')
        else:
            print(f"Hi there, {person}")
    elif isinstance(person, dict) and 'name' in person and 'age' in person:
        print(f"It's, {person['name']}. Born {person['age']} years ago")
    elif isinstance(person, dict) and 'name' in person:
        print(f"It's {person['name']}")
    elif isinstance(person, tuple) and len(person) == 2:
        first, last = person
        print(f"Hello, {first} {last}")
    else:
        print('Not sure what kind of person this is')

Il codice può essere costruito in modo più elegante con l’istru­zio­ne match-case. De­scri­via­mo di­ret­ta­men­te la struttura dei singoli formati; i singoli valori possono essere estratti come variabili. Il codice è più chiaro, meno complesso e più facile da leggere:

def match_person(person):
    match person:
        case 'Jack':
            print('Jack himself has arrived')
        case str() as name:
            print(f"Hi there, {name}")
        case {'name': name, 'age': age}:
            print(f"It's, {name}. Born {age} years ago")
        case {'name': name}:
            print(f"It's {name}")
        case (first, last):
            print(f"Hello, {first} {last}")
        case _:
            print('Not sure what kind of person this is')
Vai al menu prin­ci­pa­le