Hur man använder Python Not Equal och Equal Operators

Utforska jämförelseoperatorer i Python

I Python används operatorerna för ”inte lika med” och ”lika med” för att avgöra om två objekt har samma värde. Denna genomgång förklarar hur dessa operatorer används, tillsammans med många kodexempel.

Du kommer att lära dig följande i denna handledning:

• Syntaxen och användningsområdena för operatorn ”inte lika med” (!=)
• Syntaxen och exemplen för operatorn ”lika med” (==)
• Användningen av operatorerna ”är” och ”är inte” för att undersöka identiteten hos Python-objekt.

Låt oss starta utforskningen.

Syntax för ”inte lika med” i Python

För två godtyckliga Python-objekt, låt oss kalla dem obj1 och obj2, är den generella syntaxen för att använda operatorn ”inte lika med” följande:

<obj1> != <obj2>

• Detta resulterar i True om värdena för obj1 och obj2 inte är desamma.
• Annars returneras False.

Viktigt att notera: obj1 och obj2 kan vara av olika typer som heltal, flyttal, textsträngar, listor och mer.

Exempel med ”inte lika med” i Python

Låt oss undersöka några kodexempel för att få en djupare förståelse för hur operatorn ”inte lika med” fungerar.

Jämförelser med ”inte lika med”

Här är det första exemplet:

num1 = 27
num2 = 3 * 9

resultat = num1 != num2
print(resultat)

# Utdata: False

Testa gärna koden i en Python-miljö eller använd en online Python IDE.

I detta fall är num1 = 27 och num2 beräknas också till 27. Eftersom värdena är lika returnerar operatorn != värdet False.

Nu ett annat exempel:

I följande exempel har variabeln num1 värdet 7, medan num2 är strängen ”7”. Eftersom de tillhör olika datatyper resulterar != i värdet True.

num1 = 7
num2 = "7"

resultat = num1 != num2
print(resultat)
# Utdata: True

Om vi konverterar strängen till ett heltal får vi följande:

num1 = 7
num2 = int("7")

resultat = num1 != num2
print(resultat)
# Utdata: False

Nu är båda variablerna num1 och num2 heltal med samma värde 7. Därmed returnerar operationen False.

Operatören ”inte lika med” kan även användas med Python-samlingar, såsom listor, tupler och mängder.

Notera: För datamängder som listor, jämför operatorn ”inte lika med” de enskilda objekten i samlingarna. Två listor lista1 och lista2, båda med längden n, är endast lika om lista1[i] == lista2[i] för alla i från 0 till n-1.

Här är ett exempel:

lista1 = [2, 4, 6, 8]
lista2 = [2, 4, 6, 9]

resultat = lista1 != lista2
print(resultat)

# Utdata: True

I detta exempel skiljer sig lista1 och lista2 åt i ett element. Därför ger operatorn != det förväntade värdet True.

Användning av ”inte lika med” i villkor

Operatören ”inte lika med” är ofta en del av Python-villkor.

Följande kod visar hur man kan avgöra om ett tal är udda eller inte.

Ett tal som inte är jämnt delbart med 2 är udda. Detta motsvarar villkoret num % 2 != 0.

num = 7
if (num % 2 != 0):
  print("Talet är udda.")
else:
  print("Talet är jämnt.")

# Utdata: Talet är udda.

Villkor kan också användas i listomfattningar för att filtrera element i en lista baserat på ett givet villkor. I följande exempel innehåller udda_tal alla udda tal under 10.

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

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

Detta avslutar vår diskussion om operatorn ”inte lika med” (!=).✅

Som du kanske har förväntat dig, har operatorn ”lika med” motsatt effekt jämfört med ”inte lika med”.

Mer om det i nästa avsnitt.

Syntax för ”lika med” i Python

Här är hur man använder operatorn ”lika med” i Python:

<obj1> == <obj2>  #där <obj1> och <obj2> är giltiga Python-objekt

• Detta ger värdet True om obj1 och obj2 har samma värde.
• Annars returneras False.

Exempel med ”lika med” i Python

Operatören ”lika med” (==) används på liknande sätt som operatorn ”inte lika med”.

Vi ska nu koda några exempel för att illustrera hur man använder:

• ”lika med” för att jämföra strängar,
• ”lika med” för att kontrollera om ett tal är jämnt, och
• ”lika med” i listomfattning.

Jämförelser med ”lika med”

I följande exempel har str1 och str2 samma värde. Därför ger == resultatet True.

str1 = "kodning"
str2 = "kodning"

resultat = str1 == str2
print(resultat)
# Utdata: True

Användning av Python ”lika med” operatorn

Låt oss nu använda operatorn ”lika med” i ett villkorsuttryck.

Ett tal är jämnt om det är jämnt delbart med 2. Detta motsvaras av villkoret num % 2 == 0.

num = 10
if (num % 2 == 0):
  print("Talet är jämnt.")
else:
  print("Talet är udda.")

# Utdata: Talet är jämnt.

Låt oss utvidga exemplet och använda Python-listomfattning för att få alla jämna tal under 10.

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

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

I exemplet ovan:

• range(10) returnerar ett område som kan itereras för att få alla heltal från 0 till 9.
• Villkoret num % 2 == 0 är sant endast för jämna tal.
• jamna_tal är listan med alla jämna tal under 10.

Du har nu sett hur man kollar likhet med hjälp av operatorerna ”inte lika med” (!=) och ”lika med” (==).

Nästa avsnitt kommer att förklara hur man verifierar identiteten för två objekt. Det vill säga, kontrollera om två Python-objekt är identiska.

Användning av ”är” och ”är inte” i Python

Om du är ny inom Python kan du bli förvirrad av skillnaden mellan operatorerna == och är. Låt oss reda ut det här.

I ett tidigare exempel såg vi att str1 och str2 hade samma värde, och operatorn == returnerade True.

Kör nu följande kod:

str1 = "kodning"
str2 = "kodning"

resultat = str1 is str2
print(resultat)
# Utdata: False

Som du ser returnerar str1 is str2 värdet False.

Låt oss ta ett steg tillbaka och se vad operatorn är gör.

Operatorn är kan tillämpas på två Python-objekt. Den returnerar True endast om objekten är identiska, vilket betyder att de refererar till samma minnesplats.

Även om str1 är lika med str2, är str1 is str2 falskt eftersom de representerar olika objekt i minnet. Därför har de olika identiteter.

== och är är INTE samma sak.

I Python kan man använda funktionen id() för att ta reda på ett objekts identitet.

▶ Kör följande kod för att se identiteterna för str1 och str2:

print(id(str1))
# Exempelutdata: 139935398870320

print(id(str2))
# Exempelutdata: 139935398871344

Som du ser har str1 och str2 olika identiteter. Därför returnerar str1 is str2 värdet False som förväntat.

Sammanfattningsvis:

<obj1> is <obj2> # returnerar True om och endast om
id(<obj1>) == id(<obj2>) # returnerar True

Låt oss verifiera det:

str1 = "kodning"
str2 = str1

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

# Utdata
True
True

Intuitivt nog gör operatorn är inte motsatsen till operatorn är.

Operatören är inte tillämpas på två Python-objekt. Den returnerar False endast om objekten är identiska, det vill säga refererar till samma plats i minnet. Annars returneras True.

I exemplet ovan, försök att byta ut är mot är inte för att se hur det påverkar resultaten.

Sammanfattning 👩‍💻

Jag hoppas att du hade nytta av denna guide.

Sammanfattningsvis har du lärt dig:

• hur man använder operatorerna ”lika med” (==) och ”inte lika med” (!=) för att se om två objekt har samma värde,
• skillnaden mellan likhet och identitet för Python-objekt, och
• hur Python operatorerna ”är” och ”är inte” används för att avgöra om två Python-objekt är identiska.

Lär dig om tidsskillnader eller hur man gör ett ormspel i Python.

Vi ses i nästa handledning. Fram till dess, ha kul med lärandet och programmeringen!🎉