Numpy - Codice [Link] - Colab [Link]
Importiamo la libreria
import numpy as np
Array monodimensionale - Vettore
# Creazione di un array monodimensionale
vettore = [Link]([1, 2, 3, 4, 5])
print(vettore)
# Output: [1 2 3 4 5]
[1 2 3 4 5]
print(vettore[1])
print(vettore[4])
Shape e DType
Shape fornisce informazioni circa la forma dell'array
[Link]
(5,)
dtype fornisce informazioni circa il tipo di oggetti contenuti nell'array
[Link]
dtype('int64')
1 di 11 10/12/2024, 15:30
Numpy - Codice [Link] - Colab [Link]
size fornisce informazioni sul quantitativo di oggetti contenuti nell'array
[Link]
ndim fornisce informazioni sulle dimensioni dell'array
[Link]
Array da Lista Python
# Creiamo una lista Python
lista_python = [1, 2, 3, 4, 5]
# Convertiamo la lista in un array NumPy
array_numpy = [Link](lista_python)
# Stampiamo l'array NumPy
print(array_numpy)
# Output: [1 2 3 4 5]
[1 2 3 4 5]
E se invece la lista passata è mista, ossia non possiede oggetti di un solo tipo?
# Creiamo una lista Python
lista_python = [1, 2, 'casa', 4, 5]
# Convertiamo la lista in un array NumPy
array_numpy = [Link](lista_python)
# Stampiamo l'array NumPy
print(array_numpy)
# Output: [1 2 3 4 5]
['1' '2' 'casa' '4' '5']
2 di 11 10/12/2024, 15:30
Numpy - Codice [Link] - Colab [Link]
array_numpy.dtype
dtype('<U21')
# Creiamo una lista Python
lista_python = [1, 2, 3.3, 4, 5]
# Convertiamo la lista in un array NumPy
array_numpy = [Link](lista_python)
# Stampiamo l'array NumPy
print(array_numpy)
# Output: [1 2 3 4 5]
[1. 2. 3.3 4. 5. ]
array_numpy.dtype
dtype('float64')
Operazioni Matematiche e il Broadcasting
Dobbiamo prestare particolare attenzione alle operazioni matematiche che possiamo fare in
Numpy, poiché il comportamento differisce da quello delle liste.
Gli operatori che siamo, infatti, abituati ad usare, potrebbero restituire un output completamente
diverso.
lista1 = [1,2,3,4,5]
lista2 = [1,2,3,4,5]
lista3 = lista1 + lista2
print(lista3)
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
array1 = [Link]([1,2,3,4,5])
array2 = [Link]([1,2,3,4,5])
array3 = array1 + array2
print(array3)
3 di 11 10/12/2024, 15:30
Numpy - Codice [Link] - Colab [Link]
[ 2 4 6 8 10]
Questo accade grazie al broadcasting. Il broadcasting è un meccanismo che consente a Numpy
di eseguire operazioni tra array di diverse dimensioni o tra un array e uno scalare, anche quando
le dimensioni non sono compatibili tra loro. In questo modo, Numpy può estendere
automaticamente la dimensione di uno degli operandi in modo da rendere possibile l’operazione.
array4 = array1 * 3
print(array4)
[ 3 6 9 12 15]
array4 = array1 + 3
print(array4)
[4 5 6 7 8]
array4 = array1 - 1
print(array4)
[0 1 2 3 4]
array4 = array1/2
print(array4)
[0.5 1. 1.5 2. 2.5]
Che, avendo una lista, corrisponde in Python all'esecuzione del seguente codice:
lista4 = []
for i in lista1:
new = i * 3
[Link](new)
print(lista4)
[3, 6, 9, 12, 15]
Array di zeri
4 di 11 10/12/2024, 15:30
Numpy - Codice [Link] - Colab [Link]
zeri = [Link](4)
print(zeri)
[0. 0. 0. 0.]
Principali Funzioni in Numpy
Array Bidimensionale - Matrice
# Creazione di un array bidimensionale
matrice = [Link]([[1, 2, 3], [4, 5, 6]])
print(matrice)
# Output:
# [[1 2 3]
# [4 5 6]]
[[1 2 3]
[4 5 6]]
5 di 11 10/12/2024, 15:30
Numpy - Codice [Link] - Colab [Link]
Matrice di zeri
mat = [Link]( (2,3) ) # 2 righe, 3 colonne
print(mat)
[[0. 0. 0.]
[0. 0. 0.]]
Matrice di uno
mat = [Link]( (2,3) ) # 2 righe, 3 colonne
print(mat)
[[1. 1. 1.]
[1. 1. 1.]]
Operazioni matematiche sulle Matrici
print(mat)
[[1. 1. 1.]
[1. 1. 1.]]
mat2 = mat * 3
print(mat2)
[[3. 3. 3.]
[3. 3. 3.]]
mat2 = mat + 3
print(mat2)
[[4. 4. 4.]
[4. 4. 4.]]
mat2 = mat - 2
print(mat2)
[[-1. -1. -1.]
6 di 11 10/12/2024, 15:30
Numpy - Codice [Link] - Colab [Link]
[[-1. -1. -1.]
[-1. -1. -1.]]
Slicing
a = [Link]([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(a)
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
b = a[:2, 1:3]
print(b)
[[2 3]
[6 7]]
Numpy è davvero più e�ciente di Python?
Memoria
In questo esempio, verranno creati una lista Python e un array Numpy di dimensione 1000.
Verranno calcolate le dimensioni di ciascun elemento e quindi le dimensioni totali di entrambe le
strutture e verrà effettuato un confronto in termini di consumo di memoria.
import sys
# dichiarazione di una lista di 1000 elementi
L = list(range(1000))
# stampa della dimensione di ciascun elemento della lista
print("Dimensione di ciascun elemento della lista in byte: ", [Link]
# stampa della dimensione totale della lista
print("Dimensione totale della lista in byte: ", [Link](L) + [Link]
7 di 11 10/12/2024, 15:30
Numpy - Codice [Link] - Colab [Link]
# dichiarazione di un array Numpy di 1000 elementi
D = [Link](1000)
# stampa della dimensione di ciascun elemento dell'array Numpy
print("Dimensione di ciascun elemento dell'array Numpy in byte: ", [Link]
# stampa della dimensione totale dell'array Numpy
print("Dimensione totale dell'array Numpy in byte: ", [Link] * [Link]
Dimensione di ciascun elemento della lista in byte: 24
Dimensione totale della lista in byte: 32056
Dimensione di ciascun elemento dell'array Numpy in byte: 8
Dimensione totale dell'array Numpy in byte: 8000
Tempo
In questo esempio, verranno create due liste Python e due array Numpy, ciascuno contenente
1.000.000 di elementi. Verrà eseguita la moltiplicazione degli elementi sia nelle liste che negli
array Numpy, e la differenza di tempo necessaria per l'esecuzione dell'operazione in entramble
strutture dati sarà analizzata per determinare quale dei due impiega meno tempo per completare
l'operazione.
import time
# dimensione degli array e delle liste
size = 1000000
# dichiarazione delle liste
list1 = range(size)
list2 = range(size)
# dichiarazione degli array
array1 = [Link](size)
array2 = [Link](size)
# cattura del tempo prima della moltiplicazione delle liste Python
initialTime = [Link]()
# moltiplicazione degli elementi di entrambe le liste e memorizzazione in un
8 di 11 10/12/2024, 15:30
Numpy - Codice [Link] - Colab [Link]
# moltiplicazione degli elementi di entrambe le li
resultantList = [(a * b) for a, b in zip(list1, list2)]
# calcolo del tempo di esecuzione
print("Tempo impiegato dalle Liste per eseguire la moltiplicazione:",
([Link]() - initialTime),
"secondi")
# cattura del tempo prima della moltiplicazione degli array di NumPy
initialTime = [Link]()
# moltiplicazione degli elementi di entrambi gli array di NumPy e memorizzaz
resultantArray = array1 * array2
# calcolo del tempo di esecuzione
print("Tempo impiegato dagli Array di NumPy per eseguire la moltiplicazione:
([Link]() - initialTime),
"secondi")
Tempo impiegato dalle Liste per eseguire la moltiplicazione: 0.12993788719177246 secondi
Tempo impiegato dagli Array di NumPy per eseguire la moltiplicazione: 0.010719537734985352 s
Un'applicazione reale: le immagini
Inserite un'immagine nel vostro Google Drive e selezionate il percorso esatto dell'immagine.
#Colleghiamoci al nostro Google Drive
from [Link] import drive
[Link]('/content/drive')
Drive already mounted at /content/drive; to attempt to forcibly remount, call [Link]("/
Importiamo una libreria per l'uso delle immagini
import cv2
from [Link] import cv2_imshow #purtroppo questa funzionalità d
img = [Link]('/content/drive/MyDrive/FI/[Link]',[Link]
cv2_imshow(img)
9 di 11 10/12/2024, 15:30
Numpy - Codice [Link] - Colab [Link]
cv2_imshow(img)
[Link]
(300, 450)
print(img)
[[148 148 149 ... 133 148 138]
[146 147 147 ... 200 154 144]
[143 144 144 ... 162 163 155]
...
[ 32 30 29 ... 76 85 80]
[ 32 30 29 ... 82 80 76]
[ 32 30 29 ... 93 96 91]]
10 di 11 10/12/2024, 15:30
Numpy - Codice [Link] - Colab [Link]
11 di 11 10/12/2024, 15:30