పరిస్థితిని బట్టి శ్రేణికి ఏదైనా ఫంక్షన్‌ని వర్తింపజేయడానికి రెండు పద్ధతులు ఉన్నాయి. మేము శ్రేణిలోని ప్రతి మూలకంపై ఫంక్షన్‌ను ఒక్కొక్కటిగా వర్తింపజేసినప్పుడు ఉపయోగపడే “అక్షం మీద వర్తించు” ఫంక్షన్‌ను వర్తింపజేయవచ్చు మరియు ఇది n-డైమెన్షనల్ శ్రేణులకు ఉపయోగపడుతుంది. రెండవ పద్ధతి 'అక్షం వెంట వర్తించు' ఇది ఒక డైమెన్షనల్ శ్రేణికి వర్తిస్తుంది.
సింటాక్స్:
విధానం 1: అక్షం వెంట వర్తించండి
మొద్దుబారిన. వర్తిస్తాయి_అక్షం ( 1d_ఫంక్షన్ , అక్షం , అరె , * args , ** క్వార్గ్స్ )సింటాక్స్‌లో, మనకు “numpy.apply” ఫంక్షన్ ఉంది, దానికి మనం ఐదు ఆర్గ్యుమెంట్‌లను పాస్ చేస్తాము. '1d_function' అయిన మొదటి ఆర్గ్యుమెంట్ ఒక డైమెన్షనల్ శ్రేణిపై పనిచేస్తుంది, ఇది అవసరం. రెండవ ఆర్గ్యుమెంట్, “యాక్సిస్”, మీరు శ్రేణిని స్లైస్ చేసి, ఆ ఫంక్షన్‌ను వర్తింపజేయాలనుకుంటున్న అక్షం. మూడవ పరామితి “arr”, ఇది మనం ఫంక్షన్‌ను వర్తింపజేయాలనుకుంటున్న శ్రేణి. అయితే “* args” మరియు “*kwargs” జోడించాల్సిన అవసరం లేని అదనపు వాదనలు.
ఉదాహరణ 1:
“వర్తించు” పద్ధతులను బాగా అర్థం చేసుకునే దిశగా వెళుతూ, దరఖాస్తు పద్ధతుల పనితీరును తనిఖీ చేయడానికి మేము ఒక ఉదాహరణను ప్రదర్శిస్తాము. ఈ సందర్భంలో, మేము “apply_along_Axis” ఫంక్షన్‌ని చేస్తాము. మన మొదటి దశకు వెళ్దాం. మేము ముందుగా మా NumPy లైబ్రరీలను npగా చేర్చుతాము. ఆపై, మేము '8, 1, 7, 4, 3, 9, 5, 2, మరియు 6' అనే పూర్ణాంక విలువలతో 3×3 మాతృకను కలిగి ఉన్న 'arr' పేరుతో ఒక శ్రేణిని సృష్టిస్తాము. తదుపరి పంక్తిలో, మేము apply_along_Axis ఫంక్షన్ యొక్క ఫలితాన్ని ఉంచడానికి బాధ్యత వహించే “శ్రేణి” పేరుతో వేరియబుల్‌ని సృష్టిస్తాము.
ఆ ఫంక్షన్‌కు, మేము మూడు వాదనలను పాస్ చేస్తాము. మొదటిది మేము శ్రేణికి వర్తింపజేయాలనుకుంటున్న ఫంక్షన్, మన విషయంలో ఇది క్రమబద్ధీకరించబడిన ఫంక్షన్ ఎందుకంటే మన శ్రేణి క్రమబద్ధీకరించబడాలి. అప్పుడు, మనం రెండవ ఆర్గ్యుమెంట్ “1”ని పాస్ చేస్తాము అంటే మన శ్రేణిని axis=1 వెంట స్లైస్ చేయాలనుకుంటున్నాము. చివరగా, ఈ సందర్భంలో క్రమబద్ధీకరించాల్సిన శ్రేణిని మేము పాస్ చేస్తాము. కోడ్ చివరిలో, మేము రెండు శ్రేణులను ప్రింట్ చేస్తాము - అసలు శ్రేణి అలాగే ఫలిత శ్రేణి - ఇవి ప్రింట్() స్టేట్‌మెంట్ ఉపయోగించి ప్రదర్శించబడతాయి.
దిగుమతి మొద్దుబారిన వంటి ఉదా
అరె = ఉదా అమరిక ( [ [ 8 , 1 , 7 ] , [ 4 , 3 , 9 ] , [ 5 , రెండు , 6 ] ] )
అమరిక = ఉదా వర్తిస్తాయి_అక్షం ( క్రమబద్ధీకరించబడింది , 1 , అరె )
ముద్రణ ( 'అసలు శ్రేణి:' , అరె )
ముద్రణ ( 'క్రమబద్ధీకరించబడిన శ్రేణి:' , అమరిక )
కింది అవుట్‌పుట్‌లో మనం చూడగలిగినట్లుగా, మేము రెండు శ్రేణులను ప్రదర్శించాము. మొదటిదానిలో, విలువలు యాదృచ్ఛికంగా మాతృకలోని ప్రతి వరుసలో ఉంచబడతాయి. కానీ రెండవదానిలో, క్రమబద్ధీకరించబడిన శ్రేణిని మనం చూడవచ్చు. మేము అక్షం “1”ని దాటినందున, ఇది పూర్తి శ్రేణిని క్రమబద్ధీకరించలేదు కానీ ప్రదర్శించబడినట్లుగా వరుసల వారీగా క్రమబద్ధీకరించబడింది. ప్రతి అడ్డు వరుస క్రమబద్ధీకరించబడింది. అందించిన శ్రేణిలోని మొదటి అడ్డు వరుస “8, 1 మరియు 7”. క్రమబద్ధీకరించబడిన శ్రేణిలో ఉన్నప్పుడు, మొదటి వరుస '1, 7 మరియు 8'. ఇలాగే, ప్రతి అడ్డు వరుస క్రమబద్ధీకరించబడింది.
విధానం 2: అక్షం మీద వర్తించండి
మొద్దుబారిన. గొడ్డలిపై_వర్తిస్తాయి ( ఫంక్ , a , అక్షతలు )ఇవ్వబడిన సింటాక్స్‌లో, మేము ఇచ్చిన అక్షంపై ఫంక్షన్‌ను వర్తింపజేయడానికి బాధ్యత వహించే numpy.apply_over_axis ఫంక్షన్‌ని కలిగి ఉన్నాము. apply_over_axis ఫంక్షన్ లోపల, మేము మూడు ఆర్గ్యుమెంట్‌లను పాస్ చేస్తాము. మొదటిది చేయవలసిన విధి. రెండవది శ్రేణి. మరియు చివరిది మనం ఫంక్షన్‌ను వర్తింపజేయాలనుకుంటున్న అక్షం.
ఉదాహరణ 2:
కింది సందర్భంలో, మేము 'వర్తించు' ఫంక్షన్ యొక్క రెండవ పద్ధతిని నిర్వహిస్తాము, దీనిలో మేము త్రిమితీయ శ్రేణి మొత్తాన్ని గణిస్తాము. గుర్తుంచుకోవాల్సిన ఒక విషయం ఏమిటంటే, రెండు శ్రేణుల మొత్తం అంటే మనం మొత్తం శ్రేణిని లెక్కించమని కాదు. కొన్ని శ్రేణులలో, మేము అడ్డు వరుసల వారీ మొత్తాన్ని గణిస్తాము అంటే మేము అడ్డు వరుసలను జోడించి వాటి నుండి ఒకే మూలకాన్ని పొందుతాము.
మన కోడ్‌కి ముందుకు వెళ్దాం. మేము మొదట NumPy ప్యాకేజీని దిగుమతి చేసి, ఆపై త్రిమితీయ శ్రేణిని కలిగి ఉన్న వేరియబుల్‌ని సృష్టిస్తాము. మా విషయంలో, వేరియబుల్ 'arr'. తదుపరి పంక్తిలో, మేము apply_over_axis ఫంక్షన్ యొక్క ఫలిత శ్రేణిని కలిగి ఉన్న మరొక వేరియబుల్‌ని సృష్టిస్తాము. మేము మూడు ఆర్గ్యుమెంట్‌లతో వేరియబుల్ “arr”కి apply_over_Axis ఫంక్షన్‌ని కేటాయిస్తాము. np.sum అయిన మొత్తాన్ని లెక్కించడానికి NumPy యొక్క అంతర్నిర్మిత ఫంక్షన్ మొదటి వాదన. రెండవ పరామితి శ్రేణి. మూడవ ఆర్గ్యుమెంట్ అనేది ఫంక్షన్ వర్తించే అక్షం, ఈ సందర్భంలో మనకు “[0, 2]” అక్షం ఉంటుంది. కోడ్ చివరిలో, మేము ప్రింట్() స్టేట్‌మెంట్‌ని ఉపయోగించి రెండు శ్రేణులను అమలు చేస్తాము.
దిగుమతి మొద్దుబారిన వంటి ఉదాఅరె = ఉదా అమరిక ( [ [ [ 6 , 12 , రెండు ] , [ రెండు , 9 , 6 ] , [ 18 , 0 , 10 ] ] ,
[ [ 12 , 7 , 14 ] , [ రెండు , 17 , 18 ] , [ 0 , ఇరవై ఒకటి , 8 ] ] ] )
అమరిక = ఉదా గొడ్డలిపై_వర్తిస్తాయి ( ఉదా మొత్తం , అరె , [ 0 , రెండు ] )
ముద్రణ ( 'అసలు శ్రేణి:' , అరె )
ముద్రణ ( 'శ్రేణి మొత్తం:' , అమరిక )
కింది చిత్రంలో చూపిన విధంగా, మేము apply_over_axis ఫంక్షన్‌ని ఉపయోగించి మా త్రిమితీయ శ్రేణులలో కొన్నింటిని లెక్కించాము. మొదట ప్రదర్శించబడిన శ్రేణి '2, 3, 3' ఆకారంతో అసలైన శ్రేణి మరియు రెండవది అడ్డు వరుసల మొత్తం. మొదటి వరుస మొత్తం “53”, రెండవది “54” మరియు చివరిది “57”.
ముగింపు
ఈ కథనంలో, NumPyలో అప్లికేషన్ ఫంక్షన్ ఎలా ఉపయోగించబడుతుందో మరియు అక్షం వెంబడి లేదా శ్రేణులపై వివిధ ఫంక్షన్‌లను ఎలా వర్తింపజేయవచ్చో మేము అధ్యయనం చేసాము. NumPy అందించిన 'వర్తించు' పద్ధతులను ఉపయోగించి వాటిని ముక్కలు చేయడం ద్వారా కావలసిన అడ్డు వరుస లేదా నిలువు వరుసపై ఏదైనా ఫంక్షన్‌ని వర్తింపజేయడం సులభం. మేము దానిని మొత్తం శ్రేణికి వర్తింపజేయనవసరం లేనప్పుడు ఇది సమర్థవంతమైన మార్గం. దరఖాస్తు పద్ధతిని ఎలా ఉపయోగించాలో తెలుసుకోవడానికి ఈ పోస్ట్ మీకు ప్రయోజనకరంగా ఉంటుందని మేము ఆశిస్తున్నాము.