Mayroong dalawang paraan upang ilapat ang anumang function sa array depende sa kundisyon. Maaari naming ilapat ang function na 'mag-apply sa ibabaw ng axis' na kapaki-pakinabang kapag inilapat namin ang function sa bawat elemento ng array nang paisa-isa, at ito ay kapaki-pakinabang para sa mga n-dimensional na array. Ang pangalawang paraan ay 'ilapat sa kahabaan ng axis' na nalalapat sa isang one-dimensional na array.
Syntax:
Paraan 1: Ilapat sa Kahabaan ng Axis
numpy. apply_along_axis ( 1d_function , aksis , arr , *args , **quargs )Sa syntax, mayroon kaming function na 'numpy.apply' kung saan ipinapasa namin ang limang argumento. Ang unang argumento na '1d_function' ay gumagana sa one-dimensional array, na kinakailangan. Habang ang pangalawang argumento, ang 'axis', ay ang isa kung saang axis mo gustong hatiin ang array at ilapat ang function na iyon. Ang ikatlong parameter ay 'arr' na kung saan ay ang ibinigay na array kung saan gusto naming ilapat ang function. Habang ang '*args' at '*kwargs' ay ang mga karagdagang argumento na hindi kailangang idagdag.
Halimbawa 1:
Sa paglipat patungo sa isang mas mahusay na pag-unawa sa mga 'mag-apply' na mga pamamaraan, nagsasagawa kami ng isang halimbawa upang suriin ang paggana ng mga pamamaraan ng paglalapat. Sa pagkakataong ito, ginagawa namin ang function na 'apply_along_Axis'. Magpatuloy tayo sa ating unang hakbang. Isama muna namin ang aming mga NumPy library bilang np. At pagkatapos, gumawa kami ng array na pinangalanang 'arr' na mayroong 3×3 matrix na may mga integer value na '8, 1, 7, 4, 3, 9, 5, 2, at 6'. Sa susunod na linya, lumikha kami ng isang variable na pinangalanang 'array' na responsable para sa paghawak ng resulta ng function na apply_along_Axis.
Sa function na iyon, pumasa kami ng tatlong argumento. Ang una ay ang function na gusto naming ilapat sa array, sa aming kaso ito ay ang sorted function dahil gusto namin ang aming array ay pinagsunod-sunod. Pagkatapos, ipinapasa namin ang pangalawang argumento '1' na nangangahulugang gusto naming hatiin ang aming array kasama ang axis=1. Sa huli, ipinapasa namin ang array na pag-uri-uriin sa kasong ito. Sa dulo ng code, ipi-print lang namin ang parehong array - ang orihinal na array pati na rin ang resultang array - na ipinapakita gamit ang print() statement.
angkat numpy bilang hal.
arr = hal. array ( [ [ 8 , 1 , 7 ] , [ 4 , 3 , 9 ] , [ 5 , dalawa , 6 ] ] )
array = hal. apply_along_axis ( pinagsunod-sunod , 1 , arr )
print ( 'ang orihinal na array ay:' , arr )
print ( 'ang pinagsunod-sunod na array ay:' , array )
Tulad ng nakikita natin sa sumusunod na output, ipinakita namin ang parehong mga array. Sa una, ang mga halaga ay random na inilalagay sa bawat hilera ng matrix. Ngunit sa pangalawa, makikita natin ang pinagsunod-sunod na hanay. Dahil naipasa namin ang axis na '1', hindi nito pinagbukud-bukod ang kumpletong array ngunit pinagsunod-sunod ito ayon sa ipinapakita. Ang bawat hilera ay pinagsunod-sunod. Ang unang hilera sa ibinigay na array ay '8, 1, at 7'. Habang nasa sorted array, ang unang row ay '1, 7 at 8'. Katulad nito, ang bawat hilera ay pinagsunod-sunod.
Paraan 2: Ilapat sa ibabaw ng Axis
numpy. apply_over_axes ( func , a , mga palakol )Sa ibinigay na syntax, mayroon kaming function na numpy.apply_over_axis na responsable para sa paglalapat ng function sa ibinigay na axis. Sa loob ng function na apply_over_axis, ipinapasa namin ang tatlong argumento. Ang una ay ang function na gagawin. Ang pangalawa ay ang array mismo. At ang huli ay ang axis kung saan gusto naming ilapat ang function.
Halimbawa 2:
Sa sumusunod na pagkakataon, ginagawa namin ang pangalawang paraan ng function na 'apply' kung saan kinakalkula namin ang kabuuan ng three-dimensional na array. Ang isang bagay na dapat tandaan ay ang kabuuan ng dalawang array ay hindi nangangahulugan na kinakalkula natin ang buong array. Sa ilan sa mga array, kinakalkula namin ang row-wise sum na nangangahulugan na idinaragdag namin ang mga row at makuha ang isang elemento mula sa kanila.
Sumulong tayo sa ating code. Una naming ini-import ang NumPy package at pagkatapos ay gumawa ng variable na nagtataglay ng three-dimensional array. Sa aming kaso, ang variable ay 'arr'. Sa susunod na linya, gumawa kami ng isa pang variable na nagtataglay ng resultang array ng function na apply_over_axis. Itinalaga namin ang function na apply_over_Axis sa variable na 'arr' na may tatlong argumento. Ang unang argumento ay ang built-in na function ng NumPy upang kalkulahin ang kabuuan na np.sum. Ang pangalawang parameter ay ang array mismo. Ang ikatlong argumento ay ang axis kung saan inilalapat ang function, sa kasong ito mayroon kaming '[0, 2]' na axis. Sa dulo ng code, isinasagawa namin ang parehong mga array gamit ang print() na pahayag.
angkat numpy bilang hal.arr = hal. array ( [ [ [ 6 , 12 , dalawa ] , [ dalawa , 9 , 6 ] , [ 18 , 0 , 10 ] ] ,
[ [ 12 , 7 , 14 ] , [ dalawa , 17 , 18 ] , [ 0 , dalawampu't isa , 8 ] ] ] )
array = hal. apply_over_axes ( hal. kabuuan , arr , [ 0 , dalawa ] )
print ( 'ang orihinal na array ay:' , arr )
print ( 'ang kabuuan ng array ay:' , array )
Gaya ng ipinapakita sa sumusunod na figure, kinakalkula namin ang ilan sa aming mga three-dimensional na array gamit ang function na apply_over_axis. Ang unang ipinakitang array ay ang orihinal na array na may hugis na '2, 3, 3' at ang pangalawa ay ang kabuuan ng mga row. Ang unang-row sum ay '53', ang pangalawa ay '54' at ang huli ay '57'.
Konklusyon
Sa artikulong ito, pinag-aralan namin kung paano ginagamit ang function na apply sa NumPy at kung paano namin mailalapat ang iba't ibang mga function sa mga array sa kahabaan o sa ibabaw ng axis. Madaling ilapat ang anumang function sa nais na row o column sa pamamagitan ng paghiwa sa mga ito gamit ang 'apply' na mga pamamaraan na ibinigay ng NumPy. Ito ay isang mahusay na paraan kapag hindi namin kailangang ilapat ito sa buong array. Inaasahan naming kapaki-pakinabang ang post na ito sa pag-aaral kung paano gamitin ang paraan ng paglalapat.