Introduzione alla lezione
- Variabile: contenitore con un nome e un valore
- Tipo di dato: definisce cosa può contenere e come si usa
- Operatore: simbolo/azione che elabora valori
- Parametro: input fornito a una funzione o programma
Obiettivi
Scrivere in pseudocodice e in Python funzioni che usano variabili, operatori e parametri.
Variabili: i contenitori dei dati
Una variabile è come una scatola con un'etichetta (nome) che contiene un valore. Il contenuto può cambiare durante l'esecuzione del programma, ma il nome rimane lo stesso.
Anatomia di una variabile
- Nome. Identificativo univoco. Deve essere descrittivo:
eta,totaleVendite. - Valore. Il dato memorizzato:
25,"Mario",True. - Tipo. Natura del dato: numero intero, decimale, stringa, booleano, lista, ecc.
Tipi di dati principali
| Tipo | Descrizione | Esempi | Uso Comune |
|---|---|---|---|
| Intero (int) | Numeri senza decimali | 7, -3, 0, 1000 | Contatori, età, quantità |
| Decimale (float) | Numeri con virgola | 3.14, -0.5, 2.718 | Prezzi, misure, percentuali |
| Stringa (str) | Sequenza di caratteri | "Ciao", "Roma", "123" | Testi, nomi, messaggi |
| Booleano (bool) | Vero o falso | True, False | Condizioni, flag, stato |
| Lista (list) | Sequenza ordinata | [1, 2, 3], ["a", "b"] | Collezioni, array |
| Dizionario (dict) | Coppie chiave-valore | {"nome": "Mario", "eta": 30} | Strutture dati complesse |
// Dichiarazione e assegnazione
numeroStudenti = 25
temperaturaMedia = 18.5
nomeCitta = "Livorno"
iscritto = vero
voti = [18, 24, 27, 30]
persona = {nome: "Anna", eta: 22}
# Dichiarazione e assegnazione
numero_studenti = 25 # int
temperatura_media = 18.5 # float
nome_citta = "Livorno" # str
iscritto = True # bool
voti = [18, 24, 27, 30] # list
persona = {"nome": "Anna", "eta": 22} # dict
# Python è dinamicamente tipizzato
x = 10 # x è un int
x = "ciao" # ora x è una stringa (possibile ma sconsigliato)
Regole per i nomi delle variabili
- Devono iniziare con una lettera o underscore (_)
- Possono contenere lettere, numeri e underscore
- Non possono essere parole riservate (if, for, while, etc.)
- Python è case-sensitive:
nome≠Nome - Usa nomi descrittivi:
totale_venditeè meglio ditv
Operatori: strumenti per elaborare i dati
Gli operatori sono i simboli e le parole chiave con cui si eseguono operazioni su valori e variabili: calcoli, confronti, condizioni.
Operatori aritmetici
| Operatore | Nome | Esempio | Risultato |
|---|---|---|---|
| + | Addizione | 7 + 3 | 10 |
| - | Sottrazione | 7 - 3 | 4 |
| * | Moltiplicazione | 7 * 3 | 21 |
| / | Divisione | 7 / 3 | 2.333... |
| // | Divisione intera | 7 // 3 | 2 |
| % | Modulo (resto) | 7 % 3 | 1 |
| ** | Potenza | 2 ** 3 | 8 |
Operatori di confronto
| Operatore | Nome | Esempio | Risultato |
|---|---|---|---|
| == | Uguale a | 5 == 5 | True |
| != | Diverso da | 5 != 3 | True |
| > | Maggiore di | 7 > 3 | True |
| < | Minore di | 3 < 7 | True |
| >= | Maggiore o uguale | 5 >= 5 | True |
| <= | Minore o uguale | 3 <= 7 | True |
Operatori logici
- AND (e). Vero se entrambe le condizioni sono vere.
(5 > 3) and (10 > 7)→ True - OR (o). Vero se almeno una condizione è vera.
(5 > 10) or (3 < 7)→ True - NOT (non). Inverte il valore booleano.
not (5 > 10)→ True
a = 7
b = 3
// Aritmetici
somma = a + b // 10
differenza = a - b // 4
prodotto = a * b // 21
quoziente = a / b // 2.333...
resto = a % b // 1
potenza = a ** 2 // 49
// Confronto e Logici
maggiore = (a > b) // vero
pari = (a % 2 == 0) // falso
condizione = (a > 5) AND (b < 5) // vero
a = 7
b = 3
# Aritmetici
somma = a + b
resto = a % b
pari = (a % 2 == 0)
# Confronto e Logici
maggiore_di_cinque = (a > 5 and b > 1) # True
non_pari = not (a % 2 == 0) # True
# Attenzione alla divisione per zero!
if b != 0:
risultato = a / b
else:
print("Errore: divisione per zero!")
Differenza tra = e ==
- = è l'operatore di assegnazione: assegna un valore a una variabile
- == è l'operatore di confronto: verifica se due valori sono uguali
- Esempio:
x = 5(assegno 5 a x) vsx == 5(x è uguale a 5?)
È lo scambio che in aula vedo più spesso nelle prime lezioni: si scrive un uguale dove ne servono due.
Funzioni, parametri e scope
Le funzioni sono blocchi di codice riutilizzabili che eseguono un compito specifico. I parametri sono valori che passiamo alle funzioni per personalizzarne il comportamento. Lo scope definisce dove una variabile è visibile e utilizzabile nel codice.
Anatomia di una funzione
- Nome. Identificativo della funzione:
calcola_media,trova_massimo - Parametri (Input). Valori in ingresso che la funzione riceve ed elabora
- Ritorno (Output). Valore che la funzione restituisce dopo l'elaborazione
// Funzione senza parametri
FUNZIONE saluta()
STAMPA "Ciao a tutti!"
FINE FUNZIONE
// Funzione con parametri
FUNZIONE somma(x, y)
RESTITUISCI x + y
FINE FUNZIONE
// Funzione con più parametri
FUNZIONE calcola_media(a, b, c)
totale = a + b + c
media = totale / 3
RESTITUISCI media
FINE FUNZIONE
// Utilizzo
risultato = somma(5, 7) // 12
media_voti = calcola_media(24, 27, 30) // 27
# Funzione base
def saluta():
print("Ciao a tutti!")
# Funzione con parametri
def somma(x, y):
return x + y
# Funzione con parametri e logica
def calcola_sconto(prezzo, percentuale):
sconto = prezzo * (percentuale / 100)
prezzo_finale = prezzo - sconto
return prezzo_finale
# Funzione con parametri di default
def potenza(base, esponente=2):
return base ** esponente
# Utilizzo
risultato = somma(5, 7) # 12
prezzo_scontato = calcola_sconto(100, 20) # 80.0
quadrato = potenza(5) # 25 (usa default)
cubo = potenza(5, 3) # 125
Scope (ambito) delle variabili
Lo scope determina dove una variabile può essere utilizzata. Esistono due tipi principali:
- Scope Globale. Variabili definite fuori dalle funzioni, visibili ovunque nel programma
- Scope Locale. Variabili definite dentro una funzione, visibili solo in quella funzione
- Regola d'Oro. Preferisci parametri espliciti piuttosto che variabili globali per funzioni chiare
# Variabile globale
valore_globale = 10
def funzione_esempio():
# Variabile locale
valore_locale = 5
# Posso accedere sia a globale che locale
risultato = valore_globale + valore_locale
return risultato # 15
def funzione_con_parametri(x):
# x è un parametro locale
# Meglio usare parametri che dipendere da globali
return x * 2
# Utilizzo
print(funzione_esempio()) # 15
print(funzione_con_parametri(7)) # 14
# Questa riga causerebbe errore:
# print(valore_locale) # ERRORE: valore_locale non è visibile qui!
Come si scrivono le funzioni
- Single Responsibility: Ogni funzione dovrebbe fare una cosa sola
- Nomi Descrittivi: Il nome deve indicare chiaramente cosa fa la funzione
- Parametri Espliciti: Evita dipendenze da variabili globali
- Documentazione: Commenta cosa fa la funzione, i parametri e il ritorno
- Riutilizzo: Scrivi funzioni che possano essere riutilizzate in contesti diversi
Esercizi pratici guidati
Risolvi gli esercizi prima in pseudocodice, poi scrivili in Python.
- Calcolatrice Parametrica. Scrivi una funzione
calcola(a, b, operatore)che prende due numeri e un operatore (+, -, *, /) e restituisce il risultato. Gestisci la divisione per zero. - Controllo Pari/Dispari. Crea una funzione
is_pari(n)che restituisceTruese il numero è pari,Falsealtrimenti. Usa l'operatore modulo (%). - Media di Lista. Scrivi una funzione
calcola_media(lista)che calcola la media dei valori. Gestisci il caso della lista vuota. - Trova Massimo. Implementa
trova_max(a, b)che restituisce il maggiore tra due numeri. Poi estendila per accettare tre numeri. - Conversione Temperature. Crea
celsius_to_fahrenheit(c)efahrenheit_to_celsius(f). Formula: F = (C × 9/5) + 32 - Verifica Età. Funzione
is_maggiorenne(eta)che restituisceTruese età >= 18. Aggiungi controllo per età valide (0-120).
Soluzioni guidate
Soluzione Esercizio 1 - Calcolatrice
def calcola(a, b, operatore):
"""Calcolatrice semplice con 4 operazioni base"""
if operatore == '+':
return a + b
elif operatore == '-':
return a - b
elif operatore == '*':
return a * b
elif operatore == '/':
if b != 0:
return a / b
else:
return "Errore: divisione per zero"
else:
return "Operatore non valido"
# Test
print(calcola(10, 5, '+')) # 15
print(calcola(10, 5, '-')) # 5
print(calcola(10, 5, '*')) # 50
print(calcola(10, 5, '/')) # 2.0
print(calcola(10, 0, '/')) # Errore: divisione per zero
Soluzione Esercizio 2 - Pari/Dispari
def is_pari(n):
"""Verifica se un numero è pari"""
return n % 2 == 0
# Test
print(is_pari(4)) # True
print(is_pari(7)) # False
print(is_pari(0)) # True (zero è pari)
print(is_pari(-6)) # True (anche negativi)
Soluzione Esercizio 3 - Media Lista
def calcola_media(lista):
"""Calcola la media di una lista di numeri"""
if len(lista) == 0:
return None # oppure 0, o un messaggio di errore
somma = sum(lista) # funzione built-in Python
media = somma / len(lista)
return media
# Test
print(calcola_media([10, 20, 30])) # 20.0
print(calcola_media([5, 5, 5, 5])) # 5.0
print(calcola_media([])) # None
print(calcola_media([100])) # 100.0
Soluzione Esercizio 4 - Trova Massimo
def trova_max(a, b):
"""Trova il maggiore tra due numeri"""
if a > b:
return a
else:
return b
# oppure, in una riga: return a if a > b else b
def trova_max_tre(a, b, c):
"""Trova il maggiore tra tre numeri"""
massimo = a
if b > massimo:
massimo = b
if c > massimo:
massimo = c
return massimo
# oppure: return max(a, b, c) # funzione built-in
# Test
print(trova_max(10, 5)) # 10
print(trova_max_tre(10, 25, 15)) # 25
Esercizio avanzato
Crea una funzione analizza_numero(n) che restituisce un dizionario con le informazioni sul numero: se è pari o dispari, se è positivo, negativo o zero, e il suo quadrato.
analizza_numero(5)
# Output: {
# 'numero': 5,
# 'pari': False,
# 'segno': 'positivo',
# 'quadrato': 25
# }
Test finale Unità Formativa 1 - Lezioni 1 e 2
Soglia di superamento: 60/100
Test completo su algoritmi, flowcharts, pseudocodice, variabili, tipi di dati, operatori e funzioni. Compila con attenzione. Al termine potrai scaricare un file .txt con gli esiti.
Riepilogo della lezione
Punti chiave
- Variabili come contenitori di dati
- Tipi principali: numeri, stringhe, booleani, liste
- Operatori aritmetici, di confronto e logici
- Funzioni con parametri e concetto di scope
Nella prossima lezione si passa ai database con MySQL: creare database e tabelle, gestire le relazioni e interrogare i dati con le query SQL.
Vuoi approfondire la programmazione con un percorso completo?
Scopri i corsi e la formazione di Federico Boggia su programmazione, dati e digitale.