Immagina di dover organizzare il magazzino di un e-commerce o di analizzare l’andamento dei prezzi in una settimana di borsa. Non hai a che fare con singoli numeri, ma con griglie di dati che si intrecciano. Muoversi tra righe e colonne non è solo un esercizio di stile: è il momento in cui smetti di scrivere script sequenziali e inizi a costruire strutture capaci di contenere la complessità della realtà.

In Python, le matrici sono il primo vero banco di prova per chi vuole passare dal ‘far girare il codice’ al ‘gestire l’informazione’.

Vediamo come domarle senza farsi venire il mal di testa con gli indici.

Esercizio 1: Sistema di Gestione di una Biblioteca (Livello Facile)

Testo: Sei il programmatore di una piccola biblioteca. La biblioteca ha 3 scaffali e su ogni scaffale ci sono 5 libri. Rappresenta questa situazione con una matrice biblioteca dove ogni riga rappresenta uno scaffale e ogni colonna rappresenta la quantità di libri presenti in quella posizione. Inizializza la matrice con valori casuali tra 0 e 10 (libri per posizione). Calcola:

1. Il numero totale di libri nella biblioteca

2. Il numero di libri nello scaffale più pieno

3. La posizione (scaffale, colonna) con il maggior numero di libri

Soluzione

import random

# 1. Creazione della matrice biblioteca
def crea_biblioteca(righe=3, colonne=5):
    """
    Crea una matrice che rappresenta la biblioteca.
    Ogni cella contiene il numero di libri in quella posizione.
    """
    biblioteca = []
    for i in range(righe):
        scaffale = []
        for j in range(colonne):
            # Numero casuale di libri tra 0 e 10
            scaffale.append(random.randint(0, 10))
        biblioteca.append(scaffale)
    return biblioteca

# 2. Calcolo del totale dei libri
def totale_libri(biblioteca):
    """
    Calcola il numero totale di libri sommando tutti gli elementi.
    """
    totale = 0
    for scaffale in biblioteca:
        totale += sum(scaffale)  # Somma gli elementi di ogni riga
    return totale

# 3. Scaffale più pieno
def scaffale_piu_pieno(biblioteca):
    """
    Trova l'indice dello scaffale con più libri.
    """
    max_libri = 0
    indice_scaffale = 0
    
    for i, scaffale in enumerate(biblioteca):
        libri_scaffale = sum(scaffale)
        if libri_scaffale > max_libri:
            max_libri = libri_scaffale
            indice_scaffale = i
    
    return indice_scaffale, max_libri

# 4. Posizione con più libri
def posizione_max_libri(biblioteca):
    """
    Trova la posizione (scaffale, colonna) con il maggior numero di libri.
    """
    max_valore = biblioteca[0][0]
    posizione = (0, 0)
    
    for i in range(len(biblioteca)):
        for j in range(len(biblioteca[0])):
            if biblioteca[i][j] > max_valore:
                max_valore = biblioteca[i][j]
                posizione = (i, j)
    
    return posizione, max_valore

# ESECUZIONE PRINCIPALE
print("=== SISTEMA GESTIONE BIBLIOTECA ===\n")

# Creiamo la biblioteca
biblioteca = crea_biblioteca()
print("Matrice biblioteca:")
for i, scaffale in enumerate(biblioteca):
    print(f"Scaffale {i}: {scaffale}")

# Calcoli
totale = totale_libri(biblioteca)
print(f"\n1. Totale libri in biblioteca: {totale}")

scaffale_idx, libri_scaffale = scaffale_piu_pieno(biblioteca)
print(f"2. Scaffale più pieno: scaffale {scaffale_idx} con {libri_scaffale} libri")

pos, valore = posizione_max_libri(biblioteca)
print(f"3. Posizione con più libri: scaffale {pos[0]}, colonna {pos[1]} con {valore} libri")

=== SISTEMA GESTIONE BIBLIOTECA ===

Matrice biblioteca:
Scaffale 0: [8, 2, 0, 9, 5]
Scaffale 1: [1, 6, 7, 5, 0]
Scaffale 2: [2, 4, 2, 6, 8]

1. Totale libri in biblioteca: 65
2. Scaffale più pieno: scaffale 0 con 24 libri
3. Posizione con più libri: scaffale 0, colonna 3 con 9 libri

import random

# 1. Creazione matrice temperature
def genera_temperature(settimane=4, giorni=7, min_temp=15, max_temp=35):
    """
    Crea una matrice di temperature casuali.
    """
    temperature = []
    for settimana in range(settimane):
        temp_settimana = []
        for giorno in range(giorni):
            temp_settimana.append(random.randint(min_temp, max_temp))
        temperature.append(temp_settimana)
    return temperature

# 2. Temperatura media per settimana
def medie_settimanali(temperature):
    """
    Calcola la temperatura media per ogni settimana.
    """
    medie = []
    for settimana in temperature:
        media = sum(settimana) / len(settimana)
        medie.append(round(media, 1))
    return medie

# 3. Giorno più caldo per settimana
def giorni_piu_caldi(temperature):
    """
    Trova la temperatura massima e il giorno corrispondente per ogni settimana.
    """
    risultati = []
    for i, settimana in enumerate(temperature):
        max_temp = max(settimana)
        giorno = settimana.index(max_temp)  # Indice del giorno con temp massima
        risultati.append((i, giorno, max_temp))
    return risultati

# 4. Settimana con media più alta
def settimana_piu_calda(medie):
    """
    Trova l'indice della settimana con la temperatura media più alta.
    """
    max_media = max(medie)
    settimana_idx = medie.index(max_media)
    return settimana_idx, max_media

# ESECUZIONE PRINCIPALE
print("=== ANALISI DATI METEO ===\n")

# Genera dati
temperature = genera_temperature()
print("Matrice temperature (settimane × giorni):")
for i, settimana in enumerate(temperature):
    print(f"Settimana {i+1}: {settimana}")

# Calcolo medie
medie = medie_settimanali(temperature)
print("\n2. Temperature medie settimanali:")
for i, media in enumerate(medie):
    print(f"Settimana {i+1}: {media}°C")

# Giorni più caldi
caldi = giorni_piu_caldi(temperature)
print("\n3. Giorni più caldi per settimana:")
for sett, giorno, temp in caldi:
    print(f"Settimana {sett+1}: giorno {giorno+1} ({temp}°C)")

# Settimana più calda
sett_idx, temp_media = settimana_piu_calda(medie)
print(f"\n4. Settimana più calda: settimana {sett_idx+1} con media di {temp_media}°C")

# Analisi aggiuntiva: differenza tra max e min per settimana
print("\n5. Escursione termica settimanale (differenza max-min):")
for i, settimana in enumerate(temperature):
    escursione = max(settimana) - min(settimana)
    print(f"Settimana {i+1}: {escursione}°C")

=== ANALISI DATI METEO ===

Matrice temperature (settimane × giorni):
Settimana 1: [33, 29, 21, 27, 33, 22, 19]
Settimana 2: [32, 32, 15, 33, 27, 17, 35]
Settimana 3: [18, 25, 30, 28, 18, 32, 29]
Settimana 4: [22, 32, 20, 18, 21, 34, 21]

2. Temperature medie settimanali:
Settimana 1: 26.3°C
Settimana 2: 27.3°C
Settimana 3: 25.7°C
Settimana 4: 24.0°C

3. Giorni più caldi per settimana:
Settimana 1: giorno 1 (33°C)
Settimana 2: giorno 7 (35°C)
Settimana 3: giorno 6 (32°C)
Settimana 4: giorno 6 (34°C)

4. Settimana più calda: settimana 2 con media di 27.3°C

5. Escursione termica settimanale (differenza max-min):
Settimana 1: 14°C
Settimana 2: 20°C
Settimana 3: 14°C
Settimana 4: 16°C

def giorno_piu_caldo_assoluto(temperature):
    giorni = len(temperature[0])
    medie_giorni = []
    
    for giorno in range(giorni):
        somma = 0
        for settimana in temperature:
            somma += settimana[giorno]
        media = somma / len(temperature)
        medie_giorni.append(media)
    
    giorno_max = medie_giorni.index(max(medie_giorni))
    return giorno_max, medie_giorni[giorno_max]

Perché questi esercizi sono interessanti?

1. Esercizio 1 (Biblioteca): La struttura dei dati spaziali.

   Questo esercizio non riguarda i libri, ma la mappatura dello spazio. In ambito professionale, questa logica si applica alla gestione di magazzini fisici (Amazon style), alla creazione di griglie per videogame (dove ogni cella è una coordinata) o alla gestione di posti a sedere in un teatro. La peculiarità è l’accesso diretto via indici (i, j), che è l’operazione più veloce possibile in informatica per recuperare un dato.

2. Esercizio 2 (Meteo): L’analisi temporale e statistica.

   Qui passiamo dalla gestione dello spazio alla gestione del tempo. La matrice diventa una serie storica. Questo è il “pane quotidiano” dei Data Analyst. La particolarità interessante è la necessità di cambiare prospettiva: a volte serve analizzare la riga (la settimana), altre volte la colonna (il lunedì di ogni settimana). Saper “ruotare” mentalmente la matrice è ciò che distingue un programmatore junior da uno che sa manipolare i Big Data.