Python Language
vergelijkingen

Syntaxis

• ! = - Is niet gelijk aan

• == - Is gelijk aan

• > - groter dan

• < - minder dan

• >= - groter dan of gelijk aan

• <= - kleiner dan of gelijk aan

• is - test of objecten exact hetzelfde object zijn

• is not = test of objecten niet exact hetzelfde object zijn

parameters

Groter dan of kleiner dan

x > y
x < y

Deze operatoren vergelijken twee soorten waarden, ze zijn kleiner dan en groter dan operatoren. Voor getallen vergelijkt dit eenvoudigweg de numerieke waarden om te zien welke groter is:

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

Voor tekenreeksen vergelijken ze lexicografisch, wat vergelijkbaar is met alfabetische volgorde, maar niet helemaal hetzelfde.

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

In deze vergelijkingen worden kleine letters als 'groter dan' in hoofdletters beschouwd, daarom is "gamma" < "OMEGA" onwaar. Als ze allemaal hoofdletters waren, zou dit het verwachte alfabetische bestelresultaat opleveren:

"GAMMA" < "OMEGA"
# True

Elk type definieert zijn berekening met de operatoren < en > anders, dus u moet onderzoeken wat de operatoren met een bepaald type bedoelen voordat u het gebruikt.

Niet gelijk aan

x != y  

Dit geeft True terug als x en y niet gelijk zijn en anders False retourneert.

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

Gelijk aan

x == y 

Deze uitdrukking evalueert of x en y dezelfde waarde zijn en retourneert het resultaat als een Booleaanse waarde. Over het algemeen moeten type en waarde overeenkomen, dus de int 12 is niet hetzelfde als de tekenreeks '12' .

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

Merk op dat elk type een functie moet definiëren die wordt gebruikt om te evalueren of twee waarden hetzelfde zijn. Voor ingebouwde typen gedragen deze functies zich zoals je zou verwachten en evalueren ze gewoon dingen op basis van dezelfde waarde. Aangepaste typen kunnen echter gelijkheidstesten definiëren als wat ze maar willen, inclusief altijd True of altijd False retourneren.

Ketenvergelijkingen

U kunt meerdere items vergelijken met meerdere vergelijkingsoperatoren met ketenvergelijking. Bijvoorbeeld

x > y > z

is slechts een korte vorm van:

x > y and y > z

Dit wordt alleen geëvalueerd als True als beide vergelijkingen True .

De algemene vorm is

a OP b OP c OP d ...

Waar OP staat voor een van de meerdere vergelijkingsbewerkingen die u kunt gebruiken, en de letters willekeurige geldige uitdrukkingen vertegenwoordigen.

Merk op dat 0 != 1 != 0 resulteert in True , ook al is 0 != 0 False . In tegenstelling tot de algemene wiskundige notatie waarin x != y != z betekent dat x , y en z verschillende waarden hebben. Chaining == operaties hebben in de meeste gevallen de natuurlijke betekenis, aangezien gelijkheid over het algemeen van voorbijgaande aard is.

Stijl

Er is geen theoretische limiet op het aantal items en vergelijkingsbewerkingen die u gebruikt zolang u de juiste syntaxis heeft:

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

Het bovenstaande geeft True terug als elke vergelijking True retourneert. Het gebruik van ingewikkelde kettingvorming is echter geen goede stijl. Een goede kettingvorming zal "directioneel" zijn, niet ingewikkelder dan

1 > x > -4 > y != 8

Bijwerkingen

Zodra een vergelijking False retourneert, wordt de uitdrukking onmiddellijk geëvalueerd in False , waarbij alle resterende vergelijkingen worden overgeslagen.

Merk op dat de uitdrukking exp in a > exp > b slechts eenmaal zal worden geëvalueerd, terwijl in het geval van

a > exp and exp > b

exp wordt tweemaal berekend als a > exp waar is.

Vergelijking met `is` versus` == `

Een veel voorkomende valkuil is het verwarren van de operatoren voor het vergelijken van gelijkheid is en == .

a == b vergelijkt de waarde van a en b .

a is b zal de identiteiten van a en b .

Illustreren:

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 [!!]

In principe is kan worden gezien als afkorting voor id(a) == id(b) .

Verder zijn er eigenaardigheden van de runtime-omgeving die de zaken nog ingewikkelder maken. Korte tekenreeksen en kleine gehele getallen zullen True retourneren in vergelijking met is , omdat de Python-machine probeert minder geheugen te gebruiken voor identieke objecten.

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

Maar langere tekenreeksen en grotere gehele getallen worden afzonderlijk opgeslagen.

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

U zou moeten gebruiken is om op None te testen:

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

Een gebruik van is is om te testen op een "sentinel" (dwz een uniek object).

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

Objecten vergelijken

Om de gelijkheid van aangepaste klassen te vergelijken, kunt u == en != __ne__ methoden __eq__ en __ne__ definiëren. U kunt ook __lt__ ( < ), __le__ ( <= ), __gt__ ( > ) en __ge__ ( > ) __ge__ . Merk op dat u slechts twee vergelijkingsmethoden hoeft te negeren, en Python kan de rest aan ( == is hetzelfde als not < en not > , enz.)

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

Merk op dat deze eenvoudige vergelijking ervan uitgaat dat other (het object waarmee wordt vergeleken) hetzelfde objecttype is. In vergelijking met een ander type geeft dit een foutmelding:

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'

Het controleren van isinstance() of iets dergelijks helpt dit te voorkomen (indien gewenst).

Common Gotcha: Python dwingt het typen niet af

In veel andere talen, als u het volgende uitvoert (Java-voorbeeld)

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

... krijg je een foutmelding. Je kunt niet zomaar strings met zulke getallen vergelijken. In Python is dit een volkomen legale verklaring - het zal gewoon oplossen naar False .

Een veel voorkomende gotcha is de volgende

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

Deze vergelijking zal evalueren om False zonder een fout, elke keer, mogelijk verbergen van een bug of het breken van een voorwaardelijk.