Appunti per secondo parziale di Informatica

Esercitazione e appunti di informatica in preparazione al 2° parziale

Lezione 01/04/2026

Numero di righe della matrice

Definire una funzione righe_matrice(matrice) che restituisca il numero di righe della matrice.

Colonna:

def num_righe(matrice):
def num_righe(matrice):
return len(matrice)
return len(matrice)

In Python, una matrice non esiste come tipo di dato unico. La rappresentiamo come una lista di liste.

Numero di colonne della matrice

Definire una funzione numero_colonne(matrice) che restituisca il numero di colonne della matrice.

def num_colonne(matrice):
def num_colonne(matrice):
return len(matrice[0])
return len(matrice[0])

mat=[[a,b,c]
mat=[[a,b,c]
[d,e,f]]
[d,e,f]]

Somma degli elementi della matrice

Definire una funzione somma_elementi(matrice) che restituisca la somma di tutti gli elementi della matrice.

def somma_elementi(matrice):
def somma_elementi(matrice):
somma=0
somma=0
for riga in matrice:
for riga in matrice:
for elemento in riga:
for elemento in riga:
somma+=elemento
somma+=elemento
return somma
return somma

L'obiettivo è sommare ogni singolo numero presente dentro una matrice. Per farlo, non possiamo limitarci a guardare la "scatola esterna" (come facevamo per contare le righe), dobbiamo entrare in ogni riga e poi entrare in ogni colonna per leggere il valore.

Strategia di risoluzione (Algoritmo)

Dobbiamo immaginare di essere un contabile che deve svuotare dei sacchetti di monete:

• Prepariamo un contenitore vuoto per il totale (chiamiamolo somma_totale) e partiamo da 0.
• Prendiamo la prima riga della matrice.
• Per ogni numero presente in quella riga, lo aggiungiamo al nostro somma_totale.
• Passiamo alla seconda riga e ripetiamo l'operazione.
• Continuiamo fino all'ultima riga.
• Restituiamo il valore finale accumulato.

def somma_elementi(matrice):
def somma_elementi(matrice):
# PASSO 1: Inizializziamo l'accumulatore
# PASSO 1: Inizializziamo l'accumulatore
somma_totale = 0
somma_totale = 0
# PASSO 2: Primo ciclo - Scorriamo le righe una per una
# PASSO 2: Primo ciclo - Scorriamo le righe una per una
for riga in matrice:
for riga in matrice:
# PASSO 3: Secondo ciclo - Entriamo nella riga appena presa
# PASSO 3: Secondo ciclo - Entriamo nella riga appena presa
# e scorriamo ogni singolo elemento (valore)
# e scorriamo ogni singolo elemento (valore)
for valore in riga:
for valore in riga:
# PASSO 4: Aggiungiamo il valore al totale
# PASSO 4: Aggiungiamo il valore al totale
somma_totale += valore # Equivale a: somma_totale =
somma_totale += valore # Equivale a: somma_totale =
somma_totale + valore
somma_totale + valore
# PASSO 5: Una volta finiti tutti i cicli, restituiamo il risultato
# PASSO 5: Una volta finiti tutti i cicli, restituiamo il risultato
return somma_totale
return somma_totale

Conteggio degli zeri

Definire una funzione conta_zeri(matrice) che restituisca il numero di zeri presenti nella matrice.

def conta_zeri(matrice):
def conta_zeri(matrice):
conta=0
conta=0
for riga in matrice:
for riga in matrice:
for elemento in riga:
for elemento in riga:
if elemento ==0:
if elemento ==0:
conta+=1
conta+=1
return conta
return conta

Dobbiamo "ispezionare" ogni singola cella della matrice e chiederci: "Questo elemento è uno zero?". Se la risposta è sì, incrementiamo un contatore.

Strategia di risoluzione (Algoritmo)

Immagina di avere una griglia di caselle e di dover mettere una crocetta su un foglio ogni volta che trovi uno zero:

• Prepariamo una variabile contatore e la impostiamo a 0.
• Iniziamo a scansionare la prima riga.
• Per ogni elemento della riga, verifichiamo la condizione: elemento == 0.
• Se la condizione è Vera, aggiungiamo 1 al nostro contatore.
• Se la condizione è Falsa, non facciamo nulla e passiamo all'elemento successivo.
• Ripetiamo per tutte le righe fino alla fine.

def conta_zeri(matrice):
def conta_zeri(matrice):
# PASSO 1: Inizializziamo il contatore a zero
# PASSO 1: Inizializziamo il contatore a zero
numero_zeri = 0
numero_zeri = 0
# PASSO 2: Ciclo esterno per scorrere le righe
# PASSO 2: Ciclo esterno per scorrere le righe
for riga in matrice:
for riga in matrice:
# PASSO 3: Ciclo interno per scorrere gli elementi di ogni riga
# PASSO 3: Ciclo interno per scorrere gli elementi di ogni riga
for elemento in riga:
for elemento in riga:
# PASSO 4: Controllo condizionale (Il cuore del problema)
# PASSO 4: Controllo condizionale (Il cuore del problema)
if elemento == 0:
if elemento == 0:
# Se l'elemento è proprio 0, incrementiamo il contatore
# Se l'elemento è proprio 0, incrementiamo il contatore
numero_zeri = numero_zeri + 1
numero_zeri = numero_zeri + 1
# PASSO 5: Restituiamo il totale dei conteggi effettuati
# PASSO 5: Restituiamo il totale dei conteggi effettuati
return numero_zeri
return numero_zeri

Massimo della matrice

Definire una funzione massimo_matrice(matrice) che restituisca il massimo elemento contenuto nella matrice.

def massimo_matrice(matrice):
def massimo_matrice(matrice):
massimo=matrice[0][0] return max(max(riga) for
massimo=matrice[0][0] return max(max(riga) for
for riga in matrice: riga in matrice)
for riga in matrice: riga in matrice)
for elemento in riga:
for elemento in riga:
if elemento>massimo
if elemento>massimo
massimo=elemento
massimo=elemento
return massimo
return massimo

Dobbiamo passare al setaccio l'intera matrice e isolare il valore numerico più alto.

Strategia di risoluzione (Algoritmo)

Immagina di essere un arbitro che deve decretare il vincitore di un torneo:

• Il punto di partenza: Prendiamo il primissimo elemento della matrice (posizione [0][0]) e diciamo: "Per ora, il campione è lui".
• Il confronto: Iniziamo a guardare tutti gli altri elementi, uno per uno.
• La sfida: Se troviamo un numero maggiore del nostro campione attuale, quel numero diventa il nuovo campione.
• Fine della fiera: Una volta controllate tutte le celle, l'ultimo "campione" rimasto sarà il valore massimo assoluto.

Somma di una riga

Definire una funzione somma_riga(matrice,i) che restituisca la somma degli elementi della riga i.

def somma_riga(matrice,i):
def somma_riga(matrice,i):
somma=0
somma=0
for elemento in matrice[i]:
for elemento in matrice[i]:
somma+=elemento
somma+=elemento
return somma
return somma

Dobbiamo isolare una singola riga (indicata dall'indice i) e calcolare il totale dei suoi valori.

Nota importante sugli indici: In informatica (e in Python), si inizia a contare da 0. Quindi:

• i = 0 è la prima riga.
• i = 1 è la seconda riga.

Strategia di risoluzione (Algoritmo)

Invece di usare due cicli, qui ne basta uno solo. Perché? Perché sappiamo già quale riga ci serve!

• Accesso diretto: Puntiamo subito alla riga corretta usando l'indice: matrice[i].
• Preparazione: Creiamo una variabile somma impostata a 0.
• Scansione: Scorriamo con un ciclo for ogni elemento presente in quella specifica riga.
• Accumulo: Aggiungiamo ogni elemento alla nostra somma.
• Risultato: Restituiamo il totale.

def somma_riga(matrice, i):
def somma_riga(matrice, i):
# PASSO 1: Isoliamo la riga che ci interessa
# PASSO 1: Isoliamo la riga che ci interessa
# Se i=0, riga_selezionata sarà la prima sottolista
# Se i=0, riga_selezionata sarà la prima sottolista
riga_selezionata = matrice[i]
riga_selezionata = matrice[i]
# PASSO 2: Inizializziamo l'accumulatore
# PASSO 2: Inizializziamo l'accumulatore
totale = 0
totale = 0
# PASSO 3: Ciclo FOR (uno solo!)
# PASSO 3: Ciclo FOR (uno solo!)
# Scorriamo solo gli elementi della riga che abbiamo isolato
# Scorriamo solo gli elementi della riga che abbiamo isolato
for elemento in riga_selezionata:
for elemento in riga_selezionata:
# PASSO 4: Aggiungiamo l'elemento al totale
# PASSO 4: Aggiungiamo l'elemento al totale
totale = totale + elemento
totale = totale + elemento
# PASSO 5: Restituiamo il risultato della riga
# PASSO 5: Restituiamo il risultato della riga
return totale
return totale

Somma di una colonna

Definire una funzione somma_colonna(matrice,j) che restituisca la somma degli elementi della colonna di indice j.

def somma_colonna(matrice,j):
def somma_colonna(matrice,j):
somma=0
somma=0
for i in range(len(matrice):
for i in range(len(matrice):
somma+=matrice[i][j]
somma+=matrice[i][j]
return somma
return somma

Dobbiamo "verticalizzare" il nostro sguardo sulla matrice per isolare tutti gli elementi che si trovano all'indice j.

Strategia di risoluzione (Algoritmo)

Dato che gli elementi della colonna sono distribuiti in righe diverse, dobbiamo necessariamente scorrere tutte le righe.

• Preparazione: Creiamo una variabile somma_verticale e la impostiamo a 0.
• Viaggio tra le righe: Usiamo un ciclo for per visitare ogni riga della matrice.
• Accesso mirato: All'interno di ogni riga, andiamo a leggere solo l'elemento che si trova in posizione j.
• Accumulo: Aggiungiamo quell'elemento specifico al nostro totale.
• Risultato: Restituiamo il valore finale.

def somma_colonna(matrice, j):
def somma_colonna(matrice, j):
# PASSO 1: Inizializziamo l'accumulatore
# PASSO 1: Inizializziamo l'accumulatore
totale_colonna = 0
totale_colonna = 0
# PASSO 2: Ciclo FOR per scorrere tutte le righe
# PASSO 2: Ciclo FOR per scorrere tutte le righe
# (Dobbiamo passare per ogni "piano" del palazzo)
# (Dobbiamo passare per ogni "piano" del palazzo)
for riga in matrice:
for riga in matrice:
# PASSO 3: Accediamo all'elemento in posizione j della riga corrente
# PASSO 3: Accediamo all'elemento in posizione j della riga corrente
# riga[j] ci dà il valore "verticale" che stiamo cercando
# riga[j] ci dà il valore "verticale" che stiamo cercando
valore_colonna = riga[j]
valore_colonna = riga[j]
# PASSO 4: Aggiungiamo il valore al totale
# PASSO 4: Aggiungiamo il valore al totale
totale_colonna = totale_colonna + valore_colonna
totale_colonna = totale_colonna + valore_colonna
# PASSO 5: Restituiamo la somma della colonna
# PASSO 5: Restituiamo la somma della colonna
return totale_colonna
return totale_colonna

Diagonale principale

Definire una funzione diagonale_principale(matrice) che restituisca una lista contenente gli elementi della diagonale principale della matrice. (La matrice è quadrata).

def diagonale_principale(matrice):
def diagonale_principale(matrice):
diagonale=[]
diagonale=[]
for i in range(len(matrice)):
for i in range(len(matrice)):
diagonale.append(matrice[i][i])
diagonale.append(matrice[i][i])
return diagonale
return diagonale ...a a a a1,1 2,1 3,1 ,1i...a a1,2 2,2 ... ...a 1,3... ... ...... ... ...a a1, ,n i i

Per estrarre la diagonale principale di una matrice quadrata, dobbiamo identificare gli elementi dove l'indice di riga e l'indice di colonna sono identici: (0,0), (1,1), (2,2),..., (n,n).

Scomposizione del tuo codice

diagonale = []: Inizializzi correttamente una lista vuota. Questo è il tuo "contenitore" dove accumulerai i valori man mano che li trovi.

range(len(matrice)): Questa è la scelta ottimale. len(matrice) ti dà il numero di righe. Usando range, ottieni una sequenza di numeri (0, 1, 2...) che userai come coordinata.

matrice[i][i]: Qui avviene la magia. Usando la stessa variabile i sia per la riga che per la colonna, costringi Python a muoversi esattamente sulla linea diagonale.

• Al primo giro ($i=0$): prendi l'elemento in alto a sinistra.
• Al secondo giro ($i=1$): scendi di una riga e ti sposti a destra di una colonna.

.append(...): Metodo perfetto per aggiungere l'elemento trovato in coda alla tua lista.

def diagonale_principale(matrice):
def diagonale_principale(matrice):
return [matrice[i][i] for i in range(len(matrice))]
return [matrice[i][i] for i in range(len(matrice))]

Somma della diagonale

Definire una funzione somma_diagonale(matrice) che restituisca la somma degli elementi della diagonale principale della matrice. (La matrice è quadrata).

def diagonale_principale(matrice):
def diagonale_principale(matrice):
somma=0
somma=0
for i in range(len(matrice)):
for i in range(len(matrice)):
somma+=0
somma+=0
return somma
return somma

Somma degli elementi di ogni colonna

Definire una funzione somma_colonna(matrice) che restituisca la lista contenente la somma degli elementi di ogni colonna della matrice.

def somma_colonne(matrice):
def somma_colonne(matrice):
risulato=[]
risulato=[]
num_col=len(matrice[0])
num_col=len(matrice[0])
for j in range(num_col):
for j in range(num_col):
somma=0
somma=0
for i in range(len(matrice)):
for i in range(len(matrice)):
somma+=matrice[i][j]:
somma+=matrice[i][j]:
risultato.append(somma)
risultato.append(somma)
return risultato
return risultato

Posizione del massimo

Definire una funzione posizione_massimo(matrice) che restituisca una coppia (riga, colonna) contenente la posizione del massimo elemento della matrice.

def posizione_massimo(matrice):
def posizione_massimo(matrice):
max_val=matrice[0][0]
max_val=matrice[0][0]
max_i=0
max_i=0
max_j=0
max_j=0
for i in range(len(matrice)):
for i in range(len(matrice)):
for j in range(len(matrice[i]):
for j in range(len(matrice[i]):
if matrice[i][j]>max_val:
if matrice[i][j]>max_val:
max_val=matrice[i][j]
max_val=matrice[i][j]
max_i=i
max_i=i
max_j=j
max_j=j
return(max_i,max_j)
return(max_i,max_j)

Riga con elementi tutti uguali

Definisci una funzione riga_uguale(matrice) che restituisca True se esiste almeno una riga i cui elementi sono tutti uguali, False altrimenti.

def riga_tutta_uguale(matrice):
def riga_tutta_uguale(matrice):
for riga in matrice:
for riga in matrice:
tutti uguali=True
tutti uguali=True
for j in range(1,len(riga)):
for j in range(1,len(riga)):
if riga[j] != riga[0]:
if riga[j] != riga[0]:
tutti_uguali=False
tutti_uguali=False
if tutti_uguali
if tutti_uguali
return True
return True

Matrice diagonale

Definire una funzione matrice_diagonale(matrice) che restituisca True se la matrice quadrata è diagonale, False altrimenti. Una matrice diagonale ha tutti gli elementi fuori dalla diagonale principale uguali a 0.

def matrice_diagonale(matrice):
def matrice_diagonale(matrice):
for i in range(len(matrice)):
for i in range(len(matrice)):
for j in range(len(matrice)):
for j in range(len(matrice)):
if i!=j and matrice[i][j]!=0:
if i!=j and matrice[i][j]!=0:
return False
return False
return True
return True