Python è un linguaggio di programmazione ad alto livello, interpretato e pensato per la programmazione “general purpose”. Python supporta un sistema dei tipi dimanico e diversi paradigmi di programmazione tra cui la programmazione orientata agli oggetti, la programmazione imperativa, la programmazione funzionale e la programmazione procedurale. Il linguaggio è stato ideato nel 1991 da Guido van Rossum e il suo nome è ispirato alla serie TV satirica Monty Python’s Flying Circus (https://en.wikipedia.org/wiki/Monty_Python%27s_Flying_Circus ).

Benché Python non sia nato come linguaggio di programmazione per il calcolo scientifico e il machine learning, la sua estrema versatilità ha contribuito al nascere di una serie di librerire che rendono la computazione numerica in Python comoda ed efficiente. Buona parte di queste librerie fanno parte di “SciPy” (https://www.scipy.org/), un ecosistema di software open-source per il calcolo scientifico. Altre librerie, quali ad esempio PyTorch (http://pytorch.org/) mettono a disposizione una serie di strumenti per il calcolo parallelo su GPU orientato al Machine Learning. In queste dispense introdurremo il linguaggio Python 3, vedremo i fondamenti di NumPy, libreria per il calcolo scientifico e Matplotlib, libreria per il plot 2D/3D, e introdurremo gli elementi fondamentali di PyTorch, libreria per il calcolo parallelo su GPU e l’ottimizzazione di algoritmi di machine learning basati sulla discesa del gradiente.

NOTA: Questo laboratorio contiene molte nozioni di base. Il materiale più importante è denotato da un asterisco ‘*’.

Referenze importanti da consultare durante il corso, solo le seguenti documentazioni:

• Python 3.8: https://docs.python.org/3.8/index.html;
• Numpy: http://www.numpy.org/;
• Matplotlib: https://matplotlib.org/;
• Pandas: https://pandas.pydata.org/.

1 Introduzione a Python

1.1 Numeri

I tipi di dato numerici in Python sono int, float e complex. Noi ci concentreremo su int e float. Alcuni esempi di operazioni tra numeri:

1

3 + 5 #somma

8

1

2 - 8 #differenza

-6

1

3 * 5 #prodotto

15

1

3 / 2 #divisione, da notare che in Python 3, la divisione tra numeri interi restituisce un float

1.5

1

3 // 2 #divisione intera

1

1

9 ** 2 #elevamento a potenza

81

1

4 % 2 #modulo

0

1

(1 + 4) * (3 - 2) #uso delle parentesi

5

1.2 Variabili e Tipi

In generale, i numeri senza virgola vengono interpretati come int, mentre quelli con virgola come float. Dato che Python è tipizzato dinamicamente, non dobbiamo esplicitamente dichiarare il tipo di una variabile. Il tipo verrà associato alla variabile non appena vi assegniamo un valore. Possiamo controllare il tipo di una variabile mediante la funzione type:

1
2
3
4
5
6

x = 3
y = 9
z = 1.5
h = x/y
l = x//y
type(x), type(y), type(z), type(h), type(l)

(int, int, float, float, int)

E’ possibile effettuare il casting da un tipo a un altro mediante le funzioni int e float:

1

int(2.5)

2

1

float(3)

3.0

Come in C, sono definite le operazioni “in place” tra variabili:

1
2
3
4

x = 8
y = 12
x+=y #del tutto equivalente a x=x+y
x

20

Non sono definite le notazioni “++” e “–”. Per effettuare un incremento di una unità, va utilizzata la notazione +=1:

1
2
3

a=1
a+=1
a

2

Domanda 1 Qual è il tipo della seguente variabile? 1 x = (3//2*2)**2+(3*0.0)

1.3 Booleani

I booleani vengono rappresentati mediante le parole chiave True e False (iniziano entrambe per maiuscola).

1
2

print(True)
print(False)

True
False

1

type(True)

bool

E’ possibile generare booleani mediante gli operatori di confronto:

1

5==5

True

1

7==5

False

1

5>4

True

1

9>10

False

1

9<=10

True

1

11<=10

False

Gli operatori logici sono and e or:

1
2
3

print(5==5 and 3<5)
print(3>5 or 3<5)
print(3>9 or 3<2)

True
True
False

E’ possibile effettuare in controllo sui tipi mediante type e ==:

1

type(2.5)==float

True

1

type(2)==float

False

In alternativa, è possibile utilizzare la funzione isinstance:

1

isinstance(2.5,float)

True

1

isinstance(2.5,int)

False

La funzione isinstance è particolarmente comoda quando si vuole controllare che una variabile appartenga a uno tra una serie di tipi. Ad esempio, se vogliamo controllare che una variabile contenga un numero:

1

isinstance(2.5,(float,int))

True

1

isinstance(5,(float,int))

True

1.4 Stampa

La stampa avviene mediante la funzione print:

1
2

var = 2.2
print(var)

2.2

Possiamo stampare una riga vuota omettendo il parametro di print:

1
2
3

print(2)
print()
print(3)

2

3

Alternativamente, possiamo specificare di inserire due “a capo” alla fine della stampa specificando il parametro end="\n\n" ("\n\n" è una stringa - approfondiremo le stringhe in seguito):

1
2

print(2, end="\n\n")
print(3)

2

3

Lo stesso metodo può essere usato per omettere l’inserimento di spazi tra due stampe consecutive:

1
2

print(2, end="") #"" rappresenta una stringa vuota
print(3)

23

Possiamo stampare più elementi di seguito separando gli argomenti di print con delle virgole. Inoltre, la funzione print permette di stampare anche numeri, oltre a stringhe:

1

print(1,8/2,7,14%6,True)

1 4.0 7 2 True

1.5 Liste

Le liste sono una struttura dati di tipo sequenziali che possono essere utilizzate per rappresentare sequenze di valori di qualsiasi tipo. Le liste possono anche contenere elementi di tipi misti. Una lista si definisce utilizzando le parentesi quadre:

1
2

l = [1,2,3,4,5] #questa è una lista (parentesi quadre)
print(l)

[1, 2, 3, 4, 5]

Le liste possono essere indicizzate utilizzando le parentesi quadre. L’indicizzazione inizia da 0 come in C:

1
2
3

print(l[0],l[2])
l[0]=8 #assegnamento di un nuovo valore alla prima locazione di memoria
print(l)

1 3
[8, 2, 3, 4, 5]

E’ possibile aggiungere nuovi valori a una lista mediante la funzione append:

1
2
3
4
5
6
7

l = []
print(l)
l.append(1)
l.append(2.5)
l.append(8)
l.append(-12)
print(l)

[]
[1, 2.5, 8, -12]

Le liste possono essere concatenate mediante l’operatore somma:

1
2
3

l1 = [1,5]
l2 = [4,6]
print(l1+l2)

[1, 5, 4, 6]

L’operatore di moltiplicazione può essere utilizzato per ripetere una lista. Ad esempio:

1
2

l1 = [1,3]
print(l1*2) #concatena l1 a se stessa per due volte

[1, 3, 1, 3]

Utilizzando l’operatore di moltiplicazione, è possibile creare velocemente liste con un numero arbitrario di valori uguali. Ad esempio:

1
2

print([0]*5) #lista di 5 zeri
print([0]*4+[1]*1) #4 zeri seguiti da 1 uno

[0, 0, 0, 0, 0]
[0, 0, 0, 0, 1]

La lunghezza di una lista può essere ottenuta utilizzando la funzione len:

1
2

print(l2)
print(len(l2))

[4, 6]
2

L’operatore == non controlla se le lunghezze sono uguali, ma verifica che il contenuto delle due liste sia effettivamente uguale:

1
2

print([1,2,3]==[1,2,3])
print([1,2,3]==[1,3,2])

True
False

E’ possibile controllare che un elemento appartenga alla lista mediante la parola chiave in:

1
2

print(7 in [1,3,4])
print(3 in [1,3,4])

False
True

Le funzioni max e min possono essere utilizzate per calcolare il massimo e il minimo di una lista:

1
2
3

l=[-5,2,10,6]
print(max(l))
print(min(l))

10
-5

E’ possibile rimuovere un valore da una lista mediante il metodo remove:

1
2
3
4

l=[1,2,3,4,2]
print(l)
l.remove(2)
print(l)

[1, 2, 3, 4, 2]
[1, 3, 4, 2]

Tale metodo tuttavia rimuove solo la prima occorrenza del valore passato. Se vogliamo rimuovere un valore identificato da uno specifico indice, possiamo usare il costrutto del:

1
2
3
4

l=[1,2,3,4,2]
print(l)
del l[4]
print(l)

[1, 2, 3, 4, 2]
[1, 2, 3, 4]

Inoltre, per accedere all’ultimo elemento e rimuoverlo, possiamo usare il metodo pop:

1
2
3
4

l=[1,2,3,4,5]
print(l)
print(l.pop())
print(l)

[1, 2, 3, 4, 5]
5
[1, 2, 3, 4]

1.5.1 Indicizzazione e Slicing *

E’ possibile estrarre una sottolista da una lista specificando il primo indice (incluso) e l’ultimo indice (escluso) separati dal simbolo :. Questa notazione è in qualche modo reminiscende del metodo substr delle stringhe di C++.

1
2
3
4

l = [1,2,3,4,5,6,7,8]
print("Lista l     ->", l)
print("l[0:3]      ->", l[0:3]) #dall'indice 0 (incluso) all'indice 3 (escluso)
print("l[1:2]      ->", l[1:2]) #dall'indice 1 (incluso) all'indice 2 (escluso)

Lista l     -> [1, 2, 3, 4, 5, 6, 7, 8]
l[0:3]      -> [1, 2, 3]
l[1:2]      -> [2]

Quando il primo indice è omesso, questo viene automaticamente sostituito con “0”:

1
2
3

print("l[:2]       ->", l[:2]) #dall'indice 0 (incluso) all'indice 2 (escluso)
#equivalente al seguente:
print("l[0:2]      ->", l[0:2]) #dall'indice 0 (incluso) all'indice 2 (escluso)

l[:2]       -> [1, 2]
l[0:2]      -> [1, 2]

Analogamente, se omettiamo il secondo indice, esso viene sostituito con l’ultimo indice della lista:

1
2
3
4

print("Ultimo indice della lista:",len(l))
print("l[3:]       ->", l[3:]) #dall'indice 3 (incluso) all'indice 5 (escluso)
#equivalente al seguente:
print("l[3:5]      ->", l[3:8]) #dall'indice 3 (incluso) all'indice 5 (escluso)

Ultimo indice della lista: 8
l[3:]       -> [4, 5, 6, 7, 8]
l[3:5]      -> [4, 5, 6, 7, 8]

Omettendo entrambi gli indici:

1
2
3

print("l[:]         ->", l[:]) #dall'indice 0 (incluso) all'indice 5 (escluso)
#equivalente a:
print("l[0:8]       ->", l[0:8]) #dall'indice 0 (incluso) all'indice 8 (escluso)

l[:]         -> [1, 2, 3, 4, 5, 6, 7, 8]
l[0:8]       -> [1, 2, 3, 4, 5, 6, 7, 8]

E’ inoltre possibile specificare il “passo”, come terzo numero separato da un altro simbolo ::

1
2
3
4
5

print("l[0:8:2]    ->", l[0:8:2]) 
#da 0 (incluso) a 8 (escluso) a un passo di 2 (un elemento sì e uno no)
#equivalente a:
print("l[::2]      ->", l[0:8:2]) 
#da 0 (incluso) a 8 (escluso) a un passo di 2 (un elemento sì e uno no)

l[0:8:2]    -> [1, 3, 5, 7]
l[::2]      -> [1, 3, 5, 7]

Per invertire l’ordine degli elementi, è inoltre possibile specificare un passo negativo. In questo caso, bisogna assicurarsi che il primo indice sia maggiore del secondo:

1
2
3
4
5

print("l[5:2:-1]    ->", l[5:2:-1]) 
#da 5 (incluso) a 2 (escluso) a un passo di -1
print("l[2:5:-1]    ->", l[2:5:-1]) 
#in questo caso, il primo indice è più piccolo del secondo, 
#quindi il risultato sarà una lista vuota

l[5:2:-1]    -> [6, 5, 4]
l[2:5:-1]    -> []

Anche in questo caso, omettendo degli indici, questi verranno rimpiazzati con le scelte più ovvie. Nel caso dell’omissione però, cambiano le condizioni di inclusione ed esclusione degli indici. Vediamo qualche esempio:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

print("l[:2:-1]     ->", l[:2:-1]) 
#dall'ultimo indice (incluso) a 2 (escluso) a un passo di -1
#equivalente a:
print("l[8:2:-1]    ->", l[8:2:-1]) 

print()
print("l[3::-1]     ->", l[3::-1]) 
#dal terzo indice (incluso) a 0 (incluso, in quanto omesso) a un passo di -1
#simile, ma non equivalente a:
print("l[3:0:-1]    ->", l[3:0:-1]) 
#dal terzo indice (incluso) a 0 (escluso) a un passo di -1

print()
print("l[::-1]      ->", l[::-1])
#dall'ultimo indice (incluso) al primo (incluso, in quanto omesso) a un passo di -1
#simile, ma non equivalente a:
print("l[8:0:-1]    ->", l[8:0:-1]) 
#dall'ultimo indice (incluso) al primo (escluso) a un passo di -1

l[:2:-1]     -> [8, 7, 6, 5, 4]
l[8:2:-1]    -> [8, 7, 6, 5, 4]

l[3::-1]     -> [4, 3, 2, 1]
l[3:0:-1]    -> [4, 3, 2]

l[::-1]      -> [8, 7, 6, 5, 4, 3, 2, 1]
l[8:0:-1]    -> [8, 7, 6, 5, 4, 3, 2]

La notazione ::-1, in particolare, è utile per invertire le liste:

1
2

print(l)
print(l[::-1])

[1, 2, 3, 4, 5, 6, 7, 8]
[8, 7, 6, 5, 4, 3, 2, 1]

Indicizzazione e slicing possono essere utilizzate anche per assegnare valori agli elementi delle liste. Ad esempio:

1
2
3
4

l = [5,7,9,-1,2,6,5,4,-6]
print(l)
l[3]=80
print(l)

[5, 7, 9, -1, 2, 6, 5, 4, -6]
[5, 7, 9, 80, 2, 6, 5, 4, -6]

E’ anche possibile assegnare più di un elemento alla volta:

1
2

l[::2]=[0,0,0,0,0] #assegno 0 ai numeri di posizione dispari
print(l)

[0, 7, 0, 80, 0, 6, 0, 4, 0]

Le liste possono anche essere annidate:

1
2

a1 = [1,2,[4,8,[7,5]],[9],2]
print(a1)

[1, 2, [4, 8, [7, 5]], [9], 2]

L’indicizzazione di queste strutture annidate avviene concatenando gli indici come segue:

1
2
3

print(a1[2][2][0]) #il primo indice seleziona la lista [4,8,...]
#il secondo indice seleziona la lista [7,5]
#il terzo indice seleziona l'elemento 7

7

Domanda 2 Estrarre la lista [3, 1.2] dalla seguente lista: 1 l = [1, 4, 5, [7, 9, -1, [0, 3, 2, 1.2], 8, []]]

1.6 Tuple

Le tuple sono simili alle liste, ma sono immutabili. Non possono cioè essere modificate dopo la loro inizializzazione. A differenza delle liste, le tuple vengono definite utilizzando le parentesi tonde:

1
2
3
4

l = [1,2,3,4,5] #questa è una lista (parentesi quadre)
t = (1,2,3,4,5) #questa è una tupla (parentesi tonde)
print(l)
print(t)

[1, 2, 3, 4, 5]
(1, 2, 3, 4, 5)

Le regole di indicizzazione e slicing viste per le liste valgono anche per tuple. Tuttavia, come accennato prima, le tuple non possono essere modificate:

1
2
3
4
5

t = (1,3,5)
try:
    t[0]=8 #restituisce un errore in quanto le tuple sono immutabili
except Exception as e:
    print(e)

'tuple' object does not support item assignment

Inizializzare una tupla con un solo elemento produrrà un numero. Ciò avviene in quanto le parentesi tonde vengono utilizzate anche per raggruppare i diversi termini di una operazione:

1
2

t=(1)
print(t)

1

Per definire una tupla monodimensionale, dobbiamo aggiungere esplicitamente una virgola, dopo il primo elemento:

1
2

t=(1,)
print(t)

(1,)

E’ inoltre possibile omettere le parentesi nella definizione delle tuple:

1
2
3

t1=1,3,5
t2=1,
print(t1,t2)

(1, 3, 5) (1,)

E’ possibile convertire tuple in liste e viceversa:

1
2
3
4
5
6
7

l=[1,2,3,4,5,6,7,8]
t=(4,5,6,7,4,8,2,4)
ttl = list(t)
ltt = tuple(l)

print(ttl)
print(ltt)

[4, 5, 6, 7, 4, 8, 2, 4]
(1, 2, 3, 4, 5, 6, 7, 8)

Le tuple possono inoltre essere create e “spacchettate” al volo:

1
2
3
4
5
6

t1=1,2,3

print(t1)

a,b,c=t1 #spacchettamento della tupla
print(a,b,c)

(1, 2, 3)
1 2 3

Questo sistema permette di effettuare lo swap di due variabili in una sola riga di codice:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

var1 = "Var 1"
var2 = "Var 2"

print(var1,var2)

var1,var2=var2,var1
print(var1,var2)

#equivalente a:
var1 = "Var 1"
var2 = "Var 2"
t = (var2,var1)
var1=t[0]
var2=t[1]
print(var1,var2)

Var 1 Var 2
Var 2 Var 1
Var 2 Var 1

Le tuple annidate possono essere spacchetate come segue:

1
2
3
4
5

t = (1,(2,3),(4,5,6))
x,(t11,t12),(t21,t22,t23) = t
print(t)
print(x, t11, t12, t21, t22, t23)
#La notazione a,b,c,d,e,f = t restituirebbe un errore

(1, (2, 3), (4, 5, 6))
1 2 3 4 5 6

Domanda 3 Qual è la differenza principale tra tuple e liste? Si faccia l’esempio di un caso in cui una tupla è un tipo più appropriato rispetto a una lista.

1.7 Stringhe

In Python possiamo definire le stringhe in tre modi:

1
2
3
4
5
6

s1 = 'Singoli apici'
s2 = "Doppi apici, possono contenere anche apici singoli '' "
s3 = """Tripli
doppi apici
possono essere definite su più righe"""
type(s1), type(s2), type(s3)

(str, str, str)

La stampa avviene mediante la funzione “print”:

1
2
3

print(s1)
print(s2)
print(s3)

Singoli apici
Doppi apici, possono contenere anche apici singoli '' 
Tripli
doppi apici
possono essere definite su più righe

Le stringhe hanno inoltre una serie di metodi predefiniti:

1
2
3
4
5
6
7

print("ciao".upper()) #rendi tutto maiuscolo
print("CIAO".lower()) #tutto minuscolo
print("ciao come stai".capitalize()) #prima lettera maiuscola
print("ciao come stai".split()) #spezza una stringa e restituisce una lista
print("ciao, come stai".split(','))# spezza quando trova la virgola
print("-".join(["uno","due","tre"])) #costruisce una stringa concatenando gli elementi 
#della lista e separandoli mediante il delimitatore

CIAO
ciao
Ciao come stai
['ciao', 'come', 'stai']
['ciao', ' come stai']
uno-due-tre

Le stringhe possono essere indicizzate in maniera simile agli array per ottenere delle sottostringhe:

1
2
3
4
5

s = "Hello World"
print(s[:4]) #primi 4 caratteri
print(s[4:]) #dal quarto carattere alla fine
print(s[4:7]) #dal quarto al sesto carattere
print(s[::-1]) #inversione della stringa

Hell
o World
o W
dlroW olleH

Il metodo split in particolare può essere utilizzato per la tokenizzazione o per estrarre sottostringhe in maniera agevole. Ad esempio, supponiamo di voler estrarre il numero 2017 dalla stringa A-2017-B2:

1

print("A-2017-B2".split('-')[1])

2017

L’operatore == controlla che due stringhe siano uguali:

1
2

print("ciao"=="ciao")
print("ciao"=="ciao2")

True
False

Gli altri operatori rispecchiano l’ordinamento lessicografico tra stringhe:

1
2

print("abc"<"def")
print("Abc">"def")

True
False

Domanda 4 Quale codice permette di manipolare la stringa azyp-kk9-382 per ottenere la stringa Kk9?

1.7.1 Formattazione di Stringhe *

Possiamo costruire stringhe formattate seguendo una sintassi simile a quella di printf:

1
2
3
4

#per costruire la stringa formattata, faccio seguire la stringa dal simbolo "%" e poi inserisco
#una tupla contenente gli argomenti
s1 = "Questa %s è formattata. Posso inserire numeri, as esempio %0.2f" % ("stringa",3.00002)
print(s1)

Questa stringa è formattata. Posso inserire numeri, as esempio 3.00

Un modo alternativo e più recente di formattare le strighe consiste nell’usare il metodo “format”:

1
2
3

s2 = "Questa {} è formattata. Posso inserire numeri, ad esempio {}"\
    .format("stringa",3.000002)# il carattere "\" permette di spezzare la riga
print(s2)

Questa stringa è formattata. Posso inserire numeri, ad esempio 3.000002

E’ possibile specificare il tipo di ogni argomento utilizzando i due punti:

1
2

print("Questa {:s} è formattata. Posso inserire numeri, ad esempio {:0.2f}"\
      .format("stringa",3.00002)) #parametri posizionali, senza speci

Questa stringa è formattata. Posso inserire numeri, ad esempio 3.00

E’ anche possibile assegnare nomi agli argomenti in modo da richiamarli in maniera non ordinata:

1
2

print("Questa {str:s} è formattata. Posso inserire numeri, ad esempio {num:0.2f}"\
    .format(num=3.00002, str="stringa"))

Questa stringa è formattata. Posso inserire numeri, ad esempio 3.00

Domanda 5 Date le variabili: 1 2 3 a = "hello" b = "world" c = 2.0 Usare la formattazione delle stringhe per stampare la stringa hello 2 times world.

1.7.2 Formattazione di Stringhe mediante F-Strings *

Le f-string permettono di formattare le stringhe in maniera ancora più compatta ed elegante. In particolare, la notazione ‘f’ permette di includere all’interno di una stringa i valori di variabili contenuti in variabili disponibili nello scope corrente. Esempio:

1
2

x = 2
print(f"x={x}")

x=2

La ‘f’ prima della stringa denota l’inizio di una f-string. Il contenuto tra le parentesi graffe viene di fatto valutato come del codice. Ciò permette di fare cose del genere:

1

print(f"x={x+2}")

x=4

O cose del genere:

1
2

a={'x':2, 'y':'string'}
print(f"x={a['x']}, y={a['y']}")

x=2, y=string

Anche in questo caso è possibile specificare un formato dopo il simbolo ‘:’ all’interno delle parentesi graffe:

1

print(f"x={a['x']:0.2f}")

x=2.00

1.7.3 Espressioni Regolari *

Spesso può tornare utile manipolare stringhe mediante le espressioni regolari. Ciò permette di cercare pattern, isolarli ed eliminarli. Le espressioni regolari sono fornite dal pacchetto re. Vediamo una stringa di esempio:

1

s = "Stringa con nmero 029876 e testo"

Vediamo ad esempio come estrarre il numero all’interno della stringa:

1
2

import re
re.search('[0-9]+',s)

<re.Match object; span=(18, 24), match='029876'>

Il metodo search restituisce un oggetto di tipo re.Match che specifica gli indici di inizio e fine del match nella stringa (span) e il testo trovato. Per accedere al testo, dobbiamo utilizzare il metodo group:

1

re.search('[0-9]+',s).group()

'029876'

Il metodo search restituisce solo il primo match. In alcuni casi, può essere utile cercare lo stesso pattern più volte all’interno di una stringa. Per farlo, possiamo utilizzare il metodo finditer, come nell’esempio seguente:

1
2

s = "Stringa con numeri 029845 18029 numeri formattati 0234-672, 0xxx-1o2 indirizzi@email.com, #hashtags, @names"
re.finditer('[0-9]+',s)

<callable_iterator at 0x7ffbf0132128>

Questo restituisce un iterator che permette di accedere ai diversi match. Per estrarre il testo contenuto in ogni match possiamo fare come segue:

1

[m.group() for m in re.finditer('[0-9]+',s)]

['029845', '18029', '0234', '672', '0', '1', '2']

Cerchiamo solo i numeri strutturati del tipo ####-###:

1

[m.group() for m in re.finditer('[0-9]{4}-[0-9]{3}',s)]

['0234-672']

Cerchiamo gli indirizzi email:

1

[m.group() for m in re.finditer('[a-zA-Z0-9-_.]+@[a-zA-Z0-9-_.]+',s)]

['indirizzi@email.com']

E’ possibile rimuovere alcuni pattern mediante il metodo sub. Ad esempio, possiamo eliminare le email con:

1

re.sub('[a-zA-Z0-9-_.]+@[a-zA-Z0-9-_.]+','',s)

'Stringa con numeri 029845 18029 numeri formattati 0234-672, 0xxx-1o2 , #hashtags, @names'

Possiamo anche suddividere una riga in più righe sulla base di un pattern. Per esempio, suddividiamo ogni volta che troviamo un trattino:

1

re.split('-',s)

['Stringa con numeri 029845 18029 numeri formattati 0234',
 '672, 0xxx',
 '1o2 indirizzi@email.com, #hashtags, @names']

Suddividiamo ogni volta che troviamo un numero di una o più cifre:

1

re.split('[0-9]+',s)

['Stringa con numeri ',
 ' ',
 ' numeri formattati ',
 '-',
 ', ',
 'xxx-',
 'o',
 ' indirizzi@email.com, #hashtags, @names']

E’ possibile trovare maggiori informazioni nella documentazione ufficiale: https://docs.python.org/3/library/re.html.

1.8 Dizionari *

I dizionari sono simili a delle liste, ma vengono indicizzate da oggetti di tipo “hashable”, ad esempio stringhe:

1
2
3
4

d = {"val1":1, "val2":2}
print(d)

print(d["val1"])

{'val1': 1, 'val2': 2}
1

E’ possibile ottenere la lista delle chiavi e dei valori come segue:

1
2

print(d.keys()) #chiavi e valori sono in ordine casuale
print(d.values())

dict_keys(['val1', 'val2'])
dict_values([1, 2])

E’ possibile indicizzare dizionari con tuple (che sono “hashable”)

1
2
3

d = {(2,3):5, (4,6):11}

print(d[(2,3)])

5

I dizionari possono anche essere estesi dinamicamente:

1
2
3

d = dict() #dizionario vuoto
d["chiave"]="valore"
print(d)

{'chiave': 'valore'}

Possiamo controllare che un elemento si trovi tra le chiavi di un dizionario come segue:

1
2
3

d = {1:'ciao', '5': 5, 8: -1}
print(5 in d)
print('5' in d)

False
True

E’ possibile controllare che un elemento si trovi tra i valori di un dizionario come segue:

1

print(-1 in d.values())

True

1.9 Set

I set sono delle strutture dati che possono contenere solo una istanza di un dato elemento:

1
2

s = {1,2,3,3}
print(s) #può essere contenuto solo un "3"

{1, 2, 3}

Possiamo aggiungere un elemento a un set mediante il metodo “add”:

1
2
3
4
5

print(s)
s.add(5)
print(s)
s.add(1) #non ha effetto. 1 è già presente
print(s)

{1, 2, 3}
{1, 2, 3, 5}
{1, 2, 3, 5}

Anche in questo caso, possiamo controllare l’appartenenza di un elemento ad un set mediante la parola chiave in:

1
2
3

s={1,5,-1}
print(-1 in s)
print(8 in s)

True
False

E’ inoltre possibile creare set da liste:

1

set([1,3,3,2,5,1])

{1, 2, 3, 5}

1.10 Costrutti if/elif/else

I costrutti condizionali funzionano in maniera simile ai linguaggi basati su C. A differenza di tali linguaggi tuttavia, Python sostituisce le parentesi con l’indentazione obbligatoria. Il seguente codice C++:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

int var1 = 5;
int var2 = 10;
if(var1<var2) {
    int var3 = var1+var2;
    cout << "Hello World "<<var3;
}
cout << "End";```
viene invece scritto come segue:


```python
var1 = 5
var2 = 10
if var1<var2:
    var3 = var1+var2
    print("Hello World",var3)
print("End")

Hello World 15
End

In pratica:

• la condizione da verificare non è racchiusa tra parentesi;
• i due punti indicano l’inizio del corpo dell’if;
• l’indentazione stabilisce cosa appartiene al corpo dell’if e cosa non appartiene al corpo dell’if.

Dal momento che l’indentazione ha valore sintattico, essa diventa obbligatoria. Inoltre, non è possibile indentare parti di codice ove ciò non è significativo. Ad esempio, il seguente codice restituirebbe un errore:

1
2

print("Hello")
    print("World")

Le regole di indentazione appena viste, valgono anche per i cicli e altri costrutti in cui è necessario deliminare blocchi di codice. Il costrutto if, permette anche di specificare un ramo else e un ramo elif per i controlli in cascata. Vediamo alcuni esempi:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

true_condition = True
false_condition = False

if true_condition: #i due punti ":" sono obbligatori
    word="cool!"
    print(word) #l'indentazione è obbligatoria
    
if false_condition:
    print("not cool :(")
    
if not false_condition: #neghiamo la condizione con "not"
    word="cool"
    print(word,"again :)")
    
if false_condition:
    word="this"
    print(word+" is "+"false")
else: #due punti + indentazione
    print("true")
    
if false_condition:
    print("false")
elif 5>4: #implementa un "else if"
    print("5>4")
else:
    print("4<5??")

cool!
cool again :)
true
5>4

E’ anche possibile verificare se un valore appartiene a una lista. Ciò è molto utile per verificare se un parametro è ammesso.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

allowed_parameters = ["single", "double", 5, -2]

parameter = "double"

if parameter in allowed_parameters:
    print(parameter,"is ok")
else:
    print(parameter,"not in",allowed_parameters)

x=8
if x in allowed_parameters:
    print(x,"is not ok")
else:
    print(x,"not in",allowed_parameters)

double is ok
8 not in ['single', 'double', 5, -2]

Una variante “inline” del costrutto if può essere utilizzata per gli assegnamenti condizionali:

1
2
3
4

var1 = 5
var2 = 3
m = var1 if var1>var2 else var2 #calcola il massimo
print(m)

5

In Python non esiste il costrutto switch, per implementare il quale si utilizza una lista di elif in cascata:

1
2
3
4
5
6
7
8
9

s = "ciao"
if s=="help":
    print("help")
elif s=="world":
    print("hello",s)
elif s=="ciao":
    print(s,"mondo")
else:
    print("Default")

ciao mondo

Domanda 6 Si consideri il seguente codice: 1 2 3 4 5 6 7 8 9 x=2 if x>0: y=12 x=x+y print y else: z=28 h=12 print z+h Si evidenziino eventuali errori sintattici. Si riscriva il codice in C++ o Java e si confrontino le due versioni del codice.

1.11 Cicli while e for

I cicli while, si definiscono come segue:

1
2
3
4

i=0
while i<5: #due punti ":"
    print(i) #indentazione
    i+=1

0
1
2
3
4

La sintassi dei cicli for è un po’ diversa dalla sintassi standard del C. I cicli for in Python sono più simili a dei foreach e richiedono un “iterable” (ad esempio una lista o una tupla) per essere eseguiti:

1
2
3

l=[1,7,2,5]
for v in l:
    print(v)

1
7
2
5

Per scrivere qualcosa di equivalente al seguente codice C:

1

for (int i=0; i<5; i++) {...}

possiamo utilizzare la funzione range che genera numeri sequenziali al volo:

1
2

for i in range(5):
    print(i)

0
1
2
3
4

Range non genera direttamente una lista, ma un “generator” di tipo range, ovvero un oggetto capace di generare numeri. Se vogliamo convertirlo in una lista, dobbiamo farlo esplicitamente:

1
2
3

print(range(5)) #oggetto di tipo range, genera numeri da 0 a 5 (escluso)
print(list(range(5))) #range non fa altro che generare numeri consecutivi
#convertendo range in una lista, possiamo verificare quali numeri vengono generati

range(0, 5)
[0, 1, 2, 3, 4]

Se volessimo scorrere contemporaneamente indici e valori di un array potremmo scrivere:

1
2
3

array=[1,7,2,4,5] 
for i in range(len(array)):
    print(i,"->",array[i])

0 -> 1
1 -> 7
2 -> 2
3 -> 4
4 -> 5

In Python però, è possibile utilizzare la funzione enumerate per ottenere lo stesso risultato in maniera più compatta:

1
2

for index,value in enumerate(array): #get both index and value
    print(index,"->",value)

0 -> 1
1 -> 7
2 -> 2
3 -> 4
4 -> 5

Supponiamo adesso di voler scorrere contemporaneamente tutti gli iesimi elementi di più liste. Ad esempio:

1
2
3
4
5
6

a1=[1,6,2,5]
a2=[1,8,2,7]
a3=[9,2,5,2]

for i in range(len(a1)):
    print(a1[i],a2[i],a3[i])

1 1 9
6 8 2
2 2 5
5 7 2

Una funzione molto utile quando si lavora con i cicli è zip, che permette di raggruppare gli elementi corrispondenti di diverse liste:

1
2
3
4

l1 = [1,6,5,2]
l2 = [3,8,9,2]
zipped=list(zip(l1,l2))
print(zipped)

[(1, 3), (6, 8), (5, 9), (2, 2)]

In pratica, zip raggruppa gli elementi i-esimi delle liste in tuple. La i-esima tupla di zipped contiene gli i-esimi elementi delle due liste. Combinando zip con un ciclo for, possiamo ottenere il seguente risultato:

1
2

for v1,v2,v3 in zip(a1,a2,a3):
    print(v1,v2,v3)

1 1 9
6 8 2
2 2 5
5 7 2

che è equivalente al codice visto in precedenza. E’ anche possibile combinare zip e enumerate come segue:

1
2

for i,(v1,v2,v3) in enumerate(zip(a1,a2,a3)):
    print(i,"->",v1,v2,v3)

0 -> 1 1 9
1 -> 6 8 2
2 -> 2 2 5
3 -> 5 7 2

Attenzione, anche zip, come range, produce un generator. Pertanto è necessario convertirlo esplicitamente in una lista per stamparne i valori:

1
2

print(zip(l1,l2))
print(list(zip(l1,l2)))

<zip object at 0x7ffbf014f108>
[(1, 3), (6, 8), (5, 9), (2, 2)]

1.12 Comprensione di liste e dizionari *

La comprensione di liste è uno strumento sintattico che permette di definire liste al volo a partire da altre liste, in maniera iterativa. Ad esempio, è possibile moltiplicare tutti gli elementi di una lista per un valore, come segue:

1
2
3
4
5
6

a = list(range(8))

b = [x*3 for x in a] #la lista "a" viene iterata. La variabile "x" conterrà di volta in volta i valori di a

print(a)
print(b)

[0, 1, 2, 3, 4, 5, 6, 7]
[0, 3, 6, 9, 12, 15, 18, 21]

E’ anche possibile includere solo alcuni elementi selettivamente:

1

print([x for x in a if x%2==0]) #include solo i numeri pari

[0, 2, 4, 6]

1
2
3
4
5
6
7
8

a = [1,3,8,2,9]
b = [4,9,2,1,4]

c = [x+y for x,y in zip(a,b)]

print(a)
print(b)
print(c) #i suoi elementi sono le somme degli elementi di a e b

[1, 3, 8, 2, 9]
[4, 9, 2, 1, 4]
[5, 12, 10, 3, 13]

I meccanismi di comprensione si possono utilizzare anche nel caso dei dizionari:

1
2
3
4

a = ["one","two","three","four","five","six","seven"]
b = range(1,8)
d = {i:s for i,s in zip(a,b)}
print(d)

{'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6, 'seven': 7}

Domanda 7 Tutte le operazioni che si possono fare mediante comprensione di liste e dizionari possono essere fatte mediante un ciclo for? Quali sono i vantaggi principali di queste tecniche rispetto a l’utilizzo dei cicli for?

1.13 Definizione di Funzioni

Considerato quanto già detto sulla indentazione, la definizione di una funzione è molto naturale:

1
2
3
4

def fun(x, y):
    return x**y

print(fun(3,2)) #il valore di default "2" viene utilizzato

9

Inoltre, in maniera simile a quanto avviene con il linguaggio C, è possibile definire valori di default per i parametri:

1
2
3
4

def fun(x, y=2):
    return x**y

print(fun(3)) #il valore di default "2" viene utilizzato

9

I parametri di una funzione possono essere specificati in un ordine diverso rispetto a quello in cui essi sono stati definiti richiamandone il nome:

1

print(fun(y=3,x=2))

8

E’ possibile definire una funzione che restituisce più di un elemento utilizzando le tuple:

1
2
3
4
5
6
7

def soMuchFun(x,y):
    return x**y, y**x

print(soMuchFun(2,3))

a,b=soMuchFun(2,3) #posso "spacchettare" la tupla restituita
print(a,b)

(8, 9)
8 9

E’ inoltre possibile definire funzioni anonime come segue:

1
2
3
4
5
6
7
8

myfun = lambda x: x**2 #un input e un output
print(myfun(2))

myfun1 = lambda x,y: x+y #due input e un output
print(myfun1(2,3))

myfun2 = lambda x,y: (x**2,y**2) #due input e due output
print(myfun2(2,3))

4
5
(4, 9)

Domanda 8 Qual è il vantaggio di definire una funzione mediante lambda? Quali sono i suoi limiti?

1.14 Map e Filter

Le funzioni map e filter permettono di eseguire operazioni sugli elementi di una lista. In particolare, map applica una funzione a tutti gli elementi di una lista:

1
2
3
4
5
6
7

def pow2(x):
    return(x**2)

l1 = list(range(6))
l2 = list(map(pow2,l1)) #applica pow2 a tutti gli elementi della lista
print(l1)
print(l2)

[0, 1, 2, 3, 4, 5]
[0, 1, 4, 9, 16, 25]

Quando si utilizzano map e filter, tornano particolarmente utili le funzioni anonime, che ci permettono di scrivere in maniera più compatta. Ad esempio, possiamo riscrivere quanto visto sopra come segue:

1
2

l2 = list(map(lambda x: x**2, l1))
print(l2)

[0, 1, 4, 9, 16, 25]

Filter permette di selezionare un sottoinsieme degli elementi di una lista sulla base di una condizione. La condizione viene specificata passando una funzione che prende in input l’elemento della lista e restituisce un booleano:

1

print(list(filter(lambda x: x%2==0,l1))) #filtra solo i numeri pari

[0, 2, 4]

1.15 Programmazione Orientata agli Oggetti - Definizione di Classi

La programmazione orientata agli oggetti in Python è intuitiva. Le principali differenze rispetto ai più diffusi linguaggi di programmazione orientata agli oggetti sono le seguenti:

• non esistono i modificatori di visibilità (private, protected e public). Per convenzione, tutti i simboli privati vanno preceduti da “__”;
• ogni metodo è una funzione con un argomento di default (self) che rappresenta lo stato dell’oggetto;
• il costruttore si chiama “__init__”.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class Classe(object): #ereditiamo dalla classe standard "object"
    def __init__(self, x): #costruttore
        self.x=x #inserisco il valore x nello stato dell'oggetto
    
    def prt(self):
        print(self.x)
    
    def power(self,y=2):
        self.x =  self.x**y
        
c = Classe(3)
c.prt()
c.power(3)
c.prt()
c.power()
c.prt()

3
27
729

Per estendere una classe, si fa come segue:

1
2
3
4
5
6
7
8
9

class Classe2(Classe): #derivo la classe "Classe" ed eredito metodi e proprietà
    def __init__(self,x):
        super(Classe2, self).__init__(x) #chiamo il costruttore della classe madre
    def prt(self): #ridefinisco il metodo prt
        print("yeah",self.x)
        
c2 = Classe2(2)
c2.power()
c2.prt()

yeah 4

1.16 Duck Typing

Per identificare i tipi dei dati, Python segue il principio del duck typing. Secondo tale principio, i tipi sono definiti utilizzando il duck test:

If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.

Ciò significa che i tipi sono definiti in relazione alle operazioni che possono essere eseguite su di essi. Vediamo un esempio (preso da Wikipedia).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class Sparrow(object):
    def fly(self):
        print("Sparrow flying")

class Airplane(object):
    def fly(self):
        print("Airplane flying")

class Whale(object):
    def swim(self):
        print("Whale swimming")

def lift_off(entity):
    entity.fly()

sparrow = Sparrow()
airplane = Airplane()
whale = Whale()

try:
    lift_off(sparrow) 
    lift_off(airplane) 
    lift_off(whale) #Errore, il "tipo" di questo oggetto non permette di eseguire il metodo "fly". 
                    #Secondo il duck test, questo tipo è incompatibile
except AttributeError as e:
    print("Error:",e)
        

Sparrow flying
Airplane flying
Error: 'Whale' object has no attribute 'fly'

1.17 Eccezioni *

In maniera simile a molti linguaggi moderni, Python supporta l’uso delle eccezioni. E’ possibile catturare una eccezione con il costrutto try - except:

1
2
3
4

try:
    5/0
except:
    print("Houston, abbiamo un problema!")

Houston, abbiamo un problema!

In Python, le eccezioni sono tipizzate. Possiamo decidere quali tipi di eccezioni catturare come segue:

1
2
3
4

try:
    5/0
except ZeroDivisionError:
    print("Houston, abbiamo un problema!")

Houston, abbiamo un problema!

Possiamo avere accesso all’eccezione scatenata (ad esempio ottenere maggiori informazioni) come segue:

1
2
3
4
5

try:
    5/0
except ZeroDivisionError as e:
    print("Houston, abbiamo un problema!")
    print(e)

Houston, abbiamo un problema!
division by zero

E’ possibile lanciare una eccezione mediante raise:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

def div(x,y):
    if y==0:
        raise ZeroDivisionError("Cannot divide by zero!")
    else:
        return x/y
try:
    div(5,2)
    div(5,0)
except Exception as e:
    print(e)

Cannot divide by zero!

Possiamo definire nuove eccezioni estendendo la classe Exception:

1
2
3
4
5
6
7
8

class MyException(Exception):
    def __init__(self, message):
        self.message = message

try:
    raise MyException("Exception!")
except Exception as e:
    print(e)

Exception!

Un modo veloce e comodo per lanciare una eccezione (un AssertionError nello specifico) quando qualcosa va male, è utilizzare assert, che prende in input un booleano e, opzionalmente, un messaggio di errore. Il booleano va posto uguale a False se qualcosa è andato storto. Vediamo un esempio:

1
2
3
4
5
6
7
8
9

def div(x,y):
    assert y!=0, "Cannot divide by zero!"
    return x/y

try:
    div(5,2)
    div(5,0)
except:
    print('Assert failed')

Assert failed

1.18 Definizione di Moduli

Quando si costruiscono programmi complessi, può essere utile raggruppare le definizioni di funzione e classi in moduli. Il modo più semplice di definire un modulo in Python consiste nell’inserire le definizioni all’interno di un file apposito modulo.py. Le definizioni potranno poi essere importati mediante la sintassi from modulo import funzione, a patto che il file che richiama le funzioni e quello che definisce il modulo si trovino nella stessa cartella. Vediamo un esempio:

1
2
3
4
5
6

#file modulo.py
def mysum(a,b):
    return a+b

def myprod(a,b):
    return a*b

1
2
3
4

#file main.py (stessa cartella di modulo.py)
from modulo import mysum, myprod
print(mysum(2,3)) #5
print(myprod(2,3)) #6

Altre informazioni su usi più avanzati di moduli e pacchetti possono essere reperite qui: https://docs.python.org/3/tutorial/modules.html.

2 Numpy

Numpy è la libreria di riferimento di scipy per il calcolo scientifico. Il cuore della libreria è costituito dai numpy array che permettono di gestire agevolmente operazioni tra vettori e matrici. Gli array di Python sono in generale tensori, ovvero strutture numeriche dal numero di dimensioni variabili, che possono dunque essere array monodimensionali, matrici bidimensionali, o strutture a più dimensioni (es. cuboidi 10 x 10 x 10). Per utilizzare gli array di numpy, dobbiamo prima importare il pacchetto numpy:

1

import numpy as np #la notazione "as" ci permette di referenziare il namespace numpy semplicemente con np in futuro

2.1 Numpy Arrays *

Un array multidimensionale di numpy può essere definito a partire da una lista di liste, come segue:

1
2
3
4
5

l = [[1,2,3],[4,5,2],[1,8,3]] #una lista contenente tre liste
print("List of lists:",l) #viene visualizzata così come l'abbiamo definita
a = np.array(l) #costruisco un array di numpy a partire dalla lista di liste
print("Numpy array:\n",a) #ogni lista interna viene identificata come una riga di una matrice bidimensionale
print("Numpy array from tuple:\n",np.array(((1,2,3),(4,5,6)))) #posso creare numpy array anche da tuple

List of lists: [[1, 2, 3], [4, 5, 2], [1, 8, 3]]
Numpy array:
 [[1 2 3]
 [4 5 2]
 [1 8 3]]
Numpy array from tuple:
 [[1 2 3]
 [4 5 6]]

Ogni array di numpy ha una proprietà shape che ci permette di determinare il numero di dimensioni della struttura:

1

print(a.shape) #si tratta di una matrice 3 x 3

(3, 3)

Vediamo qualche altro esempio

1
2
3
4
5
6

array = np.array([1,2,3,4]) 
matrice = np.array([[1,2,3,4],[5,4,2,3],[7,5,3,2],[0,2,3,1]]) 
tensore = np.array([[[1,2,3,4],['a','b','c','d']],[[5,4,2,3],['a','b','c','d']],[[7,5,3,2],['a','b','c','d']],[[0,2,3,1],['a','b','c','d']]]) 
print('Array:',array, array.shape) #array monodimensionale, avrà una sola dimensione
print('Matrix:\n',matrice, matrice.shape)
print('matrix:\n',tensore, tensore.shape) #tensore, avrà due dimensioni

Array: [1 2 3 4] (4,)
Matrix:
 [[1 2 3 4]
 [5 4 2 3]
 [7 5 3 2]
 [0 2 3 1]] (4, 4)
matrix:
 [[['1' '2' '3' '4']
  ['a' 'b' 'c' 'd']]

 [['5' '4' '2' '3']
  ['a' 'b' 'c' 'd']]

 [['7' '5' '3' '2']
  ['a' 'b' 'c' 'd']]

 [['0' '2' '3' '1']
  ['a' 'b' 'c' 'd']]] (4, 2, 4)

Vediamo qualche operazione tra numpy array:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

a1 = np.array([1,2,3,4]) 
a2 = np.array([4,3,8,1]) 
print("Sum:",a1+a2) #somma tra vettori
print("Elementwise multiplication:",a1*a2) #moltiplicazione tra elementi corrispondenti
print("Power of two:",a1**2) #quadrato degli elementi
print("Elementwise power:",a1**a2) #elevamento a potenza elemento per elemento
print("Vector product:",a1.dot(a2)) #prodotto vettoriale
print("Minimum:",a1.min()) #minimo dell'array
print("Maximum:",a1.max()) #massimo dell'array
print("Sum:",a2.sum()) #somma di tutti i valori dell'array
print("Product:",a2.prod()) #prodotto di tutti i valori dell'array
print("Mean:",a1.mean()) #media di tutti i valori dell'array

Sum: [ 5  5 11  5]
Elementwise multiplication: [ 4  6 24  4]
Power of two: [ 1  4  9 16]
Elementwise power: [   1    8 6561    4]
Vector product: 38
Minimum: 1
Maximum: 4
Sum: 16
Product: 96
Mean: 2.5

Operazioni tra matrici:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

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

print("Sum:",m1+m2) #somma tra matrici
print("Elementwise product:\n",m1*m2) #prodotto elemento per elemento
print("Power of two:\n",m1**2) #quadrato degli elementi
print("Elementwise power:\n",m1**m2) #elevamento a potenza elemento per elemento
print("Matrix multiplication:\n",m1.dot(m2)) #prodotto matriciale
print("Minimum:",m1.min()) #minimo
print("Maximum:",m1.max()) #massimo
print("Minimum along columns:",m1.min(0)) #minimo per colonne
print("Minimum along rows:",m1.min(1)) #minimo per righe
print("Sum:",m1.sum()) #somma dei valori
print("Mean:",m1.mean()) #valore medio
print("Diagonal:",m1.diagonal()) #diagonale principale della matrice
print("Transposed:\n",m1.T) #matrice trasposta

Sum: [[ 9  4  4  8]
 [ 5  8  8  4]
 [11  9  5  2]
 [ 0  3 11  7]]
Elementwise product:
 [[ 8  4  3 16]
 [ 0 16 12  3]
 [28 20  6  0]
 [ 0  2 24  6]]
Power of two:
 [[ 1  4  9 16]
 [25 16  4  9]
 [49 25  9  4]
 [ 0  4  9  1]]
Elementwise power:
 [[   1    4    3  256]
 [   1  256   64    3]
 [2401  625    9    1]
 [   1    2 6561    1]]
Matrix multiplication:
 [[20 26 51 30]
 [48 37 57 42]
 [68 48 59 45]
 [12 21 26  8]]
Minimum: 0
Maximum: 7
Minimum along columns: [0 2 2 1]
Minimum along rows: [1 2 2 0]
Sum: 47
Mean: 2.9375
Diagonal: [1 4 3 1]
Transposed:
 [[1 5 7 0]
 [2 4 5 2]
 [3 2 3 3]
 [4 3 2 1]]

2.2 Linspace, Arange, Zeros, Ones, Eye e Random *

Le funzioni linspace, arange, zeros, ones, eye e random di numpy sono utili a generare array numerici al volo. In particolare, la funzione linspace, permette di generare una sequenza di n numeri equispaziati che vanno da un valore minimo a un valore massimo:

1
2

a=np.linspace(10,20,5) # genera 5 valori equispaziati che vanno da 10 a 20
print(a)

[10.  12.5 15.  17.5 20. ]

arange è molto simile a range, ma restituisce direttamente un array di numpy: