“ఈ ట్యుటోరియల్‌లో, మేము NumPy డివైడ్() ఫంక్షన్ అంటే ఏమిటో మరియు ఈ ఫంక్షన్‌ను వివిధ వివరించిన ఉదాహరణలతో ఎలా ఉపయోగించాలో నేర్చుకోబోతున్నాము.
మీకు తెలిసినట్లుగా, ఫంక్షన్ పేరుతో, అనగా, విభజించండి. మేము గణితం గురించి మాట్లాడినట్లయితే, పేర్కొన్న సమాధానాన్ని పొందడానికి మేము రెండు సంఖ్యలను విభజిస్తాము.
పరిచయం
ఇక్కడ విభజన ఫంక్షన్ మేము పైన చర్చించిన విధంగానే పని చేస్తుంది; ఒకే తేడా ఏమిటంటే, అక్కడ మనం రెండు సంఖ్యలను విభజిస్తున్నాము మరియు ఇక్కడ మేము శ్రేణుల యొక్క ప్రతి మూలకాన్ని విభజిస్తున్నాము. అందుకే దీనిని మూలకాల వారీగా విభజన అంటారు.
NumPy డివైడ్() ఫంక్షన్ అదే పరిమాణంలోని NumPy శ్రేణులను విభజిస్తుంది. NumPy డివైడ్() నిజమైన విభజనలను నిర్వహిస్తుంది, అంటే మనం అవుట్‌పుట్‌ను ఫ్లోటింగ్ పాయింట్‌లో పొందుతాము.
వాక్యనిర్మాణం
NumPyలో డివైడ్() ఫంక్షన్ యొక్క వ్రాత శైలి మరియు అమలు గురించి చర్చిద్దాం. మొదట, మనం ఉపయోగిస్తున్న పైథాన్ లైబ్రరీ పేరును వ్రాయాలి, అది “నంపీ” అని, ఆపై మనకు “డివైడ్” అనే ఫంక్షన్ పేరు ఉంటుంది, దానిని మనం నిర్వహించబోతున్నాము. అప్పుడు మేము ఫంక్షన్‌కు పారామితులను పాస్ చేసాము.
పారామితులు
NumPyలో డివైడ్() ఫంక్షన్ అమలు సమయంలో మనం ఆమోదించిన అవసరమైన మరియు ఐచ్ఛిక పారామితులు క్రిందివి.
అవసరమైన పారామితులు
శ్రేణి1: డివిడెండ్ మూలకాలను కలిగి ఉండే శ్రేణి.
శ్రేణి2: అనేది డివైజర్ ఎలిమెంట్‌లను కలిగి ఉండే శ్రేణి.
ఐచ్ఛిక పారామితులు
బయట: డిఫాల్ట్‌గా, దాని విలువ 'ఏదీ లేదు', ఇది విలువ నిల్వ చేయబడిందని సూచిస్తుంది. విలువ ఇవ్వకపోతే, తాజాగా కేటాయించిన శ్రేణి తిరిగి ఇవ్వబడుతుంది.
ఎక్కడ: ఈ పరామితి ఇన్‌పుట్ శ్రేణిలో ప్రసారం చేయబడుతుంది. ప్రకటన నిజమైతే, అవుట్‌పుట్ శ్రేణి యూనివర్సల్ ఫంక్షన్ (ufunc) ఫలితానికి సెట్ చేయబడుతుంది. అది తప్పు అయితే, అవుట్ అర్రే దాని అసలు ఫలితాన్ని అలాగే ఉంచుతుంది.
రిటర్న్ విలువ
ఇన్‌పుట్ శ్రేణి యొక్క రిటర్న్ చేయబడిన విలువ కొత్తగా ఏర్పడిన శ్రేణి, ఇది డివైడ్() ఫంక్షన్ యొక్క మూలకాల వారీగా విభజనను కలిగి ఉంటుంది.
ఉదాహరణ 01: స్కేలార్ విలువతో 1D అర్రేని విభజించండి
ఇప్పుడు డివైడ్() ఫంక్షన్ యొక్క మొదటి ఉదాహరణ వైపు వెళ్దాం. రెండు శ్రేణులను మూలకం వారీగా విభజించడానికి డివైడ్() ఫంక్షన్ ఉపయోగించబడుతుందని మనకు తెలుసు, కానీ ఇక్కడ మా మొదటి ఉదాహరణలో, మనకు డివిడెండ్‌గా శ్రేణి ఉంది మరియు రెండవది మనకు డివైజర్‌గా స్కేలార్ విలువ ఉంటుంది. పైథాన్ ప్రోగ్రామ్‌ను అమలు చేయడానికి, ముందుగా, మీరు ఈ ప్రోగ్రామ్‌ను అమలు చేయడానికి ఏదైనా పైథాన్ కంపైలర్‌ను ఇన్‌స్టాల్ చేయాలి.
ఇప్పుడు, మన మొదటి కోడ్ లైన్‌ను లైన్ ద్వారా వివరించడం ప్రారంభిద్దాం. మేము NumPy డివిజన్() ఫంక్షన్‌ని ఉపయోగిస్తాము కాబట్టి, మేము ముందుగా NumPy మాడ్యూల్‌ని దిగుమతి చేసుకోవాలి. అప్పుడు మేము డివైడ్() ఫంక్షన్‌ని అమలు చేయబోతున్నామని చూపే “ఇంప్లిమెంటేషన్ ఆఫ్ డివైడ్() ఫంక్షన్:” అనే సందేశాన్ని ప్రదర్శించడానికి ప్రింట్() పద్ధతిని ఉపయోగిస్తాము. ఆపై, మేము ప్రింట్ () పద్ధతిలో “\n” ఫార్మాట్ స్పెసిఫైయర్‌ని ఉపయోగిస్తాము, అది కొత్త లైన్‌లోకి ప్రవేశించడానికి ఉపయోగించబడుతుంది.
అప్పుడు మేము మా డివిడెండ్ శ్రేణిని “[2, 4, 6, 8, 10]” “అరే1” పేరుతో సృష్టిస్తాము. అవుట్‌పుట్‌లో array1ని ప్రదర్శించడానికి, మేము ప్రింట్() పద్ధతిని పిలిచాము మరియు దానిలోని శ్రేణిని పాస్ చేసాము. మేము array1కి సంబంధించి సంబంధిత సందేశాన్ని కూడా ప్రదర్శించాలనుకుంటున్నాము, కాబట్టి మేము ముద్రణ పద్ధతిలో సందేశాన్ని డబుల్ కొటేషన్ మార్కులలో కూడా వ్రాసాము. అప్పుడు మేము 'scaler_value' పేరుతో '2' అనే స్కేలార్ వేరియబుల్‌ను డివైజర్‌గా సృష్టిస్తాము మరియు మేము ప్రింట్() పద్ధతిని ఉపయోగించి మరియు దానిలోని వేరియబుల్ పేరును పాస్ చేయడం ద్వారా స్కేలార్ వేరియబుల్ విలువను ప్రదర్శిస్తాము.
నంపిని దిగుమతి చేయండి వంటి ఉదాముద్రణ ( 'డివైడ్() ఫంక్షన్ అమలు: \n ' )
శ్రేణి1 = [ రెండు , 4 , 6 , 8 , 10 ]
ముద్రణ ( 'డివిడెండ్ అర్రే:' , శ్రేణి1 )
scaler_value = రెండు
ముద్రణ ( 'డివైజర్:' , స్కేలర్_విలువ )
new_array = np.divide ( శ్రేణి1, స్కేలర్_విలువ )
ముద్రణ ( 'కోషెంట్ అర్రే:' , new_array )
మా డివిడెండ్ శ్రేణి మరియు డివైజర్ స్కేలార్ వేరియబుల్‌ని సృష్టించిన తర్వాత, NumPyలో విభజనను నిర్వహించడానికి డివైడ్() ఫంక్షన్‌ని పిలుద్దాం. మీరు లైన్ 1లో చూసినట్లుగా, మేము నంపీని అలియాస్ npగా దిగుమతి చేస్తాము. కాబట్టి ఫంక్షన్‌ను కాల్ చేయడానికి, మొదట, మేము “np” అని వ్రాస్తాము ఎందుకంటే ఇది NumPy ఫంక్షన్, ఆపై ఫంక్షన్ పేరు “డివైడ్” అని వ్రాసి, డివైడ్() ఫంక్షన్ బ్రాకెట్‌లలో పారామీటర్‌ను పాస్ చేయండి; ఈ ఉదాహరణలో, మేము అవసరమైన పారామితులకు పాస్ చేసాము, అనగా, array1 మరియు scaler_value. NumPy divide() ఫంక్షన్‌ని వ్రాసిన తర్వాత, మేము ఈ ఫంక్షన్‌ను మరొక కొత్త శ్రేణిలో నిల్వ చేసాము ఎందుకంటే మనకు ఈ ఫంక్షన్ మళ్లీ కావాలనుకున్నప్పుడు, మేము శ్రేణి పేరు ద్వారా divide() ఫంక్షన్‌ని కాల్ చేయవలసిన అవసరం లేదు, అనగా new_array. అప్పుడు మేము ప్రింట్ () పద్ధతిని (ముందే నిర్వచించిన పద్ధతి) కాల్ చేయడం ద్వారా కొత్త శ్రేణిని ప్రింట్ చేస్తాము.
పైన చూపిన కోడ్ యొక్క అవుట్‌పుట్ షెల్‌లో కనిపించే విధంగా ఇక్కడ చూపబడుతుంది. మీరు చూస్తున్నట్లుగా, మేము [1 2 3 4 5] భాగస్వామ్య శ్రేణిని పొందుతాము.
ఉదాహరణ 02: రెండు శ్రేణులను మూలకం వారీగా విభజించడం
ఇప్పుడు 2కి వెళ్లండి nd డివైడ్() ఫంక్షన్ యొక్క ఉదాహరణ. ఈ ఉదాహరణలో, డివైడ్() ఫంక్షన్‌ని నిర్వహించడానికి మనకు రెండు ఇన్‌పుట్ శ్రేణులు ఉన్నాయి. శ్రేణి1 “[5, 10, 15, 20, 25],” మరియు శ్రేణి2 “[3, 7, 11, 13, 17]”. మరియు మేము ముందుగా నిర్వచించిన పద్ధతి ప్రింట్() పద్ధతిని కాల్ చేయడం ద్వారా రెండు శ్రేణులను ప్రదర్శిస్తాము. అప్పుడు మేము డివైడ్() ఫంక్షన్‌ని పిలుస్తాము మరియు దానిలోని పారామితులను (అనగా, అర్రే1 మరియు అర్రే2) పాస్ చేస్తాము మరియు ఫంక్షన్‌ను “new_array” పేరుతో మరొక కొత్త శ్రేణిలో నిల్వ చేస్తాము మరియు ప్రింట్ () పద్ధతిని కాల్ చేయడం ద్వారా దాన్ని ప్రింట్ చేస్తాము.
నంపిని దిగుమతి చేయండి వంటి ఉదాముద్రణ ( 'డివైడ్() ఫంక్షన్ అమలు: \n ' )
శ్రేణి1 = [ 5 , 10 , పదిహేను , ఇరవై , 25 ]
ముద్రణ ( 'డివిడెండ్ అర్రే1:' , శ్రేణి1 )
శ్రేణి2 = [ 3 , 7 , పదకొండు , 13 , 17 ]
ముద్రణ ( 'డివైజర్ అర్రే2:' , శ్రేణి2 )
new_array = np.divide ( శ్రేణి1,శ్రేణి2 )
ముద్రణ ( 'కోషెంట్ అర్రే:' , new_array )
NumPyలో డివైడ్() ఫంక్షన్ యొక్క ఎగువ-ఇలస్ట్రేటెడ్ ఉదాహరణ యొక్క అవుట్‌పుట్ ప్రదర్శన ఇక్కడ ఉంది.
ఉదాహరణ 03: డివైడ్() ఫంక్షన్‌లో బహుళ డైమెన్షనల్ అర్రేలు
ఇందులో 3 RD ఉదాహరణకు, మేము బహుళ-డైమెన్షనల్ శ్రేణిలో డివైడ్() ఫంక్షన్‌లను అమలు చేయబోతున్నాము. ముందుగా, డివైడ్() ఫంక్షన్‌ని అమలు చేయడానికి మేము NumPy మాడ్యూల్‌ని దిగుమతి చేస్తాము. అప్పుడు మేము 'array1' మరియు 'array2' అనే రెండు శ్రేణులను సృష్టించాము మరియు మేము ముందే నిర్వచించిన ప్రింట్() పద్ధతిని కాల్ చేసి, ఈ శ్రేణులను అందులో పాస్ చేయడం ద్వారా రెండు శ్రేణులను ముద్రించాము. అప్పుడు మేము డివైడ్() ఫంక్షన్‌ను అలియాస్ npతో పిలిచి, దానిలోని array1 మరియు array2ని పాస్ చేసాము మరియు ఈ మొత్తం ఫంక్షన్‌ను 'new_array' పేరుతో మరొక శ్రేణిలో నిల్వ చేసాము, తద్వారా మనం ఈ ఫంక్షన్‌ని మళ్లీ మళ్లీ కాల్ చేయాల్సిన అవసరం లేదు. అప్పుడు మేము print() పద్ధతిని ఉపయోగించి 'new_array'ని ప్రింట్ చేస్తాము.
నంపిని దిగుమతి చేయండి వంటి ఉదాముద్రణ ( 'డివైడ్() ఫంక్షన్ అమలు: \n ' )
శ్రేణి1 = [ [ 35 , 72 , 66 , ఇరవై ఒకటి ] , [ 90 , 89 , యాభై , 88 ] ]
ముద్రణ ( 'డివిడెండ్ అర్రే1:' , శ్రేణి1 )
శ్రేణి2 = [ [ 19 , 99 , 43 , 22 ] , [ 87 , 46 , 75 , 18 ] ]
ముద్రణ ( 'డివైజర్ అర్రే2:' , శ్రేణి2 )
new_array = np.divide ( శ్రేణి1,శ్రేణి2 )
ముద్రణ ( 'కోషెంట్ అర్రే: \n ' , new_array )
NumPyలో డివైడ్() ఫంక్షన్ యొక్క పైన నిర్వచించిన కోడ్ యొక్క అవుట్‌పుట్ ఏమిటో చూద్దాం. మీరు క్రింద చూస్తున్నట్లుగా, మేము arra1 మరియు array2లను విభజించడం ద్వారా కావలసిన quotient శ్రేణిని పొందాము.
ముగింపు
ఈ ఆర్టికల్‌లో, డివైడ్() ఫంక్షన్ అంటే ఏమిటో మేము తెలుసుకున్నాము మరియు మేము అనేక విభిన్న ఉదాహరణలను కూడా అమలు చేసాము మరియు ఈ ఉదాహరణల కోడ్ యొక్క ప్రతి పంక్తిని వివరించాము, తద్వారా గందరగోళానికి గురికాదు.