Generare array con valori predefiniti

Generare array con valori predefiniti

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.

Funzioni per generare di array in NumPy

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 i nostri corsi in diretta!

corsi Python

np.eye

np.eye: Crea una matrice identità con dimensioni specificate

import numpy as np

# Creazione di una matrice identità
identity_matrix = np.eye(3)  # Matrice identità 3x3
print(identity_matrix)

# Output:
# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]

np.diag

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.

Alcuni link utili

Corso in diretta su Python

Indice tutorial sul linguaggio Python

Introduzione alla programmazione ad oggetti

Come definire una classe in Python

Classi in Python

Metodi delle classi in Python

Calcolatrice in Python utilizzando le classi

Come aggiungere un numero random in un file che contiene dei numeri

Come creare matrici in Python

np.concatenate

np.concatenate

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.

np.concatenate lungo l’asse delle righe

Facciamo adesso un esempio di come utilizzare np.concatenate per concatenare due array lungo l’asse delle righe:

import numpy as np

array1 = np.array([[1, 2, 3],
                   [4, 5, 6]])
array2 = np.array([[7, 8, 9],
                   [10, 11, 12]])

concatenated_array = np.concatenate((array1, array2), axis=0)
print("Array concatenato lungo le righe:")
print(concatenated_array)

Questo esempio restituirebbe l’array concatenato lungo le righe:

Array concatenato lungo le righe:
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]

np.concatenate lungo l’asse delle colonne

Ecco un esempio di come utilizzare numpy.concatenate per concatenare lungo l’asse delle colonne:

import numpy as np

# Due array
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])

# Concatenazione lungo l'asse delle colonne
result = np.concatenate((arr1, arr2), axis=1)

print("Risultato della concatenazione:")
print(result)

Questo esempio restituirebbe l’array concatenato lungo le colonne:

Risultato della concatenazione:
[[1 2 5 6]
 [3 4 7 8]]

Migliora le tue capacità di programmazione Python seguendo i nostri corsi in diretta!

corsi Python

Considerazioni su np.concatenate

Ci sono alcune altre considerazioni da fare riguardo a np.concatenate:

  1. 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.
  2. 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.
  3. 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.
  4. Tipo di dato: np.concatenate preserverà il tipo di dato degli array di input nell’array risultante.
  5. Broadcasting: Se gli array hanno dimensioni diverse, NumPy eseguirà il broadcasting prima di concatenarli lungo l’asse specificato.
  6. 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.
  7. 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.

Alcuni link utili

Corso in diretta su Python

Indice tutorial sul linguaggio Python

Introduzione alla programmazione ad oggetti

Come definire una classe in Python

Classi in Python

Metodi delle classi in Python

Calcolatrice in Python utilizzando le classi

Come aggiungere un numero random in un file che contiene dei numeri

Come creare matrici in Python

Broadcasting

Broadcasting

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 i nostri corsi in diretta!

corsi Python

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:

  1. Le dimensioni degli array vengono confrontate da destra verso sinistra.
  2. 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.
  3. 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.
  4. 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

Esempio di broadcasting

Vediamo un esempio pratico di operazioni con array di dimensione diversa ma compatibile:

import numpy as np

# Creazione di un array unidimensionale e un array bidimensionale
arr1 = np.array([1, 2, 3])
arr2 = np.array([[4, 5, 6], [7, 8, 9]])

# Addizione con Broadcasting
result_addition = arr1 + arr2
print("Addizione con Broadcasting:")
print(result_addition)

# Sottrazione con Broadcasting
result_subtraction = arr1 - arr2
print("Sottrazione con Broadcasting:")
print(result_subtraction)

# Moltiplicazione con Broadcasting
result_multiplication = arr1 * arr2
print("Moltiplicazione con Broadcasting:")
print(result_multiplication)

# Divisione con Broadcasting
result_division = arr1 / arr2
print("Divisione con Broadcasting:")
print(result_division)

# Potenza con Broadcasting
result_power = arr1 ** arr2
print("Potenza con Broadcasting:")
print(result_power)

Per capire l’output, dobbiamo considerare come avviene il broadcasting tra gli array arr1 e arr2 per ciascuna operazione aritmetica.

Addizione con Broadcasting

Addizione con Broadcasting:
[[ 5  6  7]
 [ 8  9 10]]

In questo caso, arr1 viene esteso per corrispondere alla forma di arr2, diventando:

[[1 2 3]
 [1 2 3]]

Quindi l’addizione viene eseguita elemento per elemento tra arr1 e arr2.

L’output sarà il seguente:

Addizione con Broadcasting:
[[ 5 7 9]
[ 8 10 12]]

Sottrazione con Broadcasting

Anche in questo caso, arr1 viene esteso come nel caso precedente e la sottrazione viene eseguita elemento per elemento.

L’output sarà dunque il seguente:

Sottrazione con Broadcasting:
[[-3 -3 -3]
 [-6 -6 -6]]

Moltiplicazione con Broadcasting

Come per le operazioni precedenti, arr1 viene esteso per corrispondere alla forma di arr2 e la moltiplicazione viene eseguita elemento per elemento.

L’output sarà dunque il seguente:

Moltiplicazione con Broadcasting:
[[ 4 10 18]
 [ 7 16 27]]

Divisione con Broadcasting

Analogamente alle operazioni precedenti, arr1 viene esteso e la divisione viene eseguita elemento per elemento.

L’output sarà dunque il seguente:

Divisione con Broadcasting:
[[0.25 0.4  0.5 ]
 [0.14285714 0.25 0.33333333]]

Potenza con Broadcasting

Anche qui, arr1 viene esteso e la potenza viene calcolata elemento per elemento.

L’output sarà dunque il seguente:

Potenza con Broadcasting:
[[    1    32   729]
 [    1   256  19683]]

Migliora le tue capacità di programmazione Python seguendo i nostri corsi in diretta!

corsi Python

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.

Alcuni link utili

Corso in diretta su Python

Indice tutorial sul linguaggio Python

Introduzione alla programmazione ad oggetti

Come definire una classe in Python

Classi in Python

Metodi delle classi in Python

Calcolatrice in Python utilizzando le classi

Come aggiungere un numero random in un file che contiene dei numeri

Come creare matrici in Python

Operazioni aritmetiche con gli array Numpy

Operazioni aritmetiche con gli array Numpy

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)

In output visualizziamo dunque: Divisione: [6. 3.5 2.66666667 2.25 2. ]

Infine, eseguiamo la potenza tra i due array:

# Potenza di un array
result_power = arr1 ** 2
print("Potenza:", result_power)

In output visualizziamo: Potenza: [ 1 128 6561 262144 9765625]

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 i nostri corsi in diretta!

corsi Python

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.

Alcuni link utili

Corso in diretta su Python

Indice tutorial sul linguaggio Python

Introduzione alla programmazione ad oggetti

Come definire una classe in Python

Classi in Python

Metodi delle classi in Python

Calcolatrice in Python utilizzando le classi

Come aggiungere un numero random in un file che contiene dei numeri

Come creare matrici in Python

NumPy

NumPy

NumPy è una libreria Python essenziale per l’analisi numerica e scientifica. Il suo nome deriva da “Numerical Python” e fornisce supporto per la creazione, la manipolazione e l’operazione su array multidimensionali e matrici, insieme a una vasta collezione di funzioni matematiche ad alte prestazioni per operazioni vettoriali e matriciali.

Migliora le tue capacità di programmazione Python seguendo i nostri corsi in diretta!

corsi Python

Caratteristiche principali NumPy

Ecco dunque alcune delle caratteristiche principali di questa libreria:

  1. Array N-Dimensionali: Il concetto fondamentale in NumPy è l’array multidimensionale, noto come ndarray. Gli array NumPy possono avere qualsiasi numero di dimensioni e contengono elementi dello stesso tipo di dato, rendendoli ideali per rappresentare dati matriciali, immagini, suoni, serie temporali e altro ancora.
  2. Operazioni Vettoriali e Matriciali: NumPy offre una vasta gamma di funzioni per eseguire operazioni matematiche e statistiche sugli array. Queste operazioni, come la somma, la moltiplicazione e il calcolo delle statistiche, sono ottimizzate per le prestazioni e possono essere eseguite su array di grandi dimensioni in modo efficiente.
  3. Funzioni Matematiche: NumPy include inoltre numerose funzioni matematiche per operazioni comuni come trigonometria, algebra lineare, calcolo differenziale e integrale, generazione di numeri casuali e altro ancora. Queste funzioni sono progettate per lavorare con gli array NumPy e offrono prestazioni elevate.
  4. Broadcasting: NumPy supporta il broadcasting, un meccanismo che consente di eseguire operazioni tra array di diverse forme in modo automatico ed efficiente, senza la necessità di espandere gli array o trasmetterli.
  5. Integrazione con altre librerie: NumPy è comunemente utilizzato come base per molte altre librerie di analisi dati e scientifiche in Python, tra cui Pandas, SciPy e Matplotlib. Questa integrazione semplifica lo scambio di dati tra queste librerie e consente agli utenti di sfruttare le funzionalità specializzate di ciascuna libreria.

Conclusioni

Quindi, NumPy fornisce un’infrastruttura potente e flessibile per l’analisi numerica e scientifica in Python. È dunque diventato uno strumento fondamentale per ricercatori, scienziati dei dati e ingegneri che lavorano con dati numerici complessi. Offre una vasta gamma di funzionalità per manipolare, analizzare e visualizzare dati numerici in modo efficiente e potente.

Nei prossimi articoli scopriremo come installarlo ed effettueremo i primi esempi pratici.

Alcuni link utili

Corso in diretta su Python

Indice tutorial sul linguaggio Python

Introduzione alla programmazione ad oggetti

Definire una classe in Python

Classi in Python

Metodi delle classi in Python

Calcolatrice in Python utilizzando le classi

Come aggiungere un numero random in un file che contiene dei numeri

Ciclo for else

Ciclo for else

Il ciclo for … else in Python è un costrutto modo potente per gestire situazioni in cui si desidera eseguire un blocco di codice solo se il ciclo for è stato completato con successo, senza l’uso di un flag o variabile di controllo aggiuntiva.

Il costrutto for…else è particolarmente utile quando si desidera eseguire un’azione se un elemento è trovato o se il ciclo termina con successo, senza dover aggiungere complessità al codice utilizzando variabili di controllo aggiuntive.

Ecco come funziona:

for elemento in sequenza:
    # Blocco di codice del ciclo
    if condizione:
        # Codice da eseguire se la condizione è soddisfatta
        break
else:
    # Blocco di codice da eseguire se il ciclo è stato completato senza interruzioni

Quando il ciclo “for” viene eseguito senza interruzioni, il blocco di codice sotto “else” verrà eseguito. Se viene incontrata un’istruzione “break” all’interno del ciclo, il blocco di codice sotto “else” non verrà eseguito.

Primo esempio ciclo for else in Python

Ecco un esempio pratico per illustrare l’utilizzo del ciclo for … else:

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

for elemento in elenco:
    if elemento == 6:
        print("Numero trovato!")
        break
else:
    print("Numero non trovato!")

In questo esempio, se il numero 6 è presente nell’elenco, verrà stampato “Numero trovato!”. Altrimenti, verrà stampato “Numero non trovato!”.

Secondo esempio ciclo for else in Python

In questo secondo esempio verifichiamo se un numero è primo con il ciclo for else:

numero = 17

for i in range(2, numero // 2 + 1):
    if numero % i == 0:
        print(f"{numero} non è un numero primo.")
        break
else:
    print(f"{numero} è un numero primo.")

In questo esempio, il programma verifica se il numero dato è un numero primo. Se trova un divisore diverso da 1 e se stesso, il ciclo si interrompe e viene stampato un messaggio che indica che il numero non è primo. Se il ciclo termina senza interruzioni, viene stampato un messaggio che indica che il numero è primo.

Migliora le tue capacità di programmazione Python seguendo i nostri corsi in diretta!

corsi Python

Terzo esempio ciclo for else

In questo esempio verifichiamo se un numero è un quadrato perfetto:

numero = 25

for i in range(numero):
    if i * i == numero:
        print(f"{numero} è un quadrato perfetto.")
        break
else:
    print(f"{numero} non è un quadrato perfetto.")

Il ciclo for scorre tutti i numeri da 0 a numero - 1. Se trova un numero il cui quadrato è uguale a numero, allora il numero è un quadrato perfetto e il messaggio corrispondente viene stampato. Se il ciclo termina senza interruzioni, significa che il numero non è un quadrato perfetto e viene stampato un messaggio appropriato.

Conclusioni

Il costrutto for…else in Python consente di gestire situazioni in cui si desidera eseguire un blocco di codice solo se il ciclo for è stato completato con successo, senza la necessità di utilizzare flag o variabili di controllo aggiuntive.

Questo costrutto è particolarmente utile quando si desidera eseguire un’azione se un elemento è trovato durante l’iterazione o se il ciclo termina con successo senza interruzioni, aggiungendo un’eleganza e una chiarezza al codice senza introdurre complessità inutile.

Abbiamo esaminato diversi esempi di utilizzo del costrutto for…else, dal trovare un elemento in un elenco alla verifica se un numero è primo o un quadrato perfetto, dimostrandone l’efficacia nel semplificare il codice e migliorare la sua leggibilità.

Seguite le prossime lezioni per altri importanti argomenti del linguaggio Python e se volete approfondire vi suggerisco il libro avvincente “50 Algoritmi per imparare Python” disponibile su Amazon.

Alcuni link utili

Corso in diretta su Python

Le liste

Contare gli elementi di una lista con count

Tuple

Numeri random

Introduzione ai dizionari in Python

Ordinare un dizionario in Python

Operazioni con i file in Python

Python Sort

Introduzione alla programmazione ad oggetti