Guida Python interattiva: Funzioni

Q: Come definisco una funzione in Python?

Usa la parola chiave def, seguita dal nome della funzione, dalle parentesi per i parametri e dai due punti. Il blocco indentato sotto è il corpo della funzione. Esempio: def greet(name): print(f'Hi, {name}').

Q: Cosa fa return in Python?

return restituisce un valore a chi ha chiamato la funzione. Una funzione senza un return esplicito restituisce None in automatico. Appena viene eseguito return, la funzione esce subito: il codice che segue nello stesso blocco viene saltato.

Funzioni in Python: def, return, argomenti predefiniti e keyword

Come definire e usare le funzioni in Python: parametri, valori restituiti, argomenti predefiniti, argomenti keyword e abitudini di naming che mantengono il codice leggibile.

Questa pagina include editor eseguibili: modifica, esegui e vedi subito l'output.

Di Kevin Spektor, Cofondatore e CTO

Pubblicato il Apr 23, 2026

Una funzione è un blocco di passaggi con un nome

Ogni volta che ti ritrovi a scrivere le stesse righe più di una volta, o vuoi dare un nome a un piccolo pezzo di logica, sei pronto per scrivere una funzione. Le funzioni sono il primo vero strumento per gestire la complessità in un programma Python.

La forma di base:

def greet(name):
    print(f"Hello, {name}")

greet("Ada")
greet("Boris")

Vediamola pezzo per pezzo:

def è la parola chiave che inizia la definizione di una funzione.
greet è il nome della funzione.
(name) è la lista dei parametri, cioè gli input che la funzione riceve.
I due punti chiudono l'intestazione; il blocco indentato sotto è il corpo.
greet("Ada") è una chiamata. Python esegue il corpo con name associato a "Ada".

Le funzioni restano ferme finché non vengono chiamate. Definirne una non la esegue. Chiamarla con greet("Ada") sì.

Parametri e argomenti

La parola parametro indica il nome dentro la definizione della funzione. La parola argomento indica il valore passato quando la chiami. Nelle conversazioni informali non è un grosso problema, ma la distinzione aiuta a leggere i messaggi di errore.

def power(base, exponent):
    return base ** exponent

print(power(2, 10))
print(power(5, 3))

Qui base ed exponent sono parametri. 2 e 10 sono argomenti. Python li associa in ordine: il primo argomento al primo parametro, e così via.

return: restituire un valore

print scrive sullo schermo. return restituisce un valore a chi chiama, così può usarlo:

def power(base, exponent):
    return base ** exponent

result = power(2, 10)
print(result + 1)

Senza return, una funzione restituisce None per impostazione predefinita:

def greet(name):
    print(f"Hello, {name}")

value = greet("Ada")
print("got back:", value)   # got back: None

return fa anche uscire subito dalla funzione. Vedrai spesso dei return anticipati usati per gestire i casi limite prima della logica principale:

def discount(price, percent):
    if percent < 0 or percent > 100:
        return None
    return price * (1 - percent / 100)

print(discount(50, 20))
print(discount(50, 150))

I return anticipati evitano che il corpo principale finisca annidato in profondità dentro if/else.

Argomenti predefiniti

Un parametro può avere un valore predefinito, usato quando chi chiama non ne fornisce uno:

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Ada")
greet("Boris", "Good morning")

Tutti i parametri con valore predefinito devono venire dopo quelli senza. def f(a, b=1, c): è un errore di sintassi.

La trappola dei valori predefiniti mutabili

È il tranello più famoso di Python. Guarda:

def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item("apple"))
print(add_item("banana"))

Ti aspetteresti che ogni chiamata parta da una lista vuota. Invece la lista predefinita è condivisa tra le chiamate, e gli elementi si accumulano. Python valuta il valore predefinito una sola volta, quando la funzione viene definita, e riusa per sempre quell'unica lista.

Lo schema sicuro è usare None come valore predefinito e creare la lista dentro la funzione:

def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

print(add_item("apple"))
print(add_item("banana"))

Ora ogni chiamata che non passa items riceve una lista nuova. La regola vale per liste, dict, set: qualsiasi cosa sia mutabile.

Argomenti keyword

Puoi passare gli argomenti per nome invece che per posizione. Così puoi saltare i parametri intermedi e rendere più leggibili le chiamate lunghe:

def post(title, body, draft=False, tags=None):
    status = "draft" if draft else "published"
    print(f"[{status}] {title}")
    print(body)
    print("tags:", tags or [])

post("Python functions", "How to write them", draft=True, tags=["python", "tutorial"])

Argomenti posizionali e keyword si possono mescolare, ma i posizionali devono venire prima:

post("Title", body="Body text", draft=True)    # va bene
# post(body="Body", "Title")                    # SyntaxError

Quando una funzione ha più di tre o quattro parametri, preferire gli argomenti keyword rende le chiamate molto più leggibili.

Parametri solo posizionali e solo keyword

Python ti permette di indicare che alcuni parametri si possono passare solo per posizione (con /) o solo per nome (con *):

def configure(env, /, *, debug=False, log_level="info"):
    print(env, debug, log_level)

configure("prod")                          # va bene: env posizionale
configure("prod", debug=True)              # va bene
# configure(env="prod")                    # errore: env è solo posizionale
# configure("prod", True, "info")          # errore: debug e log_level sono solo keyword

Non ti servono il primo giorno. Diventano utili quando progetti delle API e vuoi fissare il modo in cui chi chiama usa la tua funzione.

Docstring e nomi

La prima riga dentro una funzione può essere una docstring, una stringa tra virgolette triple che Python tratta come documentazione:

def discount(price, percent):
    """Return the final price after applying a percentage discount."""
    return price * (1 - percent / 100)

help(discount)

Strumenti come help(), i suggerimenti degli IDE e i generatori di documentazione leggono la docstring in automatico. Una riga sola è molto meglio di niente.

E per favore, pensa ai nomi:

I nomi delle funzioni dovrebbero essere verbi: fetch_profile, compute_total, is_valid.
Usa il lower_snake_case.
Le funzioni che restituiscono un booleano spesso iniziano con is_, has_ o can_.

Un buon nome rende la chiamata comprensibile da sola, senza bisogno di un commento.

Le funzioni pure sono più facili da capire

Una funzione pura restituisce lo stesso output per lo stesso input e non ha effetti collaterali: non modifica lo stato globale, non stampa su stdout (se non per il debug) e non scrive su file.

# Pura: facile da testare, facile da capire.
def total(price, tax_rate):
    return price * (1 + tax_rate)

# Impura: modifica una variabile esterna.
cart = []
def add_to_cart(item):
    cart.append(item)

print(total(100, 0.08))
add_to_cart("apple")
print(cart)

Entrambe hanno il loro posto, ma nel codice che vuoi riutilizzare e testare, spingi il più possibile verso le funzioni pure.

Un piccolo esempio funzionante

Una funzione veloce che combina valori predefiniti, argomenti keyword e return:

def format_address(street, city, country="US", zip_code=None):
    parts = [street, city]
    if zip_code:
        parts.append(zip_code)
    parts.append(country)
    return ", ".join(parts)

print(format_address("1 Main St", "Boston"))
print(format_address("1 Main St", "Boston", zip_code="02108"))
print(format_address("Place Vendôme 1", "Paris", country="France"))

Prossimo argomento: liste di argomenti flessibili

A volte non sai con quanti argomenti verrà chiamata una funzione, oppure vuoi inoltrare a un'altra funzione tutti gli argomenti che arrivano. Se ne occupano *args e **kwargs. È la prossima pagina.

Domande frequenti

Come definisco una funzione in Python?

Usa la parola chiave def, seguita dal nome della funzione, dalle parentesi per i parametri e dai due punti. Il blocco indentato sotto è il corpo della funzione. Esempio: def greet(name): print(f'Hi, {name}').

Cosa fa return in Python?

return restituisce un valore a chi ha chiamato la funzione. Una funzione senza un return esplicito restituisce None in automatico. Appena viene eseguito return, la funzione esce subito: il codice che segue nello stesso blocco viene saltato.

Cosa sono gli argomenti predefiniti in Python?

Gli argomenti predefiniti permettono a un parametro di avere un valore preimpostato, usato se chi chiama non ne fornisce uno. def greet(name='friend'): significa che greet() senza argomenti usa 'friend'. Non usare mai valori predefiniti mutabili come []: più sotto trovi lo schema sicuro.

Concetti correlati