Moje Google-fu mnie zawiodło.

Czy w Pythonie następujące dwa testy na równoważność są równoważne?

n = 5
# Test one.
if n == 5:
    print 'Yay!'

# Test two.
if n is 5:
    print 'Yay!'

Czy dotyczy to obiektów, w których porównywałbyś instancje ( listpowiedzmy)?

Okej, więc ten rodzaj odpowiedzi na moje pytanie:

L = []
L.append(1)
if L == [1]:
    print 'Yay!'
# Holds true, but...

if L is [1]:
    print 'Yay!'
# Doesn't.

Więc ==testy sprawdzają, gdzie istesty sprawdzają, czy są one tym samym obiektem?

iszwróci, Truejeśli dwie zmienne wskazują ten sam obiekt, ==jeśli obiekty, do których odnoszą się zmienne, są równe.

>>> a = [1, 2, 3]
>>> b = a
>>> b is a 
True
>>> b == a
True

# Make a new copy of list `a` via the slice operator, 
# and assign it to variable `b`
>>> b = a[:] 
>>> b is a
False
>>> b == a
True

W twoim przypadku drugi test działa tylko dlatego, że Python buforuje małe obiekty całkowite, co jest szczegółem implementacji. W przypadku większych liczb całkowitych to nie działa:

>>> 1000 is 10**3
False
>>> 1000 == 10**3
True

To samo dotyczy literałów łańcuchowych:

>>> "a" is "a"
True
>>> "aa" is "a" * 2
True
>>> x = "a"
>>> "aa" is x * 2
False
>>> "aa" is intern(x*2)
True

Zobacz także to pytanie .

Istnieje prosta zasada, która mówi, kiedy użyć ==lub is.

• ==oznacza równość wartości . Użyj go, jeśli chcesz wiedzieć, czy dwa obiekty mają tę samą wartość.
• isjest dla równości odniesienia . Użyj go, jeśli chcesz wiedzieć, czy dwa odniesienia odnoszą się do tego samego obiektu.

Ogólnie rzecz biorąc, gdy porównujesz coś do prostego typu, zwykle sprawdzasz równość wartości , więc powinieneś użyć ==. Na przykład, celem twojego przykładu jest prawdopodobnie sprawdzenie, czy x ma wartość równą 2 ( ==), a nie xto, czy dosłownie odnosi się do tego samego obiektu co 2.

Należy zwrócić uwagę na coś innego: ze względu na sposób działania implementacji referencji CPython otrzymasz nieoczekiwane i niespójne wyniki, jeśli omyłkowo użyjesz isdo porównania równości referencji na liczbach całkowitych:

>>> a = 500
>>> b = 500
>>> a == b
True
>>> a is b
False

To dość dużo, co można się spodziewać: ai bmają taką samą wartość, ale są odrębnymi podmiotami. Ale co z tym?

>>> c = 200
>>> d = 200
>>> c == d
True
>>> c is d
True

Jest to niezgodne z wcześniejszym wynikiem. Co tu się dzieje? Okazuje się, że referencyjna implementacja Pythona buforuje obiekty całkowite z zakresu -5..256 jako instancje singletonów ze względu na wydajność. Oto przykład, który to pokazuje:

>>> for i in range(250, 260): a = i; print "%i: %s" % (i, a is int(str(i)));
... 
250: True
251: True
252: True
253: True
254: True
255: True
256: True
257: False
258: False
259: False

To kolejny oczywisty powód, dla którego nie należy używać is: zachowanie należy do implementacji, gdy błędnie używa się go do równości wartości.

==określa, czy wartości są równe, a jednocześnie isokreśla, czy są dokładnie tym samym obiektem.

Czy istnieje różnica pomiędzy ==oraz isw Pythonie?

Tak, mają bardzo ważną różnicę.

==: sprawdź równość - semantyka polega na tym, że równoważne obiekty (niekoniecznie te same obiekty) będą testować jako równe. Jak mówi dokumentacja :

Operatory <,>, ==,> =, <= i! = Porównują wartości dwóch obiektów.

is: sprawdź tożsamość - semantyka polega na tym, że obiekt (przechowywany w pamięci) jest obiektem. Ponownie dokumentacja mówi :

Operatorzy isi is nottesty do identyfikacji obiektu: x is yjest prawdziwe wtedy i tylko wtedy x, a yto ten sam obiekt. Tożsamość obiektu określa się za pomocą id()funkcji. x is not ydaje odwrotną wartość prawdy.

Zatem sprawdzenie tożsamości jest takie samo, jak sprawdzenie równości identyfikatorów obiektów. To jest,

a is b

jest taki sam jak:

id(a) == id(b)

gdzie idjest wbudowana funkcja, która zwraca liczbę całkowitą, która „gwarantuje, że jest unikalna wśród jednocześnie istniejących obiektów” (patrz help(id)) oraz gdzie ai bsą dowolnymi obiektami.

Inne wskazówki użytkowania

Powinieneś używać tych porównań dla ich semantyki. Służy isdo sprawdzania tożsamości i ==równości.

Ogólnie rzecz biorąc, używamy isdo sprawdzania tożsamości. Jest to zwykle przydatne, gdy szukamy obiektu, który powinien istnieć tylko raz w pamięci, zwany w dokumentacji „singletonem”.

Przypadki użycia isobejmują:

• None
• wartości wyliczeniowe (przy użyciu wyliczeń z modułu wyliczeniowego)
• zwykle moduły
• zwykle obiekty klasy wynikające z definicji klas
• zwykle obiekty funkcyjne wynikające z definicji funkcji
• wszystko inne, co powinno istnieć tylko raz w pamięci (ogólnie wszystkie singletony)
• konkretny obiekt, który chcesz według tożsamości

Typowe przypadki użycia ==obejmują:

• liczby, w tym liczby całkowite
• smyczki
• listy
• zestawy
• słowniki
• niestandardowe obiekty zmienne
• inne wbudowane niezmienne obiekty, w większości przypadków

Ogólny przypadek użycia, znowu, dla ==, jest przedmiotem chcesz nie może być taki sam przedmiot, a nie może być równoważny jeden

Kierunki PEP 8

PEP 8, oficjalny przewodnik po języku Python dla standardowej biblioteki, wspomina również o dwóch przypadkach użycia dlais :

Porównania z singletonami, takie jak, Nonenależy zawsze przeprowadzać z operatorami równości islub is notnigdy.

Uważaj też na pisanie, if xkiedy naprawdę masz na myśli if x is not None- np. Podczas testowania, czy zmienna lub argument, który domyślnie ma None wartość, została ustawiona na inną wartość. Druga wartość może mieć typ (na przykład kontener), który może być fałszywy w kontekście logicznym!

Wnioskowanie o równości na podstawie tożsamości

Jeśli isjest to prawda, równość zwykle można wywnioskować - logicznie, jeśli obiekt jest sam, to powinien on przetestować jako równoważny sam sobie.

W większości przypadków ta logika jest prawdziwa, ale opiera się na implementacji __eq__specjalnej metody. Jak mówią doktorzy ,

Domyślne zachowanie dla porównania równości ( ==i !=) opiera się na tożsamości obiektów. Zatem porównanie równości wystąpień o tej samej tożsamości powoduje równość, a porównanie równości wystąpień o różnych tożsamościach powoduje nierówność. Motywacją dla tego domyślnego zachowania jest pragnienie, aby wszystkie obiekty były refleksyjne (tj. X to y oznacza x == y).

oraz w celu zachowania spójności zaleca:

Porównanie równości powinno być zwrotne. Innymi słowy, identyczne obiekty powinny się równać:

x is y implikuje x == y

Widzimy, że jest to domyślne zachowanie niestandardowych obiektów:

>>> class Object(object): pass
>>> obj = Object()
>>> obj2 = Object()
>>> obj == obj, obj is obj
(True, True)
>>> obj == obj2, obj is obj2
(False, False)

Przeciwne jest również zwykle prawda - jeśli coś nie jest równe, zwykle można wywnioskować, że nie są one tym samym przedmiotem.

Ponieważ testy równości można dostosować, wnioskowanie to nie zawsze jest prawdziwe dla wszystkich typów.

Wyjątek

Godnym uwagi wyjątkiem jest nan- zawsze testuje się jako nie równy sobie:

>>> nan = float('nan')
>>> nan
nan
>>> nan is nan
True
>>> nan == nan           # !!!!!
False

Sprawdzanie tożsamości może być znacznie szybsze niż sprawdzanie równości (co może wymagać rekurencyjnego sprawdzania członków).

Ale nie można go zastąpić równością, w której można znaleźć więcej niż jeden obiekt jako równoważny.

Zauważ, że porównanie równości list i krotek zakłada, że ​​tożsamość obiektów jest równa (ponieważ jest to szybka kontrola). Może to powodować sprzeczności, jeśli logika jest niespójna - tak jak w przypadku nan:

>>> [nan] == [nan]
True
>>> (nan,) == (nan,)
True

Przestroga:

Pytanie próbuje użyć isdo porównania liczb całkowitych. Nie należy zakładać, że wystąpienie liczby całkowitej jest tym samym wystąpieniem, co wystąpienie innego odwołania. Ta historia wyjaśnia, dlaczego.

Komentator miał kod, który polegał na tym, że małe liczby całkowite (od -5 do 256 włącznie) są singletonami w Pythonie, zamiast sprawdzania równości.

Wow, może to prowadzić do pewnych podstępnych błędów. Miałem kod, który sprawdzał, czy a jest b, co działało tak, jak chciałem, ponieważ aib są zwykle małymi liczbami. Błąd pojawił się dopiero dzisiaj, po sześciu miesiącach produkcji, ponieważ aib były w końcu wystarczająco duże, aby nie zostać zbuforowane. - gwg

Działało w rozwoju. Być może minęło trochę nieprzyzwoitych wydarzeń.

I działało w produkcji - dopóki kod nie sprawdził liczby całkowitej większej niż 256, w którym momencie nie powiodło się w produkcji.

Jest to błąd produkcyjny, który mógł zostać wykryty podczas przeglądania kodu lub ewentualnie za pomocą narzędzia sprawdzającego styl.

Podkreślę: nie używaj isdo porównywania liczb całkowitych.

Jaka jest różnica między isi ==?

==i issą różne porównania! Jak już powiedzieli inni:

• == porównuje wartości obiektów.
• is porównuje odniesienia do obiektów.

W nazwach Python odnoszą się do obiektów, na przykład w tym przypadku value1i value2odnoszą się do intinstancji przechowującej wartość 1000:

value1 = 1000
value2 = value1

Ponieważ value2odnosi się do tego samego obiektu isi ==da True:

>>> value1 == value2
True
>>> value1 is value2
True

W kolejnym przykładzie nazwy value1i value2odnosi się do innych intprzypadkach, nawet jeśli obie przechowywać ten sam całkowitą:

>>> value1 = 1000
>>> value2 = 1000

Ponieważ przechowywana ==będzie ta sama wartość (liczba całkowita) True, dlatego często nazywa się ją „porównywaniem wartości”. Jednak iswróci, Falseponieważ są to różne obiekty:

>>> value1 == value2
True
>>> value1 is value2
False

Kiedy stosować który?

Ogólnie isjest to znacznie szybsze porównanie. Dlatego CPython buforuje (a może ponowne użycie byłoby lepszym terminem) niektóre obiekty, takie jak małe liczby całkowite, niektóre ciągi znaków itp. Ale to powinno być traktowane jako szczegół implementacji, który może (nawet jeśli jest to mało prawdopodobne) zmienić w dowolnym momencie bez ostrzeżenia.

Powinieneś używać tylko,is jeśli:

• chcę sprawdzić, czy dwa obiekty są tak naprawdę tym samym obiektem (a nie tylko tą samą „wartością”). Przykładem może być, jeśli ty używać singleton jako obiekt stały.

• chcę porównać wartość ze stałą Python . Stałe w Pythonie to:

  • None
  • True¹
  • False¹
  • NotImplemented
  • Ellipsis
  • __debug__
  • zajęcia (na przykład int is intlub int is float)
  • mogą istnieć dodatkowe stałe we wbudowanych modułach lub modułach innych firm. Na przykład np.ma.maskedz modułu NumPy)

W każdym innym przypadku należy użyć== do sprawdzenia równości.

Czy mogę dostosować zachowanie?

Jest pewien aspekt, o ==którym nie wspomniano już w innych odpowiedziach: jest to część „modelu danych” Pythona . Oznacza to, że jego zachowanie można dostosować za pomocą tej __eq__metody. Na przykład:

class MyClass(object):
    def __init__(self, val):
        self._value = val

    def __eq__(self, other):
        print('__eq__ method called')
        try:
            return self._value == other._value
        except AttributeError:
            raise TypeError('Cannot compare {0} to objects of type {1}'
                            .format(type(self), type(other)))

To tylko sztuczny przykład ilustrujący, że metoda naprawdę nazywa się:

>>> MyClass(10) == MyClass(10)
__eq__ method called
True

Zauważ, że domyślnie (jeśli nie __eq__można znaleźć innej implementacji w klasie lub nadklasach) __eq__używa is:

class AClass(object):
    def __init__(self, value):
        self._value = value

>>> a = AClass(10)
>>> b = AClass(10)
>>> a == b
False
>>> a == a

Dlatego tak naprawdę ważne jest wdrożenie, __eq__jeśli chcesz „więcej” niż tylko porównanie referencji dla klas niestandardowych!

Z drugiej strony nie można dostosowywać isczeków. Zawsze będzie się porównywał tylko wtedy, gdy masz to samo odniesienie.

Czy te porównania zawsze zwracają wartość logiczną?

Ponieważ __eq__można go ponownie wdrożyć lub zastąpić, nie ogranicza się do zwrotu Truelub False. To mogło powrócić niczego (ale w większości przypadków należy zwrócić wartość logiczną!).

Na przykład z tablicami NumPy ==zwróci tablicę:

>>> import numpy as np
>>> np.arange(10) == 2
array([False, False,  True, False, False, False, False, False, False, False], dtype=bool)

Ale isczeki zawsze będą zwracane Truelub False!

¹ Jak wspomniał Aaron Hall w komentarzach:

Zasadniczo nie powinieneś wykonywać żadnych testów is Trueani is Falsekontroli, ponieważ zwykle używa się tych „kontroli” w kontekście, który domyślnie przekształca warunek na wartość logiczną (na przykład w ifinstrukcji). Tak więc is Trueporównanie i niejawna obsada boolean wymaga więcej pracy niż wykonanie obsady boolean - a ty ograniczasz się do booleanów (co nie jest uważane za pytoniczne).

Jak wspomina PEP8:

Nie porównuj wartości boolowskich z Trueani nie Falseużywaj ==.

Yes:   if greeting:
No:    if greeting == True:
Worse: if greeting is True:

Oni są zupełnie inni . issprawdza tożsamość obiektu, a ==sprawdza równość (pojęcie, które zależy od typów dwóch operandów).

To tylko szczęśliwy zbieg okoliczności, że „ is” wydaje się działać poprawnie z małymi liczbami całkowitymi (np. 5 == 4 + 1). Jest tak, ponieważ CPython optymalizuje przechowywanie liczb całkowitych w zakresie (-5 do 256), czyniąc je singletonami . To zachowanie jest całkowicie zależne od implementacji i nie ma gwarancji, że zostanie zachowane we wszelkiego rodzaju drobnych operacjach transformacyjnych.

Na przykład Python 3.5 tworzy także singletony krótkich ciągów, ale krojenie ich zakłóca takie zachowanie:

>>> "foo" + "bar" == "foobar"
True
>>> "foo" + "bar" is "foobar"
True
>>> "foo"[:] + "bar" == "foobar"
True
>>> "foo"[:] + "bar" is "foobar"
False

https://docs.python.org/library/stdtypes.html#comparisons

istesty dla testów tożsamości ==dla równości

Każda (mała) wartość całkowita jest odwzorowana na pojedynczą wartość, więc każda 3 jest identyczna i równa. Jest to szczegół implementacji, ale nie jest częścią specyfikacji języka

Twoja odpowiedź jest poprawna. isOperatora porównuje identyczności dwóch przedmiotów. ==Operatora porównuje wartości dwóch przedmiotów.

Tożsamość obiektu nigdy się nie zmienia po utworzeniu; możesz myśleć o tym jako o adresie obiektu w pamięci.

Możesz kontrolować zachowanie porównawcze wartości obiektów, definiując __cmp__metodę lub bogatą metodę porównywania , taką jak __eq__.

Spójrz na pytanie o przepełnienie stosu Operator „jest” Pythona zachowuje się nieoczekiwanie przy liczbach całkowitych .

Sprowadza się to głównie do tego, że „ is” sprawdza, czy są one tym samym obiektem, a nie tylko sobie równe (liczby poniżej 256 są szczególnym przypadkiem).

W skrócie issprawdza, czy dwa odwołania wskazują na ten sam obiekt, czy nie. ==sprawdza, czy dwa obiekty mają tę samą wartość, czy nie.

a=[1,2,3]
b=a        #a and b point to the same object
c=list(a)  #c points to different object 

if a==b:
    print('#')   #output:#
if a is b:
    print('##')  #output:## 
if a==c:
    print('###') #output:## 
if a is c:
    print('####') #no output as c and a point to different object 

Jak powiedział John Feminella, przez większość czasu będziesz używać == i! =, Ponieważ Twoim celem jest porównanie wartości. Chciałbym tylko podzielić na kategorie, co zrobiłbyś przez resztę czasu:

Istnieje jedna i tylko jedna instancja NoneType, tzn. None nie jest singletonem. W konsekwencji foo == Nonei foo is Noneznaczy to samo. Jednak istest jest szybszy i należy użyć konwencji Pythona foo is None.

Jeśli robisz jakieś introspekcji lub mucking ze zbierania śmieci lub sprawdzanie, czy zwyczaj wybudowany internowanie łańcuchów gadżet działa lub suchlike, a następnie prawdopodobnie masz przypadków użycia za footo bar.

Prawda i fałsz są również (teraz) singletonami, ale nie ma przypadku foo == Trueużycia ani przypadku użycia foo is True.

Większość z nich już odpowiedziała na ten temat. Podobnie jak dodatkowa uwaga (oparta na moim zrozumieniu i eksperymentach, ale nie z udokumentowanego źródła), oświadczenie

== jeśli obiekty, do których odnoszą się zmienne, są równe

z powyższych odpowiedzi należy rozumieć jako

== jeśli obiekty, do których odnoszą się zmienne, są równe i obiekty należące do tego samego typu / klasy

. Doszedłem do tego wniosku na podstawie poniższego testu:

list1 = [1,2,3,4]
tuple1 = (1,2,3,4)

print(list1)
print(tuple1)
print(id(list1))
print(id(tuple1))

print(list1 == tuple1)
print(list1 is tuple1)

Tutaj zawartość listy i krotki są takie same, ale typ / klasa są różne.

Różnica w Pythonie między jest i jest równa (==)

Operator is może wydawać się taki sam jak operator równości, ale nie są tacy sami.

Sprawdza, czy obie zmienne wskazują ten sam obiekt, podczas gdy znak == sprawdza, czy wartości dwóch zmiennych są takie same.

Więc jeśli operator is zwraca True, to równość jest zdecydowanie True, ale przeciwieństwo może, ale nie musi być True.

Oto przykład pokazujący podobieństwo i różnicę.

>>> a = b = [1,2,3]
>>> c = [1,2,3]
>>> a == b
True
>>> a == c
True
>>> a is b
True
>>> a is c
False
>>> a = [1,2,3]
>>> b = [1,2]
>>> a == b
False
>>> a is b
False
>>> del a[2]
>>> a == b
True
>>> a is b
False

Tip: Avoid using is operator for immutable types such as strings and numbers, the result is unpredictable.

Ponieważ inne osoby w tym poście szczegółowo odpowiadają na pytanie, chciałbym przede wszystkim podkreślić porównanie między ciągami znakówis i == dla nich, które mogą dawać różne wyniki, i zachęcam programistów do ich ostrożnego korzystania.

Do porównania ciągów należy użyć ==zamiast is:

str = 'hello'
if (str is 'hello'):
    print ('str is hello')
if (str == 'hello'):
    print ('str == hello')

Na zewnątrz:

str is hello
str == hello

Ale w poniższym przykładzie ==i isbędzie uzyskać różne wyniki:

str = 'hello sam'
    if (str is 'hello sam'):
        print ('str is hello sam')
    if (str == 'hello sam'):
        print ('str == hello sam')

Na zewnątrz:

str == hello sam

Wniosek:

Użyj isostrożnie, aby porównać ciągi znaków