Python Language
jämförelser

Syntax

• ! = - Är inte lika med

• == - Är lika med

• > - större än

• < - mindre än

• >= - större än eller lika med

• <= - mindre än eller lika med

• is - testa om objekt är exakt samma objekt

• är inte = testa om objekt inte är exakt samma objekt

parametrar

Större än eller mindre än

x > y
x < y

Dessa operatörer jämför två typer av värden, de är de mindre än och större än operatörerna. För siffror jämförs helt enkelt de numeriska värdena för att se vilka som är större:

12 > 4
# True
12 < 4
# False
1 < 4
# True

För strängar kommer de att jämföra leksikografiskt, vilket liknar alfabetisk ordning men inte riktigt samma.

"alpha" < "beta"
# True
"gamma" > "beta"
# True
"gamma" < "OMEGA"
# False

I dessa jämförelser betraktas små bokstäver som "större än" versaler, varför "gamma" < "OMEGA" är falskt. Om de alla hade stora versaler skulle det returnera det förväntade alfabetiska ordningsresultatet:

"GAMMA" < "OMEGA"
# True

Varje typ definierar sin beräkning med < och > operatörerna på olika sätt, så du bör undersöka vad operatörerna menar med en viss typ innan du använder den.

Inte lika med

x != y  

Detta returnerar True om x och y inte är lika och annars returnerar False .

12 != 1
# True
12 != '12'
# True
'12' != '12'
# False

Lika med

x == y 

Detta uttryck utvärderar om x och y är samma värde och returnerar resultatet som ett booleskt värde. I allmänhet måste både typ och värde matcha, så int 12 är inte samma som strängen '12' .

12 == 12
# True
12 == 1
# False
'12' == '12'
# True
'spam' == 'spam'
# True
'spam' == 'spam '
# False
'12' == 12
# False

Observera att varje typ måste definiera en funktion som kommer att användas för att utvärdera om två värden är desamma. För inbyggda typer uppträder dessa funktioner som du kan förvänta dig och utvärderar bara saker baserade på att vara samma värde. Men anpassade typer kan definiera jämställdhetstestning som vad de än skulle vilja, inklusive att alltid återlämna True eller alltid returnera False .

Jämförelse av kedjor

Du kan jämföra flera objekt med flera jämförelseoperatörer med kedjegjämförelse. Till exempel

x > y > z

är bara en kort form av:

x > y and y > z

Detta kommer att utvärderas till True endast om båda jämförelserna är True .

Den allmänna formen är

a OP b OP c OP d ...

Där OP representerar en av de flera jämförelser som du kan använda och bokstäverna representerar godtyckliga giltiga uttryck.

Observera att 0 != 1 != 0 utvärderar till True , även om 0 != 0 är False . Till skillnad från den vanliga matematiska notationen där x != y != z betyder att x , y och z har olika värden. Kedja == operationer har i de flesta fall den naturliga betydelsen, eftersom jämlikhet i allmänhet är transitiv.

Stil

Det finns ingen teoretisk gräns för hur många objekt och jämförelser du använder så länge du har korrekt syntax:

1 > -1 < 2 > 0.5 < 100 != 24

Ovanstående returnerar True om varje jämförelse returnerar True . Att använda veckad kedja är dock inte en bra stil. En bra kedja kommer att vara "riktad", inte mer komplicerad än

1 > x > -4 > y != 8

Bieffekter

Så snart en jämförelse returnerar False utvärderas uttrycket omedelbart till False och hoppar över alla återstående jämförelser.

Observera att uttrycket exp i a > exp > b kommer att utvärderas endast en gång, medan i fallet med

a > exp and exp > b

exp kommer att beräknas två gånger om a > exp är sant.

Jämförelse med `är` vs` == `

En vanlig fallgrop är att förvirra jämställdhetsjämförelseoperatörerna is och == .

a == b jämför värdet på a och b .

a is b kommer att jämföra identiteten på a och b .

Att illustrera:

a = 'Python is fun!'
b = 'Python is fun!'
a == b # returns True
a is b # returns False

a = [1, 2, 3, 4, 5]
b = a      # b references a
a == b     # True
a is b     # True
b = a[:]   # b now references a copy of a
a == b     # True
a is b     # False [!!]

I princip, is kan betraktas som en förkortning för id(a) == id(b) .

Utöver detta finns det förfrågningar om runtime-miljön som ytterligare komplicerar saker. Korta strängar och små heltal kommer att återkomma True jämfört med is grund av att Python-maskinen försöker använda mindre minne för identiska objekt.

a = 'short'
b = 'short'
c = 5
d = 5
a is b # True
c is d # True

Men längre strängar och större heltal lagras separat.

a = 'not so short'
b = 'not so short'
c = 1000
d = 1000
a is b # False
c is d # False

Du bör använda is att testa för None :

if myvar is not None:
    # not None
    pass
if myvar is None:
    # None
    pass

En användning av is att testa för en "sentinel" (dvs. ett unikt objekt).

sentinel = object()
def myfunc(var=sentinel):
    if var is sentinel:
        # value wasn’t provided
        pass
    else:
        # value was provided
        pass

Jämförelse av objekt

För att jämföra jämlikheten mellan anpassade klasser kan du åsidosätta == och != __eq__ definiera __eq__ och __ne__ metoder. Du kan också åsidosätta __lt__ ( < ), __le__ ( <= ), __gt__ ( > ) och __ge__ ( > ). Observera att du bara behöver åsidosätta två jämförelsemetoder, och Python kan hantera resten ( == är samma som not < och not > osv.)

class Foo(object):
    def __init__(self, item):
        self.my_item = item
    def __eq__(self, other):
        return self.my_item == other.my_item
    
a = Foo(5)
b = Foo(5)
a == b     # True
a != b     # False
a is b     # False

Observera att denna enkla jämförelse antar att other (objektet som jämförs med) är samma objekttyp. Jämförelse med en annan typ kommer att kasta ett fel:

class Bar(object):
    def __init__(self, item):
        self.other_item = item
    def __eq__(self, other):
        return self.other_item == other.other_item
    def __ne__(self, other):
        return self.other_item != other.other_item
    
c = Bar(5)
a == c    # throws AttributeError: 'Foo' object has no attribute 'other_item'

Att kontrollera isinstance() eller liknande hjälper till att förhindra detta (om så önskas).

Vanlig Gotcha: Python tvingar inte att skriva

På många andra språk, om du kör följande (Java-exempel)

if("asgdsrf" == 0) {
    //do stuff
}

... får du ett fel. Du kan inte bara jämföra strängar med heltal som det. I Python är detta ett helt juridiskt uttalande - det kommer bara att lösa sig till False .

En vanlig gotcha är följande

myVariable = "1"
if 1 == myVariable:
    #do stuff

Denna jämförelse utvärderar False utan fel varje gång, eventuellt döljer ett fel eller bryter en villkorad.