In questa lezione vedremo come generare array con valori predefiniti, che è una parte fondamentale della programmazione con NumPy. NumPy infatti fornisce diverse funzioni per creare array con valori predefiniti, che possono essere utilizzate per inizializzare array con valori specifici, come zeri, uni, valori casuali o valori sequenziali.
Perchè è importante saper generare array con valori predefiniti?
La generazione di array con valori predefiniti è una funzionalità fondamentale nella programmazione con NumPy, poiché fornisce un modo efficiente per creare e inizializzare array con valori specifici. Questa capacità è dunque essenziale in numerose applicazioni scientifiche, ingegneristiche e computazionali, dove spesso si lavora con grandi quantità di dati e si eseguono calcoli complessi.
Utilizzare valori predefiniti per inizializzare gli array permette di risparmiare tempo e risorse computazionali, poiché evita la necessità di assegnare manualmente valori agli elementi dell’array uno per uno. Inoltre, fornisce un modo coerente e standardizzato per inizializzare gli array, garantendo che i dati siano correttamente formattati e pronti per l’elaborazione.
Questo è particolarmente importante in contesti come l’analisi dei dati, il machine learning, la simulazione numerica e molte altre aree in cui NumPy è ampiamente utilizzato. La capacità di generare array con valori predefiniti consente quindi ai ricercatori, agli ingegneri e ai programmatori di concentrarsi sulle complesse operazioni di calcolo e analisi, senza doversi preoccupare della gestione manuale dei dati.
Dunque, la generazione di array con valori predefiniti è un pilastro della programmazione con NumPy, consentendo agli utenti di lavorare in modo efficiente e produttivo con dati di grandi dimensioni e complessi.
Ecco dunque alcune delle principali funzioni di generazione di array in NumPy:
np.zeros
np.zeros: Crea un array di dimensioni specificate riempito con zeri.
import numpy as np
# Creazione di un array di zeri
zeros_array = np.zeros((3, 4)) # Array 3x4
print(zeros_array)
# Output:
# [[0. 0. 0. 0.]
# [0. 0. 0. 0.]
# [0. 0. 0. 0.]]
np.ones
np.ones: Crea un array di dimensioni specificate riempito con gli uni.
import numpy as np
# Creazione di un array di uni
ones_array = np.ones((2, 3)) # Array 2x3
print(ones_array)
# Output:
# [[1. 1. 1.]
# [1. 1. 1.]]
np.full
np.full: Crea un array di dimensioni specificate riempito con un valore specificato.
import numpy as np
# Creazione di un array con un valore specifico
full_array = np.full((2, 2), 5) # Array 2x2 con valore 5
print(full_array)
# Output:
# [[5 5]
# [5 5]]
np.arange
np.arange: Crea un array con valori sequenziali all’interno di un intervallo specificato.
import numpy as np
# Creazione di un array con valori sequenziali
seq_array = np.arange(0, 10, 2) # Valori da 0 a 9 con passo 2
print(seq_array)
# Output:
# [0 2 4 6 8]
np.linspace
np.linspace: Crea un array con valori equidistanti all’interno di un intervallo specificato.
import numpy as np
# Creazione di un array con valori equidistanti
lin_array = np.linspace(0, 10, 5) # 5 valori equidistanti tra 0 e 10
print(lin_array)
# Output:
# [ 0. 2.5 5. 7.5 10. ]
np.random.rand
np.random.rand: Crea un array con valori casuali da una distribuzione uniforme tra 0 e 1.
import numpy as np
# Creazione di un array con valori casuali
rand_array = np.random.rand(2, 3) # Array 2x3 con valori casuali
print(rand_array)
# Output:
# [[0.45644918 0.98712347 0.12345678]
# [0.78901234 0.56789012 0.23456789]]
Migliora le tue capacità di programmazione Python seguendo il nostro corso in diretta!
np.eye
np.eye: Crea una matrice identità con dimensioni specificate
np.diag: Crea una matrice diagonale con gli elementi forniti lungo la diagonale principale.
import numpy as np
# Creazione di una matrice diagonale
diag_matrix = np.diag([1, 2, 3]) # Matrice diagonale con valori [1, 2, 3]
print(diag_matrix)
# Output:
# [[1 0 0]
# [0 2 0]
# [0 0 3]]
np.empty
np.empty: Crea un array non inizializzato con dimensioni specificate. Gli elementi possono contenere valori residui dalla memoria, quindi è consigliabile inizializzare esplicitamente l’array.
import numpy as np
# Creazione di un array non inizializzato
empty_array = np.empty((2, 2)) # Array 2x2 non inizializzato
print(empty_array)
# Output:
# [[1. 0.]
# [0. 1.]]
np.zeros_like e np.ones_like
np.zeros_like e np.ones_like: Crea un array di zeri o uni con le stesse dimensioni di un altro array specificato.
import numpy as np
# Creazione di un array di zeri con le stesse dimensioni di un altro array
original_array = np.array([[1, 2], [3, 4]])
zeros_like_array = np.zeros_like(original_array)
print(zeros_like_array)
# Creazione di un array di uni con le stesse dimensioni di un altro array
ones_like_array = np.ones_like(original_array)
print(ones_like_array)
# Output:
# [[0 0]
# [0 0]]
# Output:
# [[1 1]
# [1 1]]
Conclusioni
La generazione di array con valori predefiniti è una parte essenziale della programmazione con NumPy, dato che offre una vasta gamma di funzioni per creare array con valori specifici. Queste funzioni sono quindi utili in molte situazioni, dalle operazioni di base sulle matrici alle complesse elaborazioni di dati scientifici o applicazioni di machine learning.
In questa lezione, abbiamo esplorato diverse funzioni di generazione di array, tra cui np.zeros, np.ones, np.full, np.arange, np.linspace, np.random.rand, np.eye, np.diag, np.empty, np.zeros_like e np.ones_like. Ogni funzione ha le proprie caratteristiche e scopi specifici, consentendo di creare array con valori predefiniti in modo flessibile e efficiente.
È importante comprendere quando e perché utilizzare ciascuna di queste funzioni, poiché ciò può influire sulle prestazioni e sulla leggibilità del codice. Ad esempio, la scelta tra la generazione di valori casuali o sequenziali può essere cruciale in applicazioni di machine learning, mentre la creazione di array con valori specifici può essere utile per inizializzare pesi di reti neurali o matrici di trasformazione.
Dunque, in conclusione, con una buona comprensione delle funzioni di generazione di array in NumPy e la loro corretta applicazione, è possibile scrivere codice più conciso, efficiente e facile da mantenere, contribuendo al successo dei progetti di programmazione Python.
La funzione np.concatenate di NumPy consente di concatenare array lungo un asse specificato. Questa funzione è utile quando si desidera combinare più array in uno nuovo.
Ecco la sua sintassi di base:
numpy.concatenate((array1, array2, ...), axis=0, out = None)
Dove:
array1, array2, ecc. sono gli array che si desidera concatenare.
axis specifica l’asse lungo il quale concatenare gli array. Per impostazione predefinita, axis è 0, il che significa che gli array verranno concatenati lungo l’asse delle righe. Se si desidera concatenare lungo l’asse delle colonne, si può impostare axis = 1.
out: (opzionale) array in cui inserire il risultato della concatenazione.
Migliora le tue capacità di programmazione Python seguendo il nostro corso in diretta!
Considerazioni su np.concatenate
Ci sono alcune altre considerazioni da fare riguardo a np.concatenate:
Specificare gli array da concatenare: Innanzitutto possiamo specificare un elenco di array da concatenare come argomenti di np.concatenate, oppure su possono passare gli array come una lista o una tupla.
Axis parameter: Il parametro axis di np.concatenate specifica lungo quale asse verrà eseguita la concatenazione. Per esempio, axis = 0 indica la concatenazione lungo l’asse delle righe (verticale), mentre axis = 1 indica la concatenazione lungo l’asse delle colonne (orizzontale). Assicuriamoci di specificare correttamente l’asse desiderato in base alla nostra esigenza di concatenazione.
Dimensioni compatibili: Affinché l’operazione di concatenazione vada a buon fine, è importante assicurarsi che le dimensioni degli array lungo l’asse di concatenazione siano compatibili tra loro. Ad esempio, se si desidera concatenare lungo le colonne, le righe degli array devono avere la stessa lunghezza.
Tipo di dato: np.concatenate preserverà il tipo di dato degli array di input nell’array risultante.
Broadcasting: Se gli array hanno dimensioni diverse, NumPy eseguirà il broadcasting prima di concatenarli lungo l’asse specificato.
Assegnazione ad un nuovo array: Si può assegnare il risultato della concatenazione a una nuova variabile, oppure si può sovrascrivere uno degli array di input con il risultato della concatenazione.
Efficienza: np.concatenate è implementato in C, il che lo rende efficiente per grandi operazioni di concatenazione su array NumPy. Utilizzare np.concatenate è dunque generalmente più efficiente rispetto a iterare manualmente sugli array e concatenarli uno per uno. NumPy è ottimizzato per eseguire operazioni su array in modo efficiente, quindi sfruttare le funzionalità fornite da np.concatenate può portare a codice più compatto e veloce.
Conclusioni
In questa lezione abbiamo esplorato la funzione np.concatenate di NumPy, che consente di concatenare array lungo un asse specificato. È una funzione estremamente utile quando si lavora con dati multidimensionali e si desidera combinare più array in uno nuovo.
Abbiamo imparato a utilizzare np.concatenate per concatenare array lungo le righe e le colonne, specificando l’asse desiderato tramite il parametro axis. È importante prestare attenzione alle dimensioni degli array e al tipo di dato, poiché np.concatenate preserverà il tipo di dato degli array di input nell’array risultante e richiederà che le dimensioni degli array lungo l’asse di concatenazione siano compatibili tra loro.
Inoltre, abbiamo discusso l’efficienza di np.concatenate, sottolineando che è generalmente più efficiente rispetto a iterare manualmente sugli array e concatenarli uno per uno, grazie alla sua implementazione ottimizzata in C.
Infine, abbiamo anche esaminato alcune considerazioni importanti da tenere a mente quando si utilizza np.concatenate, come la specifica degli array da concatenare, il broadcasting, l’assegnazione ad un nuovo array e l’efficienza.
Utilizzando dunque np.concatenate in modo efficace, è possibile scrivere codice più conciso e veloce per combinare array in modo efficiente e intuitivo in NumPy.
Introduciamo il concetto di broadcasting, un concetto fondamentale in NumPy che consente di eseguire operazioni aritmetiche tra array di forme diverse ma compatibili. In pratica, il broadcasting permette a NumPy di estendere automaticamente le dimensioni degli array in modo da renderli compatibili per le operazioni.
Quindi, quando si esegue un’operazione aritmetica su due array, NumPy confronta le loro forme elemento per elemento, partendo dalla destra. Se dunque le dimensioni dei due array non corrispondono, NumPy estende automaticamente le dimensioni degli array più piccoli aggiungendo dimensioni di lunghezza 1 fino a quando entrambi gli array hanno la stessa dimensione lungo ciascuna dimensione.
Il broadcasting dunque consente di scrivere codice più conciso ed efficiente, eliminando la necessità di espandere manualmente gli array per renderli compatibili. Questo rende NumPy uno strumento potente per eseguire operazioni su dati multidimensionali in modo rapido e intuitivo.
Migliora le tue capacità di programmazione Python seguendo il nostro corso in diretta!
Quando può essere applicato il broadcasting?
Il broadcasting in NumPy può essere applicato quando le dimensioni degli array sono compatibili o possono essere allungate in modo da essere compatibili. In generale funziona secondo le seguenti regole:
Le dimensioni degli array vengono confrontate da destra verso sinistra.
Per ogni dimensione, le dimensioni degli array devono essere uguali, oppure una delle dimensioni deve essere 1. Dunque, se le dimensioni non sono uguali e nessuna delle dimensioni è 1, il broadcasting non è possibile e verrà generato un errore.
Se una delle dimensioni di un array è 1 in una determinata dimensione e l’altra dimensione è maggiore di 1, l’array con la dimensione 1 verrà “trasformato” per avere la stessa dimensione dell’altro array in quella dimensione.
Se le dimensioni di entrambi gli array sono 1 in una determinata dimensione, la dimensione verrà estesa a quella dimensione dell’array risultante.
N.B. Il broadcasting non può essere applicato direttamente se le dimensioni non sono compatibili per le operazioni aritmetiche. Infatti richiede che le dimensioni degli array siano compatibili o che almeno una delle dimensioni sia 1.
Facciamo un esempio di broadcasting possibile:
import numpy as np
# Array con dimensioni compatibili per il broadcasting
arr1 = np.array([[1, 2, 3], [4, 5, 6]]) # shape: (2, 3)
arr2 = np.array([10, 20, 30]) # shape: (3,)
# Broadcasting possibile: arr2 viene esteso a [(10, 20, 30), (10, 20, 30)]
result = arr1 + arr2
E un esempio di broadcasting non possibile:
import numpy as np
# Array con dimensioni non compatibili per il broadcasting
arr1 = np.array([[1, 2, 3], [4, 5, 6]]) # shape: (2, 3)
arr2 = np.array([10, 20]) # shape: (2,)
# Broadcasting non possibile: le dimensioni non sono compatibili
result = arr1 + arr2 # Genera un errore
Migliora le tue capacità di programmazione Python seguendo il nostro corso in diretta!
Compatibilità tra array
Nel caso del broadcasting in NumPy, se si sa che potrebbero verificarsi degli errori a causa di dimensioni non compatibili degli array, utilizzare un blocco try ed except può essere un modo per gestire elegantemente queste situazioni.
Ecco di seguito un esempio di come gestire l’eccezione:
import numpy as np
arr1 = np.array([[1, 2, 3], [4, 5, 6]]) # Dimensione: (2, 3)
arr2 = np.array([[7, 8, 9]]) # Dimensione: (1, 2)
try:
result = arr1 + arr2
print("Risultato dell'addizione:", result)
except ValueError as e:
print("Errore durante il broadcasting:", e)
In questo esempio se il broadcasting non è possibile, verrà generato un errore di ValueError durante l’operazione e verrà stampato un messaggio di errore personalizzato.
Conclusioni
Questo articolo ha fornito una panoramica del concetto di broadcasting in NumPy, spiegando quando può essere applicato e quali sono le regole che lo caratterizzano. In particolare abbiamo visto che consente di eseguire operazioni aritmetiche tra array di forme diverse ma compatibili in modo efficiente e intuitivo, eliminando la necessità di espandere manualmente gli array per renderli compatibili.
È un concetto fondamentale in NumPy che rende il codice più conciso ed efficiente, contribuendo così a una migliore gestione e manipolazione dei dati multidimensionali. Comprendere il broadcasting è essenziale per sfruttare appieno le potenzialità di NumPy nell’analisi numerica e scientifica in Python.
Dunque, il broadcasting rappresenta uno strumento potente per eseguire operazioni su dati multidimensionali in modo rapido e intuitivo, contribuendo così a semplificare e ottimizzare il processo di sviluppo e analisi dei dati in Python.
In questa lezione eseguiremo le operazioni aritmetiche con gli array e NumPy in Python. L’obiettivo sarà dunque quello di applicare queste operazioni su array unidimensionali, bidimensionali e multidimensionali.
Operazioni aritmetiche con gli array Numpy unidimensionali
Innanzitutto creiamo due array unidimensionali, della stessa dimensione usando np.array:
import numpy as np
# Creazione di due array
arr1 = np.array([1, 2, 3, 4, 5])
arr2 = np.array([6, 7, 8, 9, 10])
Dopo, eseguiamo l’addizione dei due array:
# Addizione di due array
result_addition = arr1 + arr2
print("Addizione:", result_addition)
In output visualizziamo: Addizione:[ 7 9 11 13 15 ]
Quindi, eseguiamo adesso la sottrazione:
# Sottrazione di due array
result_subtraction = arr1 - arr2
print("Sottrazione:", result_subtraction)
In output visualizziamo dunque: Sottrazione: [-5 -5 -5 -5 -5]
Poi, eseguiamo la moltiplicazione tra i due array:
# Moltiplicazione di due array
result_multiplication = arr1 * arr2
print("Moltiplicazione:", result_multiplication)
In output visualizziamo: Moltiplicazione: [ 6 14 24 36 50]
Eseguiamo anche la divisione:
# Divisione di due array
result_division = arr2 / arr1
print("Divisione:", result_division)
Operazioni aritmetiche con gli array Numpy multidimensionali
Allo stesso modo si svolgono tali operazioni sia con gli array bidimensionali sia con quelli multidimensionali della stessa dimensione.
Creiamo dunque due array bidimensionali:
import numpy as np
# Creazione di due array bidimensionali
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[7, 8, 9], [10, 11, 12]])
Le operazioni aritmetiche si eseguono allo stesso modo:
# Addizione di due array bidimensionali
result_addition = arr1 + arr2
print("Addizione:")
print(result_addition)
# Sottrazione di due array bidimensionali
result_subtraction = arr1 - arr2
print("Sottrazione:")
print(result_subtraction)
# Moltiplicazione di due array bidimensionali
result_multiplication = arr1 * arr2
print("Moltiplicazione:")
print(result_multiplication)
# Divisione di due array bidimensionali
result_division = arr1 / arr2
print("Divisione:")
print(result_division)
# Potenza di due array bidimensionali
result_power = arr1 ** arr2
print("Potenza:")
print(result_power)
Operazioni aritmetiche con array Numpy di dimensioni diverse
Può capitare anche che gli array non abbiamo la stessa dimensione, ma che siano compatibili. Quando eseguiamo operazioni aritmetiche con array di dimensioni diverse in NumPy ma che oddisfano determinate condizioni, il broadcasting può essere applicato automaticamente. Il broadcasting è un meccanismo che consente a NumPy di eseguire operazioni tra array con forme diverse, rendendo le dimensioni compatibili per l’operazione.
Nella prossima lezione approndiremo in dettaglio questo argomento.
Migliora le tue capacità di programmazione Python seguendo il nostro corso in diretta!
Conclusioni
In questa lezione, abbiamo esplorato le operazioni aritmetiche di base su array NumPy della stessa dimensione e array di dimensione diverse. NumPy offre un modo potente ed efficiente per eseguire operazioni matematiche su array unidimensionali, bidimensionali e multidimensionali, che sono essenziali per l’analisi numerica e scientifica in Python. Siamo in grado di eseguire facilmente operazioni come addizione, sottrazione, moltiplicazione, divisione e potenza su array della stessa dimensione utilizzando NumPy. È importante controllare attentamente le dimensioni degli array quando si eseguono operazioni aritmetiche, specialmente quando si lavora con array multidimensionali per evitare errori. Nelle prossime lezioni vedremo come fare.
In questa lezione parleremo dell’installazione di NumPy. Infatti, per poter utilizzare questa libreria, occorre innanzitutto assicurarci di averla installata nel nostro ambiente di sviluppo Python. Se ancora non abbiamo provveduto con l’installazione, possiamo procedere utilizzando pip, ovvero il noto gestore dei pacchetti di Python.
Per verificare se NumPy non è installato nel nostro ambiente Python, possiamo dunque eseguire il seguente comando in una shell o nel terminale del nostro sistema operativo:
pip show numpy
Se NumPy non è installato, riceveremo, nel nsotro caso, un messaggio di errore che indica che il pacchetto non è stato trovato.
Altrimenti, possiamo anche utilizzare il comando import direttamente in un file o ambiente Python. Ad esempio, possiamo aprire un interprete Python e provare ad importare NumPy:
import numpy
Se NumPy non è installato, riceveremo, in questo caso, un errore di importazione che indica che il modulo non può essere trovato.
Questi presentati sono due modi comuni per verificare se NumPy è installato nel nostro sistema.
Migliora le tue capacità di programmazione Python seguendo il nostro corso in diretta!
Installazione NumPy
Se NumPy non è installato nel sistema, possiamo dunque eseguire il seguente comando nel nostro terminale o prompt dei comandi:
pip install numpy
Attendiamo che l’installazione sia completa e iniziamo a lavorare con questa importante libreria di Python!
Creazione di array unidimensionali con NumPy
Dopo l’installazione di NumPy, possiamo iniziare a utilizzarlo nei nostri script Python. Ecco un esempio di come importare NumPy e utilizzarlo per eseguire operazioni di base, dopo la sua installazione:
import numpy as np
# Creazione di un array unidimensionale (vettore)
arr = np.array([1, 2, 3, 4, 5])
print("Array creato:", arr)
In questo esempio, abbiamo importato NumPy utilizzando l’alias np per convenienza. Abbiamo quindi creato un array unidimensionale utilizzando la funzione np.array().
Creazione di array bidimensionali con NumPy
In questo esempio creiamo un array bidimensionale (matrice), ovvero un array che ha due dimensioni (righe e colonne), utilizzando la funzione np.array().
import numpy as np
# Creazione di un array bidimensionale (matrice)
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("Array bidimensionale (matrice):")
print(arr2d)
Definizione di matrice
Ricordiamo la definizione di matrice:
Una matrice è una struttura dati bidimensionale composta da righe e colonne di elementi, organizzati in una griglia rettangolare. Ogni elemento della matrice è identificato da due indici: l’indice della riga e l’indice della colonna.
Formalmente, una matrice è una collezione rettangolare di numeri, simboli o espressioni, disposti in righe e colonne, come:
dove m rappresenta il numero di righe ed n rappresenta il numero di colonne. Gli elementi della matrice sono denotati con aij, dove i rappresenta l’indice della riga e j rappresenta l’indice della colonna.
Le matrici sono ampiamente utilizzate in vari campi, tra cui matematica, fisica, informatica e ingegneria, per rappresentare dati strutturati in modo tabulare, risolvere sistemi di equazioni lineari, eseguire trasformazioni geometriche, elaborare immagini e altro ancora. In algebra lineare, le matrici sono oggetti fondamentali utilizzati per rappresentare trasformazioni lineari e risolvere una vasta gamma di problemi.
In Python possiamo definire una matrice A utilizzando una lista di liste in Python, dove ogni lista interna rappresenta una riga della matrice. Utilizzando un ciclo for, la matrice viene poi visualizzata stampando ogni riga separatamente.
# Definizione di una matrice in Python
A = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
# Visualizzazione della matrice
print("Matrice A:")
for row in A:
print(row)
La visualizzazione della matrice apparirà in questo modo:
Matrice A:
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
Creazione di array multidimensionali con NumPy
In questo esempio creiamo un array multidimensionale (tensor) utilizzando la funzione np.array().
import numpy as np
# Creazione di un array multidimensionale (tensor)
arr3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]])
print("Array multidimensionale (tensor):")
print(arr3d)
Definizione di tensore
Un tensore è una generalizzazione delle matrici e dei vettori che può avere più di due indici per identificare i suoi elementi. In altre parole, un tensore è un’entità matematica che generalizza i concetti di scalare, vettore e matrice in spazi di dimensioni superiori. I tensori sono ampiamente utilizzati in vari campi, tra cui fisica, ingegneria, informatica e machine learning, per rappresentare e manipolare dati multidimensionali.
Definizione formale: Formalmente, un tensore di ordine n è una struttura dati multidimensionale che contiene n indici, e ogni elemento del tensore è identificato da un insieme di n indici. Ad esempio, un tensore di ordine 1 è un vettore, un tensore di ordine 2 è una matrice, e un tensore di ordine superiore a 2 è un tensore multidimensionale.
Utilizzo: I tensori sono utilizzati per rappresentare dati di diversa natura, come:
Immagini e video, dove ogni pixel può essere rappresentato come un tensore multidimensionale.
Dati sensoriali, come segnali audio o dati provenienti da sensori.
Dati strutturati e non strutturati in analisi dei dati e machine learning.
Campi vettoriali e tensoriali in fisica e ingegneria, come lo spazio-tempo nella teoria della relatività.
Modelli e parametri in reti neurali e deep learning.
I tensori sono una componente chiave in molti algoritmi e applicazioni avanzate, come il riconoscimento di immagini, la classificazione del testo, il riconoscimento del linguaggio naturale e altro ancora. La loro flessibilità e potenza li rendono uno strumento fondamentale in numerosi campi della scienza e dell’ingegneria.
In Python, i tensori sono comunemente rappresentati e manipolati utilizzando la libreria TensorFlow, che è stata sviluppata da Google per il machine learning e altre applicazioni che coinvolgono calcoli su tensori. TensorFlow offre un’interfaccia user-friendly per la creazione, l’analisi e l’elaborazione di tensori multidimensionali in modo efficiente e ottimizzato per la GPU.
In questa lezione abbiamo parlato dell’installazione di NumPy e come effettuare le prime creazioni di array unidimensionali, bidimensionali (matrici) e multidimensionali (tensor) utilizzando np.array. Nelle prossima lezione impararemo a svolgere le operazioni con gli array in NumPy.
Commenti recenti