Habang magkakaiba ang mga variable, mahalagang suriin ang parehong nilalaman at kani-kanilang mga datatypes. Kailan man magkakaiba ang mga halaga ng dalawang input, nasiyahan ang pahayag. Sa buong Python, maaari naming gamitin ang! = O hindi upang hindi pantay na operasyon. Kailan man ang mga halaga ng anumang dalawang variable ng Python o operan na ibinibigay sa magkabilang panig ng hindi pantay na operator ay hindi pantay, dapat itong bumalik nang totoo, kung hindi man totoo. Maraming mga nakaayos na mga wika ng query ay maaaring magreklamo tungkol sa pagtutugma ng iba't ibang mga uri dahil ang Python ay may kakayahang umangkop ngunit mahigpit na nai-type. Dapat ibalik ng hindi pantay na operator ang Totoo tuwing ang mga halagang ibinigay sa dalawang variable ay pareho; gayunpaman, sila ay may iba't ibang uri. Mayroon tayong ilang mga halimbawa upang makita ang pagtatrabaho ng sawa Hindi pantay na operator. Una sa lahat, dapat mong tiyakin na ang iyong system ay may naka-install at naka-configure na tool na sawa. Ilunsad ang iyong naka-install na tool sa sawa upang magsimulang magtrabaho. Sa oras ng pagpapatupad ng artikulong ito, nagtatrabaho kami sa tool na Spyder Python.
Halimbawa 01:
Ang aming unang halimbawa ay maglalaman ng iba't ibang mga paraan upang ihambing ang dalawa o higit pang mga halaga ng variable na uri gamit ang HINDI Pantay na operator. Ngayon ang tool ay binuksan, huwag kalimutang magdagdag ng suporta sawa dito. Nasimulan namin ang dalawang variable na uri ng integer, x at y sa script. Pagkatapos nito, ginamit namin ang! = Sign upang ihambing ang parehong mga halaga ng mga variable, at ang resulta ng Boolean ay nai-save sa isang bagong variable, c. Sa pagtatapos ng code, ang halagang Boolean na naimbak sa variable c ay mai-print.
I-save natin ang aming code bilang test.py at ipatupad ito sa pamamagitan ng pagpindot sa berdeng pagpapatupad na pindutan ng tool na Spyder. Nakuha namin ang resulta bilang Mali sapagkat ang parehong mga halaga ay pantay at pareho sa uri ng data.
Na-update namin ang code tulad ng nasa ibaba. Idineklara namin ang tatlong magkakaibang mga variable, na may 2 sa mga ito ay may parehong halaga, at ang huli ay may iba't ibang halaga. Ginamit namin ang HINDI Pantay na operator sa unang pahayag nang direkta upang mai-print ang resulta ng paghahambing sa pagitan ng mga variable na a at b. Pagkatapos ay inihambing namin ang mga variable a at c sa labas ng pahayag na naka-print at nai-print ang resulta. Pagkatapos ay idineklara namin ang isang string type variable q at inihambing ito sa variable na integer a sa pahayag na naka-print. I-save ang script at isagawa ito.
Maaari mong makita na ang resulta ay nagpakita ng isang Mali at dalawang Tunay na mga halaga kumpara sa iba't ibang mga variable. Ang unang dalawang resulta ay sa pagitan ng mga variable ng uri ng integer, ngunit ang huling paghahambing ay sa pagitan ng mga variable ng integer at string type. Samakatuwid, nagbabalik ito ng True pareho na hindi pantay.
Halimbawa 02:
Tingnan natin ang operator na Hindi Pantay na ginamit sa pahayag na kung habang ginagamit ang sawa. Gumamit kami ng dalawang variable sa code. Ang variable x ay isang uri ng integer, at ang y ay isang uri ng string. Pagkatapos ay nasimulan na namin ang kung pahayag at ginamit ang HINDI Pantay na operator sa loob nito sa loob ng parehong pagpapatakbo upang suriin kung pantay sila o hindi. Sa huli, naka-print na ilang pahayag.
Sa pagpapatupad ng isang test.py script file, nakuha namin ang string bilang output halaga tulad ng ipinakita sa imahe sa ibaba.
Tingnan natin ang isa pang halimbawa. Sa pagkakataong ito ay ginamit na namin ang parehong mga variable ng uri ng string at inihambing ang mga ito sa loob ng kung pahayag. Sa wakas, ginamit namin ang pahayag sa pag-print upang mai-print ang parehong mga variable na may ilang mga halaga ng string sa mga ito. Ang output ay dapat na walang error.
Habang isinasagawa ang file na ito, wala kaming mga error at nakuha ang gumaganang output tulad ng sa ibaba.
Magkaroon tayo ng ilang mga kumplikadong halimbawa mula ngayon. Sa pagkakataong ito, gumagamit kami ng isang integer variable z na may halaga na 21. Una naming kinakalkula ang modulus ng isang variable z na may integer 2. Pagkatapos nito, ginamit namin ang kung pahayag upang magamit ang HINDI Pantay na operator dito upang ihambing ang kinakalkula na halaga na may 0. Habang ang kinakalkula na modulus ay hindi katumbas ng 0, dapat itong i-print ang halaga ng variable z at ang string na nagsasabi ay hindi kahit na ginamit sa pahayag ng pag-print.
Matapos i-save at maipatupad ang file, wala kaming mga error, at ang variable z ay nai-print kasama ang isang string ay hindi pantay.
Halimbawa 03:
Sa halimbawa sa itaas, ginamit lamang namin ang kung pahayag. Sa oras na ito gagamitin namin ang kung-ibang pahayag sa aming halimbawa. Na-update namin ang code tulad ng nasa ibaba. Una sa lahat, simulan ang isang variable na uri ng integer na may halagang 10. Pagkatapos nito, ginamit namin ang pahayag na kung-iba sa aming code. Ang kung bahagi ng pahayag ay gumagamit ng hindi operator upang ihambing ang variable a sa halagang 20. Kung ang kondisyon ay nasiyahan, mai-print nito ang aming Mga Halaga ay hindi Pantay; kung hindi man, ibibigay ang kontrol sa ibang pahayag upang mai-print na ang Mga Halaga ay Pantay.
I-save ang iyong code at patakbuhin ito. Maaari mong makita ang kundisyon sa kung nasisiyahan ang pahayag, at inililimbag nito na ang Mga Halaga ay hindi Pantay.
Tingnan muna natin ang isa pang halimbawa. Inihayag namin ang isang str str na mayroon ang halagang Aqsa kung ginagamit ng pahayag ang string na ito upang ihambing ito sa ilang halaga at mai-print ang mensahe. Kapag nabigo ang kundisyon ng kung pahayag, ililipat ang kontrol sa pahayag ng elif upang makita kung ang variable str ay hindi katumbas ng isang ibinigay na halaga. Pagkatapos nito, magpi-print ito ng isang mensahe.
Tulad ng kundisyon sa kung pahayag ay nasiyahan upang mai-print nito ang unang pahayag na naka-print, at ang kontrol ay hindi kailanman ibibigay sa pahayag ng elif.
Halimbawa, baguhin natin ang halaga ng isang variable str sa Yasin. Sa oras na ito ang kondisyong nabanggit sa kung pahayag ay magkakamali, at ang kontrol ay ibibigay sa pahayag ng elif. Samakatuwid, ang naka-print na pahayag ng pahayag ng elif ay mai-print habang natutugunan ang kundisyon.
Ngayon kapag naipatupad namin muli ang code, ipapakita nito ang resulta ng pahayag na naka-print na nabanggit sa loob ng bahagi ng elif ng nakapugad na pahayag na kung may iba pa.
Halimbawa 04:
Panghuli, gagawa kami ng isang kumplikadong halimbawa upang subukan ang HINDI Pantay na operator ng paghahambing sa oras na ito. Kaya, nasimulan namin ang isang klase na nagngangalang Test. Sa loob ng klase na ito, pinasimulan namin ang isang variable i pagkakaroon ng halaga 0. Ang isa pang variable, data, ay napasimulan na may halaga na wala rito. Pagkatapos nito, pinasimulan namin ang isang tagapagbuo ng klase na ito upang makuha ang mga halaga ng mga variable na ito mula sa halimbawa ng klase. Pagkatapos ay nasimulan namin ang isang built-in na HINDI Pantay na pamamaraan sa aming code at ginamit ang pahayag na kung-iba dito. Tatlong bagay ang nilikha upang maipadala ang mga halaga sa taga-buo. Pagkatapos nito, inihambing namin ang mga bagay sa bawat isa sa loob ng pahayag na naka-print upang mai-print ang resulta ng paghahambing. I-save ang code at patakbuhin ito.
Ipinapakita ng output ang Mali bilang isang pagbabalik sa unang pahayag na naka-print dahil ang mga halagang na-parse sa parehong mga bagay ay pareho. Sa kabaligtaran, ang pangalawang pahayag ng pag-print ay nagbabalik ng Totoo dahil ang t2 at t3 ay parehong may magkakaibang halaga at hindi pantay.
Konklusyon:
Sa tulong ng mahusay na ipinaliwanag na mga script ng guhit, natutunan namin kung ano ang Python Not Equal Comparison Function at kung paano ito ginagamit upang matukoy kung ang dalawang variable ay hindi magkapareho.