Python Language
Porównania

Składnia

• ! = - Nie jest równy

• == - jest równe

• > - większy niż

• < - mniej niż

• >= - większy lub równy

• <= - mniejszy lub równy

• is - sprawdź, czy obiekty są dokładnie tym samym obiektem

• nie jest = sprawdź, czy obiekty nie są dokładnie tym samym obiektem

Parametry

Większy lub mniejszy niż

x > y
x < y

Operatory te porównują dwa typy wartości, są one mniejsze i większe niż operatory. W przypadku liczb po prostu porównuje wartości liczbowe, aby zobaczyć, która jest większa:

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

W przypadku ciągów porównają leksykograficznie, co jest podobne do porządku alfabetycznego, ale nie do końca takie samo.

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

W tych porównaniach małe litery są uważane za „większe niż” wielkie litery, dlatego "gamma" < "OMEGA" jest fałszem. Gdyby wszystkie były dużymi literami, zwracałby oczekiwany wynik uporządkowania alfabetycznego:

"GAMMA" < "OMEGA"
# True

Każdy typ definiuje obliczenia za pomocą operatorów < i > inaczej, dlatego przed użyciem należy sprawdzić, co oznaczają operatory dla danego typu.

Nie równy

x != y  

Powrócisz True jeśli x i y nie są sobie równe, a inaczej zwraca False .

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

Równy

x == y 

Wyrażenie to jeśli x i y są takie same i powrotu wynik jako wartość logiczna. Zasadniczo zarówno typ, jak i wartość muszą być zgodne, więc liczba całkowita 12 nie jest taka sama jak ciąg '12' .

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

Zauważ, że każdy typ musi zdefiniować funkcję, która będzie używana do oceny, czy dwie wartości są takie same. W przypadku typów wbudowanych funkcje te zachowują się tak, jak można się spodziewać, i po prostu oceniają rzeczy na podstawie bycia tą samą wartością. Jednak typy niestandardowe mogą definiować testowanie równości jako cokolwiek chcą, w tym zawsze zwracając True lub Zawsze zwracając False .

Porównania łańcuchowe

Możesz porównać wiele elementów za pomocą wielu operatorów porównania z porównaniem łańcucha. Na przykład

x > y > z

jest tylko krótką formą:

x > y and y > z

Doprowadzi to do wartości True tylko wtedy, gdy oba porównania będą True .

Ogólna forma to

a OP b OP c OP d ...

Gdzie OP reprezentuje jedną z wielu operacji porównania, których można użyć, a litery reprezentują dowolne prawidłowe wyrażenia.

Zauważ, że 0 != 1 != 0 wartość True , nawet jeśli 0 != 0 to False . W przeciwieństwie do zwykłego zapisu matematycznego, w którym x != y != z oznacza, że x , y i z mają różne wartości. Łańcuchy == operacje mają naturalne znaczenie w większości przypadków, ponieważ równość jest na ogół przechodnia.

Styl

Nie ma teoretycznego ograniczenia liczby używanych elementów i operacji porównania, o ile masz odpowiednią składnię:

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

Powyższe zwraca wartość True jeśli każde porównanie zwraca wartość True . Jednak stosowanie zawiłego łączenia nie jest dobrym stylem. Dobry łańcuch będzie „kierunkowy”, nie bardziej skomplikowany niż

1 > x > -4 > y != 8

Skutki uboczne

Gdy tylko jedno porównanie zwróci wartość False , wyrażenie natychmiast False wartość na False , pomijając wszystkie pozostałe porównania.

Zauważ, że wyrażenie exp w a > exp > b zostanie ocenione tylko raz, podczas gdy w przypadku

a > exp and exp > b

exp zostanie obliczone dwukrotnie, jeśli a > exp jest prawdziwe.

Porównanie przez `is` vs` == `

Częstym błędem jest niejasna operatory porównania równość is i == .

a == b porównuje wartość a i b .

a is b porówna tożsamości a i b .

Ilustrować:

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

Zasadniczo is może być uważany jako skrót dla id(a) == id(b) .

Poza tym istnieją dziwactwa środowiska wykonawczego, które jeszcze bardziej komplikują sytuację. Krótkie ciągi i małe liczby całkowite powróci True w porównaniu ze is , ze względu na maszynie Pythona próbuje użyć mniej pamięci dla identycznych obiektów.

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

Ale dłuższe ciągi i większe liczby całkowite będą przechowywane osobno.

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

Powinieneś użyć is przetestować na None :

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

Zastosowanie is jest test na „Sentinel” (czyli unikalny obiekt).

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

Porównywanie obiektów

Aby porównać równość klas niestandardowych, możesz przesłonić == i != , Definiując metody __eq__ i __ne__ . Możesz również zastąpić __lt__ ( < ), __le__ ( <= ), __gt__ ( > ) i __ge__ ( > ). Zauważ, że wystarczy zastąpić dwie metody porównania, a Python może obsłużyć resztę ( == jest taki sam, jak not < i not > itd.)

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

Zauważ, że to proste porównanie zakłada, że other (porównywany obiekt) jest tego samego typu. Porównanie z innym typem spowoduje błąd:

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'

Sprawdzanie isinstance() lub podobnego pomoże temu zapobiec (w razie potrzeby).

Typowa Gotcha: Python nie wymusza pisania

W wielu innych językach, jeśli uruchomisz następujące (przykład Java)

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

... dostaniesz błąd. Nie można po prostu porównywać ciągów znaków z liczbami całkowitymi. W Pythonie jest to całkowicie legalne oświadczenie - po prostu rozwiąże się ono na False .

Typowa gotcha jest następująca

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

To porównanie zmieni się w False bez błędu, za każdym razem, potencjalnie ukrywając błąd lub łamiąc warunek.