A feltételektől függően kétféle módon lehet bármely függvényt alkalmazni a tömbre. Alkalmazhatjuk az „alkalmazás a tengelyre” függvényt, amely akkor hasznos, ha a függvényt egyenként alkalmazzuk a tömb minden elemére, és hasznos az n-dimenziós tömböknél. A második módszer az „alkalmaz a tengely mentén”, amely egydimenziós tömbre vonatkozik.
Szintaxis:
1. módszer: Alkalmazza a tengely mentén
zsibbadt. alkalmaz_tengely mentén ( 1d_függvény , tengely , arr , *args , **quargs )A szintaxisban van a „numpy.apply” függvény, amelyhez öt argumentumot adunk át. Az első argumentum, amely az „1d_function”, az egydimenziós tömbön működik, ami szükséges. Míg a második argumentum, az „tengely” az, amelyik tengelyére szeretné felvágni a tömböt, és alkalmazni szeretné a függvényt. A harmadik paraméter az „arr”, amely az adott tömb, amelyre a függvényt alkalmazni akarjuk. Míg az „*args” és a „*kwargs” olyan további érvek, amelyeket nem szükséges hozzáadni.
1. példa:
Az „alkalmazási” módszerek jobb megértése felé haladva egy példát mutatunk be az alkalmazott módszerek működésének ellenőrzésére. Ebben az esetben végrehajtjuk az „apply_along_Axis” függvényt. Folytassuk az első lépésünkkel. Először a NumPy könyvtárainkat np. Ezután létrehozunk egy „arr” nevű tömböt, amely egy 3×3-as mátrixot tartalmaz egész számokkal, amelyek értékei „8, 1, 7, 4, 3, 9, 5, 2 és 6”. A következő sorban létrehozunk egy „array” nevű változót, amely az apply_along_Axis függvény eredményének tárolásáért felelős.
Ennek a függvénynek három argumentumot adunk át. Az első az a függvény, amelyet a tömbre szeretnénk alkalmazni, esetünkben ez a rendezett függvény, mert azt szeretnénk, hogy a tömbünk rendezve legyen. Ezután átadjuk a második „1” argumentumot, ami azt jelenti, hogy a tömbünket az axis=1 mentén szeretnénk szeletelni. Végül átadjuk azt a tömböt, amelyet ebben az esetben rendezni kell. A kód végén egyszerűen kinyomtatjuk mindkét tömböt – az eredeti és a kapott tömböt –, amelyek a print() utasítással jelennek meg.
import zsibbadt mint például.
arr = például. sor ( [ [ 8 , 1 , 7 ] , [ 4 , 3 , 9 ] , [ 5 , két , 6 ] ] )
sor = például. alkalmaz_tengely mentén ( rendezve , 1 , arr )
nyomtatás ( 'az eredeti tömb a következő:' , arr )
nyomtatás ( 'a rendezett tömb a következő:' , sor )
Ahogy a következő kimenetben láthatjuk, mindkét tömböt megjelenítettük. Az elsőben az értékek véletlenszerűen kerülnek a mátrix minden sorába. De a másodikban láthatjuk a rendezett tömböt. Mióta áthaladtunk az „1” tengelyen, nem rendezte a teljes tömböt, hanem soronként rendezte a megjelenített módon. Minden sor rendezve van. Az adott tömb első sora „8, 1 és 7”. A rendezett tömbben az első sor „1, 7 és 8”. Ugyanígy minden sor rendezve van.
2. módszer: Alkalmazás a tengely felett
zsibbadt. alkalmaz_a_tengelyek felett ( func , a , tengelyek )Az adott szintaxisban van egy numpy.apply_over_axis függvény, amely a függvény adott tengelyen történő alkalmazásáért felelős. Az apply_over_axis függvényen belül három argumentumot adunk át. Az első a végrehajtandó funkció. A második maga a tömb. Az utolsó pedig az a tengely, amelyen a függvényt alkalmazni akarjuk.
2. példa:
A következő példában végrehajtjuk az „alkalmaz” függvény második módszerét, amelyben kiszámítjuk a háromdimenziós tömb összegét. Ne feledje, hogy két tömb összege nem jelenti azt, hogy a teljes tömböt kiszámítjuk. Egyes tömbökben soronkénti összeget számítunk ki, ami azt jelenti, hogy összeadjuk a sorokat, és kivesszük belőlük az egyetlen elemet.
Térjünk tovább a kódunkra. Először importáljuk a NumPy csomagot, majd létrehozunk egy változót, amely tartalmazza a háromdimenziós tömböt. Esetünkben a változó az „arr”. A következő sorban hozunk létre egy másik változót, amely tartalmazza az apply_over_axis függvény eredményül kapott tömbjét. Az application_over_Axis függvényt az „arr” változóhoz rendeljük három argumentummal. Az első argumentum a NumPy beépített függvénye az np.sum összeg kiszámításához. A második paraméter maga a tömb. A harmadik argumentum az a tengely, amelyre a függvényt alkalmazzuk, ebben az esetben „[0, 2]” tengelyünk van. A kód végén mindkét tömböt végrehajtjuk a print() utasítással.
import zsibbadt mint például.arr = például. sor ( [ [ [ 6 , 12 , két ] , [ két , 9 , 6 ] , [ 18 , 0 , 10 ] ] ,
[ [ 12 , 7 , 14 ] , [ két , 17 , 18 ] , [ 0 , huszonegy , 8 ] ] ] )
sor = például. alkalmaz_a_tengelyek felett ( például. összeg , arr , [ 0 , két ] )
nyomtatás ( 'az eredeti tömb a következő:' , arr )
nyomtatás ( 'a tömb összege:' , sor )
A következő ábrán látható módon néhány háromdimenziós tömbünket az apply_over_axis függvény segítségével számítottuk ki. Az első megjelenített tömb az eredeti tömb „2, 3, 3” alakú, a második pedig a sorok összege. Az első sor összege „53”, a második „54”, az utolsó pedig „57”.
Következtetés
Ebben a cikkben azt tanulmányoztuk, hogyan használják az Apply függvényt a NumPy-ban, és hogyan alkalmazhatjuk a különböző függvényeket tömbökön a tengely mentén vagy felett. Könnyű bármilyen függvényt alkalmazni a kívánt sorra vagy oszlopra, ha a NumPy által biztosított „alkalmaz” metódusokkal szeleteljük őket. Ez egy hatékony módszer, amikor nem kell a teljes tömbre alkalmazni. Reméljük, hogy ezt a bejegyzést hasznosnak találja az alkalmazási módszer használatának megtanulásához.