Ovaj vodič će vas uputiti kako da iskoristite NumPy funkciju `linspace()` za generisanje nizova sa ravnomerno raspoređenim brojevima u programskom jeziku Python.
Upoznćete se sa sintaksom funkcije `linspace()` biblioteke NumPy, a zatim ćete kroz primere savladati njenu upotrebu.
Napomena: Da biste pratili ovaj vodič, neophodno je da imate instalirane Python i NumPy.
Nemate još uvek instaliran NumPy? Pripremili smo kratko uputstvo za instalaciju.
Započnimo!
Instalacija i uvoz NumPy biblioteke
Pre nego što krenemo na sam vodič, brzo ćemo proći kroz korake potrebne za instalaciju NumPy biblioteke.
⏩ Ukoliko već imate instaliran NumPy, slobodno pređite na sledeći odeljak.
- Ako koristite Google Colab – okruženje Jupyter notebook-a zasnovano na oblaku, možete odmah uvesti NumPy i početi sa kodiranjem (preporučeno za ovaj vodič ✅).
- Ako želite da podesite lokalno radno okruženje, preporučuje se da instalirate Anaconda Python distribuciju. Anaconda već sadrži nekoliko unapred instaliranih, korisnih paketa. Možete preuzeti instalacioni program za vaš operativni sistem. Sam proces podešavanja traje samo nekoliko minuta. ⌛
- Ukoliko već imate instaliran Python na svom računaru, možete instalirati Anaconda distribuciju. Možete koristiti `conda` ili `pip` za instaliranje i upravljanje paketima. Pokrenite jednu od sledećih komandi iz komandne linije Anaconda-e kako biste instalirali NumPy.
# Instalacija NumPy-a pomoću conda conda install numpy # Instalacija NumPy-a pomoću pip pip install numpy
Sledeći korak je uvoz NumPy biblioteke pod pseudonimom `np`, pokretanjem sledeće komande. Ovo će vam omogućiti da pristupate NumPy-u koristeći `np`, umesto da svaki put kucate `numpy`.
import numpy as np
Od sada ćemo koristiti tačku za pristup svim funkcijama unutar NumPy biblioteke na sledeći način: `np.
Zašto koristiti ravnomerno raspoređene brojeve?
Prilikom rada sa NumPy nizovima, često se javlja potreba za kreiranjem niza brojeva koji su ravnomerno raspoređeni u okviru određenog intervala.
Pre nego što nastavimo, pogledajmo kratko drugu sličnu funkciju, `np.arange()`.
NumPy `linspace()` vs NumPy `arange()`
Ako ste već koristili NumPy, verovatno ste za kreiranje niza brojeva u određenom opsegu koristili funkciju `np.arange()`.
Podsetimo se da `np.arange(start, stop, step)` vraća niz brojeva od `start` do `stop` (ne uključujući `stop`), u koracima od `step`; podrazumevana veličina koraka je 1.
Međutim, vrednost koraka ne mora uvek biti očigledna. Pogledajmo zašto je to tako.
Na primer, ako vam trebaju 4 ravnomerno raspoređena broja između 0 i 1, znate da korak mora biti 0.25. Ali ako koristite `np.arange()`, on ne uključuje vrednost zaustavljanja od 1. Dakle, morate odabrati interval koji premašuje vrednost zaustavljanja.
Sledeća slika ilustruje još nekoliko primera gde vam je potreban određen broj ravnomerno raspoređenih tačaka u intervalu [a, b].
Ravnomerno raspoređene tačke u intervalu
Naš prvi primer, 4 ravnomerno raspoređene tačke u [0,1] je bio prilično jednostavan. Znamo da veličina koraka između tačaka treba da bude 0.25.
Pretpostavimo da imate malo složeniji primer – gde treba da navedete 7 ravnomerno raspoređenih tačaka između 1 i 33. U ovom slučaju, vrednost koraka možda nije odmah jasna. Naravno, možete ručno izračunati vrednost koraka u ovom slučaju.
Međutim, funkcija `np.linspace()` je tu da vam to olakša! 😄
Korišćenje NumPy `linspace()`
Kada koristite `np.linspace()`, potrebno je samo da navedete broj tačaka u intervalu, bez brige o veličini koraka. I dobićete niz koji želite.
Sa ovom motivacijom, nastavimo sa učenjem sintakse funkcije `linspace()` u sledećem odeljku.
Sintaksa NumPy `linspace()`
Sintaksa za korišćenje funkcije `np.linspace()` je prikazana ispod:
np.linspace(start, stop, num, endpoint, retstep, dtype, axis)
Na prvi pogled, gornja sintaksa može izgledati prilično komplikovano sa puno parametara.
Međutim, većina njih su opcioni parametri, a mi ćemo doći do mnogo jednostavnije sintakse za nekoliko minuta.
Krenimo sada sa raščlanjivanjem gornje sintakse:
- `start` i `stop` su početna i krajnja tačka intervala, respektivno. I `start` i `stop` mogu biti skalari ili nizovi. U ovom vodiču ćemo se ograničiti na skalarne početne i krajnje vrednosti.
- `num` je broj ravnomerno raspoređenih tačaka. To je opcioni parametar sa podrazumevanom vrednošću 50.
- `endpoint` je takođe opcioni parametar koji može biti `True` ili `False`.
- Podrazumevana vrednost je `True`, što znači da će krajnja tačka podrazumevano biti uključena u interval. Međutim, možete ga postaviti na `False` da biste isključili krajnju tačku.
- `retstep` je još jedan opcioni parametar koji uzima Bulove vrednosti `True` ili `False`. Kada je postavljeno na `True`, vraća se vrednost koraka.
- `dtype` je tip podataka brojeva u nizu. Tip se obično zaključuje kao `float` i ne mora biti eksplicitno naveden.
- `axis` je još jedan opcioni parametar koji označava osu duž koje treba da se čuvaju brojevi. Ovo je relevantno samo kada su `start` i `stop` sami nizovi.
▶ Šta tačno vraća `np.linspace()`?
Funkcija vraća N-dimenzionalni niz ravnomerno raspoređenih brojeva. A ako je parametar `retstep` postavljen na `True`, vraća i veličinu koraka.
Na osnovu dosadašnje diskusije, evo pojednostavljene sintakse za korišćenje `np.linspace()`:
np.linspace(start, stop, num)
Gornja linija koda će vratiti niz ravnomerno raspoređenih brojeva u intervalu [`start`, `stop`].
Sada kada znate sintaksu, krenimo sa primerima kodiranja.
Kako napraviti ravnomerno raspoređene nizove pomoću NumPy `linspace()`
#1. Kao prvi primer, kreirajmo niz od 20 ravnomerno raspoređenih brojeva u intervalu [1, 5].
Možete navesti vrednosti `start`, `stop` i `num` kao argumente ključne reči. Ovo je prikazano u ćeliji koda ispod:
import numpy as np arr1 = np.linspace(start = 1,stop = 5,num = 20) print(arr1) # Izlaz: [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. ]
Obratite pažnju na to kako brojevi u nizu počinju sa 1 i završavaju sa 5 – uključujući obe krajnje tačke. Takođe, primetite kako su brojevi, uključujući tačke 1 i 5, predstavljeni kao `float` u vraćenom nizu.
#2. U prethodnom primeru, prosledili ste vrednosti za `start`, `stop` i `num` kao argumente ključne reči. Ako argumente prosledite ispravnim redosledom, možete ih koristiti i kao pozicione argumente samo sa vrednostima, kao što je prikazano u nastavku.
import numpy as np arr2 = np.linspace(1,5,20) print(arr2) # Izlaz: [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. Hajde sada da kreiramo još jedan niz gde smo postavili `retstep` na `True`.
To znači da će funkcija sada vratiti i niz i korak. A možemo ih raspakovati u dve promenljive, `arr3` (niz) i `step_size` (vraćena veličina koraka).
Sledeća ćelija koda objašnjava kako to možete uraditi.
import numpy as np arr3, step_size = np.linspace(1,5,20,retstep = True) print(arr3) # Izlaz: [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. ] # Izlaz: print(step_size) 0.21052631578947367
#4. Kao poslednji primer, postavimo `endpoint` na `False` i proverimo šta se dešava.
import numpy as np arr4 = np.linspace(1,5,20,endpoint = False) print(arr4) # Izlaz: [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]
U vraćenom nizu, vidimo da je 1 uključeno, dok 5 nije uključeno. I poslednja vrednost u nizu je 4.8, ali i dalje imamo 20 brojeva.
Do sada smo generisali samo nizove ravnomerno raspoređenih brojeva. U sledećem odeljku, vizualizovaćemo ih crtanjem.
Kako iscrtati ravnomerno raspoređene brojeve u intervalu
U ovom odeljku, izabraćemo [10, 15] kao interval od interesa. Zatim ćemo koristiti `np.linspace()` da generišemo dva niza, svaki sa 8 odnosno 12 tačaka.
Kada ovo bude gotovo, možemo koristiti funkciju crtanja iz biblioteke `matplotlib` da ih nacrtamo.
Radi jasnoće, spojićemo dva niza od N1=8 i N2=12 ravnomerno raspoređenih tačaka na različitim pozicijama duž y-ose.
Sledeći isječak koda to demonstrira.
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'Ravnomerno raspoređeni brojevi u intervalu [{a},{b}]')
plt.xlabel('Interval')
plt.show()
Generisanje ravnomerno raspoređenih tačaka može biti od pomoći prilikom rada sa matematičkim funkcijama. O tome ćemo učiti u sledećem odeljku.
Kako koristiti NumPy `linspace()` sa matematičkim funkcijama
Nakon što generišete niz ravnomerno raspoređenih brojeva koristeći `np.linspace()`, možete izračunati vrednosti matematičkih funkcija u intervalu.
U donjoj ćeliji koda, prvo generišemo 50 ravnomerno raspoređenih tačaka u intervalu od 0 do 2π. Zatim kreiramo niz koristeći `np.sin()` na nizu `x`. Imajte na umu da možete preskočiti parametar `num`, pošto je podrazumevana vrednost 50. Ipak, mi ćemo ga eksplicitno koristiti.
Kao sledeći korak, možemo iscrtati sinusnu funkciju u intervalu [0, 2π]. Da bismo to uradili, možemo koristiti matplotlib, kao u prethodnom primeru. Konkretno, funkcija `plot()` u `matplotlib.pyplot` se koristi za kreiranje linijskog grafikona.
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()
Sada, pokrenite gornji kod tako što ćete N postaviti na 10. Dobićete dijagram kao što je prikazano na slici ispod.
Možete videti da prikaz nije baš gladak, jer ste odabrali samo 10 tačaka u intervalu.
Generalno, što je veći broj tačaka koji uzmete u obzir, to će biti glađi prikaz funkcije.
Zaključak
Evo rezimea onoga što smo naučili.
- `np.linspace(start, stop, num)` vraća niz brojeva ravnomerno raspoređenih u intervalu [`start`, `stop`].
- Postavite `endpoint` opcionalnog parametra na `False` da biste isključili `stop` i postavili interval na [`start`, `stop`).
- Opciono postavite `retstep` na `True` da biste dobili veličinu koraka.
- Generišite ravnomerno raspoređene nizove pomoću `np.linspace()`, a zatim koristite niz sa matematičkim funkcijama.
Nadam se da sada razumete kako funkcija `np.linspace()` radi. Možete pokrenuti gornje primere u Jupyter notebook-u. Pogledajte naš vodič za Jupyter notebook ili druge Jupyter alternative koje možete razmotriti.
Vidimo se uskoro u drugom Python vodiču. Do tada, nastavite sa kodiranjem!😀