Come usare la funzione linspace() di NumPy

NumPy è un pacchetto fondamentale nell’ecosistema della data science in Python, che offre un’ampia gamma di funzioni per manipolare in modo efficiente i dati numerici. Tra queste, la funzione linspace() è spesso usata per generare valori equidistanti su un intervallo specificato, risultando uno strumento utile per attività che richiedono intervalli numerici precisi, come la visualizzazione dei dati e la modellazione matematica. In questo tutorial, ti mostrerò tutti i dettagli della funzione linspace().

La risposta breve: come usare np.linspace()

Se hai fretta, ecco la spiegazione più rapida della funzione linspace(). La funzione linspace() di NumPy genera un array di numeri equidistanti su un intervallo definito. Qui, per esempio, creiamo un array che parte da 0 e finisce a 100, con un intervallo di 5 numeri. Come ti aspetti, restituisce un array con [0, 25, 75, 100].

import numpy as np

# Basic usage of linspace to create an array from 0 to 100 with 5 elements
linspace_example = np.linspace(0, 100.0, 5)
linspace_example # Return example

# Output: array([  0.,  25.,  50.,  75., 100.])
Offerto da

Perché usare la funzione linspace() di NumPy?

La funzione linspace() è un metodo semplice ed efficiente per generare valori a spaziatura lineare, offrendo una soluzione utile in vari scenari in cui servono intervalli numerici specifici, come nella visualizzazione dei dati, nelle simulazioni e persino nella messa a punto di algoritmi. Ecco alcuni esempi di dove si può usare linspace():

• Attività di visualizzazione dei dati: Ad esempio, quando crei un grafico a linee per rappresentare la traiettoria di un satellite nel tempo, linspace() può essere usato per generare gli intervalli temporali a cui vengono campionati i dati di posizione, garantendo una linea fluida e continua nel grafico.
• Simulazioni: Nel modeling finanziario, per valutare l’impatto di tassi di interesse variabili sul prezzo delle obbligazioni, linspace() può produrre un intervallo di tassi d’interesse dal minimo possibile al massimo previsto, consentendo un’analisi completa su tutto lo spettro.
• Ricerca scientifica: Studiando gli effetti del riscaldamento globale sulle calotte polari, i ricercatori potrebbero usare linspace() per creare una serie di intervalli temporali equidistanti nell’arco di più decenni. A ogni intervallo, potrebbero simulare l’aumento medio della temperatura globale e il suo impatto sui tassi di scioglimento dei ghiacci.

Sintassi e utilizzo di NumPy linspace() con esempi

Come accennato, la funzione linspace() crea valori a spaziatura lineare, utili per varie computazioni numeriche. Prima di vedere gli esempi, diamo un’occhiata ai diversi argomenti che puoi usare con linspace().

Argomenti di NumPy linspace()

• start: Il valore iniziale della sequenza.
• stop: Il valore finale della sequenza.
• num (opzionale): L’intervallo specificato. Il valore predefinito è 50 e deve essere non negativo.
• endpoint (opzionale): Se True (predefinito), stop è l’ultimo campione. Se False, il valore di stop non è incluso nella sequenza generata da linspace(). Questo significa che la funzione creerà campioni equidistanti all’interno dell’intervallo da start fino a poco prima di stop, escludendo di fatto lo stesso valore di stop dalla sequenza. Può essere utile quando ti serve un intervallo che si avvicina ma non raggiunge l’estremo, permettendo un controllo più flessibile sui valori generati.
• retstep (opzionale): Se True, restituisce (samples, step), dove step è la distanza tra i campioni.
• dtype (opzionale): Il tipo dell’array in output. Se non specificato, il dtype verrà determinato dagli argomenti start e stop.
• axis (opzionale): L’asse del risultato in cui memorizzare i campioni, solo quando si lavora con array multidimensionali.

Creare array monodimensionali con linspace()

Ora che abbiamo compreso bene gli argomenti disponibili in linspace(), vediamo alcuni esempi pratici!

Creare un array monodimensionale equidistante usando linspace()

Questo esempio crea un array di 7 numeri equidistanti tra 0 e 10.

import numpy as np

# Create an array of 7 evenly spaced elements from 0 to 10
uniform_array = np.linspace(0, 10, num=7)
print("Uniform Array")
uniform_array
Offerto da

Uniform Array
array([ 0., 1.66666667, 3.33333333, 5., 6.66666667,8.33333333, 10.])
Offerto da

Escludere l’endpoint in un array monodimensionale equidistante usando linspace()

In questo caso, generiamo un array di 8 numeri tra 10 e 20, ma escludiamo il valore finale (20) dall’array, mostrando l’argomento endpoint in azione.

import numpy as np


# Create an array of 8 elements from 10 to 20, excluding 20
exclude_final_array = np.linspace(10, 20, num=8, endpoint=False)
print("Array Excluding Final Value")
exclude_final_array
Offerto da

Array Excluding Final Value
array([10. , 11.25, 12.5 , 13.75, 15. , 16.25, 17.5 , 18.75])
Offerto da

Includere la dimensione del passo in un array monodimensionale equidistante usando linspace()

Qui creiamo un array di 4 elementi tra -5 e 5. Inoltre, acquisciamo e mostriamo la dimensione del passo.

import numpy as np


# Create an array of 4 elements from -5 to 5 and capture the step size
step_array, step = np.linspace(-5, 5, num=4, retstep=True)
print("Array with Defined Step Size", step_array)
print("Step Size", step)Offerto da

Array with Defined Step Size [-5.         -1.66666667  1.66666667  5.        ]
Step Size 3.3333333333333335
Offerto da

Creare array N-dimensionali con linspace()

linspace() è utile anche per generare array multidimensionali. Qui mostriamo alcuni esempi pratici.

Generare un array bidimensionale usando linspace()

Questo esempio illustra come generare un array 2D in cui ogni riga passa gradualmente dal vettore [0, 10] a [5, 15], creando un effetto gradiente in 4 passaggi.

import numpy as np


# Perform column-wise linear interpolation from [10, 20] to [15, 25] over 3 steps
column_interpolation_array = np.linspace([10, 20], [15, 25], num=3, axis=1)
print("Column-wise Interpolation Array:")
print(column_interpolation_array)Offerto da

Column-wise Interpolation Array:
[[10.  12.5 15. ]
 [20.  22.5 25. ]]
Offerto da

Alternative a linspace() di NumPy

Sebbene linspace() sia molto utile, esistono alternative da considerare, come la funzione arange() di NumPy e le list comprehension.

Usare la funzione arange() di NumPy

La funzione arange() genera valori all’interno di un dato intervallo. A differenza di linspace(), si specifica la distanza tra i valori invece del numero di valori.

# Using arange to generate values from 0 to 10, spaced by 2
arange_example = np.arange(0, 10, 2)
arange_example

# Returns array([0, 2, 4, 6, 8])

# Using linspace() to generate values from 0 to 10, with interval set to 2
linspace_example = np.linspace(0, 10, 2)
linspace_example

# Returns array([0.,10.0])
Offerto da

Usare le list comprehension

Le list comprehension offrono un modo più pythonic di generare liste, anche se non hanno i vantaggi di vettorizzazione e la flessibilità di NumPy linspace().

list_comp = [x for x in range(10)]
print(list_comp)

# Outputs [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]Offerto da

Considerazioni finali

La funzione linspace() di NumPy è uno strumento fondamentale nella cassetta degli attrezzi della data science, che offre precisione e flessibilità nella generazione di sequenze numeriche. Se vuoi rafforzare le tue competenze in NumPy, dai un’occhiata a questo tutorial sugli array NumPy, a questo cheat sheet su NumPy o valuta di iscriverti al nostro corso Introduction to NumPy.