పైథాన్ సమాన ఆపరేటర్ కాదు

విభిన్న వేరియబుల్స్ అయితే, కంటెంట్‌లు మరియు సంబంధిత డేటాటైప్‌లు రెండింటినీ పరిశీలించడం ముఖ్యం. రెండు ఇన్‌పుట్‌ల విలువలు భిన్నంగా ఉన్నప్పుడు, స్టేట్‌మెంట్ సంతృప్తి చెందుతుంది. పైథాన్ అంతటా, మేము ఉపయోగించవచ్చు! = లేదా సమానమైన ఆపరేషన్‌లు చేయకూడదు. సమానమైన ఆపరేటర్‌కు ఇరువైపులా సరఫరా చేయబడిన ఏదైనా రెండు పైథాన్ వేరియబుల్స్ లేదా ఒపెరాండ్‌ల విలువలు సమానంగా లేనప్పుడు, అది తప్పక నిజమని, తప్పు అని తిరిగి ఇవ్వాలి. పైథాన్ సరళంగా ఇంకా గట్టిగా టైప్ చేయబడినందున అనేక నిర్మాణాత్మక ప్రశ్న భాషలు వివిధ రకాలైన మ్యాచింగ్ గురించి గర్జిస్తాయి. సమానమైన ఆపరేటర్ రెండు వేరియబుల్స్‌లో అందించిన విలువలు ఒకేలా ఉన్నప్పుడు ట్రూని తిరిగి ఇవ్వాలి; అయితే, అవి వివిధ రకాలు. పైథాన్ పనిని సమాన ఆపరేటర్‌గా చూడడానికి కొన్ని ఉదాహరణలు చూద్దాం. అన్నింటిలో మొదటిది, మీ సిస్టమ్ పైథాన్ టూల్ ఇన్‌స్టాల్ చేసి కాన్ఫిగర్ చేయబడిందని మీరు నిర్ధారించుకోవాలి. పని చేయడం ప్రారంభించడానికి మీ ఇన్‌స్టాల్ చేసిన పైథాన్ సాధనాన్ని ప్రారంభించండి. ఈ కథనాన్ని అమలు చేసే సమయంలో, మేము స్పైడర్ పైథాన్ సాధనంపై పని చేస్తున్నాము.

ఉదాహరణ 01:

మా మొదటి ఉదాహరణ NOT సమాన ఆపరేటర్‌ను ఉపయోగించి రెండు లేదా అంతకంటే ఎక్కువ వేరియబుల్ టైప్ విలువలను సరిపోల్చడానికి వివిధ మార్గాలను కలిగి ఉంటుంది. ఇప్పుడు సాధనం తెరవబడింది, దానికి పైథాన్ మద్దతును జోడించడం మర్చిపోవద్దు. మేము స్క్రిప్ట్‌లో x మరియు y అనే రెండు పూర్ణాంక-రకం వేరియబుల్స్‌ను ప్రారంభించాము. ఆ తరువాత, వేరియబుల్స్ యొక్క రెండు విలువలను సరిపోల్చడానికి మేము! = గుర్తును ఉపయోగించాము మరియు బూలియన్ ఫలితం కొత్త వేరియబుల్‌గా సేవ్ చేయబడుతుంది. కోడ్ చివరలో, వేరియబుల్ c లో నిల్వ చేయబడిన బూలియన్ విలువ ముద్రించబడుతుంది.

మన కోడ్‌ని test.py గా సేవ్ చేద్దాం మరియు స్పైడర్ సాధనం యొక్క గ్రీన్ ఎగ్జిక్యూషన్ బటన్‌ని నొక్కడం ద్వారా దాన్ని అమలు చేయండి. డేటా రకంలో రెండు విలువలు సమానంగా మరియు ఒకే విధంగా ఉన్నందున మేము ఫలితాన్ని తప్పుగా పొందాము.

మేము ఈ క్రింది విధంగా కోడ్‌ని అప్‌డేట్ చేసాము. మేము మూడు వేర్వేరు వేరియబుల్స్‌ను ప్రకటించాము, వాటిలో 2 ఒకే విలువను కలిగి ఉంటాయి మరియు చివరిది వేరే విలువను కలిగి ఉంది. వేరియబుల్స్ a మరియు b ల మధ్య పోలిక ఫలితాన్ని ప్రింట్ చేయడానికి మేము నేరుగా మొదటి స్టేట్‌మెంట్‌లో NOT ఈక్వల్ ఆపరేటర్‌ను ఉపయోగించాము. అప్పుడు మేము ప్రింట్ స్టేట్‌మెంట్ వెలుపల a మరియు c వేరియబుల్స్ పోల్చి ఫలితాన్ని ముద్రించాము. అప్పుడు మేము స్ట్రింగ్ టైప్ వేరియబుల్ q ని ప్రకటించాము మరియు ప్రింట్ స్టేట్‌మెంట్‌లోని పూర్ణాంక వేరియబుల్ a తో పోల్చాము. స్క్రిప్ట్‌ను సేవ్ చేసి దాన్ని అమలు చేయండి.

విభిన్న వేరియబుల్స్‌తో పోలిస్తే ఫలితం ఒక తప్పుడు మరియు రెండు నిజమైన విలువలను ప్రదర్శిస్తుందని మీరు చూడవచ్చు. మొదటి రెండు ఫలితాలు పూర్ణాంక టైప్ వేరియబుల్స్ మధ్య ఉన్నాయి, అయితే చివరి పోలిక పూర్ణాంకం మరియు స్ట్రింగ్ టైప్ వేరియబుల్స్ మధ్య ఉంది. అందువల్ల, రెండూ సమానం కాదని ట్రూ రిటర్న్ ఇస్తుంది.

ఉదాహరణ 02:

పైథాన్ ఉపయోగిస్తున్నప్పుడు if స్టేట్‌మెంట్‌లో ఉపయోగించిన నాట్ ఈక్వల్ ఆపరేటర్‌ను చూద్దాం. మేము కోడ్‌లో రెండు వేరియబుల్స్ ఉపయోగించాము. వేరియబుల్ x అనేది పూర్ణాంక రకం మరియు y అనేది స్ట్రింగ్ రకం. అప్పుడు మేము if స్టేట్‌మెంట్‌ని ప్రారంభించాము మరియు NOT EQUAL ఆపరేటర్‌ని రెండు ఒపెరాండ్‌లలోనూ ఉపయోగించాము, అవి సమానమేనా కాదా అని తనిఖీ చేయడానికి. చివరికి, కొన్ని స్టేట్‌మెంట్‌లను ముద్రించారు.

Test.py స్క్రిప్ట్ ఫైల్‌ను అమలు చేసిన తర్వాత, దిగువ చిత్రంలో అందించిన విధంగా స్ట్రింగ్ అవుట్‌పుట్ విలువగా మాకు లభించింది.

మరొక ఉదాహరణను చూద్దాం. ఈసారి మేము స్ట్రింగ్ టైప్ వేరియబుల్స్ రెండింటినీ ఉపయోగించాము మరియు if స్టేట్‌మెంట్‌లో వాటిని పోల్చాము. చివరగా, మేము రెండు వేరియబుల్స్‌లో కొన్ని స్ట్రింగ్ విలువలతో ముద్రించడానికి ప్రింట్ స్టేట్‌మెంట్‌ను ఉపయోగించాము. అవుట్‌పుట్ తప్పనిసరిగా లోపం లేకుండా ఉండాలి.

ఈ ఫైల్‌ను అమలు చేస్తున్నప్పుడు, మాకు ఎలాంటి లోపాలు లేవు మరియు కింది విధంగా వర్కింగ్ అవుట్‌పుట్ వచ్చింది.

ఇప్పటి నుండి కొన్ని క్లిష్టమైన ఉదాహరణలను చూద్దాం. ఈ సందర్భంలో, మేము 21 విలువ కలిగిన పూర్ణాంక వేరియబుల్ z ని ఉపయోగిస్తున్నాము. మేము మొదట ఒక వేరియబుల్ z యొక్క మాడ్యులస్‌ను పూర్ణాంకం 2 తో లెక్కించాము. ఆ తర్వాత, సరిపోల్చడానికి NOT EQUAL ఆపరేటర్‌ని ఉపయోగించడానికి if స్టేట్‌మెంట్‌ను ఉపయోగించాము. లెక్కించిన విలువ 0. తో లెక్కించబడిన మాడ్యులస్ 0 కి సమానం కానప్పటికీ, అది తప్పనిసరిగా వేరియబుల్ z విలువను ముద్రించాలి మరియు స్ట్రింగ్ చెప్పడం కూడా ప్రింట్ స్టేట్‌మెంట్‌లో ఉపయోగించబడదు.

ఫైల్‌ను సేవ్ చేసి, ఎగ్జిక్యూట్ చేసిన తర్వాత, మాకు ఎలాంటి లోపాలు లేవు, మరియు స్ట్రింగ్‌తో పాటు వేరియబుల్ z ప్రింట్ అవుట్ కూడా కాదు.

ఉదాహరణ 03:

పై ఉదాహరణలో, మేము if స్టేట్‌మెంట్‌ను ఉపయోగించాము. ఈసారి మేము మా ఉదాహరణలో if-else ప్రకటనను ఉపయోగిస్తాము. మేము ఈ క్రింది విధంగా కోడ్‌ని అప్‌డేట్ చేసాము. ముందుగా, ఒక పూర్ణాంకం రకం వేరియబుల్ a విలువ 10 తో ప్రారంభించండి, ఆ తర్వాత, మేము మా కోడ్‌లో if-else ప్రకటనను ఉపయోగించాము. ఒకవేళ స్టేట్‌మెంట్‌లో భాగం వేరియబుల్ a ని 20 విలువతో సరిపోల్చడానికి ఆపరేటర్ కాదు. షరతు సంతృప్తి చెందితే, అది మా విలువలను సమానంగా ముద్రించదు; లేకపోతే, విలువలు సమానమని ముద్రించడానికి ఇతర స్టేట్‌మెంట్‌కు నియంత్రణ ఇవ్వబడుతుంది.

మీ కోడ్‌ని సేవ్ చేసి అమలు చేయండి. ఒకవేళ స్టేట్‌మెంట్ సంతృప్తి చెందితే మీరు స్థితిని చూడవచ్చు మరియు విలువలు సమానంగా లేవని ఇది ముద్రించింది.

ఒక సారి మరొక ఉదాహరణను చూద్దాం. స్టేట్‌మెంట్ ఈ స్ట్రింగ్‌ని కొంత విలువతో సరిపోల్చడానికి మరియు సందేశాన్ని ముద్రించడానికి ఉపయోగిస్తుంటే, మేము అక్సా విలువను కలిగి ఉన్న స్ట్రింగ్ స్ట్రింగ్‌ను ప్రకటించాము. If స్టేట్మెంట్ యొక్క పరిస్థితి విఫలమైనప్పుడు, వేరియబుల్ str ఇచ్చిన విలువకు సమానం కాదా అని చూడటానికి elif స్టేట్‌మెంట్‌కు కంట్రోల్ బదిలీ చేయబడుతుంది. ఆ తరువాత, అది ఒక సందేశాన్ని ప్రింట్ చేస్తుంది.

If స్టేట్‌మెంట్‌లోని షరతు సంతృప్తి చెందినందున అది మొదటి ప్రింట్ స్టేట్‌మెంట్‌ను ప్రింట్ చేస్తుంది, మరియు నియంత్రణ ఎలిఫ్ స్టేట్‌మెంట్‌కు ఎప్పటికీ ఇవ్వబడదు.

ఉదాహరణకు, వేరియబుల్ స్ట్రార్ విలువను యాసిన్‌గా మారుద్దాం. ఈసారి if స్టేట్‌మెంట్‌లో పేర్కొన్న షరతు తప్పు అవుతుంది మరియు elif స్టేట్‌మెంట్‌కు నియంత్రణ ఇవ్వబడుతుంది. అందువల్ల, షరతుకు అనుగుణంగా ఎలిఫ్ స్టేట్‌మెంట్ ప్రింట్ స్టేట్‌మెంట్ ముద్రించబడుతుంది.

ఇప్పుడు మేము కోడ్‌ను మరోసారి అమలు చేసినప్పుడు, అది నెస్టెడ్ if-else స్టేట్‌మెంట్ యొక్క elif భాగంలో పేర్కొన్న ప్రింట్ స్టేట్‌మెంట్ ఫలితాన్ని ప్రదర్శిస్తుంది.

ఉదాహరణ 04:

చివరగా, ఈసారి సమాన పోలిక ఆపరేటర్‌ను పరీక్షించడానికి మేము సంక్లిష్టమైన ఉదాహరణ చేస్తాము. కాబట్టి, మేము పరీక్ష అనే తరగతిని ప్రారంభించాము. ఈ తరగతిలో, మేము విలువ 0. కలిగిన వేరియబుల్‌ని ప్రారంభించాము. మరొక వేరియబుల్, డేటా, దానిలో ఏదీ లేని విలువతో ప్రారంభించబడింది. దీని తరువాత, క్లాస్ ఉదాహరణ నుండి ఈ వేరియబుల్స్ విలువలను పొందడానికి మేము ఈ తరగతి యొక్క కన్స్ట్రక్టర్‌ను ప్రారంభించాము. అప్పుడు మేము మా కోడ్‌లో అంతర్నిర్మిత NOT EQUAL పద్ధతిని ప్రారంభించాము మరియు అందులో if-else స్టేట్‌మెంట్‌ను ఉపయోగించాము. నిర్మాతకు విలువలు పంపడానికి మూడు వస్తువులు సృష్టించబడ్డాయి. ఆ తర్వాత, పోలిక ఫలితాన్ని ముద్రించడానికి ప్రింట్ స్టేట్‌మెంట్‌లోని వస్తువులను ఒకదానితో ఒకటి పోల్చాము. కోడ్‌ని సేవ్ చేసి అమలు చేయండి.

మొదటి ప్రింట్ స్టేట్‌మెంట్‌కు రిటర్న్‌గా అవుట్‌పుట్ ఫాల్స్ చూపిస్తుంది ఎందుకంటే రెండు ఆబ్జెక్ట్‌లకు పార్స్ చేసిన విలువలు ఒకే విధంగా ఉంటాయి. దీనికి విరుద్ధంగా, t2 మరియు t3 రెండూ వేర్వేరు విలువలను కలిగి ఉంటాయి మరియు సమానంగా ఉండవు కాబట్టి రెండవ ముద్రణ ప్రకటన ట్రూని అందిస్తుంది.

ముగింపు:

బాగా వివరించిన ఇలస్ట్రేషన్ స్క్రిప్ట్‌ల సహాయంతో, పైథాన్ నాట్ ఈక్వల్ పోలిక ఫంక్షన్ అంటే ఏమిటి మరియు రెండు వేరియబుల్స్ ఒకేలా ఉండవని నిర్ధారించడానికి ఇది ఎలా ఉపయోగించబడుతుందో మేము నేర్చుకున్నాము.