Hoe gebruik je de NumPy-functie linspace()

NumPy is een essentiële package in het Python-data-ecosysteem, met een brede reeks functies om numerieke data efficiënt te bewerken. Daaronder wordt de functie linspace() vaak gebruikt om gelijkmatig verdeelde waarden over een opgegeven interval te genereren. Dat maakt het een handig hulpmiddel voor taken die precieze numerieke bereiken vereisen, zoals datavisualisatie en wiskundige modellering. In deze tutorial laat ik je alle ins en outs van de functie linspace() zien.

Het korte antwoord: zo gebruik je np.linspace()

Heb je haast? Hier is de snelste uitleg van de functie linspace(). De linspace()-functie van NumPy genereert een array met gelijkmatig verdeelde getallen over een gedefinieerd interval. Hier maken we bijvoorbeeld een array die begint bij 0 en eindigt bij 100, verdeeld over een interval van 5 getallen. Zoals je mag verwachten, retourneert dit een array met [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.])
Mogelijk gemaakt door

Waarom de linspace()-functie van NumPy gebruiken?

De functie linspace() is een eenvoudige en efficiënte methode om lineair verdeelde waarden te genereren. Ze biedt een handige oplossing voor allerlei scenario’s waarin specifieke numerieke bereiken nodig zijn, zoals bij datavisualisatie, simulaties en zelfs het fijnregelen van algoritmes. Hier zijn een paar voorbeelden waar linspace() kan worden gebruikt:

• Datavisualisatie: Bijvoorbeeld: bij het maken van een lijngrafiek om de baan van een satelliet in de tijd weer te geven, kun je met linspace() de tijdsintervallen genereren waarop de positiedata worden bemonsterd. Zo krijg je een vloeiende, aaneengesloten lijn in de grafiek.
• Simulaties: In financiële modellering, om de impact van variërende rentestanden op obligatieprijzen te beoordelen, kan linspace() een bereik aan rentepercentages genereren van het laagst mogelijke tot het hoogst verwachte niveau, zodat je een volledige analyse over het hele spectrum kunt uitvoeren.
• Wetenschappelijk onderzoek: Bij het bestuderen van de effecten van opwarming van de aarde op de poolijskappen kunnen onderzoekers linspace() gebruiken om een reeks gelijkmatig verdeelde tijdsintervallen over meerdere decennia te creëren. Op elk interval kunnen ze de gemiddelde stijging van de mondiale temperatuur en de impact daarvan op het smelten van ijs simuleren.

NumPy linspace() syntaxis en gebruik met voorbeelden

Zoals eerder genoemd, maakt de functie linspace() lineair verdeelde waarden aan, wat nuttig is voor diverse numerieke berekeningen. Voordat we in de voorbeelden duiken, bekijken we de verschillende argumenten die je kunt gebruiken met linspace().

Argumenten van NumPy linspace()

• start: De beginwaarde van de reeks.
• stop: De eindwaarde van de reeks.
• num (optioneel): Het opgegeven interval. De standaardwaarde is 50 en het moet niet-negatief zijn.
• endpoint (optioneel): Als True (standaard), is stop de laatste waarde. Als False, wordt de stopwaarde niet opgenomen in de door linspace() gegenereerde reeks. Dit betekent dat de functie gelijkmatig verdeelde samples maakt binnen het bereik van start tot net vóór stop, waarbij de stopwaarde zelf dus wordt uitgesloten. Dit kan handig zijn als je een bereik nodig hebt dat het eindpunt benadert maar niet bereikt, zodat je flexibeler controle hebt over het gegenereerde waardebereik.
• retstep (optioneel): Als True, retourneert (samples, step), waarbij step de afstand tussen de samples is.
• dtype (optioneel): Het type van de uitvoerarray. Als dit niet is opgegeven, wordt de dtype bepaald door de argumenten start en stop.
• axis (optioneel): De as in het resultaat waarin de samples worden opgeslagen, alleen relevant bij multidimensionale arrays.

Eendimensionale arrays maken met linspace()

Nu we de argumenten van linspace() goed begrijpen, gaan we kijken naar een paar voorbeelden in de praktijk!

Een gelijkmatig verdeelde eendimensionale array maken met linspace()

Dit voorbeeld maakt een array van 7 gelijkmatig verdeelde getallen tussen 0 en 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
Mogelijk gemaakt door

Uniform Array
array([ 0., 1.66666667, 3.33333333, 5., 6.66666667,8.33333333, 10.])
Mogelijk gemaakt door

Het eindpunt uitsluiten in een gelijkmatig verdeelde eendimensionale array met linspace()

In dit geval genereren we een array van 8 getallen tussen 10 en 20, maar sluiten we de laatste waarde (20) uit van de array. Zo zie je het endpoint-argument in actie.

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
Mogelijk gemaakt door

Array Excluding Final Value
array([10. , 11.25, 12.5 , 13.75, 15. , 16.25, 17.5 , 18.75])
Mogelijk gemaakt door

De stapgrootte opnemen in een gelijkmatig verdeelde eendimensionale array met linspace()

Hier maken we een array van 4 elementen tussen -5 en 5. We leggen ook de stapgrootte vast en tonen die.

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)Mogelijk gemaakt door

Array with Defined Step Size [-5.         -1.66666667  1.66666667  5.        ]
Step Size 3.3333333333333335
Mogelijk gemaakt door

N-dimensionale arrays maken met linspace()

linspace() is ook handig voor het genereren van multidimensionale arrays. Hieronder laten we een paar voorbeelden daarvan zien.

Een tweedimensionale array genereren met linspace()

Dit voorbeeld laat zien hoe je een 2D-array genereert waarbij elke rij soepel overgaat van de vector [0, 10] naar [5, 15], waarmee je over 4 stappen een verloop creëert.

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)Mogelijk gemaakt door

Column-wise Interpolation Array:
[[10.  12.5 15. ]
 [20.  22.5 25. ]]
Mogelijk gemaakt door

Alternatieven voor NumPy linspace()

Hoewel linspace() erg nuttig is, zijn er alternatieven het overwegen waard, zoals de functie arange() van NumPy en list comprehensions.

De NumPy-functie arange() gebruiken

De functie arange() genereert waarden binnen een gegeven interval. In tegenstelling tot linspace() specificeer je de afstand tussen de waarden in plaats van het aantal waarden.

# 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])
Mogelijk gemaakt door

List comprehensions gebruiken

List comprehensions bieden een meer Pythonic manier om lijsten te genereren, al missen ze de voordelen van vectorisatie en de flexibiliteit van NumPy linspace().

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

# Outputs [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]Mogelijk gemaakt door

Tot slot

De linspace()-functie van NumPy is een fundamenteel hulpmiddel in de data science-toolkit. Ze biedt precisie en flexibiliteit bij het genereren van numerieke reeksen. Wil je je NumPy-vaardigheden aanscherpen? Bekijk dan deze tutorial over NumPy-arrays, dit NumPy-cheat sheet, of schrijf je in voor onze Introduction to NumPy-cursus.