Descrizione
Il corso ha 2 Unità Formative, di due lezioni l'una.
UF1, Introduzione al Codice: i concetti di base, algoritmi, variabili e tipi di dati, operatori, logica di programmazione, test e debug.
UF2, MySQL Database Management: creazione e gestione database, tabelle, query SELECT, comandi INSERT/UPDATE/DELETE, indici e importazione dati.
Cosa imparerai
- Comprendere algoritmi, schemi di flusso e pseudocodice
- Scrivere codice strutturato e documentato
- Usare variabili, tipi di dati e operatori aritmetici
- Applicare logica, iterazione, procedure e funzioni
- Creare e gestire database MySQL
- Scrivere query SELECT, INSERT, UPDATE, DELETE e JOIN
- Ottimizzare le performance con indici e importare dati
- Adottare comportamenti base di sicurezza informatica
Dettagli del corso
Linguaggi e strumenti
Lezione 1 di 4
Concetti Fondamentali e Algoritmi
UF1: impari a pensare come un programmatore, anche senza computer! La Macchina di Turing, gli algoritmi, i flowchart e lo pseudocodice.
Introduzione alla lezione
Prima di scrivere codice servono i concetti su cui il codice poggia.
Sono quattro cose:
- I termini dell'informatica: le parole che un programmatore usa tutti i giorni
- Algoritmi: come risolvere problemi in modo sistematico
- Schemi di flusso (Flowchart): rappresentare visivamente la logica
- Pseudocodice: scrivere la logica prima del codice vero
Obiettivi della lezione
Al termine di questa lezione saprai anche da dove arriva la programmazione, e avrai scritto i tuoi primi algoritmi con carta e penna.
Il computer: lo strumento del programmatore
Il computer per un programmatore è come il telescopio per un astronomo.
Un astronomo studia le stelle, le galassie e l'universo. Il telescopio amplifica le sue capacità e gli fa vedere più lontano. Ma l'astronomo deve prima conoscere la fisica, l'astronomia e la matematica. Può fare calcoli, previsioni e teorie anche senza guardare nel telescopio!
Allo stesso modo, un programmatore può programmare anche senza computer! La programmazione è prima di tutto un modo di pensare, una capacità di risolvere problemi in modo logico e strutturato.
Programmazione su carta
Prima dell'era dei computer personali, i programmatori scrivevano algoritmi su carta, creavano flowchart alla lavagna e pensavano alla logica usando solo la mente. Anche oggi conviene progettare prima su carta, e aprire l'editor dopo.
Il pensiero computazionale
La capacità di scomporre problemi complessi in passi semplici, di trovare pattern e di astrarre concetti è chiamata "pensiero computazionale". Questa abilità è utile in qualsiasi ambito della vita, non solo nella programmazione!
Riflessione importante
Il computer esegue istruzioni velocemente. Il lavoro vero lo fa la mente del programmatore, che pensa, progetta e trova le soluzioni. Imparare a programmare significa imparare a pensare in modo algoritmico, e quella è una competenza che resta anche quando la tecnologia cambia.
Breve storia della programmazione
La programmazione è più vecchia dei computer moderni: il primo algoritmo scritto per una macchina è del 1843.
Le tappe
| Anno | Evento | Descrizione |
|---|---|---|
| 1843 | Ada Lovelace | Scrive il primo algoritmo pensato per essere eseguito da una macchina (la Macchina Analitica di Babbage). È considerata la prima programmatrice della storia. |
| 1936 | Alan Turing | Introduce il concetto di "Macchina di Turing", un modello teorico che definisce cosa significa "calcolare" e che è alla base di tutti i computer moderni. |
| 1945 | ENIAC | Primo computer elettronico generale programmabile. Veniva programmato fisicamente collegando cavi e interruttori! |
| 1957 | FORTRAN | Primo linguaggio di programmazione ad alto livello di grande successo, usato ancora oggi per calcoli scientifici. |
| 1972 | Linguaggio C | Dennis Ritchie crea il linguaggio C, che diventerà uno dei linguaggi più influenti di tutti i tempi. Unix, Linux, Windows sono scritti in C. |
| 1991 | Python | Guido van Rossum crea Python, un linguaggio progettato per essere semplice e leggibile. Oggi è il linguaggio più popolare al mondo. |
| 1995 | JavaScript | Nasce JavaScript per rendere le pagine web interattive. Oggi è ovunque: browser, server, mobile, desktop. |
| 2000+ | Era Moderna | Esplosione di linguaggi specializzati, intelligenza artificiale, cloud computing, app mobile. La programmazione diventa accessibile a tutti. |
Curiosità storica
Durante la Seconda Guerra Mondiale, Alan Turing usò i suoi principi di computazione per decifrare i codici segreti nazisti della macchina Enigma, e quel lavoro contribuì alla vittoria degli Alleati.
La Macchina di Turing
Nel 1936, il matematico britannico Alan Turing propose un modello teorico di macchina che potesse eseguire qualsiasi calcolo possibile. Questo modello, chiamato Macchina di Turing, è alla base teorica di tutti i computer moderni.
Cos'è una Macchina di Turing?
Una Macchina di Turing è un modello matematico astratto composto da:
Metafora: la persona con foglio e matita
Per capire meglio la Macchina di Turing, immagina una persona seduta a una scrivania infinitamente lunga, con un foglio di carta a quadretti che si estende all'infinito in entrambe le direzioni.
Cosa fa questa persona?
- Può leggere il simbolo scritto nel quadretto che ha davanti agli occhi
- Può scrivere o cancellare simboli in quel quadretto con la matita
- Può spostarsi di un quadretto a destra o sinistra lungo la scrivania
- Segue delle istruzioni precise scritte su un manuale che ha davanti
- È in uno "stato mentale" (esempio: "cerco uno zero", "sto sommando", "ho finito")
Il manuale di istruzioni contiene regole come questa:
"Se sei nello stato 'cerco uno zero' e leggi '1', scrivi '0', spostati a destra e passa allo stato 'cerco un uno'"
Questo è esattamente ciò che fa una Macchina di Turing!
- Il nastro infinito = il foglio a quadretti infinito
- La testina di lettura/scrittura = la matita e gli occhi della persona
- Gli stati = lo "stato mentale" della persona
- La tabella delle transizioni = il manuale di istruzioni
Ogni computer che usiamo oggi (smartphone, laptop, supercomputer) è in fondo questa "persona con foglio e matita", solo molto più veloce: miliardi di operazioni al secondo.
Componenti della Macchina di Turing
- Nastro infinito: un nastro diviso in celle, ciascuna contenente un simbolo (come 0, 1, o vuoto). Il nastro rappresenta la memoria, potenzialmente infinita.
- Testina di lettura/scrittura: una testina che può leggere e scrivere simboli sul nastro, e muoversi a sinistra o a destra di una cella alla volta.
- Insieme di stati: un insieme finito di "stati" in cui la macchina può trovarsi (come "stato iniziale", "stato finale", "stato di calcolo", ecc.).
- Tabella di transizione: un insieme di regole che dicono "se sei nello stato X e leggi il simbolo Y, scrivi Z, muoviti a sinistra/destra e passa allo stato W".
Esempi pratici di Macchine di Turing
Esempio 1: scrivere tre X
Compito: scrivere XXX su un nastro vuoto.
Metafora della Persona:
La persona inizia davanti a un foglio bianco e deve scrivere tre X.
Stati mentali:
- S0: "Devo scrivere la prima X"
- S1: "Devo scrivere la seconda X"
- S2: "Devo scrivere la terza X"
- FINE: "Ho finito"
Istruzioni del manuale:
SE sono in S0:
- Scrivo "X" nel quadretto corrente
- Mi sposto a DESTRA
- Passo allo stato S1
SE sono in S1:
- Scrivo "X" nel quadretto corrente
- Mi sposto a DESTRA
- Passo allo stato S2
SE sono in S2:
- Scrivo "X" nel quadretto corrente
- Passo allo stato FINE
Esecuzione passo-passo:
Nastro iniziale: [ ][ ][ ][ ][ ]...
↑ (persona qui, stato S0)
Passo 1: Scrivo X, vado a destra, stato S1
Nastro: [X][ ][ ][ ][ ]...
↑ (persona qui, stato S1)
Passo 2: Scrivo X, vado a destra, stato S2
Nastro: [X][X][ ][ ][ ]...
↑ (persona qui, stato S2)
Passo 3: Scrivo X, stato FINE
Nastro finale: [X][X][X][ ][ ]...
↑ (persona qui, stato FINE - FERMATA)
Esempio 2: sommare 1 a un numero binario
Compito: incrementare 1011 (11 in decimale) di 1.
Metafora della Persona:
Immagina di sommare 1 a un numero binario su carta, partendo dalla cifra più a destra.
Istruzioni del manuale:
1. Vai all'ultima cifra (più a destra)
2. SE leggi "1": scrivi "0", vai a sinistra (c'è riporto!)
3. SE leggi "0": scrivi "1" e FERMATI (somma completata)
4. SE leggi "vuoto": scrivi "1" e FERMATI
Esecuzione passo-passo:
Nastro iniziale: [1][0][1][1][ ][ ]... (1011₂ = 11₁₀)
↑ Parto da qui
Passo 1: Leggo [1] → Scrivo [0], vado a sinistra (riporto!)
Nastro: [1][0][1][0][ ][ ]...
↑
Passo 2: Leggo [1] → Scrivo [0], vado a sinistra (ancora riporto!)
Nastro: [1][0][0][0][ ][ ]...
↑
Passo 3: Leggo [0] → Scrivo [1], FERMATI (somma completa!)
Nastro finale: [1][1][0][0][ ][ ]... (1100₂ = 12₁₀)
↑ FINE
Verifica: 1011₂ + 1 = 1100₂ ✓ (11 + 1 = 12)
Esempio 3: trovare una X su un nastro
Compito: cercare il primo simbolo X sul nastro.
Metafora della Persona:
Scorri il foglio da sinistra a destra finché non trovi una X.
Stati mentali:
- CERCA: "Sto cercando una X"
- TROVATO: "Ho trovato la X!"
Istruzioni del manuale:
SE sono in CERCA e leggo qualsiasi simbolo diverso da X:
- Non scrivo niente
- Mi sposto a DESTRA
- Resto in stato CERCA
SE sono in CERCA e leggo "X":
- Passo allo stato TROVATO
- FERMATI
Esecuzione passo-passo:
Nastro: [A][B][C][X][Y][Z]...
↑ (inizio, stato CERCA)
Passo 1: Leggo [A] (non è X), vado a destra
Nastro: [A][B][C][X][Y][Z]...
↑ (stato CERCA)
Passo 2: Leggo [B] (non è X), vado a destra
Nastro: [A][B][C][X][Y][Z]...
↑ (stato CERCA)
Passo 3: Leggo [C] (non è X), vado a destra
Nastro: [A][B][C][X][Y][Z]...
↑ (stato CERCA)
Passo 4: Leggo [X] (trovata!), passo a stato TROVATO, FERMATI
Nastro: [A][B][C][X][Y][Z]...
↑ (stato TROVATO - FINE)
Esempio 4: invertire 0 e 1
Compito: trasformare tutti gli 0 in 1 e tutti gli 1 in 0.
Metafora della Persona:
Scorri il foglio, quando vedi 0 cambialo in 1, quando vedi 1 cambialo in 0.
Istruzioni del manuale:
SE leggo "0":
- Scrivo "1"
- Vado a DESTRA
SE leggo "1":
- Scrivo "0"
- Vado a DESTRA
SE leggo "vuoto":
- FERMATI (ho finito la sequenza)
Esecuzione passo-passo:
Nastro iniziale: [1][0][1][1][0][ ]...
↑
Passo 1: Leggo [1] → Scrivo [0], vado a destra
Nastro: [0][0][1][1][0][ ]...
↑
Passo 2: Leggo [0] → Scrivo [1], vado a destra
Nastro: [0][1][1][1][0][ ]...
↑
Passo 3: Leggo [1] → Scrivo [0], vado a destra
Nastro: [0][1][0][1][0][ ]...
↑
Passo 4: Leggo [1] → Scrivo [0], vado a destra
Nastro: [0][1][0][0][0][ ]...
↑
Passo 5: Leggo [0] → Scrivo [1], vado a destra
Nastro: [0][1][0][0][1][ ]...
↑
Passo 6: Leggo [ ] (vuoto) → FERMATI
Nastro finale: [0][1][0][0][1][ ]...
Risultato: Tutti i bit sono stati invertiti! ✓
Prova tu!
Esercizio pratico: prendi carta e penna e simula una Macchina di Turing che:
- Conta quanti "1" ci sono in una sequenza binaria
- Sostituisce ogni "A" con "B" su un nastro
- Copia una sequenza di simboli in un'altra posizione del nastro
Ricorda: puoi fare solo operazioni semplici (leggere, scrivere, spostarti di una cella, cambiare stato mentale). Ma con queste operazioni elementari puoi fare QUALSIASI calcolo!
Importanza della Macchina di Turing
- Definizione di computabilità: ha definito formalmente cosa significa che un problema può essere risolto da un computer
- Tesi di Church-Turing: qualsiasi cosa calcolabile può essere calcolata da una Macchina di Turing
- Base dei computer moderni: tutti i computer odierni sono essenzialmente Macchine di Turing (con memoria finita)
- Limiti della computazione: ha dimostrato che esistono problemi che nessun computer potrà mai risolvere (problema della fermata)
Concetto chiave
La Macchina di Turing dimostra che la programmazione è pura logica matematica. Si potrebbe costruire un computer con ingranaggi meccanici, acqua che scorre in tubi, o persino con carta e matita, senza bisogno di circuiti elettronici complessi! Il computer fisico è solo uno strumento per eseguire velocemente ciò che potremmo fare a mano (ma ci vorrebbe un'eternità).
Terminologia informatica di base
Prima di iniziare a programmare, prendi confidenza con questi termini: li userai tutti i giorni.
- Programma: un insieme di istruzioni scritte in un linguaggio di programmazione che il computer può eseguire per svolgere un compito specifico.
- Algoritmo: una sequenza finita e ordinata di passi precisi e non ambigui che risolve un problema o completa un'operazione in un tempo finito.
- Variabile: un "contenitore" che memorizza un valore in memoria. Ha un nome (identificatore) e può cambiare valore durante l'esecuzione del programma.
- Tipo di dato: definisce il tipo di valore che una variabile può contenere, numeri interi, decimali, testo (stringhe), valori booleani (vero/falso), ecc.
- Ciclo (Loop): una struttura che ripete un blocco di istruzioni più volte finché una condizione rimane vera o per un numero specifico di iterazioni.
- Condizione: un'espressione che può essere vera o falsa. Usata per prendere decisioni nel codice (if/else) e controllare i cicli.
- Funzione: un blocco di codice riutilizzabile che esegue un compito specifico. Può ricevere input (parametri) e restituire un output (valore di ritorno).
- Debug: trovare e correggere gli errori (bug) nel codice.
Cos'è un algoritmo?
Un algoritmo è una sequenza finita di istruzioni ben definite e non ambigue che, se seguite correttamente, risolvono un problema o completano un'operazione specifica.
Caratteristiche di un buon algoritmo
| Caratteristica | Descrizione |
|---|---|
| Finito | Deve terminare dopo un numero finito di passi |
| Definito | Ogni passo deve essere preciso e non ambiguo |
| Input | Può ricevere zero o più dati in ingresso |
| Output | Produce almeno un risultato |
| Efficace | Le operazioni devono essere sufficientemente semplici da essere eseguite |
| Generale | Deve funzionare per tutti i casi del problema, non solo per esempi specifici |
Esempio pratico: preparare il caffè
ALGORITMO: PreparaCaffè
INIZIO
1. Riempi la moka con acqua fino alla valvola
2. Inserisci il filtro nella moka
3. Aggiungi caffè macinato nel filtro
4. Avvita la parte superiore della moka
5. Posiziona la moka sul fornello
6. Accendi il fornello a fuoco medio
7. MENTRE il caffè non è salito
- Attendi
8. Spegni il fornello
9. Versa il caffè nella tazza
FINE
Nota importante
Gli algoritmi non sono solo per i computer! Usiamo algoritmi ogni giorno per risolvere problemi: una ricetta di cucina è un algoritmo, le istruzioni per montare un mobile sono un algoritmo, persino il percorso che fai per andare al lavoro è un algoritmo!
Algoritmo informatico: trovare il massimo
ALGORITMO: TrovaNumeroMassimo
INPUT: Una lista di numeri [n1, n2, n3, ..., nk]
OUTPUT: Il numero più grande nella lista
INIZIO
1. Imposta max = primo numero della lista
2. PER OGNI numero nella lista:
a. SE numero > max ALLORA
- max = numero
3. RESTITUISCI max
FINE
Schemi di flusso (Flowchart)
Un flowchart (o diagramma di flusso) è una rappresentazione grafica di un algoritmo. Utilizza forme geometriche standardizzate per rappresentare diversi tipi di operazioni, collegate da frecce che mostrano il flusso di esecuzione.
Simboli standard dei flowchart
- Ovale: INIZIO / FINE. Indica l'inizio o la fine di un algoritmo.
- Rettangolo: PROCESSO. Rappresenta un'operazione o un'istruzione (es, calcoli, assegnazioni).
- Rombo: DECISIONE. Indica un punto in cui si prende una decisione (SI/NO, VERO/FALSO).
- Parallelogramma: INPUT / OUTPUT. Rappresenta l'inserimento di dati o la visualizzazione di risultati.
- Freccia: FLUSSO. Indica la direzione del flusso di esecuzione da un passo all'altro.
- Cerchio: CONNETTORE. Collega parti diverse del flowchart (utile quando il diagramma è grande).
Esempio: flowchart per controllare se un numero è pari
┌──────────────┐
│ INIZIO │ ← Ovale (Start)
└──────┬───────┘
│
▼
┌─────────────────────┐
│ Inserisci un numero │ ← Parallelogramma (Input)
└──────┬──────────────┘
│
▼
┌─────────────────────────────┐
│ numero % 2 == 0 ? │ ← Rombo (Decisione)
└────┬──────────────┬─────┘
│ SI │ NO
▼ ▼
┌─────────────┐ ┌──────────────┐
│ Stampa │ │ Stampa │ ← Rettangoli (Output)
│ "È pari" │ │ "È dispari" │
└──────┬──────┘ └──────┬───────┘
│ │
└────────┬─────────┘
▼
┌─────────┐
│ FINE │ ← Ovale (End)
└─────────┘
Esercizio pratico
Prova tu: disegna un flowchart per un algoritmo che determina se una persona può entrare in un cinema (età >= 18) o se ha bisogno di un accompagnatore.
Pseudocodice
Lo pseudocodice è una descrizione testuale di un algoritmo che usa un linguaggio simile a quello di programmazione ma senza vincoli di sintassi rigida. È il ponte tra il linguaggio umano e il codice vero e proprio.
Vantaggi dello pseudocodice
- Facile da scrivere e leggere per chiunque
- Non richiede conoscenza di un linguaggio specifico
- Aiuta a concentrarsi sulla logica senza preoccuparsi della sintassi
- Facilita la comunicazione tra programmatori
- Utile per pianificare prima di scrivere codice reale
Strutture comuni in pseudocodice
1. Sequenza (istruzioni in ordine)
INIZIO
Istruzione 1
Istruzione 2
Istruzione 3
FINE
2. Selezione (IF/ELSE, condizioni)
SE condizione ALLORA
Istruzioni se vero
ALTRIMENTI
Istruzioni se falso
FINE SE
// Esempio pratico:
SE età >= 18 ALLORA
Stampa "Puoi votare"
ALTRIMENTI
Stampa "Non puoi ancora votare"
FINE SE
3. Iterazione (cicli, WHILE)
MENTRE condizione è vera FAI
Istruzioni da ripetere
FINE MENTRE
// Esempio pratico:
contatore = 1
MENTRE contatore <= 10 FAI
Stampa contatore
contatore = contatore + 1
FINE MENTRE
4. Iterazione (cicli, FOR)
PER i DA 1 A 10 FAI
Istruzioni da ripetere
FINE PER
// Esempio pratico:
PER i DA 1 A 5 FAI
Stampa "Iterazione numero: " + i
FINE PER
Esempio completo: calcolo del fattoriale
Il fattoriale di un numero n (scritto n!) è il prodotto di tutti i numeri da 1 a n. Ad esempio: 5! = 5 × 4 × 3 × 2 × 1 = 120
ALGORITMO: CalcolaFattoriale
INPUT: numero intero positivo n
OUTPUT: il fattoriale di n
INIZIO
// Controllo input
SE n < 0 ALLORA
Stampa "Errore: il numero deve essere positivo"
TERMINA
FINE SE
// Caso base
SE n == 0 O n == 1 ALLORA
risultato = 1
ALTRIMENTI
// Calcolo fattoriale
risultato = 1
PER i DA 2 A n FAI
risultato = risultato * i
FINE PER
FINE SE
// Output
Stampa "Il fattoriale di " + n + " è: " + risultato
FINE
Conversione in codice reale (Python)
Lo stesso algoritmo, in Python:
def calcola_fattoriale(n):
# Controllo input
if n < 0:
print("Errore: il numero deve essere positivo")
return None
# Caso base
if n == 0 or n == 1:
risultato = 1
else:
# Calcolo fattoriale
risultato = 1
for i in range(2, n + 1):
risultato = risultato * i
# Output
print(f"Il fattoriale di {n} è: {risultato}")
return risultato
# Test
calcola_fattoriale(5) # Output: 120
Come si fa
Prima scrivi lo pseudocodice, poi il codice. Pianificare la logica prima di aprire l'editor ti fa risparmiare tempo e ti evita errori. In aula questo passaggio lo salta sempre qualcuno: si va dritti al codice, ci si impianta a metà, e si torna indietro a scrivere lo pseudocodice.
Esercizi pratici guidati
Per ciascun esercizio prova prima a risolverlo da solo su carta, poi confronta con la soluzione proposta.
Esercizio 1: algoritmo della colazione
Compito: scrivi un algoritmo dettagliato per preparare la colazione (caffè + toast). Usa la notazione che preferisci (lista numerata, pseudocodice, flowchart).
Mostra soluzione
ALGORITMO: PreparaColazione
INIZIO
// Preparazione caffè
1. Riempi moka con acqua
2. Aggiungi caffè nel filtro
3. Metti moka sul fornello acceso
// Preparazione toast (in parallelo)
4. Inserisci pane nel tostapane
5. Imposta livello di tostatura
6. Avvia tostapane
// Attesa
7. MENTRE caffè non è pronto O toast non è pronto FAI
- Controlla caffè
- Controlla toast
8. FINE MENTRE
// Servizio
9. Versa caffè nella tazza
10. Spalma burro/marmellata sul toast
11. Servi colazione
FINE
Esercizio 2: trovare il numero maggiore tra tre
Compito: scrivi un algoritmo in pseudocodice che prende tre numeri (A, B, C) e determina quale è il più grande.
Mostra soluzione
ALGORITMO: TrovaNumeroMaggiore
INPUT: tre numeri A, B, C
OUTPUT: il numero più grande
INIZIO
Leggi A, B, C
SE A >= B E A >= C ALLORA
max = A
Stampa "Il numero maggiore è A: " + A
ALTRIMENTI SE B >= A E B >= C ALLORA
max = B
Stampa "Il numero maggiore è B: " + B
ALTRIMENTI
max = C
Stampa "Il numero maggiore è C: " + C
FINE SE
RESTITUISCI max
FINE
Esercizio 3: conta alla rovescia
Compito: crea un algoritmo che conta da 10 a 0 e stampa "BOOM!" alla fine.
Mostra soluzione
Soluzione 1, ciclo MENTRE:
ALGORITMO: ContaRovescia
INIZIO
contatore = 10
MENTRE contatore >= 0 FAI
Stampa contatore
contatore = contatore - 1
FINE MENTRE
Stampa "BOOM!"
FINE
Soluzione 2, ciclo PER:
ALGORITMO: ContaRovescia
INIZIO
PER i DA 10 A 0 PASSO -1 FAI
Stampa i
FINE PER
Stampa "BOOM!"
FINE
Esercizio 4: password validator
Compito: crea un algoritmo che chiede all'utente di inserire una password. Continua a chiedere finché non inserisce la password corretta "Turing1936".
Mostra soluzione
ALGORITMO: ValidaPassword
INIZIO
passwordCorretta = "Turing1936"
accesso = FALSO
tentativi = 0
MENTRE accesso == FALSO E tentativi < 3 FAI
Stampa "Inserisci la password: "
Leggi passwordInserita
SE passwordInserita == passwordCorretta ALLORA
accesso = VERO
Stampa "Accesso consentito!"
ALTRIMENTI
tentativi = tentativi + 1
Stampa "Password errata. Tentativi rimasti: " + (3 - tentativi)
FINE SE
FINE MENTRE
SE accesso == FALSO ALLORA
Stampa "Accesso bloccato. Troppi tentativi."
FINE SE
FINE
Altri esercizi da provare
- 5. Calcolatrice semplice: disegna un flowchart per una calcolatrice che chiede due numeri e un'operazione (+, -, *, /) e stampa il risultato. Gestisci il caso della divisione per zero!
- 6. Tavola pitagorica: crea un algoritmo che stampa l'intera tavola pitagorica (da 1×1 a 10×10). Usa due cicli annidati!
- 7. Numero primo: scrivi un algoritmo che determina se un numero è primo (divisibile solo per 1 e per se stesso). Usa un ciclo e una variabile booleana.
- 8. Simulazione Macchina di Turing: simula su carta una Macchina di Turing che inverte una sequenza binaria (tutti gli 0 diventano 1 e viceversa). Disegna il nastro ad ogni passo.
Sfida avanzata: gioco indovina il numero
Progetta un gioco completo con queste caratteristiche:
- Il computer genera un numero casuale tra 1 e 100
- L'utente ha massimo 7 tentativi
- Dopo ogni tentativo, dai un suggerimento: "troppo alto", "troppo basso"
- Tieni traccia di quanti tentativi servono
- Alla fine, chiedi se vuole giocare di nuovo
Crea sia il flowchart che lo pseudocodice completo!
Test autovalutativo di fine unità
Vuoi testare le tue competenze?
Il test di questa lezione, col punteggio e i progressi, sta su HI · Human Intelligence. Ti iscrivi gratis.
Riepilogo della lezione
Cosa hai imparato
- Terminologia informatica: programma, algoritmo, variabile, ciclo, condizione, funzione, debug
- Cos'è un algoritmo: una sequenza finita di istruzioni per risolvere un problema
- Caratteristiche di un buon algoritmo: finito, definito, con input/output, efficace e generale
- Flowchart: rappresentazione grafica degli algoritmi con simboli standard
- Simboli dei flowchart: ovale (inizio/fine), rettangolo (processo), rombo (decisione), parallelogramma (I/O)
- Pseudocodice: descrizione testuale dell'algoritmo in linguaggio semi-formale
- Strutture di controllo: sequenza, selezione (IF/ELSE), iterazione (WHILE/FOR)
Prossimi passi
Nella prossima lezione: variabili e tipi di dati, operatori aritmetici e parametri nei programmi. E i primi esempi in un linguaggio di programmazione vero.
Lezione 2 di 4
Variabili e Tipi di Dati
Variabili, tipi di dati, operatori e parametri, con esempi in pseudocodice e Python. In fondo c'è il test finale dell'Unità Formativa 1.
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
Vuoi testare le tue competenze?
Il test di questa lezione, col punteggio e i progressi, sta su HI · Human Intelligence. Ti iscrivi gratis.
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.
Lezione 3 di 4
Introduzione a MySQL
UF2: dai programmi ai dati. Installi MySQL con XAMPP e crei il tuo primo database, con le tabelle, i tipi di dati e i vincoli giusti.
Benvenuti nella UF2: MySQL
Con la prima Unità Formativa hai visto le basi della programmazione: variabili, tipi di dati, funzioni e algoritmi. Adesso si passa ai database.
Cos'è un database?
Un database è un sistema organizzato per memorizzare, gestire e recuperare dati in modo efficiente. Pensa a un database come a un archivio digitale strutturato dove puoi conservare informazioni di qualsiasi tipo: utenti, prodotti, ordini, contatti, ecc.
MySQL è uno dei sistemi di gestione database più diffusi al mondo, utilizzato da milioni di applicazioni web (Facebook, YouTube, WordPress, e-commerce). In questa UF2 imparerai a:
- Creare e gestire database e tabelle
- Definire tipi di dati e vincoli
- Stabilire relazioni tra tabelle
- Eseguire query per interrogare e modificare dati
- Gestire privilegi e sicurezza degli utenti
Perché usare MySQL?
Velocità e prestazioni
MySQL è ottimizzato per gestire milioni di record e rispondere in fretta.
Affidabilità
Supporta transazioni ACID per garantire l'integrità dei dati anche in caso di errori.
Open Source
Gratuito e con una community globale che produce tutorial, plugin e supporto.
Scalabilità
Si adatta da piccoli progetti personali a grandi applicazioni enterprise.
Architettura di MySQL
MySQL segue un'architettura client-server, che funziona così:
┌─────────────────┐
│ APPLICAZIONE │ ← Client (la tua app, sito web, script)
└────────┬────────┘
│ Query SQL
↓
┌─────────────────┐
│ SERVER MYSQL │ ← Elabora richieste, gestisce dati
└────────┬────────┘
│
↓
┌─────────────────┐
│ DATABASE 1 │
│ ┌───────────┐ │
│ │ Tabella A │ │
│ │ Tabella B │ │
│ └───────────┘ │
└─────────────────┘
┌─────────────────┐
│ DATABASE 2 │
└─────────────────┘
Concetti chiave
- Server MySQL: il "motore" che gestisce tutti i database
- Database: contenitore logico per un insieme di tabelle correlate
- Tabella: struttura che organizza i dati in righe e colonne
- Query SQL: istruzioni per comunicare con il database
Installazione e primo accesso
Per lavorare con MySQL, ti servirà installare il server sul tuo computer. L'opzione più semplice per iniziare è utilizzare XAMPP, un pacchetto gratuito che include MySQL, Apache e strumenti di gestione.
Download XAMPP
- Vai su apachefriends.org
- Scarica la versione per il tuo sistema operativo (Windows/Mac/Linux)
- Installa seguendo la procedura guidata
- Avvia il pannello di controllo XAMPP
- Clicca su "Start" accanto a MySQL
Accedere alla console MySQL
Una volta avviato MySQL, puoi accedere alla console tramite:
# Da terminale/prompt dei comandi
mysql -u root -p
# Ti verrà chiesta la password (di default è vuota, premi INVIO)
Oppure usa phpMyAdmin, l'interfaccia grafica inclusa in XAMPP:
- Apri il browser e vai su
http://localhost/phpmyadmin - Login automatico (user: root, password vuota)
Sicurezza
In un ambiente di produzione, NON lasciare mai la password di root vuota! Imposta sempre una password forte per proteggere i tuoi database.
Creare il primo database
Un database è come una cartella che contiene tutte le tabelle correlate a un progetto. Ad esempio, per un e-commerce potresti avere un database "negozio_online" con tabelle per clienti, prodotti, ordini, ecc.
Sintassi CREATE DATABASE
CREATE DATABASE nome_database;
Esempio pratico
-- Creare un database per gestire una scuola
CREATE DATABASE scuola;
-- Verificare che sia stato creato
SHOW DATABASES;
-- Selezionare il database per usarlo
USE scuola;
Convenzioni di naming
- Usa nomi descrittivi e in minuscolo:
negozio_online,biblioteca - Evita spazi (usa underscore _):
gestione_magazzinosì,gestione magazzinono - Evita caratteri speciali e accenti:
utentisì,ütéñtìno
Altri comandi utili
-- Eliminare un database (ATTENZIONE: operazione irreversibile!)
DROP DATABASE scuola;
-- Creare un database solo se non esiste già
CREATE DATABASE IF NOT EXISTS scuola;
-- Specificare il charset (importante per caratteri accentati)
CREATE DATABASE scuola
CHARACTER SET utf8mb4
COLLATE utf8mb4_unicode_ci;
Come si fa
Usa sempre utf8mb4 come charset per supportare tutti i caratteri Unicode, inclusi emoji e caratteri speciali internazionali.
Tabelle: la struttura dei dati
Una tabella è la struttura che contiene i dati. È organizzata in:
- Colonne (campi): definiscono il tipo di dato memorizzato
- Righe (record): contengono i valori effettivi
In aula, a questo punto, la domanda che mi fanno sempre è che differenza ci sia fra il database e la tabella. Il database è il contenitore, la tabella è quello che ci sta dentro: il database scuola tiene la tabella degli studenti, quella dei docenti e quella delle classi.
Esempio visivo: tabella "studenti"
| id | nome | cognome | età | classe |
|---|---|---|---|---|
| 1 | Mario | Rossi | 16 | 3A |
| 2 | Laura | Bianchi | 17 | 4B |
| 3 | Giuseppe | Verdi | 15 | 2C |
Chiave primaria (PRIMARY KEY)
Il campo id è la chiave primaria: identifica univocamente ogni record. Non possono esistere due studenti con lo stesso id!
Sintassi CREATE TABLE
CREATE TABLE nome_tabella (
nome_campo1 TIPO_DATO [opzioni],
nome_campo2 TIPO_DATO [opzioni],
...
);
Esempio completo
USE scuola;
CREATE TABLE studenti (
id INT AUTO_INCREMENT PRIMARY KEY,
nome VARCHAR(50) NOT NULL,
cognome VARCHAR(50) NOT NULL,
eta INT,
classe VARCHAR(10),
data_iscrizione DATE DEFAULT CURDATE()
);
Spiegazione
AUTO_INCREMENT: MySQL assegna automaticamente un numero progressivoPRIMARY KEY: definisce questo campo come identificatore univocoNOT NULL: il campo è obbligatorioDEFAULT CURDATE(): se non specifichi una data, usa quella odierna
Tipi di dati in MySQL
MySQL supporta molti tipi di dati. Questi sono i più comuni:
Tipi numerici
| Tipo | Descrizione | Intervallo | Esempio |
|---|---|---|---|
INT |
Numero intero | -2.147.483.648 a 2.147.483.647 | Età, quantità |
TINYINT |
Intero piccolo | -128 a 127 (o 0-255 se UNSIGNED) | Voti da 0 a 100 |
DECIMAL(M,D) |
Decimale preciso | M=cifre totali, D=decimali | Prezzi: DECIMAL(10,2) |
FLOAT |
Decimale approssimato | Numeri in virgola mobile | Coordinate GPS |
Tipi stringa/testo
| Tipo | Descrizione | Lunghezza Max | Esempio |
|---|---|---|---|
VARCHAR(n) |
Stringa variabile | 1 - 65.535 caratteri | Nome, email, indirizzo |
CHAR(n) |
Stringa fissa | 1 - 255 caratteri | Codici fiscali (16 char) |
TEXT |
Testo lungo | 65.535 caratteri | Descrizioni, articoli |
MEDIUMTEXT |
Testo molto lungo | 16 milioni di caratteri | Contenuti HTML/JSON |
Tipi data/ora
| Tipo | Formato | Esempio |
|---|---|---|
DATE |
YYYY-MM-DD | 2025-01-08 |
TIME |
HH:MM:SS | 14:30:00 |
DATETIME |
YYYY-MM-DD HH:MM:SS | 2025-01-08 14:30:00 |
TIMESTAMP |
Come DATETIME (auto-update) | Per tracciare modifiche |
Tipi speciali
| Tipo | Descrizione | Esempio |
|---|---|---|
BOOLEAN |
Vero/Falso (alias di TINYINT(1)) | attivo, confermato |
ENUM('val1','val2'...) |
Lista di valori predefiniti | ENUM('M','F') per sesso |
JSON |
Dati in formato JSON | Configurazioni, metadata |
Scegliere il tipo giusto
- Usa
VARCHARper lunghezze variabili (nomi, indirizzi) - Usa
CHARper lunghezze fisse (codici, sigle) - Usa
DECIMALper valori monetari (mai FLOAT!) - Usa
TINYINTinvece di INT per numeri piccoli (risparmia spazio)
Vincoli (Constraints)
I vincoli sono regole che garantiscono l'integrità dei dati. Impediscono l'inserimento di dati non validi o incoerenti.
| Vincolo | Descrizione | Esempio |
|---|---|---|
PRIMARY KEY |
Identifica univocamente ogni record | id INT PRIMARY KEY |
NOT NULL |
Il campo non può essere vuoto | email VARCHAR(100) NOT NULL |
UNIQUE |
Valori univoci (no duplicati) | username VARCHAR(50) UNIQUE |
DEFAULT |
Valore predefinito se non specificato | stato VARCHAR(20) DEFAULT 'attivo' |
AUTO_INCREMENT |
Incremento automatico (per ID) | id INT AUTO_INCREMENT |
CHECK |
Condizione che deve essere vera | eta INT CHECK (eta >= 18) |
Esempio con vincoli combinati
CREATE TABLE utenti (
id INT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(30) NOT NULL UNIQUE,
email VARCHAR(100) NOT NULL UNIQUE,
password_hash VARCHAR(255) NOT NULL,
eta INT CHECK (eta >= 13),
attivo BOOLEAN DEFAULT 1,
data_registrazione TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
Perché usare i vincoli?
- Integrità dei dati: prevengono errori di inserimento
- Coerenza: garantiscono che i dati seguano regole specifiche
- Performance: gli indici (PRIMARY KEY, UNIQUE) velocizzano le ricerche
- Manutenzione: riducono la necessità di validazione lato applicazione
Esercizi pratici
Usa la console MySQL o phpMyAdmin.
Esercizio 1: Biblioteca
Crea un database biblioteca con una tabella libri che contenga:
- id (chiave primaria, auto-incrementante)
- titolo (massimo 200 caratteri, obbligatorio)
- autore (massimo 100 caratteri, obbligatorio)
- anno_pubblicazione (numero intero)
- isbn (13 caratteri, univoco)
- disponibile (booleano, default TRUE)
Esercizio 2: E-commerce
Crea un database negozio con una tabella prodotti:
- id (chiave primaria)
- nome_prodotto (obbligatorio)
- descrizione (testo lungo)
- prezzo (decimale con 2 cifre decimali, obbligatorio)
- quantita_disponibile (intero, default 0)
- categoria (ENUM: 'Elettronica', 'Abbigliamento', 'Casa', 'Sport')
- data_inserimento (timestamp automatico)
Esercizio 3: Social Network
Crea un database social con una tabella post:
- id (chiave primaria)
- user_id (intero, obbligatorio - rappresenta l'autore)
- contenuto (testo medio)
- numero_like (intero, default 0)
- numero_commenti (intero, default 0)
- pubblicato (booleano, default FALSE)
- data_creazione (datetime, valore automatico)
Suggerimento
Dopo aver creato le tabelle, usa il comando DESCRIBE nome_tabella; per verificare la struttura e assicurarti che tutto sia corretto!
Riepilogo della lezione
Punti chiave
- Cos'è MySQL e a cosa serve
- L'architettura client-server dei database
- Come installare MySQL (XAMPP) e accedere alla console
- Creare database con
CREATE DATABASE - Creare tabelle con
CREATE TABLE - Tipi di dati: numerici, stringhe, date, speciali
- Vincoli: PRIMARY KEY, NOT NULL, UNIQUE, DEFAULT, AUTO_INCREMENT, CHECK
Nella prossima lezione scoprirai come inserire, modificare e interrogare dati con le quattro query SQL di base:INSERT,SELECT,UPDATE,DELETE. Imparerai anche a creare relazioni tra tabelle con le chiavi esterne (FOREIGN KEY).
Lezione 4 di 4
Query Avanzate e Modifica Dati
UF2: metti i dati nelle tabelle, li modifichi e li tiri fuori con le query avanzate e i JOIN, pronti per farci un grafico.
Introduzione
Questa è l'ultima lezione del corso. Nella Lezione 3 hai creato database e tabelle: adesso ci metti dentro i dati.
Obiettivi della Lezione
- Eseguire query SELECT avanzate con filtri e ordinamenti
- Comprendere e utilizzare i JOIN tra tabelle
- Inserire nuovi dati con INSERT e REPLACE
- Modificare record esistenti con UPDATE
- Eliminare dati con DELETE e TRUNCATE
- Importare dati in massa con LOAD DATA
- Ottimizzare le query per migliorare le performance
Query SELECT Avanzate
Struttura Base della SELECT
La sintassi completa di una query SELECT include molte clausole opzionali per filtrare, ordinare e aggregare i dati:
SELECT colonna1, colonna2, ...
FROM nome_tabella
WHERE condizione
GROUP BY colonna
HAVING condizione_gruppo
ORDER BY colonna ASC|DESC
LIMIT numero;
Filtri con WHERE
La clausola WHERE filtra i risultati in base a condizioni specifiche:
-- Filtro semplice
SELECT * FROM studenti
WHERE eta > 18;
-- Filtri multipli con AND/OR
SELECT * FROM studenti
WHERE eta > 18 AND corso = 'Informatica';
-- Filtro con LIKE (pattern matching)
SELECT * FROM studenti
WHERE nome LIKE 'Mar%'; -- Nomi che iniziano con "Mar"
-- Filtro con IN (lista di valori)
SELECT * FROM studenti
WHERE citta IN ('Roma', 'Milano', 'Firenze');
-- Filtro con BETWEEN (intervallo)
SELECT * FROM studenti
WHERE eta BETWEEN 20 AND 25;
Ordinamento con ORDER BY
ORDER BY ordina i risultati in modo crescente (ASC) o decrescente (DESC):
-- Ordinamento crescente
SELECT * FROM studenti
ORDER BY cognome ASC;
-- Ordinamento decrescente
SELECT * FROM studenti
ORDER BY eta DESC;
-- Ordinamento multiplo
SELECT * FROM studenti
ORDER BY corso ASC, eta DESC;
Limitare i Risultati con LIMIT
LIMIT restringe il numero di risultati restituiti:
-- Primi 10 risultati
SELECT * FROM studenti
LIMIT 10;
-- Risultati dalla posizione 20, ne restituisce 10
SELECT * FROM studenti
LIMIT 20, 10;
Funzioni di Aggregazione
Le funzioni di aggregazione calcolano valori su insiemi di righe:
-- Contare il numero di studenti
SELECT COUNT(*) FROM studenti;
-- Età media
SELECT AVG(eta) AS eta_media FROM studenti;
-- Età minima e massima
SELECT MIN(eta) AS eta_minima, MAX(eta) AS eta_massima
FROM studenti;
-- Somma totale
SELECT SUM(crediti) AS crediti_totali FROM esami;
Raggruppamento con GROUP BY
GROUP BY raggruppa i risultati per valori comuni:
-- Contare studenti per corso
SELECT corso, COUNT(*) AS numero_studenti
FROM studenti
GROUP BY corso;
-- Età media per corso
SELECT corso, AVG(eta) AS eta_media
FROM studenti
GROUP BY corso;
-- Filtrare gruppi con HAVING
SELECT corso, COUNT(*) AS numero_studenti
FROM studenti
GROUP BY corso
HAVING COUNT(*) > 10; -- Solo corsi con più di 10 studenti
Differenza tra WHERE e HAVING
WHERE filtra le righe prima del raggruppamento, HAVING filtra i gruppi dopo il raggruppamento. HAVING si usa sempre con GROUP BY e può contenere funzioni di aggregazione.
JOIN: Unire Dati da Più Tabelle
I JOIN combinano dati provenienti da più tabelle in base a una relazione comune.
INNER JOIN
Restituisce solo le righe che hanno corrispondenza in entrambe le tabelle:
-- JOIN tra studenti ed esami
SELECT studenti.nome, studenti.cognome, esami.materia, esami.voto
FROM studenti
INNER JOIN esami ON studenti.id = esami.studente_id;
-- Con alias per semplificare
SELECT s.nome, s.cognome, e.materia, e.voto
FROM studenti AS s
INNER JOIN esami AS e ON s.id = e.studente_id;
LEFT JOIN
Restituisce tutte le righe della tabella di sinistra, anche se non hanno corrispondenza nella tabella di destra:
-- Tutti gli studenti, anche quelli senza esami
SELECT s.nome, s.cognome, e.materia, e.voto
FROM studenti AS s
LEFT JOIN esami AS e ON s.id = e.studente_id;
RIGHT JOIN
Restituisce tutte le righe della tabella di destra, anche se non hanno corrispondenza nella tabella di sinistra:
-- Tutti gli esami, anche quelli senza studente associato
SELECT s.nome, s.cognome, e.materia, e.voto
FROM studenti AS s
RIGHT JOIN esami AS e ON s.id = e.studente_id;
JOIN Multipli
È possibile eseguire JOIN su più di due tabelle:
-- JOIN tra studenti, esami e corsi
SELECT s.nome, s.cognome, e.materia, e.voto, c.nome_corso
FROM studenti AS s
INNER JOIN esami AS e ON s.id = e.studente_id
INNER JOIN corsi AS c ON e.corso_id = c.id;
Regole pratiche per i JOIN
- Usa sempre alias per rendere le query più leggibili
- Specifica sempre le colonne da selezionare (evita SELECT *)
- Assicurati che le colonne usate nel JOIN abbiano indici per migliorare le performance
- Usa INNER JOIN quando vuoi solo le righe con corrispondenza in entrambe le tabelle
- Usa LEFT JOIN quando vuoi tutte le righe della tabella principale
INSERT: Inserire Nuovi Dati
Sintassi Base
Il comando INSERT aggiunge nuove righe a una tabella:
-- Inserimento di una singola riga
INSERT INTO studenti (nome, cognome, eta, corso)
VALUES ('Mario', 'Rossi', 22, 'Informatica');
-- Inserimento senza specificare le colonne (devi fornire tutti i valori)
INSERT INTO studenti
VALUES (1, 'Mario', 'Rossi', 22, 'Informatica');
Inserimento Multiplo
È possibile inserire più righe contemporaneamente:
-- Inserire più studenti con una sola query
INSERT INTO studenti (nome, cognome, eta, corso)
VALUES
('Mario', 'Rossi', 22, 'Informatica'),
('Laura', 'Bianchi', 21, 'Matematica'),
('Giuseppe', 'Verdi', 23, 'Fisica');
INSERT con SELECT
Puoi inserire dati provenienti da un'altra tabella:
-- Copiare studenti da una tabella temporanea
INSERT INTO studenti (nome, cognome, eta, corso)
SELECT nome, cognome, eta, corso
FROM studenti_temp
WHERE anno = 2025;
REPLACE
REPLACE funziona come INSERT, ma se esiste già una riga con la stessa chiave primaria, la elimina e inserisce la nuova:
-- Se esiste uno studente con id=1, lo sostituisce
REPLACE INTO studenti (id, nome, cognome, eta, corso)
VALUES (1, 'Mario', 'Rossi', 23, 'Informatica');
Attenzione con REPLACE
REPLACE elimina completamente la riga esistente e ne inserisce una nuova. Questo può causare la perdita di dati se non specifichi tutte le colonne. Preferisci usare INSERT ... ON DUPLICATE KEY UPDATE per aggiornamenti più sicuri.
UPDATE: Modificare Dati Esistenti
Sintassi Base
Il comando UPDATE modifica i dati esistenti in una tabella:
-- Aggiornare una singola colonna
UPDATE studenti
SET eta = 23
WHERE id = 1;
-- Aggiornare più colonne contemporaneamente
UPDATE studenti
SET eta = 23, corso = 'Ingegneria Informatica'
WHERE id = 1;
UPDATE con Condizioni Complesse
Puoi usare condizioni complesse per aggiornare più righe:
-- Aggiornare tutti gli studenti di un corso
UPDATE studenti
SET anno = 2
WHERE corso = 'Informatica' AND eta > 20;
-- Aumentare l'età di tutti gli studenti di 1 anno
UPDATE studenti
SET eta = eta + 1;
UPDATE con JOIN
È possibile aggiornare dati usando informazioni da altre tabelle:
-- Aggiornare il campo "voto_medio" nella tabella studenti
UPDATE studenti AS s
INNER JOIN (
SELECT studente_id, AVG(voto) AS media
FROM esami
GROUP BY studente_id
) AS e ON s.id = e.studente_id
SET s.voto_medio = e.media;
Attenzione: Usa Sempre WHERE!
Se ometti la clausola WHERE in un UPDATE, tutte le righe della tabella verranno aggiornate! Questo può portare a perdite di dati irreversibili. In aula capita quasi sempre a qualcuno, e per questo faccio scrivere prima la SELECT con la stessa WHERE: le righe che vedi tornare sono esattamente quelle che l'UPDATE andrà a cambiare.
DELETE: Eliminare Dati
Sintassi Base
Il comando DELETE rimuove righe da una tabella:
-- Eliminare una singola riga
DELETE FROM studenti
WHERE id = 1;
-- Eliminare più righe con condizioni
DELETE FROM studenti
WHERE eta < 18;
-- Eliminare tutti gli studenti di un corso
DELETE FROM studenti
WHERE corso = 'Fisica';
DELETE con JOIN
Puoi eliminare righe usando condizioni provenienti da altre tabelle:
-- Eliminare studenti senza esami
DELETE s
FROM studenti AS s
LEFT JOIN esami AS e ON s.id = e.studente_id
WHERE e.studente_id IS NULL;
PERICOLO: DELETE Senza WHERE
Un DELETE senza WHERE eliminerà TUTTE le righe della tabella! Questa operazione è irreversibile se non hai un backup. Usa sempre la clausola WHERE e verifica la query con una SELECT prima di eseguire il DELETE.
Altri Comandi Utili
TRUNCATE
TRUNCATE svuota completamente una tabella, ma è più veloce di DELETE perché non registra ogni singola riga eliminata:
-- Svuotare completamente la tabella studenti
TRUNCATE TABLE studenti;
-- Equivalente a DELETE FROM studenti, ma più veloce
Differenze tra DELETE e TRUNCATE
- DELETE: Può usare WHERE per eliminare righe specifiche. Più lento ma più flessibile.
- TRUNCATE: Elimina tutte le righe. Più veloce ma non può usare WHERE. Resetta anche i contatori AUTO_INCREMENT.
LOAD DATA
LOAD DATA importa grandi quantità di dati da un file (CSV, TXT, ecc.):
-- Importare dati da un file CSV
LOAD DATA INFILE '/percorso/studenti.csv'
INTO TABLE studenti
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
LINES TERMINATED BY '\n'
IGNORE 1 ROWS; -- Salta la prima riga (intestazioni)
Esempio di file CSV da importare:
nome,cognome,eta,corso
Mario,Rossi,22,Informatica
Laura,Bianchi,21,Matematica
Giuseppe,Verdi,23,Fisica
Creare Indici per Ottimizzare le Query
Senza indice MySQL legge tutta la tabella riga per riga per trovare quelle che servono; con un indice ci arriva dritto. Su tabelle grandi si sente:
-- Creare un indice su una singola colonna
CREATE INDEX idx_cognome ON studenti(cognome);
-- Indice su più colonne
CREATE INDEX idx_corso_eta ON studenti(corso, eta);
-- Indice unico (valori univoci)
CREATE UNIQUE INDEX idx_email ON studenti(email);
-- Eliminare un indice
DROP INDEX idx_cognome ON studenti;
Quando Usare gli Indici
- Su colonne usate frequentemente in WHERE, JOIN e ORDER BY
- Su colonne con alta cardinalità (molti valori diversi)
- Su chiavi esterne per migliorare i JOIN
- NON su tabelle molto piccole (< 1000 righe)
- NON su colonne che cambiano spesso (rallentano INSERT/UPDATE)
Grafici e Visualizzazione Dati con MySQL
MySQL fornisce i dati, che poi si visualizzano con strumenti esterni come Excel, Google Sheets, Power BI, Tableau, o librerie di programmazione.
Preparare Dati per i Grafici
Un grafico vuole i dati già aggregati: una riga per ogni barra, per ogni fetta, per ogni punto della linea. Le query aggregate servono a questo:
-- Dati per grafico a barre: Vendite per categoria
SELECT categoria, SUM(quantita) AS totale_vendite
FROM prodotti
GROUP BY categoria
ORDER BY totale_vendite DESC;
-- Dati per grafico a linea: Trend vendite mensili
SELECT
YEAR(data_ordine) AS anno,
MONTH(data_ordine) AS mese,
SUM(totale) AS vendite_mensili
FROM ordini
GROUP BY anno, mese
ORDER BY anno, mese;
-- Dati per grafico a torta: Distribuzione clienti per città
SELECT citta, COUNT(*) AS numero_clienti
FROM clienti
GROUP BY citta;
Tipi di Grafici e Query Corrispondenti
Grafico a Barre / Istogramma
Utilizzo: Confrontare valori tra diverse categorie.
Query tipo: SELECT categoria, COUNT(*) o SUM() con GROUP BY
-- Esempio: Numero di ordini per stato
SELECT stato_ordine, COUNT(*) AS numero_ordini
FROM ordini
GROUP BY stato_ordine
ORDER BY numero_ordini DESC;
Grafico a Linea
Utilizzo: Visualizzare trend nel tempo (serie temporali).
Query tipo: SELECT con funzioni data (DATE, YEAR, MONTH) e GROUP BY temporale
-- Esempio: Trend registrazioni utenti per giorno
SELECT
DATE(data_registrazione) AS giorno,
COUNT(*) AS nuovi_utenti
FROM utenti
WHERE data_registrazione >= DATE_SUB(CURDATE(), INTERVAL 30 DAY)
GROUP BY giorno
ORDER BY giorno;
Grafico a Torta
Utilizzo: Mostrare proporzioni di un intero (percentuali).
Query tipo: SELECT con COUNT(*) o SUM() diviso per il totale
-- Esempio: Percentuale di prodotti per categoria
SELECT
categoria,
COUNT(*) AS quantita,
ROUND(COUNT(*) * 100.0 / (SELECT COUNT(*) FROM prodotti), 2) AS percentuale
FROM prodotti
GROUP BY categoria;
Esportare Dati per Grafici
Per esportare i risultati delle query e crearci sopra dei grafici ci sono tre strade:
Metodo 1: Esportazione CSV per Excel/Google Sheets
Puoi esportare i risultati in formato CSV usando phpMyAdmin o MySQL Workbench:
-- Esportare risultati in CSV (da riga di comando)
SELECT * FROM vendite_mensili
INTO OUTFILE '/tmp/vendite.csv'
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
LINES TERMINATED BY '\n';
Metodo 2: Connessione Diretta con Python/JavaScript
Usa librerie di visualizzazione come Chart.js, Plotly, o matplotlib per creare grafici dinamici:
# Python con matplotlib esempio
import mysql.connector
import matplotlib.pyplot as plt
# Connessione al database
conn = mysql.connector.connect(
host="localhost",
user="root",
password="password",
database="mio_database"
)
cursor = conn.cursor()
cursor.execute("SELECT categoria, SUM(quantita) FROM prodotti GROUP BY categoria")
# Preparare dati per il grafico
categorie = []
quantita = []
for row in cursor:
categorie.append(row[0])
quantita.append(row[1])
# Creare grafico a barre
plt.bar(categorie, quantita)
plt.xlabel('Categoria')
plt.ylabel('Quantità')
plt.title('Vendite per Categoria')
plt.show()
Metodo 3: Strumenti di Business Intelligence
Collega MySQL a strumenti professionali come:
- Power BI (Microsoft): grafici interattivi e dashboard
- Tableau: visualizzazioni avanzate
- Google Data Studio: gratuito
- Metabase: open source, dashboard scritte in SQL
Query Utili per Dashboard Aziendali
-- KPI: Tasso di crescita mensile
SELECT
DATE_FORMAT(data_ordine, '%Y-%m') AS mese,
COUNT(*) AS ordini,
SUM(totale) AS fatturato,
AVG(totale) AS ticket_medio
FROM ordini
WHERE data_ordine >= DATE_SUB(CURDATE(), INTERVAL 12 MONTH)
GROUP BY mese
ORDER BY mese;
-- Top 10 prodotti più venduti (per grafico a barre orizzontale)
SELECT
p.nome_prodotto,
SUM(o.quantita) AS unita_vendute,
SUM(o.quantita * p.prezzo) AS ricavo_totale
FROM ordini_dettagli o
JOIN prodotti p ON o.prodotto_id = p.id
GROUP BY p.nome_prodotto
ORDER BY unita_vendute DESC
LIMIT 10;
-- Distribuzione geografica clienti (per mappa heat map)
SELECT
regione,
citta,
COUNT(*) AS numero_clienti,
SUM(totale_acquisti) AS valore_clienti
FROM clienti
GROUP BY regione, citta
ORDER BY numero_clienti DESC;
Regole pratiche per le query di visualizzazione
- Usa alias chiari (AS) per rendere le colonne leggibili nei grafici
- Limita i risultati con TOP/LIMIT per evitare grafici sovraffollati
- Arrotonda i decimali con ROUND() per una visualizzazione più pulita
- Ordina i dati in modo logico (crescente/decrescente) prima dell'export
- Usa DATE_FORMAT() per scrivere le date in modo leggibile
- Calcola percentuali e medie direttamente in SQL quando possibile
Esempio Completo: Dashboard Vendite
Quattro query che insieme fanno una dashboard di analisi vendite:
-- 1. Panoramica KPI principali
SELECT
COUNT(DISTINCT id) AS totale_ordini,
COUNT(DISTINCT cliente_id) AS clienti_attivi,
SUM(totale) AS fatturato_totale,
AVG(totale) AS valore_medio_ordine
FROM ordini
WHERE YEAR(data_ordine) = YEAR(CURDATE());
-- 2. Andamento vendite settimanali (grafico a linea)
SELECT
WEEK(data_ordine) AS settimana,
COUNT(*) AS ordini,
SUM(totale) AS fatturato
FROM ordini
WHERE data_ordine >= DATE_SUB(CURDATE(), INTERVAL 12 WEEK)
GROUP BY settimana
ORDER BY settimana;
-- 3. Categoria prodotti più venduta (grafico a torta)
SELECT
categoria,
COUNT(*) AS prodotti_venduti,
ROUND(COUNT(*) * 100.0 / (SELECT COUNT(*) FROM ordini_dettagli), 1) AS percentuale
FROM ordini_dettagli od
JOIN prodotti p ON od.prodotto_id = p.id
GROUP BY categoria
ORDER BY prodotti_venduti DESC;
-- 4. Confronto performance anno su anno
SELECT
YEAR(data_ordine) AS anno,
MONTH(data_ordine) AS mese,
SUM(totale) AS fatturato
FROM ordini
WHERE YEAR(data_ordine) IN (YEAR(CURDATE()), YEAR(CURDATE()) - 1)
GROUP BY anno, mese
ORDER BY anno, mese;
Attenzione alle Performance
Query complesse con JOIN multipli e funzioni di aggregazione possono essere lente su tabelle grandi. Considera di creare VIEW o tabelle aggregate per dashboard che vengono consultate frequentemente. Usa anche EXPLAIN per analizzare le query lente.
Esercizi Pratici
Esercizio 1: Query SELECT Avanzate
Scenario: Hai una tabella "prodotti" con colonne: id, nome, categoria, prezzo, quantita.
Richieste:
- Seleziona tutti i prodotti con prezzo superiore a 50€
- Trova i 5 prodotti più costosi
- Calcola il prezzo medio per ogni categoria
- Trova le categorie con più di 10 prodotti
- Seleziona i prodotti con quantità inferiore a 5 (quasi esauriti)
Esercizio 2: JOIN tra Tabelle
Scenario: Hai due tabelle: "clienti" (id, nome, email) e "ordini" (id, cliente_id, data, totale).
Richieste:
- Mostra tutti gli ordini con nome e email del cliente
- Trova i clienti che non hanno mai fatto ordini
- Calcola il totale speso da ogni cliente
- Trova i 3 clienti che hanno speso di più
Esercizio 3: Inserimento e Modifica Dati
Scenario: Tabella "dipendenti" con colonne: id, nome, cognome, reparto, stipendio.
Richieste:
- Inserisci 3 nuovi dipendenti
- Aumenta lo stipendio del 10% per tutti i dipendenti del reparto "Vendite"
- Cambia il reparto di un dipendente specifico
- Elimina tutti i dipendenti con stipendio inferiore a 20.000€
- Crea un indice sulla colonna "reparto"
Esercizio 4: Query Complesse
Scenario: Database di una scuola con tabelle: "studenti", "corsi", "iscrizioni" (studente_id, corso_id, voto).
Richieste:
- Trova tutti gli studenti iscritti al corso "Informatica"
- Calcola la media dei voti per ogni studente
- Trova gli studenti con media superiore a 7
- Mostra i corsi con il maggior numero di iscritti
- Trova gli studenti che non sono iscritti a nessun corso
Esercizio 5: Preparare Dati per Grafici
Scenario: Database e-commerce con tabelle: "ordini" (id, data, totale, stato), "prodotti" (id, nome, categoria, prezzo).
Richieste:
- Scrivi una query per un grafico a barre che mostri il numero di ordini per mese negli ultimi 12 mesi
- Crea una query per un grafico a torta che mostri la distribuzione percentuale degli ordini per stato (In Attesa, Spedito, Consegnato, Annullato)
- Prepara i dati per un grafico a linea che mostri il fatturato giornaliero dell'ultimo mese
- Crea una query per un grafico a barre orizzontale con le top 5 categorie prodotti più redditizie
- Scrivi una query che calcoli il tasso di crescita percentuale del fatturato mese su mese
Suggerimento: Usa DATE_FORMAT(), GROUP BY, aggregazioni (SUM, COUNT, AVG) e ordina i risultati in modo appropriato per il tipo di grafico.
Suggerimento finale
Prima di scrivere query complesse, prova a suddividerle in passaggi più semplici. Usa SELECT per verificare i dati prima di eseguire UPDATE o DELETE. Testa sempre le tue query su un database di sviluppo prima di applicarle in produzione!
Le 4 lezioni del corso sono finite. Resta il test finale: domande su algoritmi, programmazione, MySQL e digital soft skills, con risultati immediati e report scaricabile.
Vuoi portare questo corso nella tua organizzazione?
Progetto percorsi su misura su programmazione, dati e digitale per aziende, enti e team.











































