Denna handledning kommer att lära dig hur du använder NumPy linspace() för att skapa en array med jämnt fördelade tal i Python.
Du kommer att lära dig syntaxen för NumPy linspace(), följt av exempel som hjälper dig att förstå hur du använder det.
Obs: För att följa med i denna handledning måste du ha Python och NumPy installerade.
Har du inte NumPy än? Vi har sammanställt en snabb installationsguide åt dig.
Låt oss börja!
Innehållsförteckning
Installera och importera NumPy
Innan vi startar handledningen, låt oss snabbt gå igenom stegen för att installera NumPy-biblioteket.
⏩ Om du redan har NumPy installerat, hoppa gärna till nästa avsnitt.
- Om du använder Google Colab – en molnbaserad Jupyter-anteckningsbokmiljö, kan du importera NumPy och börja koda direkt. (rekommenderas för denna handledning ✅)
- Om du vill ställa in en lokal arbetsmiljö rekommenderar jag att du installerar Anaconda-distributionen av Python. Anaconda kommer med flera användbara paket förinstallerade. Du kan ladda ner installationsprogrammet för ditt operativsystem. Installationsprocessen tar bara några minuter.⌛
- Om du redan har Python installerat på din dator kan du fortfarande installera Anaconda-distributionen. Du kan använda conda eller pip för att installera och hantera paket. Du kan köra ett av följande kommandon från Anacondas kommandotolk för att installera NumPy.
# Install NumPy using conda conda install numpy # Install NumPy using pip pip install numpy
Som ett nästa steg, importera numpy under aliaset np genom att köra följande kommando. Genom att göra detta kommer du att hänvisa till NumPy som np—utan att behöva skriva ner numpy varje gång du kommer åt ett objekt i modulen.
import numpy as np
Framöver kommer vi att använda punktnotationen för att komma åt alla funktioner i NumPy-biblioteket så här: np.
Fallet för jämnt fördelade nummer
När du arbetar med NumPy-matriser finns det tillfällen då du behöver skapa en matris med jämnt fördelade nummer i ett intervall.
Innan vi går vidare, låt oss snabbt gå igenom en annan liknande funktion np.arange().
NumPy linspace() kontra NumPy arange()
Om du har använt NumPy tidigare, skulle du sannolikt ha använt np.arange() för att skapa en array av tal inom ett specificerat intervall.
Du vet att np.arange(start, stop, step) returnerar en array av tal från start upp till men inte inklusive stopp, i steg i steg; standardstegstorleken är 1.
Men värdet av steg kanske inte alltid är uppenbart. Låt oss se varför det är så.
Till exempel, om du behöver 4 jämnt fördelade nummer mellan 0 och 1, vet du att stegstorleken måste vara 0,25. Men om du använder np.arange() inkluderar det inte stoppvärdet 1. Så du måste välja ett intervall som går utöver stoppvärdet.
Följande bild illustrerar ytterligare några exempel där du behöver ett specifikt antal jämnt fördelade punkter i intervallet [a, b].
Jämnt fördelade punkter i ett intervall
Vårt första exempel på 4 jämnt fördelade punkter in [0,1] var lätt nog. Du vet att stegstorleken mellan punkterna ska vara 0,25.
Anta att du har ett lite mer involverat exempel – där du var tvungen att lista 7 jämnt fördelade punkter mellan 1 och 33. Här kanske stegstorleken inte är särskilt tydlig direkt. Du kan dock räkna ut värdet av steg manuellt i detta fall.
Men np.linspace() är här för att göra det ännu enklare för dig! 😄
Använd NumPy linspace
När du använder np.linspace() behöver du bara ange antalet punkter i intervallet – utan att oroa dig för stegstorleken. Och du får tillbaka arrayen som du vill.
Med denna motivering, låt oss fortsätta att lära oss syntaxen för NumPy linspace() i nästa avsnitt.
Syntax för NumPy linspace()
Syntaxen för att använda NumPy linspace() visas nedan:
np.linspace(start, stop, num, endpoint, retstep, dtype, axis)
Till en början kan ovanstående syntax verka mycket komplicerad med många parametrar.
De flesta av dem är dock valfria parametrar, och vi kommer fram till en mycket enklare syntax på bara ett par minuter.
Låt oss nu börja med att analysera ovanstående syntax:
- start och stopp är start- och slutpunkterna för intervallet. Både start och stopp kan vara skalärer eller arrayer. Vi kommer att begränsa oss till skalära start- och slutvärden i denna handledning.
- num är antalet jämnt fördelade punkter. Och det är en valfri parameter med ett standardvärde på 50.
- endpoint är också en valfri parameter som kan vara antingen True eller False.
- Standardvärdet är True, vilket innebär att slutpunkten kommer att inkluderas i intervallet som standard. Du kan dock ställa in den på False för att utesluta slutpunkten.
- retstep är ytterligare en valfri parameter som tar booleanerna True eller False. När den är inställd på True returneras stegvärdet.
- dtype är datatypen för talen i arrayen. Typen antas vanligtvis som flytande och behöver inte anges uttryckligen.
- axel är en annan valfri parameter som anger den axel längs vilken siffrorna ska lagras. Och detta är endast relevant när start- och stoppvärdena själva är arrayer.
▶️ Så vad returnerar np.linspace()?
Den returnerar en N-dimensionell matris med jämnt fördelade tal. Och om parametern retstep är satt till True, returnerar den också stegstorleken.
Baserat på diskussionen hittills, här är en förenklad syntax för att använda np.linspace():
np.linspace(start, stop, num)
Ovanstående kodrad kommer att returnera en matris med antal jämnt fördelade nummer i intervallet [start, stop].
Nu när du känner till syntaxen, låt oss börja koda exempel.
Hur man skapar jämnt fördelade matriser med NumPy linspace()
#1. Som vårt första exempel, låt oss skapa en matris med 20 jämnt fördelade nummer i intervallet [1, 5].
Du kan ange värdena för start, stop och num som nyckelordsargument. Detta visas i kodcellen nedan:
import numpy as np arr1 = np.linspace(start = 1,stop = 5,num = 20) print(arr1) # Output: [1. 1.21052632 1.42105263 1.63157895 1.84210526 2.05263158 2.26315789 2.47368421 2.68421053 2.89473684 3.10526316 3.31578947 3.52631579 3.73684211 3.94736842 4.15789474 4.36842105 4.57894737 4.78947368 5. ]
Lägg märke till hur siffrorna i arrayen börjar på 1 och slutar på 5 – inklusive båda slutpunkterna. Observera också hur talen, inklusive punkterna 1 och 5, representeras som flytande i den returnerade matrisen.
#2. I föregående exempel hade du angett värdena för start, stop och num som nyckelordsargument. Om du skickar in argumenten i rätt ordning kan du lika gärna använda dem som positionsargument med endast värdena, som visas nedan.
import numpy as np arr2 = np.linspace(1,5,20) print(arr2) # Output: [1. 1.21052632 1.42105263 1.63157895 1.84210526 2.05263158 2.26315789 2.47368421 2.68421053 2.89473684 3.10526316 3.31578947 3.52631579 3.73684211 3.94736842 4.15789474 4.36842105 4.57894737 4.78947368 5. ]
#3. Låt oss nu skapa en annan array där vi sätter retstep till True.
Det betyder att funktionen nu kommer att returnera både matrisen och steget. Och vi kan packa upp dem i två variabler arr3: arrayen och step_size: den returnerade stegstorleken.
Följande kodcell förklarar hur du kan göra det.
import numpy as np arr3, step_size = np.linspace(1,5,20,retstep = True) print(arr3) # Output: [1. 1.21052632 1.42105263 1.63157895 1.84210526 2.05263158 2.26315789 2.47368421 2.68421053 2.89473684 3.10526316 3.31578947 3.52631579 3.73684211 3.94736842 4.15789474 4.36842105 4.57894737 4.78947368 5. ] # Output: print(step_size) 0.21052631578947367
#4. Som ett sista exempel, låt oss ställa in endpoint till False och kontrollera vad som händer.
import numpy as np arr4 = np.linspace(1,5,20,endpoint = False) print(arr4) # Output: [1. 1.2 1.4 1.6 1.8 2. 2.2 2.4 2.6 2.8 3. 3.2 3.4 3.6 3.8 4. 4.2 4.4 4.6 4.8]
I den returnerade arrayen kan du se att 1 ingår, medan 5 inte ingår. Och det sista värdet i arrayen råkar vara 4,8, men vi har fortfarande 20 nummer.
Hittills har vi bara genererat arrayer med jämnt fördelade nummer. I nästa avsnitt, låt oss visualisera genom att plotta dessa siffror.
Hur man ritar jämnt fördelade nummer i ett intervall
Låt oss välja i det här avsnittet [10,15] som intresseintervall. Och använd sedan np.linspace() för att generera två arrayer, var och en med 8 respektive 12 punkter.
När detta är klart kan vi använda plottningsfunktionen från matplotlib-biblioteket för att plotta dem.
För tydlighetens skull kommer vi att klämma fast de två arrayerna med N1 = 8 och N2 = 12 jämnt fördelade punkter på olika positioner längs y-axeln.
Följande kodavsnitt visar detta.
import numpy as np
import matplotlib.pyplot as plt
N1 = 8
N2 = 12
a = 10
b = 15
y1 = np.zeros(N1)
y2 = np.zeros(N2)
x1 = np.linspace(a, b, N1)
x2 = np.linspace(a, b, N2)
plt.plot(x1, y1-0.5, 'o')
plt.plot(x2, y2 + 0.5, 'o')
plt.ylim([-1, 1])
plt.title(f'Evenly Spaced Numbers in the Interval [{a},{b}]')
plt.xlabel('Interval')
plt.show()
Att generera jämnt fördelade punkter kan vara till hjälp när man arbetar med matematiska funktioner. Vi kommer att lära oss om det i nästa avsnitt.
Hur man använder NumPy linspace() med matematiska funktioner
Efter att du har genererat en matris med jämnt fördelade tal med hjälp av np.linspace(), kan du beräkna värdena för matematiska funktioner i intervallet.
I kodcellen nedan genererar du först 50 jämnt fördelade punkter i intervallet 0 till 2π. Och skapa sedan arrayen y med np.sin() på arrayen x. Observera att du kan hoppa över parametern num, eftersom standardvärdet är 50. Vi kommer fortfarande att använda det explicit.
Som nästa steg kan du plotta sinusfunktionen i intervallet [0, 2π]. För att göra detta kan du använda matplotlib, som i föregående exempel. Specifikt används plot()-funktionen i matplotlib.pytplot för att skapa en linjeplot.
import numpy as np
import matplotlib.pyplot as plt
N = 50
a = 0.0
b = 2*np.pi
x = np.linspace(a, b, N)
y = np.sin(x)
plt.plot(x, y, marker = "o")
plt.ylim([-1, 1])
plt.title(f'y = sin(x)')
plt.xlabel('x ---->')
plt.show()
Kör nu ovanstående kod genom att sätta N lika med 10. Du får plotten som visas i figuren nedan.
Och du kan se att handlingen inte är särskilt jämn – eftersom du bara har plockat 10 poäng i intervallet.
Generellt gäller att ju fler poäng du tänker på, desto jämnare blir plotten av funktionen.
Slutsats
Här är en sammanfattning av vad vi har lärt oss.
- np.linspace(start, stop, num) returnerar en matris med antal jämnt fördelade tal i intervallet [start, stop].
- Ställ in den valfria parameterändpunkten på False för att utesluta stopp och ställ in intervallet på[startstopp)[startstop)
- Ställ in retstep på True valfritt för att få stegstorleken.
- Generera jämnt fördelade arrayer med np.linspace(), och använd sedan arrayen med matematiska funktioner.
Jag hoppas att du nu förstår hur np.linspace() fungerar. Du kan välja att köra ovanstående exempel i Jupyter-anteckningsboken. Kolla in vår guide om Jupyter notebook, eller andra Jupyter-alternativ du kan överväga.
Vi ses snart i en annan Python-tutorial. Tills dess, fortsätt att koda!😀