Hur man använder Python Not Equal och Equal Operators

av

I Python kan du använda operatorerna inte lika med och lika med för att kontrollera om två Python-objekt har samma värde. Denna handledning kommer att lära dig hur du använder dessa operatorer med massor av exempelkod.

I den här handledningen får du lära dig:

  • syntaxen för operatorn inte lika (!=) och användningsfall,
  • syntaxen för lika-operatorn (==) med exempel, och
  • användningen av är och är inte operatörer för att kontrollera identiteten för två Python-objekt.

Låt oss börja.

Python Not Equal Operator Syntax

För två valfria Python-objekt obj1 och obj2 är den allmänna syntaxen för att använda icke lika-operatorn:

<obj1> != <obj2>
  • returnerar True när värdena för obj1 och obj2 inte är lika, och
  • returnerar False annars.

Obs: Som nämnts ovan kan obj1 och obj2 vara heltal, flyttal, strängar, listor och så vidare.

Python Not Equal Operator Code Exempel

I det här avsnittet, låt oss koda några exempel för att förstå den inte lika operatorn bättre.

Använder Python Not Equal Operator för jämförelse

Här är vårt första exempel.

num1 = 27
num2 = 3*9

num1 != num2

# Output: False

Du kan köra kodexemplen på adminvista.com Python IDE – direkt från din webbläsare. Eller så kan du välja att köra på din lokala maskin.

Eftersom num1 = 27 och num2 också utvärderas till 27 (3*9 = 27), är värdena för num1 och num2 lika. Så operatorn != returnerar False.

Låt oss ta ett annat exempel.

I koden nedan är num1 satt till 7. Och num2 är satt till strängen 7. Eftersom de är av olika datatyper, returnerar inte lika operatorn True.

num1 = 7 
num2 = "7" 
num1 != num2 

# Output: True

Du kastar strängen till ett heltal, som visas:

num1 = 7
num2 = int("7")

num1 != num2

# Output: False

I det här fallet kan du se att det returnerade resultatet är falskt – eftersom num1 och num2 nu är lika med heltal 7.

Du kan också använda operatorn inte lika med Python-samlingar som listor, tupler och uppsättningar.

Obs: För insamlingar av data som listor fungerar den icke lika-operatorn genom att kontrollera värdena för enskilda objekt. Till exempel är två listor list1 och list2 – var och en med längden n – lika endast om list1[i] == lista2[i] för i i {0,1,2,3,..n-1}.

Här är ett exempel:

list1 = [2,4,6,8]
list2 = [2,4,6,9]

list1 != list2

# Output: True

I exemplet ovan skiljer sig list1 och list2 endast med ett element. Och operatorn inte lika != returnerar True som förväntat.

Använda Python Not Equal Operator i villkor

Du använder ofta operatorn inte lika med som en del av Pythons villkor.

Till exempel visar kodavsnittet nedan hur du kan kontrollera om ett nummer är udda eller inte.

Ett tal som inte är jämnt delbart med 2 är udda. Och detta reduceras till villkoret num%2 != 0.

num = 7
if(num%2 != 0):
  print("The number is odd.")
else:
  print("The number is even.")

# Output: The number is odd.

Du kan också använda villkor i listförståelser när du bara vill behålla de listelement som uppfyller ett specifikt villkor. I exemplet nedan är udda_10 listan över alla udda tal mindre än 10.

odd = [num for num in range(10) if num%2 != 0]
print(odd)

# Output: [1, 3, 5, 7, 9]

Och det avslutar vår diskussion om den inte lika (!=) operatorn.✅

Som du kanske har gissat vid det här laget ger operatorn lika med den motsatta effekten av den som inte är lika med operatorn.

Du kommer att lära dig mer om det i nästa avsnitt.

Python Equal Operator Syntax

Här är syntaxen för att använda Pythons lika med-operator:

<obj1> == <obj2>  #where <obj1> and <obj2> are valid Python objects
  • returnerar True när värdena för obj1 och obj2 är lika, och
  • returnerar False annars.

Python Equal Operator Code Exempel

Lika-operatorn (==) kan användas mycket likt den icke-lika operatorn.

Låt oss koda följande exempel:

  • för att kontrollera om två strängar är lika,
  • för att kontrollera om ett tal är jämnt, och
  • att använda villkor i listförståelse

Använder Python Not Equal Operator för jämförelse

I kodavsnittet nedan är str1 och str2 lika värdemässigt. Så den lika operatorn (==) returnerar True.

str1 = "coding"
str2 = "coding"

str1 == str2

# Output: True

Python Equal Operator

Låt oss nu använda lika-operatorn i ett villkorligt uttryck.

Notera: Ett tal som är jämnt delbart med 2 är jämnt. Och i kod reduceras detta till villkoret num%2 == 0

num = 10
if(num%2 == 0):
  print("The number is even.")
else:
  print("The number is odd.")

# Output: The number is even.

Låt oss nu bygga vidare på detta exempel, använd Pythons listförståelse för att få alla jämna tal mindre än 10.

even_10 = [num for num in range(10) if num%2 == 0]
print(even_10)

# Output: [0, 2, 4, 6, 8]

I exemplet ovan,

  • range(10) returnerar ett områdesobjekt som kan loopas igenom för att få alla heltal från 0 till 9.
  • Villkoret num%2 == 0 är endast sant för jämna tal.
  • Så jämn_10 är listan över alla jämna tal mindre än 10.

Hittills har du lärt dig hur du kontrollerar jämlikhet med hjälp av operatorerna inte lika (!=) och lika (==).

I nästa avsnitt kommer du att lära dig hur du verifierar identiteten för två objekt. Du kommer att kontrollera om två Python-objekt är identiska.

Hur man använder Pythons är och är inte operatörer

Om du är nybörjare i Python-programmering är det möjligt att du är förvirrad mellan operatorerna == och är. Låt oss förtydliga det i det här avsnittet.

I föregående avsnitt hade vi ett exempel där str1 och str2 där lika och operatorn == returnerade True.

Kör nu följande kodavsnitt.

str1 = "coding" 
str2 = "coding" 

str1 is str2 

# Output: False

Du kan se att str1 är str2 returnerar False.

Låt oss ta ett steg tillbaka och förstå vad Pythons operatör gör.

Operatorn is fungerar på två valfria Python-objekt.
Och returnerar True endast om de två objekten är identiska – det vill säga att de refererar till samma objekt i minnet.

Även om str1 är lika med str2, är str1 inte str2 eftersom de pekar på två olika objekt i minnet. Och därför har de olika identiteter.

== och är är INTE samma

I Python kan du använda id() funktion för att få objektets identitet.

▶ Kör följande kodcell för att få identiteterna för str1 och str2.

id(str1)

# Sample output: 139935398870320

id(str2)

# Sample output: 139935398871344

Som du kan se har str1 och str2 olika identiteter. Och str1 är str2 returnerar False som förväntat.

Sätta ihop det,

<obj1> is <obj2> # returns True if and only if
id(<obj1>) == id(<obj2>) # returns True

Låt oss snabbt verifiera detta, som visas:

str1 = "coding"
str2 = str1

print(str1 is str2)
print(id(str1) == id(str2))

# Output
True
True

Intuitivt gör is not-operatorn motsatsen till is-operatorn.

Operatören is not arbetar på två Python-objekt.
Och returnerar False endast om de två objekten är identiska – det vill säga att de refererar till samma objekt i minnet. Annars returnerar den True.

I ovanstående kodexempel, försök att ersätta är med är inte och kontrollera resultaten.

Slutsats 👩‍💻

Hoppas du tyckte att denna handledning var till hjälp.

För att sammanfatta, har du lärt dig:

  • hur man använder operatorerna lika (==) och inte lika (!=) för att kontrollera om två Python-objekt har samma värde,
  • skillnaden mellan likhet och identitet för Python-objekt, och
  • hur Pythons är och inte är operatorer hjälper till att kontrollera om två Python-objekt är identiska.

Lär dig hur du beräknar tidsskillnaden eller gör ett ormspel i python här.

Vi ses alla i nästa handledning. Tills dess, trevlig inlärning och kodning!🎉