பைதான் சமமான ஆபரேட்டர் அல்ல

மாறிகள் மாறும்போது, ​​உள்ளடக்கங்கள் மற்றும் தொடர்புடைய தரவு வகைகள் இரண்டையும் ஆராய்வது முக்கியம். இரண்டு உள்ளீடுகளின் மதிப்புகள் வேறுபடும்போதெல்லாம், அறிக்கை திருப்தி அடைகிறது. பைதான் முழுவதும், நாம் பயன்படுத்தலாம்! = அல்லது சமமான செயல்பாடுகளைச் செய்யக்கூடாது. சமமான ஆபரேட்டரின் இருபுறமும் வழங்கப்பட்ட எந்த இரண்டு பைதான் மாறிகள் அல்லது ஆபரேண்டுகளின் மதிப்புகள் சமமாக இல்லாத போதெல்லாம், அது உண்மையாகவும், தவறாகவும் திரும்ப வேண்டும். பல கட்டமைக்கப்பட்ட வினவல் மொழிகள் பைதான் நெகிழ்வாக இன்னும் இறுக்கமாக தட்டச்சு செய்யப்பட்டிருப்பதால் பல்வேறு வகைகளை பொருத்துவது பற்றி முணுமுணுக்கலாம். இரண்டு மாறிகளில் வழங்கப்பட்ட மதிப்புகள் ஒரே மாதிரியாக இருக்கும்போதெல்லாம் சமமான ஆபரேட்டர் உண்மை திரும்ப வேண்டும்; இருப்பினும், அவை பல்வேறு வகைகளில் உள்ளன. பைதான் வேலை செய்வதற்கு சமமான ஆபரேட்டர் அல்ல என்பதற்கு சில எடுத்துக்காட்டுகளைக் காண்போம். முதலில், உங்கள் கணினியில் ஒரு பைதான் கருவி நிறுவப்பட்டு உள்ளமைக்கப்பட்டிருப்பதை உறுதி செய்ய வேண்டும். வேலை செய்யத் தொடங்க உங்கள் நிறுவப்பட்ட பைதான் கருவியைத் தொடங்கவும். இந்த கட்டுரையை செயல்படுத்தும் நேரத்தில், நாங்கள் ஸ்பைடர் பைதான் கருவியில் வேலை செய்து வருகிறோம்.

எடுத்துக்காட்டு 01:

சமமான ஆபரேட்டரைப் பயன்படுத்தி இரண்டு அல்லது அதற்கு மேற்பட்ட மாறுபட்ட வகை மதிப்புகளை ஒப்பிடுவதற்கு எங்கள் முதல் எடுத்துக்காட்டில் பல்வேறு வழிகள் இருக்கும். இப்போது கருவி திறக்கப்பட்டுள்ளது, அதற்கு மலைப்பாம்பு ஆதரவைச் சேர்க்க மறக்காதீர்கள். ஸ்கிரிப்டில் x மற்றும் y ஆகிய இரண்டு முழு-வகை மாறிகளை நாங்கள் துவக்கியுள்ளோம். அதன் பிறகு, மாறிகளின் மதிப்புகள் இரண்டையும் ஒப்பிடுவதற்கு! = அடையாளத்தைப் பயன்படுத்தினோம், மேலும் பூலியன் முடிவு ஒரு புதிய மாறியாக சேமிக்கப்படும், c. குறியீட்டின் முடிவில், மாறிலியில் சேமிக்கப்பட்டுள்ள பூலியன் மதிப்பு அச்சிடப்படும்.

எங்கள் குறியீட்டை test.py ஆக சேமித்து, ஸ்பைடர் கருவியின் பச்சை செயல்படுத்தல் பொத்தானை அழுத்துவதன் மூலம் அதை செயல்படுத்துவோம். தரவு மதிப்பில் இரண்டு மதிப்புகளும் சமமாகவும் ஒரே மாதிரியாகவும் இருந்ததால் தவறான முடிவை நாங்கள் பெற்றோம்.

கீழே உள்ள குறியீட்டை நாங்கள் புதுப்பித்துள்ளோம். நாங்கள் மூன்று வெவ்வேறு மாறிகளை அறிவித்தோம், அவற்றில் 2 ஒரே மதிப்புடையவை, கடைசியாக வேறு மதிப்பு உள்ளது. மாறிகள் a மற்றும் b க்கு இடையிலான ஒப்பீட்டின் முடிவை நேரடியாக அச்சிட முதல் அறிக்கையில் NOT சமமான ஆபரேட்டரைப் பயன்படுத்தியுள்ளோம். அச்சு அறிக்கைக்கு வெளியே a மற்றும் c மாறிகளை ஒப்பிட்டு முடிவை அச்சிட்டோம். பின்னர் நாம் ஒரு சரம் வகை மாறியை அறிவித்துள்ளோம் மற்றும் அதை அச்சு அறிக்கையில் உள்ள முழு எண் a உடன் ஒப்பிட்டுள்ளோம். ஸ்கிரிப்டைச் சேமித்து இயக்கவும்.

வெவ்வேறு மாறிகளுடன் ஒப்பிடும்போது முடிவு ஒரு தவறான மற்றும் இரண்டு உண்மையான மதிப்புகளைக் காண்பித்ததை நீங்கள் காணலாம். முதல் இரண்டு முடிவுகள் முழு வகை மாறிகள் இடையே இருந்தன, ஆனால் கடைசி ஒப்பீடு முழு எண் மற்றும் சரம் வகை மாறிகள் இடையே இருந்தது. எனவே, இது இரண்டும் சமமாக இல்லை என்பது உண்மை.

உதாரணம் 02:

பைத்தானைப் பயன்படுத்தும் போது if அறிக்கையில் பயன்படுத்தப்படும் Not Equal ஆபரேட்டரைப் பார்ப்போம். குறியீட்டில் இரண்டு மாறிகள் பயன்படுத்தினோம். மாறி x என்பது ஒரு முழு எண் வகை, மற்றும் y என்பது ஒரு சரம் வகை. பின்னர் if அறிக்கையை ஆரம்பித்துள்ளோம், அதில் இரண்டு சமமானவையா இல்லையா என்பதை சரிபார்ப்பதற்கு சமமான ஆபரேட்டரை பயன்படுத்தவில்லை. இறுதியில், சில அறிக்கைகள் அச்சிடப்பட்டன.

ஒரு test.py ஸ்கிரிப்ட் கோப்பை இயக்கும்போது, ​​கீழேயுள்ள படத்தில் வழங்கப்பட்டதைப் போல சரத்தை வெளியீட்டு மதிப்பாகப் பெற்றோம்.

மற்றொரு நிகழ்வைப் பார்ப்போம். இந்த முறை நாம் சரம் வகை மாறிகள் இரண்டையும் பயன்படுத்தினோம் மற்றும் if அறிக்கையில் அவற்றை ஒப்பிட்டுள்ளோம். கடைசியாக, இரண்டு மாறிகளையும் சில சரம் மதிப்புகளுடன் அச்சிட அச்சு அறிக்கையைப் பயன்படுத்தினோம். வெளியீடு பிழையில்லாமல் இருக்க வேண்டும்.

இந்த கோப்பை இயக்கும்போது, ​​எங்களுக்கு எந்த பிழையும் இல்லை

இனிமேல் சில சிக்கலான எடுத்துக்காட்டுகளைக் காண்போம். இந்த நிகழ்வில், 21 இன் மதிப்பு கொண்ட ஒரு முழு எண் மாறியைப் பயன்படுத்துகிறோம். முதலில் நாம் ஒரு மாறி z இன் தொகுதியை முழு எண் 2 உடன் கணக்கிட்டுள்ளோம். அதன் பிறகு, ஒப்பிடுவதற்கு சமமான ஆபரேட்டரைப் பயன்படுத்துவதற்கு if அறிக்கையைப் பயன்படுத்தினோம். கணக்கிடப்பட்ட மதிப்பு 0. உடன் கணக்கிடப்பட்ட மாடுலஸ் 0 க்கு சமமாக இல்லாவிட்டாலும், அது மாறிலியான z இன் மதிப்பை அச்சிட வேண்டும் மற்றும் சரம் சொல்வது அச்சு அறிக்கையில் கூட பயன்படுத்தப்படாது.

கோப்பைச் சேமித்து செயல்படுத்திய பிறகு, எங்களுக்கு எந்த தவறும் இல்லை

உதாரணம் 03:

மேலே உள்ள எடுத்துக்காட்டில், நாங்கள் if அறிக்கையைப் பயன்படுத்தினோம். இந்த முறை if-else அறிக்கையை எங்கள் உதாரணத்தில் பயன்படுத்துவோம். கீழே உள்ள குறியீட்டை நாங்கள் புதுப்பித்துள்ளோம். முதலில், ஒரு முழு எண் வகை மாறியை a இன் மதிப்பு 10 உடன் தொடங்கவும், அதன் பிறகு, எங்கள் குறியீட்டில் if-else அறிக்கையைப் பயன்படுத்தினோம். அறிக்கையின் ஒரு பகுதி 20 ஐப் பயன்படுத்தி மாறி மாறி ஒப்பிடுவதற்கு ஆபரேட்டர் அல்ல. இல்லையெனில், மதிப்புகள் சமம் என்று அச்சிட மற்ற அறிக்கைக்கு கட்டுப்பாடு வழங்கப்படும்.

உங்கள் குறியீட்டைச் சேமித்து இயக்கவும். அறிக்கையில் திருப்தி ஏற்பட்டால், அந்த மதிப்புகள் சமமாக இல்லை என்று அது அச்சிடுகிறது.

ஒரு முறை மற்றொரு நிகழ்வைப் பார்ப்போம். அக்ஸா மதிப்புள்ள ஒரு ஸ்ட்ரிங் ஸ்ட்ரை அறிவித்துள்ளோம், இந்த ஸ்ட்ரிங்கை இந்த மதிப்பை சில மதிப்புகளுடன் ஒப்பிட்டு அச்சிட அச்செய்தியைப் பயன்படுத்துகிறோம். If அறிக்கையின் நிபந்தனை தோல்வியடையும் போது, ​​கட்டுப்பாடு elif அறிக்கைக்கு மாற்றப்படும். அதன் பிறகு, அது ஒரு செய்தியை அச்சடிக்கும்.

If அறிக்கையில் உள்ள நிபந்தனை திருப்தி அடைவதால், அது முதல் அச்சு அறிக்கையை அச்சிடும், மற்றும் கட்டுப்பாடு elif அறிக்கைக்கு வழங்கப்படாது.

உதாரணமாக, ஒரு மாறி str இன் மதிப்பை யாசினாக மாற்றுவோம். இந்த முறை if அறிக்கையில் குறிப்பிடப்பட்டுள்ள நிபந்தனை தவறாகிவிடும், மேலும் elif அறிக்கைக்கு கட்டுப்பாடு கொடுக்கப்படும். எனவே, எலிஃப் அறிக்கையின் அச்சு அறிக்கை நிபந்தனைக்கு ஏற்ப அச்சிடப்படும்.

இப்போது நாம் குறியீட்டை மீண்டும் ஒருமுறை இயக்கும்போது, ​​உள்ளமைக்கப்பட்ட if-else அறிக்கையின் elif பகுதிக்குள் குறிப்பிடப்பட்டுள்ள அச்சு அறிக்கையின் முடிவை அது காண்பிக்கும்.

எடுத்துக்காட்டு 04:

கடைசியாக, இந்த முறை சமமான ஒப்பீட்டு ஆபரேட்டரை சோதிக்க ஒரு சிக்கலான உதாரணத்தை நாங்கள் செய்வோம். எனவே, நாங்கள் டெஸ்ட் என்ற வகுப்பைத் தொடங்கியுள்ளோம். இந்த வகுப்பிற்குள், நான் ஒரு மாறியை ஆரம்பித்துள்ளேன். மதிப்பு 0. ஐ கொண்டிருக்கிறது, மற்றொரு மாறி, தரவு, ஒரு மதிப்பிலும் தொடங்கப்படவில்லை. இதற்குப் பிறகு, இந்த மாறிகளின் மதிப்புகளை வகுப்பு நிகழ்விலிருந்து பெற இந்த வகுப்பின் கட்டமைப்பாளரை நாங்கள் துவக்கியுள்ளோம். எங்கள் குறியீட்டில் உள்ளமைக்கப்பட்ட சமமற்ற முறையை நாங்கள் தொடங்கினோம் மற்றும் அதில் if-else அறிக்கையைப் பயன்படுத்தினோம். கட்டமைப்பாளருக்கு மதிப்புகளை அனுப்ப மூன்று பொருள்கள் உருவாக்கப்பட்டுள்ளன. அதன் பிறகு, ஒப்பீட்டு முடிவை அச்சிட அச்சு அறிக்கையில் உள்ள பொருட்களை ஒருவருக்கொருவர் ஒப்பிட்டுள்ளோம். குறியீட்டைச் சேமித்து இயக்கவும்.

வெளியீட்டில் பொய்யை முதல் அச்சு அறிக்கைக்கு திரும்புவதாகக் காட்டுகிறது, ஏனெனில் இரண்டு பொருள்களுக்கும் பாகுபடுத்தப்பட்ட மதிப்புகள் ஒன்றே. மாறாக, t2 மற்றும் t3 இரண்டும் வெவ்வேறு மதிப்புகளைக் கொண்டவை மற்றும் சமமானவை அல்ல என்பதால், இரண்டாவது அச்சு அறிக்கை உண்மை என்பதைத் தருகிறது.

முடிவுரை:

நன்கு விளக்கப்பட்ட விளக்கப்பட ஸ்கிரிப்டுகளின் உதவியுடன், பைதான் சமமான ஒப்பீட்டு செயல்பாடு என்ன, இரண்டு மாறிகள் ஒரே மாதிரியாக இல்லையா என்பதை தீர்மானிக்க இது எவ்வாறு பயன்படுத்தப்படுகிறது என்பதை நாங்கள் கற்றுக்கொண்டோம்.