Matrici di liste 1: introduzione¶

Riferimenti: SoftPython - matrice di liste 1

  • visualizza al meglio in
  • versione stampabile: clicca qua
  • per navigare nelle slide: premere Esc


Summer School Data Science 2023 - Modulo 1 informatica: Moodle

Docente: David Leoni david.leoni@unitn.it

Esercitatore: Luca Bosotti luca.bosotti@studenti.unitn.it

Matrici - belle eh?¶

matrice

Matrici: Ma a che servono ? 1/3¶

matrice tabella

Matrici: Ma a che servono ? 2/3¶

matrice immagine

Matrici: Ma a che servono ? 3/3¶

Matrici¶

Ci sono sostanzialmente due modi in Python di rappresentare matrici:

Liste di liste:

  1. native in Python
  2. non efficienti
  3. le liste sono pervasive in Python, probabilmente incontrerai matrici espresse come liste di liste in ogni caso
  4. forniscono un'idea di come costruire una struttura dati annidata
  5. possono servire per comprendere concetti importanti come puntatori alla memoria e copie

Numpy (più avanti):

  1. non nativamente disponibile in Python
  2. efficienti
  3. alla base di parecchie librerie di calcolo scientifico (scipy, pandas)
  4. la sintassi per accedere agli elementi lievemente diversa da quella da liste di liste
  5. in rari casi potrebbe portare problemi di installazione e/o conflitti

Matrici - liste di liste¶

Riferimenti: SoftPython - matrici liste di liste

Es. matrice 3x2:

In [2]:
m = [
        ['a','b'],
        ['c','d'],
        ['a','e']    
    ]

Assumiamo matrici con:

  • almeno una riga
  • almeno una colonna

Misure¶

matrice

Accedere alla matrice 1/2¶

In [3]:
m = [
        ['v','e','r','d','e'],
        ['r','o','s','s','o'],   
        ['v','i','o','l','a'],
    
    ]
In [4]:
m[0]
Out[4]:
['v', 'e', 'r', 'd', 'e']
In [5]:
m[1]
Out[5]:
['r', 'o', 's', 's', 'o']

Accedere alla matrice 2/2¶

In [6]:
m = [
        ['v','e','r','d','e'],
        ['r','o','s','s','o'],   
        ['v','i','o','l','a'],
    
    ]
In [7]:
m[0][0]
Out[7]:
'v'
In [8]:
m[0][1]
Out[8]:
'e'

ATTENZIONE: Quando una matrice è una lista di liste, puoi solo accedere valori con notazione m[i][j], NON con m[i,j] !!

Dimensioni della matrice¶

In [9]:
m = [
        ['v','e','r','d','e'],
        ['r','o','s','s','o'],   
        ['v','i','o','l','a'],
    
    ]
In [10]:
len(m)  # righe
Out[10]:
3
In [11]:
len(m[0])  # colonne
Out[11]:
5

Visita matrice for in¶

In [29]:
Out[29]:
Python Tutor visualization

Visita matrice for in range¶

In [30]:
Out[30]:
Python Tutor visualization

Estrarre righe¶

✪ Implementa esriga: Data una matrice mat come lista di liste, RITORNA la i-esima riga da mat come NUOVA lista.

Risolvi come preferisci.

Soluzioni possibili:

  • esrigaf con for in
  • esrigar con for in range
  • esrigas con slice
  • esrigac con list comprehension
 
def esriga(mat, i):    
    raise Exception("TODO IMPLEMENT ME!")  


m = [ ['a','b'],
      ['c','d'],
      ['a','e'] ]

assert esriga(m, 0) == ['a','b']
assert esriga(m, 1) == ['c','d']
assert esriga(m, 2) == ['a','e']

# controlla che la riga estratta sia NUOVA
r = esriga(m, 0)
r[0] = 'z'
assert m[0][0] == 'a'
print("Test passati!")

Estrarre colonne¶

✪ RITORNA la j-esima colonna da mat

DOMANDA: in questo caso, sarebbe possibile un puntatore a una regione di memoria esistente?

Soluzioni possibili:

  • escolf con for in
  • escolc con list comprehension
 
def escol(mat, j):
    raise Exception('TODO IMPLEMENT ME !')


# TEST
m = [
      ['a','b'],
      ['c','d'],
      ['a','e'],
]

assert escol(m, 0) == ['a','c','a']
assert escol(m, 1) == ['b','d','e']

# Controlla che la colonna estratta sia NUOVA
c = escol(m,0)
c[0] = 'z'
assert m[0][0] == 'a'
print("TEST PASSATI!")

matrice_vuota¶

Ci sono diversi modi di creare una nuova matrice 3x5 vuota come lista di liste che contengono degli zero.

Esempio con due cicli for annidati

In [31]:
def matrice_vuota(n, m):
    
    ret = []
    for i in range(n):
        riga = []
        ret.append(riga)
        for j in range(m):
            riga.append(0)
    return ret
    
matrice_vuota(3,5)
Out[31]:
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]

matrice_vuota nel modo elegante 1/2¶

Lista di 3 elementi tramite replicazione:

In [15]:
[0]*3
Out[15]:
[0, 0, 0]

NON creare matrici vuote così:

In [34]:
Out[34]:
Python Tutor visualization

Matrice vuota elegante 2/2: list comprehension¶

In [37]:
Out[37]:
Python Tutor visualization

Copia in profondità¶

Come produrre un clone completo di una matrice (deep clone)?

DOMANDA: questo codice funziona?

In [38]:
def deep_clone(mat):
    return mat[:]
In [40]:
def deep_clone(mat):   # corretto
        
    ret = []
    for riga in mat:
        ret.append(riga[:])
    return ret

DOMANDA: altri modi?

Modificare matrici¶

Esercizio - riempic¶

✪✪ Implementa la funzione riempic, che prende la matrice mat come lista di liste e la MODIFICA mettendo il carattere c dentro tutte le celle della matrice.

Domanda: cosa possiamo usare?

a) for in

b) for in range

c) slice

d) list comprehension

 
def riempic(mat, c):
    raise Exception('TODO IMPLEMENT ME !')

m1 = [ ['a'] ]
riempic(m1,'z')
assert m1 == [ ['z'] ]

m2 = [ ['a'] ]
riempic(m2,'y')
assert m2 == [ ['y'] ]

#     j  0   1
m3 = [ ['a','b'],    # 0
       ['c','d'],    # 1
       ['e','f'] ]   # 2

riempic(m3, 'x')
assert m3 == [ ['x','x'],    
               ['x','x'],    
               ['x','x'] ]

Altri esercizi¶

Nelle slide ho messo solo esempi dei casi principali

Su SoftPython - matrici liste di liste 1 trovate discussione e soluzioni di vari casi:

  • fateli tutti che sono importanti!
In [20]: