Python Inte jämnlikt Operator (!=)

⚡ Smart sammanfattning

Python not equal operators compare two operands and return a Boolean value when their contents differ. The != symbol works in Python 2 and 3, and because Python is dynamically typed, it compares values across different data types too.

  • 🔘 Definition: The not equal operator returns True when two operands hold different values and False when they match.
  • ☑️ Two symbols: Python provides != for every version and the older <> form, which runs only under Python 2.
  • Boolean result: Each comparison evaluates to a Boolean, making the operator ideal for conditions and validation checks.
  • 🧪 Dynamic typing: Därför att Python is strongly and dynamically typed, != can compare an integer, a float, and a string safely.
  • 🛠️ Kontrollflöde: Pairing != with if statements and while loops filters data, such as isolating even or odd numbers.
  • ⚙️ Anpassade objekt: Overriding the __ne__ method lets a class define exactly how the not equal operator behaves.

Python Inte jämnlikt Operator

Vad är Python Inte lika med Operator?

Python identifieras som ett programmeringsspråk som är mycket dynamiskt, och det anses allmänt vara ett starkt maskinskrivet språk. Detta uttalande kan förklaras genom att förstå betydelsen av att inte lika operator. I not equal operator, om värdena för de två operanderna på vardera sidan av operatorn inte är lika, då tillhandahåller operatorn sant värde, annars ger den falskt.

In not equal operator, if two variables are of different types but hold the same values in themselves, then the not equal operator returns a true. Not many programming languages can classify it as true if the variable type is of a different type, which makes Python a very dynamic language. In Python, not equal operators can be classified as one of the comparison operators.

Typer av Inte lika med operatorer med Syntax in Python

Syntaxen för båda typerna visas nedan: –

X<>Y

X!=Y

There are two types of not equal operators in Python:-

  • !=
  • <>

Den första typen, != används i Python version 2 och 3.

Den andra typen, <> används i Python version 2, and under version 3, this operator is deprecated.

Exempel på Python Inte jämnlikt Operator

Låt oss överväga två scenarier för att illustrera inte lika med i python. Följande är exemplet på inte lika operator för samma datatyp men olika värden:-

A = 44
B = 284
C = 284
print(B!=A)
print(B!=C)

Produktion:

True
False

Följande är exemplet på inte lika i python för olika datatyper men samma värden

C = 12222
X = 12222.0
Y = "12222"
print(C!=X)
print(X!=Y)
print(C!=Y)

Produktion:

False
True
True

Hur man använder Not Equal Operator med IF-utlåtande

I python kan en if-sats beskrivas som en sats som kontrollerar ingångsnivåvillkoret och exekverar när det är sant.

Låt oss ta ett grundläggande exempel på att använda if-satsen och inte är lika med operatorn som visas nedan: –

X = 5
Y = 5
if ( X != Y ):
  print("X is not equal to Y")
else:
  print("X is equal to Y")

Produktion:

X is equal to Y

Här, inte lika med != används tillsammans med if-satsen.

Hur man använder lika med (==) operator med while loop

I python itererar while-loop kodblock så länge ett villkor är sant eller falskt. Låt oss ta ett fall med att skriva ut udda tal med while-loop och lika med operatorn som visas nedan: –

m = 300
while m <= 305:
   m = m + 1
  if m%2 == 0:
     continue
   print (m)

Produktion:

301
303
305

Här lika med == används tillsammans med if-satsen.

Exempel: Hitta jämna tal genom att använda icke lika operator

I python, medan loop kan också användas med inte lika med operator. Låt oss ta ett fall med att skriva ut jämna tal med while-loop och inte lika med operatorn som visas nedan: –

m = 300
while m <= 305:
  m = m + 1
  if m%2 != 0:
    continue
  print (m)

Produktion:

302
304
306

Här, inte lika med != används tillsammans med if-satsen.

Mindergy på kontoret Python inte lika med Operator med anpassat objekt

Anpassade objekt gör det möjligt för användaren eller en utvecklare att skapa sina anpassade implementeringar. Detta gör det möjligt för utvecklarna att ändra den faktiska produktionen än vad som vanligtvis förväntas.

Låt oss ta ett exempel på ett anpassat objekt som använder inte lika med operator som visas nedan: –

Exempel:

class G9Example:

   s_n=''

def __init__(self, name):

   self.s_n = name

def __ne__(self, x):

if type(x) != type(self):

  return True

# return True for different values

if self.s_n != x.s_n:

  return True

else:

  return False

G1 = G9Example("Guru99")

G2 = G9Example("HipHop99")

G3 = G9Example("Guru99")

print(G1 != G2)

print(G2 != G3)

print(G1 != G3)

Produktion:

True

True

False

Jämförelseoperatörer i Python

Följande tabell beskriver jämförelselistan operatörer i Python: -

Operator Betydelse Exempelvis
!= Inte lika med-ger sant om operander inte har samma värden A!=B
== Lika med-Ger sant om operander har samma värden A==B
>= Större än eller lika med - ger sant som värde om den första operanden är större än eller lika med den andra operanden A>=B
<= Less än eller lika med- ger sant som värde om den första operanden är Less än eller lika med den andra operanden A<=B
> Större än – ger sant som värde om den första operanden är större än den andra operanden A>B
< Less än – ger sant som värde om den första operanden är Less än den andra operanden A<B

Användbara tips om användning av Not Equal Operator

Här är några användbara tips

  • Operatorn inte lika med kan användas i formaterade strängar.
  • Denna funktion är relativt ny och ingår i Python version 3.6.
  • Utvecklaren bör se till att syntaxen ska vara != och inte eftersom vissa typsnitt eller tolkar ändrar syntax från != till .

Vanliga frågor

The != operator returns True when two values differ, while == returns True when they are equal. Both evaluate to a Boolean True or False.

No. The <> operator worked in Python 2 but was removed in Python 3. Only != is valid in both versions, so use != in modern code.

Ja. Python is dynamically typed, so != compares different types. The integer 12222 and the string “12222” are treated as not equal.

The != operator compares values and calls __ne__, checking equality. The “is not” operator compares identity, testing whether two variables reference the same object in memory.

Use “is not None”. None is a singleton, so identity checks are faster and safer than !=, which a custom __ne__ method can override.

AI assistants confirm whether != or == fits your logic, flag risky comparisons between incompatible types, and rewrite conditions to return the result you expect.

Ja. AI traces the values and types on both sides, explains the True or False outcome, and suggests using “is not” when comparing against None.

Yes. GitHub Copilot autocompletes != conditions from a comment. Agentic AI tools refactor comparisons across a file and flag where “is not” is safer.

Sammanfatta detta inlägg med: