Lezione 2: Variabili e Tipi di Dati

Introduzione alla lezione

Le variabili sono contenitori che memorizzano valori. I tipi di dati indicano la natura del valore: numero, testo, vero/falso, ecc. Con gli operatori eseguiamo calcoli, mentre i parametri permettono di passare informazioni alle funzioni o ai programmi.

• 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

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

// 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)

Operatori: strumenti per elaborare i dati

Gli operatori sono simboli o parole chiave che eseguono operazioni su valori e variabili. Sono gli strumenti fondamentali per manipolare i dati nei programmi.

Operatori aritmetici

Operatori di confronto

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!")

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!

Esercizi pratici guidati

Metti in pratica ciò che hai imparato con questi esercizi progressivi. Cerca di risolverli prima in pseudocodice, poi implementali in Python.

1. 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.
2. Controllo Pari/Dispari. Crea una funzione is_pari(n) che restituisce True se il numero è pari, False altrimenti. Usa l'operatore modulo (%).
3. Media di Lista. Scrivi una funzione calcola_media(lista) che calcola la media dei valori. Gestisci il caso della lista vuota.
4. Trova Massimo. Implementa trova_max(a, b) che restituisce il maggiore tra due numeri. Poi estendila per accettare tre numeri.
5. Conversione Temperature. Crea celsius_to_fahrenheit(c) e fahrenheit_to_celsius(f). Formula: F = (C × 9/5) + 32
6. Verifica Età. Funzione is_maggiorenne(eta) che restituisce True se età >= 18. Aggiungi controllo per età valide (0-120).

Soluzioni guidate

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

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)

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

def trova_max(a, b):
    """Trova il maggiore tra due numeri"""
    if a > b:
        return a
    else:
        return b
    # oppure semplicemente: 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

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

Nella prossima lezione entreremo nel mondo dei database con MySQL: imparerai a creare database, tabelle, gestire relazioni e interrogare dati con query SQL.