Python: definire e richiamare funzioni in modo chiaro e sicuro

Introduzione

Le funzioni sono uno degli strumenti più importanti in Python perché permettono di organizzare il codice in blocchi riutilizzabili, leggibili e facili da testare. In pratica, una funzione è un “pezzo di programma” con un nome preciso, che puoi richiamare ogni volta che ti serve svolgere una certa operazione.

In questo tutorial vediamo un sotto-argomento molto utile e spesso sottovalutato: come definire e chiamare funzioni in modo efficace usando parametri chiari, valori di default e una struttura pensata per l’uso reale. Non ci concentriamo solo sulla sintassi base, ma su come scrivere funzioni che siano davvero comode da usare in un progetto.

L’obiettivo è capire non solo come si scrive una funzione, ma anche come si progetta bene la sua interfaccia, cioè il modo in cui altri sviluppatori — o tu stesso in futuro — la utilizzeranno.

Codice completo

# Esempio: gestione di ordini in un piccolo negozio online

def calcola_sconto(importo, percentuale=10):
    """Calcola il prezzo finale dopo uno sconto."""
    sconto = importo * percentuale / 100
    return importo - sconto


def formatta_riepilogo(nome_cliente, totale, valuta="EUR"):
    """Restituisce una stringa leggibile con il riepilogo dell´ordine."""
    return f"Cliente: {nome_cliente} | Totale: {totale:.2f} {valuta}"


def crea_ordine(nome_cliente, prodotti, spedizione=5.0, sconto_percentuale=0):
    """
    Crea un riepilogo dell´ordine partendo da una lista di prodotti.
    Ogni prodotto è rappresentato da un dizionario con chiavi:
    - nome
    - prezzo
    """
    if not prodotti:
        return "Ordine non valido: nessun prodotto inserito."

    totale_prodotti = 0
    for prodotto in prodotti:
        totale_prodotti += prodotto["prezzo"]

    totale_con_sconto = calcola_sconto(totale_prodotti, sconto_percentuale)
    totale_finale = totale_con_sconto + spedizione

    riepilogo = formatta_riepilogo(nome_cliente, totale_finale)
    return (
        f"{riepilogo}n"
        f"Prodotti: {len(prodotti)}n"
        f"Totale prodotti: {totale_prodotti:.2f} EURn"
        f"Sconto: {sconto_percentuale}%n"
        f"Spedizione: {spedizione:.2f} EURn"
        f"Totale finale: {totale_finale:.2f} EUR"
    )


# --- Chiamate della funzione ---

prodotti_ordine = [
    {"nome": "Tastiera meccanica", "prezzo": 89.90},
    {"nome": "Mouse wireless", "prezzo": 34.50},
    {"nome": "Mouse pad", "prezzo": 12.00},
]

print(crea_ordine("Luca Bianchi", prodotti_ordine))
print()
print(crea_ordine("Sara Rossi", prodotti_ordine, spedizione=7.5, sconto_percentuale=15))
print()
print(crea_ordine("Marco Verdi", []))

Spiegazione

Vediamo il codice passo per passo, perché ogni funzione è stata scritta con un obiettivo preciso.

1. Definire una funzione con def

In Python una funzione si definisce con la parola chiave def, seguita dal nome e dalle parentesi tonde:

def calcola_sconto(importo, percentuale=10):

Qui:

• calcola_sconto è il nome della funzione.
• importo è un parametro obbligatorio.
• percentuale=10 è un parametro con valore predefinito.

Questo significa che puoi chiamare la funzione anche senza specificare la percentuale, e Python userà automaticamente 10.

2. Chiamare una funzione

Una funzione si richiama scrivendo il suo nome con le parentesi:

calcola_sconto(100)

In questo caso il risultato sarà 90, perché viene applicato lo sconto del 10%.

Se invece vuoi cambiare il valore predefinito, puoi passarlo esplicitamente:

calcola_sconto(100, 20)

Qui il risultato sarà 80.

3. Usare parametri con nome per migliorare la leggibilità

Nel tutorial abbiamo chiamato la funzione principale in questo modo:

crea_ordine("Sara Rossi", prodotti_ordine, spedizione=7.5, sconto_percentuale=15)

Questa forma è molto utile perché rende la chiamata più chiara. Anche senza leggere la definizione della funzione, capisci subito cosa rappresentano i valori 7.5 e 15.

Per funzioni con più parametri, usare i nomi degli argomenti migliora la manutenzione del codice e riduce gli errori.

4. Restituire un risultato con return

Ogni funzione del nostro esempio restituisce un valore usando return. Questo è importante perché una funzione non deve per forza limitarsi a stampare qualcosa: spesso è meglio farle produrre un risultato da riutilizzare altrove.

Per esempio, formatta_riepilogo restituisce una stringa, mentre crea_ordine restituisce un testo completo con tutti i dettagli dell’ordine.

5. Validare gli input prima di procedere

Dentro crea_ordine c’è un controllo iniziale:

if not prodotti:
    return "Ordine non valido: nessun prodotto inserito."

Questa è una buona pratica fondamentale. Una funzione ben progettata non dovrebbe assumere che i dati siano sempre corretti. Se la lista dei prodotti è vuota, la funzione interrompe subito l’elaborazione e restituisce un messaggio chiaro.

6. Comporre funzioni piccole

Il codice mostra anche un concetto molto importante: una funzione può chiamarne altre. In questo caso:

• crea_ordine usa calcola_sconto
• crea_ordine usa anche formatta_riepilogo

Questo approccio è utile perché ogni funzione ha una responsabilità specifica. Risultato: codice più leggibile, più facile da testare e più semplice da modificare.

Best practice

Quando definisci e chiami funzioni in Python, tieni presenti queste buone pratiche:

• Usa nomi descrittivi: una funzione come calcola_sconto è molto più chiara di f o funzione1.
• Scrivi funzioni piccole: ogni funzione dovrebbe fare bene una sola cosa.
• Preferisci parametri espliciti: se una funzione ha molti argomenti, usa nomi chiarissimi nella chiamata.
• Evita effetti collaterali inutili: se puoi, restituisci un valore invece di stampare direttamente dentro la funzione.
• Valida i dati in ingresso: controlla liste vuote, valori negativi o tipi non attesi quando serve.
• Usa valori di default con criterio: sono utili, ma non devono nascondere comportamenti poco chiari.
• Documenta la funzione con una docstring breve ma utile, soprattutto nei progetti reali.

Un buon criterio pratico è questo: se una persona legge solo la firma della funzione, dovrebbe capire quasi subito come usarla.

Riepilogo

In questo tutorial abbiamo visto come definire e chiamare funzioni Python in modo più professionale e pratico. Il punto non è soltanto conoscere la sintassi di def e delle parentesi tonde, ma imparare a progettare funzioni che siano facili da usare e da mantenere.

Abbiamo toccato alcuni aspetti fondamentali:

• definizione di una funzione con parametri;
• chiamata della funzione con argomenti posizionali e nominati;
• uso di valori predefiniti;
• restituzione di risultati con return;
• composizione di funzioni piccole e riutilizzabili;
• controllo degli input per evitare errori.

Se inizi a ragionare sulle funzioni come blocchi autonomi e ben progettati, il tuo codice diventerà più pulito, più testabile e molto più facile da evolvere.

Approfondisci con risorse ufficiali

• Python Tutorial - Defining Functions: documentazione ufficiale sulle funzioni in Python.
• Python Language Reference: riferimento completo sulla sintassi del linguaggio.
• PEP 8: guida ufficiale allo stile del codice Python, utile per nomi e leggibilità.
• Built-in Functions: elenco delle funzioni integrate disponibili in Python.

Consultare la documentazione ufficiale è sempre una buona abitudine, soprattutto quando inizi a scrivere funzioni più complesse o quando vuoi adottare le convenzioni consigliate dalla comunità Python.