విద్యార్థుల డేటా శ్రేణుల రూపంలో నిల్వ చేయబడిందని అనుకుందాం మరియు మేము విఫలమైన విద్యార్థులను ఫిల్టర్ చేయాలనుకుంటున్నాము. మేము శ్రేణిని ఫిల్టర్ చేస్తాము మరియు విఫలమైన విద్యార్థులను మినహాయిస్తాము మరియు ఉత్తీర్ణత సాధించిన విద్యార్థి యొక్క కొత్త శ్రేణిని పొందుతాము.
NumPy అర్రేని ఫిల్టర్ చేయడానికి దశలు
దశ 1: NumPy మాడ్యూల్‌ని దిగుమతి చేస్తోంది.
దశ 2: శ్రేణిని సృష్టిస్తోంది.
దశ 3: ఫిల్టరింగ్ పరిస్థితిని జోడించండి.
దశ 4: కొత్త ఫిల్టర్ చేసిన శ్రేణిని సృష్టించండి.
సింటాక్స్:
శ్రేణులను ఫిల్టర్ చేయడానికి అనేక మార్గాలు ఉన్నాయి. ఇది ఫిల్టర్ యొక్క స్థితిపై ఆధారపడి ఉంటుంది, మనకు ఒకే షరతు ఉంటే లేదా మనకు ఒకటి కంటే ఎక్కువ షరతులు ఉంటే.
విధానం 1: ఒక షరతు కోసం మేము క్రింది వాక్యనిర్మాణాన్ని అనుసరిస్తాము
అమరిక [ అమరిక < పరిస్థితి ]పైన పేర్కొన్న సింటాక్స్‌లో, “శ్రేణి” అనేది శ్రేణి పేరు, దీని నుండి మనం మూలకాలను ఫిల్టర్ చేస్తాము. మరియు కండిషన్ అనేది మూలకాలు ఫిల్టర్ చేయబడిన స్థితి మరియు ఆపరేటర్ “<” కంటే తక్కువ సూచించే గణిత సంకేతం. మనకు ఒకే ఒక షరతు లేదా ప్రకటన ఉన్నప్పుడు దాన్ని ఉపయోగించడం సమర్ధవంతంగా ఉంటుంది.
విధానం 2: 'OR' ఆపరేటర్ని ఉపయోగించడం
అమరిక [ ( అమరిక < షరతు1 ) | ( అమరిక > షరతు2 ) ]ఈ పద్ధతిలో, “శ్రేణి” అనేది శ్రేణి పేరు, దీని నుండి మనం విలువలను ఫిల్టర్ చేస్తాము మరియు షరతు దానికి పంపబడుతుంది. ఆపరేటర్ '|' 'OR' ఫంక్షన్‌ను సూచించడానికి ఉపయోగించబడుతుంది అంటే రెండు షరతుల నుండి ఒకటి నిజం అయి ఉండాలి. రెండు షరతులు ఉన్నప్పుడు ఇది ఉపయోగపడుతుంది.
విధానం 3: “AND” ఆపరేటర్ని ఉపయోగించడం.
అమరిక [ ( అమరిక < షరతు1 ) & ( అమరిక > షరతు2 ) ]కింది వాక్యనిర్మాణంలో, “శ్రేణి” అనేది ఫిల్టర్ చేయవలసిన శ్రేణి పేరు. అయితే, పై సింటాక్స్‌లో చర్చించిన విధంగా షరతు రాష్ట్రంగా ఉంటుంది, అయితే “&” ఉపయోగించిన ఆపరేటర్ AND ఆపరేటర్, అంటే షరతు రెండూ తప్పక తప్పని సరిగా ఉండాలి.
విధానం 4: జాబితా చేయబడిన విలువల ద్వారా వడపోత
అమరిక [ ఉదా in1d ( అమరిక , [ విలువల జాబితా ] ) ]ఈ పద్ధతిలో, ఫిల్టర్ చేయవలసిన శ్రేణి యొక్క మూలకం మరొక శ్రేణిలో ఉందా లేదా అనే రెండు శ్రేణులను పోల్చడానికి ఉపయోగించే మా నిర్వచించిన శ్రేణి “np.in1d”ని మేము ఆమోదించాము. మరియు శ్రేణి np.in1d ఫంక్షన్‌కి పంపబడుతుంది, అది ఇవ్వబడిన శ్రేణి నుండి ఫిల్టర్ చేయబడుతుంది.
ఉదాహరణ # 01:
ఇప్పుడు, పైన చర్చించిన పద్ధతిని ఒక ఉదాహరణలో అమలు చేద్దాం. ముందుగా, మేము పైథాన్ అందించిన మా NumPy లైబ్రరీలను చేర్చుతాము. అప్పుడు, మేము '2', '3', '1', '9', '3', '5', '6' మరియు '1' విలువలను కలిగి ఉండే 'my_array' పేరుతో ఒక శ్రేణిని సృష్టిస్తాము. తరువాత, మనము 'my_array[(my_array < 5)]' అని ఉన్న మన ఫిల్టర్ కోడ్‌ని ప్రింట్ స్టేట్‌మెంట్‌కు పాస్ చేస్తాము అంటే మనం '5' కంటే తక్కువ విలువలను ఫిల్టర్ చేస్తున్నామని అర్థం. తదుపరి పంక్తిలో, మేము '1', '2', '6', '3', '8', '1' మరియు '0' విలువలను కలిగి ఉండటానికి బాధ్యత వహించే 'శ్రేణి' పేరు యొక్క మరొక శ్రేణిని సృష్టించాము. ప్రింట్ స్టేట్‌మెంట్‌కు, మేము 5 కంటే ఎక్కువ విలువలను ముద్రిస్తాము అనే షరతును ఆమోదించాము.
చివరగా, మేము మరొక శ్రేణిని సృష్టించాము, దానికి మేము 'arr' అని పేరు పెట్టాము. ఇది '6', '7','10', '12' మరియు '14' విలువలను కలిగి ఉంది. ఇప్పుడు ఈ శ్రేణి కోసం, కండిషన్ సరిపోలకపోతే ఏమి జరుగుతుందో చూడటానికి మేము శ్రేణిలో లేని విలువను ముద్రిస్తాము. అలా చేయడానికి, మేము '5' విలువకు సమానమైన విలువను ఫిల్టర్ చేసే షరతును ఆమోదించాము.
దిగుమతి మొద్దుబారిన వంటి ఉదానా_శ్రేణి = ఉదా అమరిక ( [ రెండు , 3 , 1 , 9 , 3 , 5 , రెండు , 6 , 1 ] )
ముద్రణ ( 'విలువలు 5 కంటే తక్కువ' , నా_శ్రేణి [ ( నా_శ్రేణి < 5 ) ] )
అమరిక = ఉదా అమరిక ( [ 1 , రెండు , 6 , 3 , 8 , 1 , 0 ] )
ముద్రణ ( '5 కంటే ఎక్కువ విలువలు' , అమరిక [ ( అమరిక > 5 ) ] )
అరె = ఉదా అమరిక ( [ 6 , 7 , 10 , 12 , 14 ] )
ముద్రణ ( 'విలువలు 5కి సమానం' , అరె [ ( అరె == 5 ) ] )
కోడ్‌ని అమలు చేసిన తర్వాత, మేము ఫలితంగా క్రింది అవుట్‌పుట్‌ను కలిగి ఉన్నాము, దీనిలో మేము 3 అవుట్‌పుట్‌లను ప్రదర్శించాము, రెండవ అమలులో '5' కంటే తక్కువ మూలకాల కోసం మొదటిది '5' కంటే ఎక్కువ విలువలను ముద్రించాము. ముగింపులో, మేము అది ఏ లోపాన్ని ప్రదర్శించకుండా చూడగలిగినందున ఉనికిలో లేని విలువను ముద్రించాము కానీ ఖాళీ శ్రేణిని ప్రదర్శిస్తాము, అంటే ఇవ్వబడిన శ్రేణిలో కావలసిన విలువ ఉనికిలో లేదు.
ఉదాహరణ # 02:
ఈ సందర్భంలో, మేము శ్రేణులను ఫిల్టర్ చేయడానికి ఒకటి కంటే ఎక్కువ షరతులను ఉపయోగించే కొన్ని పద్ధతులను ఉపయోగిస్తాము. దీన్ని అమలు చేయడానికి, మేము కేవలం NumPy లైబ్రరీని దిగుమతి చేసి, ఆపై '24', '3', '12', '9', '3', '5', విలువలతో '9' పరిమాణం యొక్క ఒక డైమెన్షనల్ శ్రేణిని సృష్టిస్తాము. '2', '6' మరియు '7'. తరువాతి పంక్తిలో, మేము ఒక ప్రింట్ స్టేట్‌మెంట్‌ను ఉపయోగించాము, దానికి మేము ఒక శ్రేణిని పాస్ చేసాము, దానిని ఆర్గ్యుమెంట్‌గా షరతుతో “my_array” పేరుతో ప్రారంభించాము. ఇందులో, మేము రెండింటి నుండి లేదా షరతును ఆమోదించాము, ఒక షరతు నిజం కావాలి. రెండూ నిజమైతే, ఇది రెండు షరతులకు సంబంధించిన డేటాను ప్రదర్శిస్తుంది. ఈ స్థితిలో, మేము '5' కంటే తక్కువ మరియు '9' కంటే ఎక్కువ విలువలను ముద్రించాలనుకుంటున్నాము. తదుపరి లైన్‌లో, మేము శ్రేణిని ఫిల్టర్ చేయడానికి షరతును ఉపయోగిస్తే ఏమి జరుగుతుందో తనిఖీ చేయడానికి మేము AND ఆపరేటర్ని ఉపయోగించాము. ఈ స్థితిలో, మేము '5' కంటే ఎక్కువ మరియు '9' కంటే తక్కువ విలువలను ప్రదర్శించాము.
నంపీని దిగుమతి చేయండి వంటి ఉదానా_శ్రేణి = ఉదా అమరిక ( [ 24 , 3 , 12 , 9 , 3 , 5 , రెండు , 6 , 7 ] )
ముద్రణ ( 'కంటే తక్కువ విలువలు 5 లేదా అంతకన్నా ఎక్కువ 9 ” , నా_శ్రేణి [ ( నా_శ్రేణి < 5 ) | ( నా_శ్రేణి > 9 ) ] )
ముద్రణ ( 'కంటే ఎక్కువ విలువలు 5 మరియు కంటే తక్కువ 9 ” , నా_శ్రేణి [ ( నా_శ్రేణి > 5 ) & ( నా_శ్రేణి < 9 ) ] )
దిగువ స్నిప్పెట్‌లో చూపినట్లుగా, పైన ఉన్న కోడ్ కోసం మా ఫలితం ప్రదర్శించబడుతుంది, దీనిలో మేము శ్రేణిని ఫిల్టర్ చేసాము మరియు క్రింది ఫలితాన్ని పొందాము. మనం చూడగలిగినట్లుగా, మొదటి అవుట్‌పుట్‌లో 9 కంటే ఎక్కువ మరియు 5 కంటే తక్కువ విలువలు ప్రదర్శించబడతాయి మరియు 5 మరియు 9 మధ్య విలువలు విస్మరించబడతాయి. అయితే, తదుపరి లైన్‌లో, మేము “6” మరియు “7” అనే “5” మరియు “9” మధ్య విలువలను ముద్రించాము. శ్రేణుల ఇతర విలువలు ప్రదర్శించబడవు.
ముగింపు
ఈ గైడ్‌లో, మేము NumPy ప్యాకేజీ ద్వారా అందించబడిన ఫిల్టర్ పద్ధతుల వినియోగాన్ని క్లుప్తంగా చర్చించాము. నంపీ అందించిన ఫిల్టర్ మెథడాలజీలను అమలు చేయడానికి ఉత్తమ మార్గం గురించి మీ కోసం వివరించడానికి మేము అనేక ఉదాహరణలను అమలు చేసాము.