Funzioni: riutilizzare il codice

Bentornato.

Nella lezione precedente hai imparato i dizionari.

I tuoi programmi hanno imparato a salvare dati strutturati con chiavi e valori.

Hai scritto cose come:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

Molto bene.

Ora i tuoi programmi possono salvare dati con significato.

Non solo valori casuali che fluttuano come palloncini confusi.

Ma ora abbiamo un altro problema.

E se dobbiamo riutilizzare lo stesso codice?

Per esempio:

print("Hello, Anna!")
print("Welcome to the program.")
print("Have a nice day!")

Poi più avanti:

print("Hello, Marco!")
print("Welcome to the program.")
print("Have a nice day!")

Poi ancora:

print("Hello, Sofia!")
print("Welcome to the program.")
print("Have a nice day!")

Funziona.

Ma è ripetitivo.

E il codice ripetitivo è pericoloso.

Perché un giorno devi cambiare qualcosa.

Poi devi cambiarlo in cinque punti.

Poi ne dimentichi uno.

Poi appare il bug.

Poi il caffè diventa carburante d’emergenza.

Le funzioni risolvono questo problema.

Le funzioni ti permettono di riutilizzare codice.

Scrivi il codice una volta.

Poi lo chiami ogni volta che ti serve.

Molto utile.

Molto pulito.

Molto Python.

Cosa imparerai

In questa lezione imparerai:

• cos’è una funzione;
• perché le funzioni sono utili;
• come creare una funzione con def;
• come chiamare una funzione;
• come funziona l’indentazione nelle funzioni;
• come usare i parametri;
• come passare argomenti;
• come restituire valori con return;
• la differenza tra print() e return;
• come usare valori predefiniti nei parametri;
• come funziona lo scope delle variabili;
• come evitare codice ripetuto;
• errori comuni dei principianti;
• come costruire piccoli programmi con le funzioni.

Alla fine di questa lezione il tuo codice sarà più organizzato.

Meno ripetizione.

Più struttura.

Meno disastri da copia-incolla.

Speriamo.

Le funzioni sono uno dei passi più grandi nella programmazione.

Prima delle funzioni, il codice è una strada lunga.

Dopo le funzioni, il codice diventa una città con i cartelli.

Puoi ancora perderti.

Ma almeno ora ci sono i cartelli.

Cos’è una funzione?

Una funzione è un blocco di codice riutilizzabile.

La definisci una volta.

Poi puoi usarla molte volte.

Esempio:

def say_hello():
    print("Hello!")

Questo crea una funzione chiamata:

say_hello

Ma creare una funzione non la esegue.

Per eseguire la funzione, devi chiamarla:

say_hello()

Esempio completo:

def say_hello():
    print("Hello!")

say_hello()

Output:

Hello!

Una funzione è come una piccola macchina.

La costruisci una volta.

Poi premi il pulsante.

Il pulsante è la chiamata della funzione.

Molto tecnico.

Molto pulsante.

La tua prima funzione

Crea un file:

functions.py

Scrivi:

def greet():
    print("Hello from a function!")

greet()

Eseguilo:

python functions.py

oppure:

python3 functions.py

Output:

Hello from a function!

Questa riga crea la funzione:

def greet():

Questa riga appartiene alla funzione:

    print("Hello from a function!")

Questa riga chiama la funzione:

greet()

Importante:

def crea la funzione.
Chiamare la funzione la esegue.

Se definisci una funzione ma non la chiami mai, non succede nulla.

Python è educato.

Non esegue funzioni se non glielo chiedi.

A differenza di alcune persone che danno consigli senza che tu li abbia chiesti.

Sintassi di una funzione

Una funzione base si scrive così:

def function_name():
    code_here

Esempio:

def show_menu():
    print("1. Add item")
    print("2. Show items")
    print("q. Quit")

Parti:

def              inizia la definizione della funzione
function_name    il nome della funzione
()               parentesi
:                inizia il corpo della funzione
indentazione     codice dentro la funzione

I due punti sono importanti.

L’indentazione è importante.

Python si preoccupa ancora dell’indentazione.

Molto.

Python vede l’indentazione come una pianta architettonica.

Se l’indentazione è sbagliata, l’edificio crolla.

Digitalmente.

Chiamare una funzione molte volte

Le funzioni possono essere chiamate molte volte.

Esempio:

def say_hello():
    print("Hello!")

say_hello()
say_hello()
say_hello()

Output:

Hello!
Hello!
Hello!

La funzione è stata scritta una volta.

Ma è stata eseguita tre volte.

Questo è il potere delle funzioni.

Niente copia-incolla dello stesso codice ovunque.

Crei un blocco riutilizzabile.

Poi lo usi quando serve.

Molto pulito.

Molto civile.

Molto diverso da una cartella chiamata final_final_REAL_final.py.

Perché le funzioni sono utili

Le funzioni ti aiutano a:

• evitare ripetizioni;
• organizzare il codice;
• riutilizzare logica;
• rendere il codice più leggibile;
• rendere il codice più facile da modificare;
• dividere problemi grandi in problemi più piccoli.

Senza funzioni, un programma può diventare un lungo fiume di codice.

Un fiume spaventoso.

Con le funzioni, puoi dividere il programma in parti più piccole.

Esempio:

mostrare menu
leggere scelta utente
aggiungere task
mostrare task
uscire dal programma

Ogni parte può diventare una funzione.

Questo rende il codice più facile da capire.

Il tuo io futuro ti ringrazierà.

Forse.

Il tuo io futuro è spesso stanco.

Indentazione nelle funzioni

Il codice dentro una funzione deve essere indentato.

Corretto:

def greet():
    print("Hello!")

Sbagliato:

def greet():
print("Hello!")

Python mostrerà:

IndentationError

Le righe indentate appartengono alla funzione.

Esempio:

def greet():
    print("Hello!")
    print("Welcome!")

print("This is outside the function.")

Qui:

print("Hello!")
print("Welcome!")

appartengono alla funzione.

Questa riga:

print("This is outside the function.")

non appartiene alla funzione.

L’indentazione decide l’appartenenza.

Come i documenti.

Ma con spazi.

Nomi delle funzioni

I nomi delle funzioni dovrebbero essere chiari.

Buono:

def show_menu():
    print("Menu")

Buono:

def calculate_total():
    print("Calculating...")

Cattivo:

def x():
    print("Something")

Cattivo:

def do_stuff():
    print("Stuff")

Usa nomi che spiegano cosa fa la funzione.

I nomi delle funzioni di solito usano lettere minuscole e underscore:

show_menu
calculate_total
add_product
get_user_name

Questo stile si chiama snake_case.

Python ama snake_case.

Non i serpenti veri.

Probabilmente.

Parametri

Un parametro permette a una funzione di ricevere dati.

Esempio:

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

Qui:

name

è un parametro.

È come una variabile di input per la funzione.

Ora chiama la funzione:

greet_user("Anna")
greet_user("Marco")
greet_user("Sofia")

Esempio completo:

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

greet_user("Anna")
greet_user("Marco")
greet_user("Sofia")

Output:

Hello, Anna!
Hello, Marco!
Hello, Sofia!

La funzione è riutilizzabile.

Il messaggio cambia in base al valore che passi.

Molto utile.

Molto pulito.

Molto meno copia-incolla.

Argomenti

Quando chiami una funzione, il valore che passi si chiama argomento.

Esempio:

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

greet_user("Anna")

Qui:

name

è il parametro.

E:

"Anna"

è l’argomento.

Spiegazione semplice:

parametro = variabile nella definizione della funzione
argomento = valore reale passato quando chiami la funzione

Spesso le persone usano queste parole in modo un po’ libero.

Non andare in panico.

L’idea importante è:

Le funzioni possono ricevere valori.

Questa è la parte che conta di più.

Funzione con due parametri

Una funzione può avere più di un parametro.

Esempio:

def greet_user(name, city):
    print(f"Hello, {name} from {city}!")

Chiamala:

greet_user("Anna", "Rome")

Esempio completo:

def greet_user(name, city):
    print(f"Hello, {name} from {city}!")

greet_user("Anna", "Rome")
greet_user("Marco", "Milan")

Output:

Hello, Anna from Rome!
Hello, Marco from Milan!

L’ordine conta.

Questo:

greet_user("Anna", "Rome")

significa:

name = Anna
city = Rome

Se li inverti:

greet_user("Rome", "Anna")

Output:

Hello, Rome from Anna!

Tecnicamente corretto.

Emotivamente strano.

Funzioni e calcoli

Le funzioni sono ottime per i calcoli.

Esempio:

def add_numbers(a, b):
    total = a + b
    print(total)

add_numbers(5, 3)

Output:

8

Qui:

a
b

sono parametri.

Questa funzione li somma e stampa il risultato.

Altro esempio:

def calculate_total(price, quantity):
    total = price * quantity
    print(f"Total: {total:.2f}")

calculate_total(10.00, 3)

Output:

Total: 30.00

È utile.

Ma c’è un modo migliore.

Invece di stampare soltanto il risultato, possiamo restituirlo.

Ed è qui che entra return.

Molto importante.

Molto funzione.

Restituire valori

Una funzione può restituire un valore.

Esempio:

def add_numbers(a, b):
    return a + b

result = add_numbers(5, 3)

print(result)

Output:

8

La funzione:

def add_numbers(a, b):
    return a + b

non stampa.

Restituisce il risultato.

Questa riga salva il risultato:

result = add_numbers(5, 3)

Poi lo stampiamo:

print(result)

Questo è molto importante.

Una funzione che restituisce un valore è più flessibile.

Puoi stampare il valore.

Oppure salvarlo.

Oppure usarlo in un altro calcolo.

Oppure passarlo a un’altra funzione.

Qui le funzioni diventano potenti.

print() vs return

Questo è molto importante.

print() mostra qualcosa sullo schermo.

return manda un valore fuori dalla funzione.

Esempio con print():

def add_numbers(a, b):
    print(a + b)

result = add_numbers(5, 3)

print(result)

Output:

8
None

Perché None?

Perché la funzione ha stampato il risultato, ma non ha restituito nulla.

Ora esempio con return:

def add_numbers(a, b):
    return a + b

result = add_numbers(5, 3)

print(result)

Output:

8

Regola semplice:

Usa print() per mostrare qualcosa.
Usa return per restituire un valore.

Questa è una delle lezioni più importanti per principianti.

Molto importante.

Molto facile da confondere.

Molto normale.

Funzione che restituisce un totale

Esempio:

def calculate_total(price, quantity):
    return price * quantity

total = calculate_total(25.00, 4)

print(f"Total: {total:.2f}")

Output:

Total: 100.00

Ora la funzione calcola.

Il programma principale decide cosa fare con il risultato.

Questo è più pulito.

La funzione ha un compito:

calcolare il totale

Il programma principale ha un altro compito:

mostrare il risultato

Questa separazione è buona.

Molto buona.

Molto professionale.

Molto “oggi niente spaghetti”.

Valori predefiniti dei parametri

Un parametro può avere un valore predefinito.

Esempio:

def greet_user(name="Guest"):
    print(f"Hello, {name}!")

Ora puoi chiamare:

greet_user("Anna")
greet_user()

Esempio completo:

def greet_user(name="Guest"):
    print(f"Hello, {name}!")

greet_user("Anna")
greet_user()

Output:

Hello, Anna!
Hello, Guest!

Quando passi un nome, Python lo usa.

Quando non passi un nome, Python usa "Guest".

Questo è utile quando un valore è opzionale.

I valori predefiniti sono come piani di riserva.

Una cosa rara nella programmazione che sembra davvero confortante.

Argomenti nominati

Puoi passare argomenti usando il nome.

Esempio:

def describe_product(name, price):
    print(f"{name}: {price:.2f}")

describe_product(name="Keyboard", price=70.00)

Output:

Keyboard: 70.00

Questo si chiama usare keyword arguments.

Può rendere le chiamate più chiare.

Specialmente quando ci sono molti parametri.

Esempio:

def create_user(name, age, city):
    print(f"{name}, {age}, {city}")

create_user(name="Anna", age=25, city="Rome")

Questo è più leggibile di:

create_user("Anna", 25, "Rome")

Entrambi funzionano.

Gli argomenti nominati rendono il significato più chiaro.

E il codice chiaro ha meno probabilità di attaccarti più tardi.

Di solito.

Scope delle variabili

Le variabili create dentro una funzione esistono solo dentro quella funzione.

Esempio:

def greet():
    message = "Hello!"

greet()

print(message)

Questo dà errore:

NameError

Perché?

Perché message è stata creata dentro la funzione.

Fuori dalla funzione non esiste.

Questo si chiama scope.

Scope significa:

dove una variabile è disponibile

Una variabile dentro una funzione è locale a quella funzione.

Vive lì.

Non si trasferisce fuori.

Molto privata.

Molto introversa.

Variabili locali

Esempio:

def calculate_total(price, quantity):
    total = price * quantity
    return total

result = calculate_total(10, 3)

print(result)

Output:

30

Qui:

total

esiste dentro la funzione.

Questo funziona:

return total

perché siamo dentro la funzione.

Ma questo non funzionerebbe:

print(total)

fuori dalla funzione.

La variabile total è locale.

Se ti serve il risultato fuori dalla funzione, restituiscilo.

Questo è il modo corretto.

Non cercare di rubare variabili locali dalla finestra.

Python chiude la finestra.

Funzione con una lista

Le funzioni possono ricevere liste.

Esempio:

def show_products(products):
    for product in products:
        print(f"- {product}")

items = ["Keyboard", "Mouse", "Notebook"]

show_products(items)

Output:

- Keyboard
- Mouse
- Notebook

La funzione riceve una lista.

Poi scorre la lista.

Questo è molto comune.

Funzioni e liste lavorano benissimo insieme.

Una lista salva molti valori.

Una funzione li processa.

Molto utile.

Molto reale.

Molto “questo potrebbe diventare un report più avanti”.

Funzione che calcola il totale di una lista

Esempio:

def calculate_total(prices):
    total = 0

    for price in prices:
        total += price

    return total

prices = [10.00, 25.50, 5.00]

total = calculate_total(prices)

print(f"Total: {total:.2f}")

Output:

Total: 40.50

Questa funzione funziona con qualsiasi lista di prezzi.

Esempio:

order_one = [10.00, 20.00]
order_two = [5.50, 7.25, 100.00]

print(calculate_total(order_one))
print(calculate_total(order_two))

La stessa funzione funziona con dati diversi.

Questa è la bellezza delle funzioni.

Scrivi una volta.

Riutilizzi.

Ti senti leggermente potente.

Funzione con un dizionario

Le funzioni possono ricevere anche dizionari.

Esempio:

def show_user(user):
    print(f"Name: {user['name']}")
    print(f"Age: {user['age']}")
    print(f"City: {user['city']}")

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

show_user(user)

Output:

Name: Anna
Age: 25
City: Rome

Questo è molto utile.

Un dizionario salva dati strutturati.

Una funzione li mostra o li processa.

Le applicazioni reali lo fanno continuamente.

Utenti.

Prodotti.

Ordini.

Profili.

Tutto diventa più facile quando le funzioni gestiscono dati strutturati.

Molto pratico.

Molto amico del backend.

Funzione con lista di dizionari

Esempio:

def show_products(products):
    for product in products:
        print(f"{product['name']}: {product['price']:.2f}")

products = [
    {"name": "Keyboard", "price": 70.00},
    {"name": "Mouse", "price": 25.00},
    {"name": "Notebook", "price": 5.50}
]

show_products(products)

Output:

Keyboard: 70.00
Mouse: 25.00
Notebook: 5.50

Questo è uno schema forte.

Conosci già le liste.

Conosci già i dizionari.

Ora stai mettendo funzioni intorno a loro.

Così i programmi diventano organizzati.

Le strutture dati salvano dati.

Le funzioni lavorano con i dati.

Idea molto importante.

Molto software.

Errore comune: dimenticare le parentesi

Sbagliato:

def greet():
    print("Hello!")

greet

Questo non chiama la funzione.

Corretto:

greet()

Le parentesi chiamano la funzione.

Senza parentesi stai solo facendo riferimento alla funzione.

Python dice:

Sì, quella funzione esiste.

Ma non la esegue.

Una chiamata di funzione ha bisogno delle parentesi.

Piccoli cerchi.

Grande responsabilità.

Errore comune: dimenticare i due punti

Sbagliato:

def greet()
    print("Hello!")

Corretto:

def greet():
    print("Hello!")

Le definizioni di funzione hanno bisogno dei due punti.

Python ama i due punti.

Le condizioni vogliono i due punti.

I cicli vogliono i due punti.

Le funzioni vogliono i due punti.

Python sta praticamente costruendo una piccola collezione di due punti.

Rispettala.

Errore comune: indentazione sbagliata

Sbagliato:

def greet():
print("Hello!")

Corretto:

def greet():
    print("Hello!")

Il corpo della funzione deve essere indentato.

Se l’indentazione è sbagliata, Python dà:

IndentationError

Non è Python che fa teatro.

Davvero non sa cosa appartiene alla funzione.

L’indentazione è struttura.

Di nuovo.

Sempre di nuovo.

Errore comune: dimenticare return

Sbagliato:

def add_numbers(a, b):
    total = a + b

result = add_numbers(5, 3)

print(result)

Output:

None

Perché?

Perché la funzione non restituisce nulla.

Corretto:

def add_numbers(a, b):
    total = a + b
    return total

result = add_numbers(5, 3)

print(result)

Output:

8

Se ti serve il valore fuori dalla funzione, restituiscilo.

Non limitarti a calcolarlo.

Un calcolo intrappolato dentro una funzione è come una pizza dietro un vetro.

Bella da vedere.

Non utile.

Errore comune: codice dopo return

Quando Python arriva a return, la funzione si ferma.

Esempio:

def test():
    return "Done"
    print("This will not run")

message = test()

print(message)

Output:

Done

Questa riga non viene eseguita:

print("This will not run")

Perché è dopo return.

return esce immediatamente dalla funzione.

Molto importante.

Tutto ciò che sta dopo return nello stesso blocco viene ignorato.

Come un consiglio dato dopo che qualcuno ha già chiuso la porta.

Errore comune: troppe responsabilità

Funzione cattiva:

def do_everything():
    print("Show menu")
    print("Ask user")
    print("Add product")
    print("Calculate total")
    print("Send email")

Questa funzione fa troppe cose.

Meglio:

def show_menu():
    print("Menu")

def add_product():
    print("Add product")

def calculate_total():
    print("Calculate total")

Una buona funzione di solito fa una cosa chiara.

Non sempre perfettamente.

Ma prova.

Le funzioni dovrebbero essere abbastanza piccole da capire.

Se una funzione diventa enorme, forse deve essere divisa.

Come una pizza.

Ma con il codice.

Mini programma: funzione di saluto

Crea un file:

greeting_function.py

Scrivi:

def greet_user(name):
    print(f"Hello, {name}!")
    print("Welcome to the program.")

user_name = input("What is your name? ")

greet_user(user_name)

Esempio:

What is your name? Anna

Output:

Hello, Anna!
Welcome to the program.

Questo programma usa:

• definizione di funzione;
• parametro;
• input utente;
• chiamata di funzione.

Semplice.

Ma importante.

Non stai più scrivendo solo codice lineare.

Stai organizzando comportamento.

Molto bene.

Mini programma: calcolatore totale

Crea un file:

total_calculator.py

Scrivi:

def calculate_total(price, quantity):
    return price * quantity

price = float(input("Price: "))
quantity = int(input("Quantity: "))

total = calculate_total(price, quantity)

print(f"Total: {total:.2f}")

Esempio:

Price: 25
Quantity: 4

Output:

Total: 100.00

Questo programma usa:

• funzione con parametri;
• return;
• input;
• conversione di tipo;
• output formattato.

Molto pratico.

Molto simile a un negozio.

Molto “questo un giorno potrebbe diventare una fattura”.

Attento.

Le fatture attirano le tasse.

Mini programma: funzione media

Crea un file:

average_function.py

Scrivi:

def calculate_average(numbers):
    total = 0

    for number in numbers:
        total += number

    return total / len(numbers)

scores = []

score_count = int(input("How many scores? "))

for number in range(1, score_count + 1):
    score = float(input(f"Score {number}: "))
    scores.append(score)

average = calculate_average(scores)

print(f"Average: {average:.2f}")

Esempio:

How many scores? 3
Score 1: 80
Score 2: 90
Score 3: 70

Output:

Average: 80.00

Questo programma combina:

• liste;
• cicli;
• funzioni;
• input;
• return;
• calcoli.

Ottima pratica per principianti.

Questo è uno schema reale.

Raccogli dati.

Passi dati a una funzione.

Ottieni risultato.

Mostri risultato.

Pulito.

Utile.

Abbastanza professionale da spaventare il codice spaghetti.

Pratica

Crea un file:

practice_functions.py

Scrivi un programma che:

• definisce una funzione chiamata calculate_discount;
• riceve price e discount_percent;
• restituisce il prezzo scontato;
• chiede all’utente prezzo e sconto;
• stampa il prezzo finale.

Soluzione esempio:

def calculate_discount(price, discount_percent):
    discount_amount = price * discount_percent / 100
    final_price = price - discount_amount
    return final_price

price = float(input("Price: "))
discount = float(input("Discount percent: "))

final_price = calculate_discount(price, discount)

print(f"Final price: {final_price:.2f}")

Esempio:

Price: 100
Discount percent: 20

Output:

Final price: 80.00

Questo è molto utile.

Gli sconti sono ovunque.

I negozi li usano.

I clienti li amano.

Gli sviluppatori li calcolano.

I commercialisti li controllano.

Ognuno ha un ruolo.

Caos molto organizzato.

Mini sfida

Crea un file:

task_manager_functions.py

Il tuo programma deve:

• iniziare con una lista vuota chiamata tasks;
• definire una funzione chiamata show_menu;
• definire una funzione chiamata add_task;
• definire una funzione chiamata show_tasks;
• usare un ciclo while True;
• permettere all’utente di aggiungere task;
• permettere all’utente di mostrare task;
• permettere all’utente di uscire.

Soluzione esempio:

tasks = []

def show_menu():
    print("----- Task Manager -----")
    print("1. Add task")
    print("2. Show tasks")
    print("q. Quit")

def add_task(tasks):
    task = input("Task: ")
    tasks.append(task)
    print("Task added.")

def show_tasks(tasks):
    if len(tasks) == 0:
        print("No tasks yet.")
    else:
        print("Tasks:")

        for task in tasks:
            print(f"- {task}")

while True:
    show_menu()

    choice = input("Choose an option: ").lower()

    if choice == "1":
        add_task(tasks)
    elif choice == "2":
        show_tasks(tasks)
    elif choice == "q":
        print("Goodbye.")
        break
    else:
        print("Unknown option.")

Questa è una versione migliore del task manager.

Perché?

Perché il codice è organizzato in funzioni.

Ogni funzione ha un compito:

show_menu      mostra il menu
add_task       aggiunge un task
show_tasks     mostra tutti i task

Il ciclo principale diventa più facile da leggere.

Questo è il senso delle funzioni.

Rendono i programmi più facili da organizzare.

Meno caos.

Più struttura.

Sempre Python.

Sfida extra: funzioni per prodotti

Crea un file:

product_functions.py

Costruisci un programma con queste funzioni:

create_product()
show_product(product)
calculate_total(products)

Ogni prodotto deve essere un dizionario con:

name
price
quantity

Idea esempio:

def create_product():
    product = {
        "name": input("Name: "),
        "price": float(input("Price: ")),
        "quantity": int(input("Quantity: "))
    }

    return product

def show_product(product):
    total = product["price"] * product["quantity"]
    print(f"{product['name']}: {product['quantity']} x {product['price']:.2f} = {total:.2f}")

def calculate_total(products):
    total = 0

    for product in products:
        total += product["price"] * product["quantity"]

    return total

products = []

product_count = int(input("How many products? "))

for number in range(1, product_count + 1):
    print(f"Product {number}")
    product = create_product()
    products.append(product)

print("----- Products -----")

for product in products:
    show_product(product)

total = calculate_total(products)

print(f"Total: {total:.2f}")

Questa sfida combina:

• funzioni;
• liste;
• dizionari;
• cicli;
• input;
• valori restituiti;
• calcoli.

Questo è Python serio per principianti.

Piccola logica da negozio.

Dati strutturati.

Codice riutilizzabile.

Molto forte.

Molto utile.

Molto “stai iniziando a costruire cose vere”.

Checklist per principianti

Quando la tua funzione non funziona, controlla:

Ho usato def?
Ho aggiunto le parentesi?
Ho aggiunto i due punti?
Ho indentato il corpo della funzione?
Ho chiamato la funzione?
Ho passato il numero giusto di argomenti?
Ho scritto correttamente il nome della funzione?
Ho usato return se mi serve un valore indietro?
Sto confondendo print() e return?
La variabile è locale alla funzione?
Ho messo codice dopo return?
La funzione fa troppe cose?

Le funzioni sono potenti.

Ma introducono nuovi errori.

È normale.

All’inizio le funzioni sembrano lavoro extra.

Poi un giorno scrivi un programma senza funzioni e senti dolore.

È lì che capisci.

La crescita è bella.

E leggermente fastidiosa.

Riassunto

Oggi hai imparato:

• le funzioni sono blocchi di codice riutilizzabili;
• def crea una funzione;
• chiamare una funzione la esegue;
• il corpo della funzione deve essere indentato;
• i parametri permettono alle funzioni di ricevere dati;
• gli argomenti sono valori passati alle funzioni;
• le funzioni possono avere più parametri;
• return restituisce un valore;
• print() mostra un valore, ma non lo restituisce;
• i valori predefiniti dei parametri sono possibili;
• gli argomenti nominati possono rendere le chiamate più chiare;
• le variabili dentro le funzioni sono locali;
• le funzioni possono ricevere liste;
• le funzioni possono ricevere dizionari;
• le funzioni possono lavorare con liste di dizionari;
• una buona funzione di solito fa un compito chiaro;
• le funzioni aiutano a organizzare programmi e ridurre ripetizioni.

Questo è un passo enorme.

Il tuo codice ora può diventare più pulito.

Più riutilizzabile.

Più organizzato.

Meno copia-incolla.

Meno caos.

Le funzioni sono uno degli strumenti principali che trasformano script da principianti in programmi reali.

Non stai più solo scrivendo comandi.

Stai creando comportamento riutilizzabile.

Questo è progresso serio.

Molto Python.

Molto livello successivo.

Prossima lezione

Nella prossima lezione impareremo i file.

I file permettono ai tuoi programmi di salvare dati.

Per ora, quando il programma termina, i dati spariscono.

Molto triste.

Molto temporaneo.

Con i file, puoi scrivere dati su disco e leggerli più tardi.

Per esempio:

salvare task
caricare task
salvare contatti
leggere note
scrivere report

Questo è molto importante.

Perché i programmi diventano molto più utili quando ricordano le cose.

La memoria è potere.

A meno che tu non abbia salvato il file sbagliato.

Allora la memoria è dramma.

Dramma molto educativo.