Matrici Numpy 2 - Esercizi

Scarica zip esercizi 

Naviga file online

Vediamo ora alcuni esercizi. I primi avranno soluzioni forniti in due versioni: la prime versioni solitamente usano cicli for ed sono quindi lente, la seconde denominate ‘pro’ evitano i cicli utilizzando tutti gli strumenti offerti da numpy. In particolare in molti casi puoi ottenere programmi molto efficienti e compatti usando in modo furbo le slice.

ATTENZIONE

Gli esercizi che seguono contengono dei test con gli assert. Per capire come svolgerli, leggi prima Gestione errori e testing

Esercizio - quadrofor

✪✪✪ Restituisce una NUOVA matrice numpy di n righe e n colonne, in cui tutti i valori sono a zero eccetto quelli sui bordi, che devono essere uguali a k

Per esempio, quadro(4, 7.0) deve dare:

array([[7.0, 7.0, 7.0, 7.0],
       [7.0, 0.0, 0.0, 7.0],
       [7.0, 0.0, 0.0, 7.0],
       [7.0, 7.0, 7.0, 7.0]])

Ingredienti:

crea una matrice pieni di zeri. ATTENZIONE: quali dimensioni ha? Bisogna usare n o k ? Leggi BENE il testo

Per questa prima versione, prova a riempire le righe e colonne, usando opportuni for in range e scrivendo direttamente nelle singole celle

Mostra soluzione

[1]:

import numpy as np

def quadrofor(n, k):
    raise Exception('TODO IMPLEMENT ME !')

r1 = np.array( [[7.0, 7.0, 7.0, 7.0],
                [7.0, 0.0, 0.0, 7.0],
                [7.0, 0.0, 0.0, 7.0],
                [7.0, 7.0, 7.0, 7.0]])

# all_close ritorna True se tutti i valori nella prima matrice sono abbastanza vicini
# (cioè entro una certa tolleranza) ai corrispondenti nella seconda
assert np.allclose(quadrofor(4, 7.0), r1)

r2 = np.array( [ [7.0] ])
assert np.allclose(quadrofor(1, 7.0), r2)

r3 = np.array( [ [7.0, 7.0],
                 [7.0, 7.0]])
assert np.allclose(quadrofor(2, 7.0), r3)

Esercizio - quadroslices

✪✪✪ Risolvi l’esercizio precedente, questa volta usando 4 slice

NON usare cicli for o while

Mostra soluzione

[2]:

import numpy as np

def quadroslices(n, k):
    raise Exception('TODO IMPLEMENT ME !')


r1 = np.array( [[7.0, 7.0, 7.0, 7.0],
                [7.0, 0.0, 0.0, 7.0],
                [7.0, 0.0, 0.0, 7.0],
                [7.0, 7.0, 7., 7.0]])

# all_close ritorna True se tutti i valori nella prima matrice sono abbastanza vicini
# (cioè entro una certa tolleranza) ai corrispondenti nella seconda
assert np.allclose(quadroslices(4, 7.0), r1)

r2 = np.array( [ [7.0] ])
assert np.allclose(quadroslices(1, 7.0), r2)

r3 = np.array( [ [7.0, 7.0],
                 [7.0, 7.0]])
assert np.allclose(quadroslices(2, 7.0), r3)

Esercizio - quadroriemp

✪✪✪ Risolvi l’esercizio precedente, questa volta usando np.full e una sola slice

NON usare cicli for o while

Mostra soluzione

[3]:

import numpy as np

def quadroriemp(n, k):
    raise Exception('TODO IMPLEMENT ME !')


r1 = np.array( [[7.0, 7.0, 7.0, 7.0],
                [7.0, 0.0, 0.0, 7.0],
                [7.0, 0.0, 0.0, 7.0],
                [7.0, 7.0, 7., 7.0]])

# all_close ritorna True se tutti i valori nella prima matrice sono abbastanza vicini
# (cioè entro una certa tolleranza) ai corrispondenti nella seconda
assert np.allclose(quadroriemp(4, 7.0), r1)

r2 = np.array( [ [7.0] ])
assert np.allclose(quadroriemp(1, 7.0), r2)

r3 = np.array( [ [7.0, 7.0],
                 [7.0, 7.0]])
assert np.allclose(quadroriemp(2, 7.0), r3)

Esercizio - media_righe

✪✪✪ Prende una matrice Numpy n x m e RITORNA una NUOVA matrice numpy di una sola colonna in cui i valori sono la media dei valori nelle corrispondenti righe della matrice in input

Esempio:

Input: matrice 5x4

Output: matrice 5x1

(3+2+1+4)/4
(6+2+3+5)/4
(4+3+6+2)/4
(4+6+5+4)/4
(7+2+9+3)/4

Ingredienti versione base (lenta):

create una matrice n x 1 da ritornare, riempiendola di zeri
visita tutte le celle della matrice originale con due for in range annidati
durante la visita, accumula nella matrice da ritornare la somma degli elementi presi da ciascuna riga della matrice originale
una volta completata la somma di una riga, puoi dividerla per la dimensione ncolonne della matrice originale
ritorna la matrice

Ingredienti versione pro (veloce):

prova ad usare il parametro axis e reshape

Mostra soluzione

[4]:

import numpy as np

def media_righe(mat):
    raise Exception('TODO IMPLEMENT ME !')
    return ret

m1 = np.array([  [5.0]  ])
r1 = np.array([  [5.0]  ])
assert np.allclose(media_righe(m1), r1)

m2 = np.array([ [5.0, 3.0] ])
r2 = np.array([ [4.0]  ])
assert np.allclose(media_righe(m2), r2)

m3 = np.array(
    [[3,2,1,4],
     [6,2,3,5],
     [4,3,6,2],
     [4,6,5,4],
     [7,2,9,3]])

r3 = np.array([ [(3+2+1+4)/4],
                [(6+2+3+5)/4],
                [(4+3+6+2)/4],
                [(4+6+5+4)/4],
                [(7+2+9+3)/4] ])

assert np.allclose(media_righe(m3), r3)

Mostra soluzione

[5]:

#SOLUZIONE EFFICIENTE media_righe_pro
import numpy as np

Esercizio - matrot

✪✪✪ RITORNA una NUOVA matrice numpy che ha i numeri della matrice numpy di input ruotati di una colonna.

Per ruotati intendiamo che:

se un numero nella matrice di input si trova alla colonna j, nella matrice di output si troverà alla colonna j+1 nella stessa riga.
Se un numero si trova nell’ultima colonna, nella matrice di output si troverà nella colonna zeresima.

Esempio:

Se abbiamo come input:

np.array(   [
                [0,1,0],
                [1,1,0],
                [0,0,0],
                [0,1,1]
            ])

Ci aspettiamo come output:

np.array(   [
                [0,0,1],
                [0,1,1],
                [0,0,0],
                [1,0,1]
            ])

Mostra soluzione

[6]:

import numpy as np

def matrot(matrice):
    raise Exception('TODO IMPLEMENT ME !')

m1 = np.array(  [ [1] ])
r1 = np.array( [  [1]  ])
assert np.allclose(matrot(m1), r1)

m2 = np.array(  [ [0,1] ])
r2 = np.array( [ [1,0] ])
assert np.allclose(matrot(m2), r2)

m3 = np.array([ [0,1,0] ])
r3 = np.array([ [0,0,1] ])
assert np.allclose(matrot(m3), r3)

m4 = np.array(  [[0,1,0],
                 [1,1,0]])
r4 = np.array(  [[0,0,1],
                 [0,1,1]])
assert np.allclose(matrot(m4), r4)


m5 = np.array([ [0,1,0],
                [1,1,0],
                [0,0,0],
                [0,1,1]])
r5 = np.array([ [0,0,1],
                [0,1,1],
                [0,0,0],
                [1,0,1]])
assert np.allclose(matrot(m5), r5)

Mostra soluzione

[7]:

#SOLUZIONE 'PRO'

Esercizio - disp

✪✪✪ Prende una matrice Numpy mat di dimensioninrighe x ncol contenente numeri interi in input e RITORNA una NUOVA matrice numpy di dimensioni nrighe x ncol che è come quella originale, ma nelle celle che contenevano numeri pari adesso ci saranno numero dispari ottenuti sommando 1 al numero pari esistente.

Esempio:

disp(np.array( [
                    [2,5,6,3],
                    [8,4,3,5],
                    [6,1,7,9]
               ]))

Deve dare in output

array([[ 3.,  5.,  7.,  3.],
       [ 9.,  5.,  3.,  5.],
       [ 7.,  1.,  7.,  9.]])

Suggerimenti versione base (lenta):

Visto che dovete ritornare una nuova matrice, cominciate con il crearne una vuota
scorrete con indici i e j tutta la matrice iniziale

Mostra soluzione

[8]:

import numpy as np

def disp(mat):
    raise Exception('TODO IMPLEMENT ME !')

m1 = np.array([ [2] ])
r1 = np.array([ [3] ])
assert np.allclose(disp(m1), r1)
assert m1[0][0] == 2  # controlla non si stia modificando la matrice originale

m2 = np.array( [ [2,5,6,3],
                 [8,4,3,5],
                 [6,1,7,9]
               ])
r2 = np.array( [ [3,5,7,3],
                 [9,5,3,5],
                 [7,1,7,9]])
assert np.allclose(disp(m2), r2)

Mostra soluzione

[9]:

#SOLUZIONE EFFICIENTE 1 con np.where

Mostra soluzione

[10]:

#SOLUZIONE veloce 2 senza np.where

Esercizio - radalt

✪✪✪ Prende una matrice numpy mat di dimensioninrighe x ncol contenente numeri interi in input e RITORNA una NUOVA matrice numpy di dimensioni nrighe x ncol, avente alle righe di indice pari i numeri della matrice originale moltiplicati per due, e alle righe di indice dispari gli stessi numeri della matrice originale

Esempio:

m  = np.array( [                      #  indice
                    [ 2, 5, 6, 3],    #    0     pari
                    [ 8, 4, 3, 5],    #    1     dispari
                    [ 7, 1, 6, 9],    #    2     pari
                    [ 5, 2, 4, 1],    #    3     dispari
                    [ 6, 3, 4, 3]     #    4     pari
               ])

Una chiamata a

radalt(m)

ritornerà la matrice numpy

array([[ 4, 10, 12,  6],
       [ 8,  4,  3,  5],
       [14,  2, 12, 18],
       [ 5,  2,  4,  1],
       [12,  6,  8,  6]])

Mostra soluzione

[11]:

import numpy as np

def radalt(mat):
    raise Exception('TODO IMPLEMENT ME !')

# INIZIO TEST: NON TOCCARE !

m1 = np.array([ [2] ])
r1 = np.array([ [4] ])
assert np.allclose(radalt(m1),r1)
assert m1[0][0] == 2  # controlla non si stia modificando la matrice originale

m2 = np.array( [ [ 2, 5, 6],
                 [ 8, 4, 3]])
r2 = np.array( [ [ 4,10,12],
                 [ 8, 4, 3]])
assert np.allclose(radalt(m2), r2)

m3 = np.array( [ [ 2, 5, 6, 3],
                 [ 8, 4, 3, 5],
                 [ 7, 1, 6, 9],
                 [ 5, 2, 4, 1],
                 [ 6, 3, 4, 3] ])
r3 = np.array( [ [ 4,10,12, 6],
                 [ 8, 4, 3, 5],
                 [14, 2,12,18],
                 [ 5, 2, 4, 1],
                 [12, 6, 8, 6] ])
assert np.allclose(radalt(m3), r3)
# FINE TEST

Mostra soluzione

[12]:

#SOLUZIONE EFFICIENTE

Esercizio - scacchiera

✪✪✪ RITORNA una NUOVA matrice numpy di n righe e n colonne, in cui le celle si alternano tra zero e uno.

Esempio: scacchiera(4) deve dare:

array([[1.0, 0.0, 1.0, 0.0],
       [0.0, 1.0, 0.0, 1.0],
       [1.0, 0.0, 1.0, 0.0],
       [0.0, 1.0, 0.0, 1.0]])

Ingredienti versione base (lenta):

per alternare, potete usare la range nella forma in cui prende 3 parametri, per esempio range(0,n,2) parte da 0, arriva fino a n escluso e salta di due in due, generando 0,2,4,6,8, …
invece range(1,n,2) genererebbe 1,3,5,7, …

Mostra soluzione

[13]:

def scacchiera(n):
    raise Exception('TODO IMPLEMENT ME !')

r1 = np.array( [ [1.0, 0.0, 1.0, 0.0],
                 [0.0, 1.0, 0.0, 1.0],
                 [1.0, 0.0, 1.0, 0.0],
                 [0.0, 1.0, 0.0, 1.0] ])

assert np.allclose(scacchiera(4), r1)

r2 = np.array( [ [1.0] ])
assert np.allclose(scacchiera(1), r2)

r3 = np.array( [ [1.0, 0.0],
                 [0.0, 1.0] ])
assert np.allclose(scacchiera(2), r3)

Mostra soluzione

[14]:

#SOLUZIONE EFFICIENTE

Esercizio - somma_alterna

✪✪✪ MODIFICA la matrice numpy in input (n x n), sommando a tutte le righe dispari le righe pari. Per esempio:

m = [[1.0, 3.0, 2.0, 5.0],
     [2.0, 8.0, 5.0, 9.0],
     [6.0, 9.0, 7.0, 2.0],
     [4.0, 7.0, 2.0, 4.0]]
somma_alterna(m)

adesso m dovrebbe essere :

m = [[1.0, 3.0, 2.0, 5.0],
     [3.0, 11.0,7.0, 14.0],
     [6.0, 9.0, 7.0, 2.0],
     [10.0,16.0,9.0, 6.0]]

Ingredienti versione base (lenta):

per alternare, potete usare la range nella forma in cui prende 3 parametri, per esempio range(0,n,2) parte da 0, arriva fino a n escluso e salta di due in due, generando 0,2,4,6,8, …
invece range(1,n,2) genererebbe 1,3,5,7, …

Mostra soluzione

[15]:

def somma_alterna(mat):
    raise Exception('TODO IMPLEMENT ME !')


m1 = np.array( [ [1.0, 3.0, 2.0, 5.0],
                 [2.0, 8.0, 5.0, 9.0],
                 [6.0, 9.0, 7.0, 2.0],
                 [4.0, 7.0, 2.0, 4.0] ])

r1 = np.array( [ [1.0, 3.0, 2.0, 5.0],
                 [3.0, 11.0,7.0, 14.0],
                 [6.0, 9.0, 7.0, 2.0],
                 [10.0,16.0,9.0, 6.0] ])

somma_alterna(m1)
assert np.allclose(m1, r1)  # controlla che abbiamo MODIFICATO la matrice originale

m2 = np.array( [ [5.0] ])
r2 = np.array( [ [5.0] ])
somma_alterna(m1)
assert np.allclose(m2, r2)

m3 = np.array( [ [6.0, 1.0],
                 [3.0, 2.0] ])
r3 = np.array( [ [6.0, 1.0],
                 [9.0, 3.0] ])
somma_alterna(m3)
assert np.allclose(m3, r3)

Mostra soluzione

[16]:

#SOLUZIONE EFFICIENTE

Esercizio - media_meta

✪✪✪ Prende in input una matrice numpy con un numero pari di colonne, e RITORNA in output una matrice numpy 1x2: il primo elemento sarà la media della metà sinistra della matrice, il secondo elemento sarà la media della metà destra.

Ingredienti:

per ottenere il numero di colonne diviso 2 come numero intero, usare l’operatore //

Mostra soluzione

[17]:

def media_meta(mat):
    raise Exception('TODO IMPLEMENT ME !')

m1 = np.array([ [7,9] ])

r1 = np.array([(7)/1, (9)/1  ])
assert np.allclose( media_meta(m1), r1)


m2 = np.array([ [3,4],
                [6,3],
                [5,2] ])

r2 = np.array([(3+6+5)/3, (4+3+2)/3  ])
assert np.allclose( media_meta(m2), r2)

m3 = np.array([ [3,2,1,4],
                [6,2,3,5],
                [4,3,6,2],
                [4,6,5,4],
                [7,2,9,3] ])

r3 = np.array([(3+2+6+2+4+3+4+6+7+2)/10, (1+4+3+5+6+2+5+4+9+3)/10  ])

assert np.allclose( media_meta(m3), r3)

Mostra soluzione

[18]:

#SOLUZIONE EFFICIENTE

Esercizio - matxarr

✪✪ Prende una matrice numpy n x m e un ndarray di m elementi, e RITORNA una NUOVA matrice numpy in cui i valori di ogni colonna della matrice di input sono moltiplicati per il corrispondente valore dell’array di n elementi.

Mostra soluzione

[19]:

def matxarr(mat, arr):
    raise Exception('TODO IMPLEMENT ME !')

m1 = np.array( [ [3,2,1],
                 [6,2,3],
                 [4,3,6],
                 [4,6,5] ] )
a1 = np.array([5, 2, 6])
r1 = np.array([ [3*5, 2*2, 1*6],
                [6*5, 2*2, 3*6],
                [4*5, 3*2, 6*6],
                [4*5, 6*2, 5*6] ])
assert np.allclose(matxarr(m1,a1), r1)

Mostra soluzione

[20]:

#SOLUZIONE EFFICIENTE

Esercizio - colgap

✪✪ Data una matrice numpy di \(n\) righe ed \(m\) colonne, RITORNA un vettore numpy di \(m\) elementi avente la differenza tra i massimi e i minimi di ciascuna colonna.

Esempio:

m = np.array([[5,4,2],
              [8,5,1],
              [6,7,9],
              [3,6,4],
              [4,3,7]])
>>> colgap(m)
array([5, 4, 8])

perchè

= 8 - 3
= 7 - 3
= 9 - 1

Mostra soluzione

[21]:

import numpy as np

def colgap(mat):
    raise Exception('TODO IMPLEMENT ME !')

# TEST
m1 = np.array([[6]])
assert np.allclose(colgap(m1), np.array([0]))
ret = colgap(m1)
assert type(ret) == np.ndarray

m2 = np.array([[6,8]])
assert np.allclose(colgap(m2), np.array([0,0]))
m3 = np.array([[2],
               [5]])

assert np.allclose(colgap(m3), np.array([3]))
m4 = np.array([[5,7],
               [2,9]])
assert np.allclose(colgap(m4), np.array([3,2]))
m5 = np.array([[4,7],
               [4,9]])
assert np.allclose(colgap(m5), np.array([0,2]))
m6 = np.array([[5,2],
               [3,7],
               [9,0]])
assert np.allclose(colgap(m6), np.array([6,7]))
m7 = np.array([[5,4,2],
               [8,5,1],
               [6,7,9],
               [3,6,4],
               [4,3,7]])
assert np.allclose(colgap(m7), np.array([5,4,8]))

Mostra soluzione

[22]:

#SOLUZIONE EFFICIENTE

Esercizio - sostmax

✪✪ Data una matrice numpy mat \(n\) x \(m\), MODIFICA la matrice sostituendo ogni cella con il valore massimo trovato nella colonna corrispondente.

Esempio:

m  = np.array([[5,4,2],
               [8,5,1],
               [6,7,9],
               [3,6,4],
               [4,3,7]])
>>> sostmax(m)    # non ritorna niente!
>>> m
np.array([[8, 7, 9],
          [8, 7, 9],
          [8, 7, 9],
          [8, 7, 9],
          [8, 7, 9]])

Mostra soluzione

[23]:

import numpy as np

def sostmax(mat):
    raise Exception('TODO IMPLEMENT ME !')

# TEST

m1 = np.array([[6]])
sostmax(m1)
assert np.allclose(m1, np.array([6]))
ret = sostmax(m1)
assert ret == None # non ritorna nulla!

m2 = np.array([[6,8]])
sostmax(m2)
assert np.allclose(m2, np.array([6,8]))

m3 = np.array([[2],
               [5]])
sostmax(m3)
assert np.allclose(m3, np.array([[5],
                                 [5]]))

m4 = np.array([[5,7],
               [2,9]])
sostmax(m4)

assert np.allclose(m4, np.array([[5,9],
                                 [5,9]]))

m5 = np.array([[4,7],
               [4,9]])
sostmax(m5)
assert np.allclose(m5, np.array([[4,9],
                                 [4,9]]))

m6 = np.array([[5,2],
               [3,7],
               [9,0]])
sostmax(m6)
assert np.allclose(m6, np.array([[9,7],
                                 [9,7],
                                 [9,7]]))

m7 = np.array([[5,4,2],
               [8,5,1],
               [6,7,9],
               [3,6,4],
               [4,3,7]])
sostmax(m7)
assert np.allclose(m7, np.array([[8, 7, 9],
                                 [8, 7, 9],
                                 [8, 7, 9],
                                 [8, 7, 9],
                                 [8, 7, 9]]))

Mostra soluzione

[24]:

#SOLUZIONE EFFICIENTE

Esercizio - quadranti

✪✪✪ Data una matrice 2n * 2n, dividere la matrice in 4 parti quadrate uguali (vedi esempio per capire meglio) e RESTITUIRE una NUOVA matrice 2 * 2 contente la media di ogni quadrante

Si assume che la matrice sia sempre di dimensioni pari

SUGGERIMENTO: per dividere per 2 e ottenere un numero intero, usare l’operatore //

Esempio:

1, 2 , 5 , 7
4, 1 , 8 , 0
2, 0 , 5 , 1
0, 2 , 1 , 1

si divide in

  1, 2 | 5 , 7
  4, 1 | 8 , 0
-----------------
  2, 0 | 5 , 1
  0, 2 | 1 , 1

e si restituisce

(1+2+4+1)/ 4  | (5+7+8+0)/4                 2.0 , 5.0
-----------------------------     =>        1.0 , 2.0
(2+0+0+2)/4   | (5+1+1+1)/4

Mostra soluzione

[25]:

import numpy as np

def quadranti(matrice):
    raise Exception('TODO IMPLEMENT ME !')


m1 = np.array( [ [3.0, 5.0],
                 [4.0, 9.0] ])
r1 = np.array([  [3.0, 5.0],
                 [4.0, 9.0],
              ])
assert np.allclose(quadranti(m1),r1)

m2 = np.array( [ [1.0, 2.0 , 5.0 , 7.0],
                 [4.0, 1.0 , 8.0 , 0.0],
                 [2.0, 0.0 , 5.0 , 1.0],
                 [0.0, 2.0 , 1.0 , 1.0] ])
r2 = np.array( [ [2.0, 5.0],
                 [1.0, 2.0] ] )
assert np.allclose(quadranti(m2),r2)

Mostra soluzione

[26]:

#SOLUZIONE EFFICIENTE

Esercizio - scendisali

✪✪✪ Scrivi una funzione che date le dimensioni di n righe e m colonne RITORNA una NUOVA matrice numpy n x m con sequenze che scendono e salgono a righe alterne come negli esempi

se m è dispari, lancia ValueError

>>> scendisali(6,10)
array([[0., 0., 0., 0., 0., 4., 3., 2., 1., 0.],
       [0., 1., 2., 3., 4., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 4., 3., 2., 1., 0.],
       [0., 1., 2., 3., 4., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 4., 3., 2., 1., 0.],
       [0., 1., 2., 3., 4., 0., 0., 0., 0., 0.]])

Mostra soluzione

[27]:

import numpy as np

def scendisali(n,m):
    raise Exception('TODO IMPLEMENT ME !')


assert np.allclose(scendisali(2,2),  np.array([[0., 0.],
                                               [0., 0.]]))
assert type(scendisali(2,2)) == np.ndarray

assert np.allclose(scendisali(2,6),  np.array([[0., 0., 0., 2., 1., 0.],
                                               [0., 1., 2., 0., 0., 0.]]))

assert np.allclose(scendisali(6,10), np.array([[0., 0., 0., 0., 0., 4., 3., 2., 1., 0.],
                                               [0., 1., 2., 3., 4., 0., 0., 0., 0., 0.],
                                               [0., 0., 0., 0., 0., 4., 3., 2., 1., 0.],
                                               [0., 1., 2., 3., 4., 0., 0., 0., 0., 0.],
                                               [0., 0., 0., 0., 0., 4., 3., 2., 1., 0.],
                                               [0., 1., 2., 3., 4., 0., 0., 0., 0., 0.]]))
try:
    scendisali(2,3)
    raise Exception("Avrei dovuto fallire prima!")
except ValueError:
    pass

Mostra soluzione

[28]:

#SOLUZIONE EFFICIENTE (SUGGERIMENTO: usare np.tile)

Esercizio - gradini

✪✪✪ Data una matrice quadrata numpy mat di dimensione n, RITORNA un NUOVO array numpy contenente i valori recuperati dalla matrice nell’ordine seguente:

1,2,*,*,*
*,3,4,*,*
*,*,5,6,*
*,*,*,7,8
*,*,*,*,9

se la matrice non è quadrata, lancia ValueError
NON usare liste python!
SUGGERIMENTO: quanti elementi deve avere l’array da ritornare? Lo puoi stabilire a priori?

Esempio:

>>> gradini(np.array([ [6,3,5,2,5],
                       [3,4,2,3,4],
                       [6,5,4,5,1],
                       [4,3,2,3,9],
                       [2,5,1,6,7] ] ))
array([6., 3., 4., 2., 4., 5., 3., 9., 7.])

Mostra soluzione

[29]:

import numpy as np


def gradini(mat):
    raise Exception('TODO IMPLEMENT ME !')

m1 = np.array([ [7] ])
assert np.allclose(gradini(m1), np.array([7]))
assert type(m1) == np.ndarray

m2 = np.array([ [6,8],
                [9,3]])
assert np.allclose(gradini(m2), np.array([6,8,3]))
assert type(m1) == np.ndarray

m3 = np.array([ [6,3,5,2,5],
                [3,4,2,3,4],
                [6,5,4,5,1],
                [4,3,2,3,9],
                [2,5,1,6,7]])

assert np.allclose(gradini(m3), np.array([6,3,4,2,4,5,3,9,7]))

try:
    gradini(np.array([[1,2,3],
                      [4,5,6]]))
    raise Exception("Avrei dovuto fallire prima!")
except ValueError:
    pass

Mostra soluzione

[30]:

#SOLUZIONE EFFICIENTE

Esercizio - scalivert

✪✪✪ Dato un numero di righe n e un numero di colonne m, RITORNA una NUOVA matrice numpy n x m avente i numeri nelle colonne pari in progressione crescente da 1 a n e nelle colonne dispari decrescente da n a 1

Mostra soluzione

[31]:

import numpy as np

def scalivert(n,m):
    raise Exception('TODO IMPLEMENT ME !')


assert np.allclose(scalivert(1,1), np.array([ [1] ]))
assert np.allclose(scalivert(1,2), np.array([ [1,1] ]))
assert np.allclose(scalivert(2,1), np.array([ [1],
                                              [2]]))
assert np.allclose(scalivert(2,2), np.array([ [1,2],
                                              [2,1]]))
assert type(scalivert(2,2)) == np.ndarray
assert np.allclose(scalivert(4,5), np.array([ [1,4,1,4,1],
                                              [2,3,2,3,2],
                                              [3,2,3,2,3],
                                              [4,1,4,1,4]]))

Mostra soluzione

[32]:

#SOLUZIONE EFFICIENTE (SUGGERIMENTO: usare np.tile)

Esercizio - compricol

✪✪✪ Data una matrice mat \(n\) x \(2m\) con numero di colonne pari, RITORNA una NUOVA matrice \(n\) x \(m\) in cui le colonne sono date dalle somma delle coppie di colonne corrispondenti di mat

se mat non ha numero di colonne pari, lancia ValueError

Esempio:

m  = np.array([[5,4,2,6,4,2],
               [7,5,1,0,6,1],
               [6,7,9,2,3,7],
               [5,2,4,6,1,3],
               [7,2,3,4,2,5]])

>>> compricol(m)
np.array([[ 9, 8, 6],
          [12, 1, 7],
          [13,11,10],
          [ 7,10, 4],
          [ 9, 7, 7]])

perchè

9 = 5 + 4     8 = 2 + 6     6 = 4 + 2
12= 7 + 5     1 = 1 + 0     7 = 6 + 1
. . .

Mostra soluzione

[33]:

import numpy as np

def compricol(mat):
    raise Exception('TODO IMPLEMENT ME !')

m1 = [[7,9]]
res = compricol(np.array(m1))
assert type(res) == np.ndarray
assert np.allclose(res, np.array([[16]]))

m2  = np.array([[5,8],
               [7,2]])
assert np.allclose(compricol(m2), np.array([[13],
                                            [9]]))
assert np.allclose(m2, np.array([[5,8],
                                 [7,2]]))  # non cambia la matrice originale

m3  = np.array([[5,4,2,6,4,2],
                [7,5,1,0,6,1],
                [6,7,9,2,3,7],
                [5,2,4,6,1,3],
                [7,2,3,4,2,5]])

assert np.allclose(compricol(m3), np.array([[ 9, 8, 6],
                                            [12, 1, 7],
                                            [13,11,10],
                                            [ 7,10, 4],
                                            [ 9, 7, 7]]))

try:
    compricol(np.array([[7,1,6],
                        [5,2,4]]))
    raise Exception("Avrei dovuto fallire!")
except ValueError:
    pass

Esercizio - revtriang

✪✪✪ Data una matrice quadrata numpy, RITORNA una NUOVA matrice numpy avente le stesse dimensioni dell’originale e i numeri nelle righe della parte triangolare inferiore (diagonale esclusa) in ordine inverso

se la matrice non è quadrata, lancia ValueError

Esempio:

m  = np.array([ [5,4,2,6,4],
                [3,5,1,0,6],
                [6,4,9,2,3],
                [5,2,8,6,1],
                [7,9,3,2,2] ])

>>> revtriang(m)
np.array([ [5, 4, 2, 6, 4],
           [3, 5, 1, 0, 6],     # 3       -> 3
           [4, 6, 9, 2, 3],     # 6,4     -> 4,6
           [8, 2, 5, 6, 1],     # 5,2,8   -> 8,2,5
           [2, 3, 9, 7, 2] ])   # 7,9,3,2 -> 2,3,9,7

Mostra soluzione

[34]:

import numpy as np

def revtriang(mat):
    raise Exception('TODO IMPLEMENT ME !')

m1 = np.array([[8]])
assert np.allclose(revtriang(m1), np.array([[8]]))


m3 = np.array([[1,5],
               [9,6]])
assert np.allclose(revtriang(m3), np.array([[1,5],
                                            [9,6]]))

m4 = np.array([[1,5,8],
               [9,6,2],
               [3,2,5]])
assert np.allclose(revtriang(m4), np.array([[1,5,8],
                                            [9,6,2],
                                            [2,3,5]]))
assert np.allclose(m4, np.array([[1,5,8],
                                 [9,6,2],
                                 [3,2,5]]))  # non cambia l'originale

m5 = np.array([[5,4,2,6,4],
               [3,5,1,0,6],
               [6,4,9,2,3],
               [5,2,8,6,1],
               [7,9,3,2,2]])
assert np.allclose(revtriang(m5), np.array([[5, 4, 2, 6, 4],
                                            [3, 5, 1, 0, 6],
                                            [4, 6, 9, 2, 3],
                                            [8, 2, 5, 6, 1],
                                            [2, 3, 9, 7, 2]]))
try:
    revtriang(np.array([[7,1,6],
                        [5,2,4]]))
    raise Exception("Avrei dovuto fallire!")
except ValueError:
    pass

Esercizio - camminas

✪✪✪ Data una matrice numpy \(n\) x \(m\) con \(m\) dispari, RITORNA un array numpy contenente tutti i numeri trovati lungo il percorso di una S, dal basso verso l’alto.

SUGGERIMENTO: puoi determinare a priori la dimensione dell’array risultante?

Esempio:

m = np.array([[5,8,2,4,6,5,7],
              [7,9,5,8,3,2,2],
              [6,1,8,3,6,6,1],
              [1,5,3,7,9,4,7],
              [1,5,3,2,9,5,4],
              [4,3,8,5,6,1,5]])

deve percorrere, dal basso verso l’alto:

m = np.array([[5,8,2,>,>,>,>],
              [7,9,5,^,3,2,2],
              [6,1,8,^,6,6,1],
              [1,5,3,^,9,4,7],
              [1,5,3,^,9,5,4],
              [>,>,>,^,6,1,5]])

Per ottenere:

>>> camminas(m)
array([4., 3., 8., 5., 2., 7., 3., 8., 4., 6., 5., 7.])

Mostra soluzione

[35]:

import numpy as np

def camminas(mat):
    raise Exception('TODO IMPLEMENT ME !')

# TEST
m1 = np.array([[7]])
assert np.allclose(camminas(m1), np.array([7]))

m2 = np.array([[7,5,2]])
assert np.allclose(camminas(m2), np.array([7,5,2]))

m3 = np.array([[9,3,5,6,0]])
assert np.allclose(camminas(m3), np.array([9,3,5,6,0]))

m4 = np.array([[7,5,2],
               [9,3,4]])
assert np.allclose(camminas(m4), np.array([9,3,5,2]))

m5 = np.array([[7,4,6],
               [8,2,1],
               [0,5,3]])
assert np.allclose(camminas(m5), np.array([0,5,2,4,6]))

m6 = np.array([[5,8,2,4,6,5,7],
               [7,9,5,8,3,2,2],
               [6,1,8,3,6,6,1],
               [1,5,3,7,9,4,7],
               [1,5,3,2,9,5,4],
               [4,3,8,5,6,1,5]])
assert np.allclose(camminas(m6), np.array([4,3,8,5,2,7,3,8,4,6,5,7]))

Esercizio - camminaz

✪✪✪ Data una matrice numpy \(n\) x \(m\) con \(m\) dispari, RITORNA un array numpy contenente tutti i numeri trovati lungo il percorso di una Z, dal basso verso l’alto.

SUGGERIMENTO: puoi determinare a priori la dimensione dell’array risultante?

Esempio:

m = np.array([[5,8,2,4,6,5,7],
              [7,9,5,8,3,2,2],
              [6,1,8,3,6,6,1],
              [1,5,3,7,9,4,7],
              [1,5,3,2,9,5,4],
              [4,3,8,5,6,1,5]])

deve percorrere, dal basso verso l’alto:

m = np.array([[<,<,<,^,6,5,7],
              [7,9,5,^,3,2,2],
              [6,1,8,^,6,6,1],
              [1,5,3,^,9,4,7],
              [1,5,3,^,9,5,4],
              [4,3,8,^,<,<,<]])

Per ottenere:

>>> camminaz(m)
array([5.,1.,6.,5.,2.,7.,3.,8.,4.,2.,8.,5.])

Mostra soluzione

[36]:

import numpy as np

def camminaz(mat):
    raise Exception('TODO IMPLEMENT ME !')

# TEST
m1 = np.array([[7]])
assert np.allclose(camminaz(m1), np.array([7]))

m2 = np.array([[7,5,2]])
assert np.allclose(camminaz(m2), np.array([2,5,7]))

m3 = np.array([[9,3,5,6,0]])
assert np.allclose(camminaz(m3), np.array([0,6,5,3,9]))

m4 = np.array([[7,5,2],
               [9,3,4]])
assert np.allclose(camminaz(m4), np.array([4,3,5,7]))

m5 = np.array([[7,4,6],
               [8,2,1],
               [0,5,3]])
assert np.allclose(camminaz(m5), np.array([3,5,2,4,7]))

m6 = np.array([[5,8,2,4,6,5,7],
               [7,9,5,8,3,2,2],
               [6,1,8,3,6,6,1],
               [1,5,3,7,9,4,7],
               [1,5,3,2,9,5,4],
               [4,3,8,5,6,1,5]])
assert np.allclose(camminaz(m6), np.array([5,1,6,5,2,7,3,8,4,2,8,5]))

Prosegui

Prova a svolgere gli esercizi delle liste di liste, ma usando invece Numpy.
Prova a rendere gli esercizi già visti più efficienti sostituendo ai cicli for delle funzioni specifiche di numpy che operano su vettori - al riguardo leggi i tutorial Nicola Zoppetti, parte Numpy
(in inglese) machinelearningplus Esercizi su Numpy (Fermarsi a difficoltà L1, L2 e se vuoi prova L3)
Challenge numpy qui su softpython