Python Ikke lige Operator (!=)

⚡ Smart opsummering

Python Operatorer, der ikke er ens, sammenligner to operander og returnerer en boolsk værdi, når deres indhold er forskelligt. Symbolet != fungerer i Python 2 og 3, og fordi Python er dynamisk typebestemt, sammenligner den også værdier på tværs af forskellige datatyper.

  • 🔘 Definition: Operatoren "ikke ens" returnerer "Sand", når to operander har forskellige værdier, og "Falsk", når de matcher.
  • ☑️ To symboler: Python angiver != for hver version og den ældre <> form, som kun kører under Python 2.
  • ✅ Boolsk resultat: Hver sammenligning evalueres til en boolsk værdi, hvilket gør operatoren ideel til betingelser og valideringstjek.
  • 🧪 Dynamisk typing: Fordi Python er stærkt og dynamisk typebestemt, != kan sammenligne et heltal, et flydende tal og en streng sikkert.
  • 🛠️ Kontrolflow: Parring af != med if-sætninger og while-løkker filtrerer data, f.eks. isolering af lige eller ulige tal.
  • 🇧🇷 Brugerdefinerede objekter: Ved at tilsidesætte __ne__-metoden kan en klasse definere præcis, hvordan operatoren, der ikke er lig med, opfører sig.

Python Ikke lige OperaTor

Hvad er Python Ikke lig med Operator?

Python er identificeret som et programmeringssprog, der er meget dynamisk, og det betragtes generelt som et stærkt typesprog. Dette udsagn kan forklares ved at forstå betydningen af ​​ikke lige operator. I not equal operator, hvis værdierne af de to operander på hver side af operatoren ikke er ens, så giver operatoren sand værdi, ellers giver den falsk.

In not equal operator, hvis to variabler er af forskellige typer, men har de samme værdier i sig selv, returnerer den ikke-lige operator en sand værdi. Ikke mange programmeringssprog kan klassificere det som sandt, hvis variabeltypen er af en anden type, hvilket gør Python et meget dynamisk sprog. I Python, ikke ens operatorer kan klassificeres som en af ​​sammenligningsoperatorerne.

Typer af Ikke lig med operatorer med Syntax in Python

Syntaksen for begge typer er vist nedenfor: –

X<>Y

X!=Y

Der er to typer af ikke-lige operatorer i Python:-

  • !=
  • <>

Den første type, != anvendes i Python version 2 og 3.

Den anden type, <> anvendes i Python version 2, og under version 3 er denne operator udfaset.

Eksempel Python Ikke lige OperaTor

Lad os overveje to scenarier for at illustrere ikke lig med i python. Følgende er eksemplet på ikke ens operator for samme datatype, men forskellige værdier:-

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

Output:

True
False

Følgende er eksemplet med ikke ens i python for forskellige datatyper, men samme værdier

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

Output:

False
True
True

Sådan bruges Not Equal Operator med IF Statement

I python kan en if-sætning beskrives som en erklæring, der kontrollerer entry-level-betingelsen og udfører, når den er sand.

Lad os tage et grundlæggende eksempel på at bruge if-sætning og ikke er lig med operator som vist nedenfor: –

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

Output:

X is equal to Y

Her ikke lig med != bruges sammen med if-erklæringen.

Sådan bruges operatoren lig med (==) med while-løkke

I python gentager while-loop kodeblok, så længe en betingelse er sand eller falsk. Lad os tage et tilfælde af udskrivning af ulige tal ved at bruge while-løkke og lig med operator som vist nedenfor: –

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

Output:

301
303
305

Her lig med == bruges sammen med if-erklæringen.

Eksempel: Find lige tal ved at bruge en ikke-lig operator

I python kan mens loop også bruges med ikke lig med operator. Lad os tage et tilfælde af udskrivning af lige tal ved at bruge while-løkke og ikke lig med operator som vist nedenfor: –

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

Output:

302
304
306

Her ikke lig med != bruges sammen med if-erklæringen.

Brugsvejledning Python ikke lige Operator med tilpasset objekt

Tilpassede objekter gør det muligt for brugeren eller en udvikler at skabe deres tilpassede implementeringer. Dette gør det muligt for udviklerne at ændre det faktiske output, end hvad der normalt forventes.

Lad os tage et eksempel på et brugerdefineret objekt, der bruger ikke lig med operator som vist nedenfor: -

Eksempel:

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)

Output:

True

True

False

Sammenligningsoperatører i Python

Følgende tabel beskriver listen over sammenligninger operatører i Python-

OperaTor Betydning Eksempel
!= Ikke lig med-giver sand, hvis operander ikke har de samme værdier A!=B
== Lige til-Giver sand, hvis operander har samme værdier A==B
>= Større end eller lig med - giver sand som værdi, hvis den første operand er større end eller lig med den anden operand A>=B
<= Less end eller lig med- giver sand som værdi, hvis den første operand er Less end eller lig med den anden operand A<=B
> Større end – giver sand som værdi, hvis den første operand er større end den anden operand A>B
< Less end – giver sand som værdi, hvis den første operand er Less end den anden operand A<B

Nyttige tips om brug af ikke lige OperaTor

Her er nogle nyttige tips

  • Operatoren ikke lig med kan bruges i formaterede strenge.
  • Denne funktion er relativt ny og er en del af Python udgave 3.6.
  • Udvikleren skal sikre, at syntaks skal være != og ikke ≠ fordi nogle skrifttyper eller fortolkere ændrer syntaks fra != til ≠.

Ofte Stillede Spørgsmål

Operatoren != returnerer True, når to værdier er forskellige, mens == returnerer True, når de er ens. Begge evalueres til en boolsk værdi, True eller False.

Nej. Operatoren <> arbejdede i Python 2, men blev fjernet i Python 3. Kun != er gyldig i begge versioner, så brug != i moderne kode.

Ja. Python er dynamisk typebestemt, så != sammenligner forskellige typer. Heltallet 12222 og strengen "12222" behandles som ikke ens.

Operatoren != sammenligner værdier og kalder __ne__, hvilket kontrollerer lighed. Operatoren “is not” sammenligner identitet og tester, om to variabler refererer til det samme objekt i hukommelsen.

Brug “is not None”. None er en singleton, så identitetstjek er hurtigere og sikrere end !=, som en brugerdefineret __ne__-metode kan tilsidesætte.

AI-assistenter bekræfter, om != eller == passer til din logik, markerer risikable sammenligninger mellem inkompatible typer og omskriver betingelser for at returnere det resultat, du forventer.

Ja. Kunstig intelligens tracundersøger værdierne og typerne på begge sider, forklarer resultatet Sandt eller Falsk og foreslår at bruge "er ikke" ved sammenligning med Ingen.

Ja. GitHub Copilot fuldfører automatisk != betingelser fra en kommentar. Agentic AI-værktøjer omstrukturerer sammenligninger på tværs af en fil og markerer, hvor "is not" er mere sikkert.

Opsummer dette indlæg med: