Istnieje prosta zasada mówiąca, kiedy należy stosować == lub is.

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

Ogólnie rzecz biorąc, kiedy porównujesz coś z prostym typem, Zwykle sprawdzasz równość wartości, więc należy użyć ==. Na przykład, intencją twojego przykładu jest prawdopodobnie sprawdzenie, czy x ma wartość równą 2 (==), a nie czy x odnosi się dosłownie do tego samego obiektu co 2.

Coś jeszcze do odnotowania: ze względu na sposób, w jaki implementacja CPython reference działa, otrzymasz nieoczekiwane i niespójne wyniki, jeśli błędnie użyjesz is do porównania równości referencji na liczbach całkowitych:

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

Tego się spodziewaliśmy: a i b mają tej samej wartości, ale są odrębnymi bytami. 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 w zakresie -5..256 jako instancje singleton ze względu na wydajność. Oto przykład demonstrujący to:

>>> 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

Jest to kolejny oczywisty powód, aby nie używać is: zachowanie jest pozostawione do implementacji, gdy błędnie używasz go dla wartości równość.

== określa, czy wartości są równe, podczas gdy is określa, czy są dokładnie tym samym obiektem i równe.

Są zupełnie inne . is sprawdza tożsamość obiektu, podczas gdy == sprawdza równość(pojęcie, które zależy od dwóch typów 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), tworząc z nich singletony. Zachowanie to jest całkowicie zależne od implementacji i nie gwarantuje zachowania pod wszelkiego rodzaju drobnych operacji transformacyjnych.

Na przykład Python 3.5 również tworzy krótkie stringi singletonów, ale ich przecięcie zakłóca to zachowanie:

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

Czy jest różnica między == a is w Pythonie?

==: sprawdzanie równości-semantyka polega na tym, że równoważne obiekty (które niekoniecznie są tym samym obiektem) będą testowane jako równe. Jak mówi dokumentacja :

Operatory , ==, >=,

is: check for identity-the semantyka polega na tym, że obiekt (przechowywany w pamięci) jest obiektem. Ponownie, dokumentacja mówi :

Operatory is i is not sprawdzają tożsamość obiektu: x is y jest prawdą wtedy i tylko wtedy, gdy x i y są tym samym obiektem. Tożsamość obiektu jest określone za pomocą funkcji id(). x is not y daje odwrotność wartość prawdy.

Tak więc sprawdzanie tożsamości jest tym samym, co sprawdzanie równości ID obiektów. Że is,

a is b

Jest tym samym co:

id(a) == id(b)

Gdzie {[16] } jest wbudowaną funkcją zwracającą liczbę całkowitą, która "jest gwarantowana jako unikalna wśród jednocześnie istniejących obiektów" (zobacz help(id)) i gdzie a i b są dowolnymi dowolnymi obiektami.

Inne Wskazówki Użytkowania

Powinieneś użyć tych porównań do ich semantyki. Użyj is, aby sprawdzić tożsamość i ==, aby sprawdzić równość.

PEP 8, oficjalny przewodnik stylu Pythona dla biblioteki standardowej wymienia również dwa przypadki użycia dla is:

Porównania do singletonów jak None powinny być zawsze wykonywane is lub is not, Nigdy operatorów równości.

Także, uważaj na pisanie if x kiedy naprawdę masz na myśli if x is not None -- na przykład podczas testowania, czy zmienna lub argument domyślnie None został ustawiony na inną wartość. Druga wartość może mieć typ (taki jako kontener), który może być false w boolean kontekst!

Wnioskowanie równości z tożsamości

Jeśli is jest prawdą, równość może Zwykle być wywnioskowana-logicznie, jeśli obiekt jest sam w sobie, to powinien testować jako jego odpowiednik.

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

Domyślne zachowanie porównywania równości (== i !=) opiera się na tożsamość przedmiotów. Stąd porównanie równości instancji z tą samą tożsamością wynika równość, a równość instancje o różnych tożsamościach powodują nierówność. A motywacją do tego domyślnego zachowania jest pragnienie, aby wszystkie obiekty powinien być refleksyjny (tzn. x jest Y oznacza x = = y).

I w trosce o spójność, zaleca:

Porównanie równości powinno być refleksyjne. Innymi słowy, identyczne obiekty powinny być równe:

x is y implikuje x == y

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

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

Contrapositive jest również zwykle prawdziwe - jeśli coś testuje się jako nie równe, zwykle można wywnioskować, że nie są one tym samym obiektem.

Ponieważ testy równości mogą być dostosowane, wnioskowanie to nie zawsze jest prawdziwe dla wszystkich typów.

Wyjątek

Godnym uwagi wyjątkiem jest nan - zawsze sprawdza się jako nie równa :

>>> 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 (które może wymagać rekurencyjnego sprawdzania członków).

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

Zauważ, że porównywanie równości list i krotek zakłada, że tożsamość obiektów jest równa (ponieważ jest to szybkie sprawdzenie). Może to tworzyć sprzeczności, jeśli logika jest niespójna - tak jak dla nan:

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

Przestroga:

Pytanie próbuje użyć is do porównania liczb całkowitych. Nie należy zakładać, że instancja liczby całkowitej jest tą samą instancją co instancja uzyskana przez inne odniesienie. Ta historia wyjaśnia dlaczego.

Komentator miał kod, który opierał się na fakcie, że małe liczby całkowite (od -5 do 256 włącznie) są singletonami w Pythonie, zamiast sprawdzać równość.

To może prowadzić do podstępnych błędów. Miałem jakiś kod. to sprawdzało, czy a jest b, co działało tak, jak chciałem, ponieważ a i b są zazwyczaj małymi liczbami. Błąd pojawił się dopiero dzisiaj, po sześciu miesiącach produkcji, ponieważ a i b były na tyle duże, że nie mogły być buforowane. - gwg

To działało w rozwoju. Mógł przejść kilka testów.

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

To jest awaria produkcji, która może zostały złapane w przeglądzie kodu lub ewentualnie za pomocą sprawdzania stylu.

Pozwól, że podkreślę: nie używaj is do porównywania liczb całkowitych.

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

is testy na tożsamość == testy równości

Każda (mała) liczba całkowita jest mapowana do pojedynczej wartości, więc każde 3 jest identyczne i równe. Jest to szczegół implementacji, a nie część specyfikacji języka

Jaka jest różnica między is a ==?

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

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

W Pythonie nazwy odnoszą się do obiektów, na przykład w tym przypadku value1 i value2 odnoszą się do instancji int przechowującej wartość 1000:

value1 = 1000
value2 = value1

Ponieważ value2 odnosi się do tego samego obiekt is i == da True:

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

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

Ponieważ ta sama wartość (liczba całkowita) jest przechowywana == będzie True, dlatego często nazywa się ją "porównaniem wartości". Jednak is zwróci False ponieważ są to różne obiekty:

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

Kiedy użyć którego?

Ogólnie is jest znacznie szybsze porównanie. Dlatego CPython buforuje (a może reuses byłoby lepszym określeniem) pewne obiekty, takie jak małe liczby całkowite, niektóre łańcuchy znaków itp. Ale to powinno być traktowane jako szczegóły implementacji , które mogą (nawet jeśli mało prawdopodobne) zmienić się w dowolnym momencie bez ostrzeżenia.

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

• chcesz sprawdzić, czy dwa obiekty są rzeczywiście tym samym obiektem (nie tylko tą samą "wartością"). Jednym z przykładów może być, jeśli ty użyj obiektu singleton jako stałej.

• Chcesz porównać wartość do Pythona stałej. Stałe w Pythonie to:

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

W w każdym innym przypadku należy użyć == aby sprawdzić równość.

Czy Mogę dostosować zachowanie?

Jest pewien aspekt ==, który nie został wymieniony jeszcze w innych odpowiedziach: jest częścią Pythons "model danych" . Oznacza to, że jego zachowanie można dostosować za pomocą __eq__ metoda. 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)))

Jest to tylko sztuczny przykład, aby zilustrować, że metoda jest naprawdę nazywa:

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

Zauważ, że domyślnie (jeśli żadna inna implementacja __eq__ nie może być znaleziona w klasie lub superklasach) __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 ważne jest, aby zaimplementować __eq__ jeśli chcesz "więcej" niż tylko porównywanie referencji dla klas niestandardowych!

Z drugiej strony nie można dostosować is kontroli. Zawsze będzie porównywać tylko , jeśli masz to samo odniesienie.

Czy te porównania zawsze zwrócą boolean?

Ponieważ __eq__ może być ponownie zaimplementowany lub nadpisany, nie ogranicza się do zwracania True lub False. To może zwrócić cokolwiek (ale w większości przypadków powinno 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 is kontrole zawsze wrócą True lub False!

¹ jak wspomniał Aaron Hall w komentarzach:

Generalnie nie powinieneś robić żadnych is True lub is False sprawdza, ponieważ zwykle używa się tych "sprawdzeń" w kontekście, który domyślnie konwertuje warunek na wartość logiczną (na przykład w instrukcji if). Tak więc wykonanie porównania is True i Ukryty boolean cast wykonuje więcej pracy niż tylko wykonanie boolean cast - i ograniczasz się do booleanów (co nie jest uważane za pythoniczne).

Jak PEP8 wspomina:

Nie porównuj wartości logicznych do True lub False używając ==.

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

Twoja odpowiedź jest prawidłowa. Operator is porównuje tożsamość dwóch obiektów. Operator == porównuje wartości dwóch obiektów.

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

Możesz kontrolować zachowanie porównywania wartości obiektu poprzez zdefiniowanie metody __cmp__ lub metodyrich comparison , takiej jak __eq__.

Spójrz na pytanie o przepełnienie stosu Operator Pythona " is " zachowuje się nieoczekiwanie z liczbami całkowitymi.

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

Jak powiedział John Feminella, większość czasu będziesz używać = = i != ponieważ twoim celem jest porównanie wartości. Chciałbym tylko skategoryzować co byś robił przez resztę czasu:

Istnieje tylko jedna instancja NoneType, tzn. None jest singletonem. W konsekwencji foo == None i foo is None oznaczają to samo. Jednak test is jest szybszy, a konwencja Pythoniczna ma używać foo is None.

Jeśli robisz jakąś introspekcję lub robisz coś ze śmieciami lub sprawdzasz, czy Twój niestandardowy gadżet do internowania ciągów działa lub coś takiego, prawdopodobnie masz przypadek użycia dla foo jest bar.

True I False są również (teraz) singletonami, ale nie ma przypadków użycia dla foo == True i nie ma przypadków użycia dla foo is True.

Właściwie chciałem dodać to jako komentarz, ale nie mogłem go łatwo upiększyć, dlatego dodawanie jako odpowiedź, proszę nie traktować tego jako odpowiedzi.

To jest to, co zrobiłem, aby zrozumieć --

Wykonaj po kolei i zrozum wyjście na każdym kroku

a = [1,2]
b = [1,2,3]
b.pop()
id(a)
id(b)
a is b
a == b

Większość z nich już odpowiedziała na to pytanie. Tylko jako dodatkowa uwaga (na podstawie mojego zrozumienia i eksperymentowania, ale nie z udokumentowanego źródła), stwierdzenie

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

Z powyższych odpowiedzi należy odczytać 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 test:

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ą inne.

W skrócie, is sprawdza, czy dwa odniesienia 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 

Operator == porównuje wartości obu operandów i sprawdza równość wartości. Operator is sprawdza, czy oba operandy odnoszą się do tego samego obiektu, czy nie.

a = [1,2,3,4]
b = a
print(a == b) # true
print(a is b) # true

But if we do

b = a[:] # b now references a copy of a
print(a == b) # true
print(a is b) # false
print(a is not b) # true

Zasadniczo, is można traktować jako skrót od id(a) == id(b). Jednak poza tym istnieją dziwactwa środowiska run-time, które jeszcze bardziej komplikują rzeczy. Krótkie ciągi i małe liczby całkowite powrócą True w porównaniu z is, ze względu na Maszyna Pythona próbuje użyć mniej pamięci dla identycznych obiektów.

a = 'python'
b = 'python'

print(a == b) # true
print(a is b) # true

Różnica w Pythonie pomiędzy is I equals (==)

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

Is sprawdza, czy obie zmienne wskazują na ten sam obiekt, podczas gdy znak = = sprawdza, czy wartości obu zmiennych są takie same.

Więc jeśli operator is zwraca True to równość jest definitywna Prawda, ale odwrotnie może być, ale nie musi być prawdą.

Oto przykład do zademonstrowania podobieństwo i różnica.

>>> 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.

"= = " porównuje wartości

"jest" porównuje podstawowe obiekty

# this pgm is to show you the diff b/n == and is

# a==b and a is b

# == compares values
# is compares references i.e compares wether two variables refer to same object(memory)

a=10
b=10
print(a==b) # returns True as a,b have same value 10 
print(a is b)
# returns True,
# we usually falsey assume that a =10 a new object . b=10 a new obj created
# but actually when b=10 ,nothing but b is pointed to 10 until value of a or b is changed from 10 

a=[1]
b=[1]
print(a==b)
#returns True as a,b have a list element 1
print(a is b)
#returns False because here two different objs are created when initiated with lists

O1 to o2 = > porównuje, jeśli o1 i O2 wskazują na tę samą fizyczną lokalizację w pamięci (innymi słowy, jeśli są tym samym obiektem)

O1 = = O2 = > tutaj python wywołuje metodę o1 _ _ cmp __(o2), która idealnie powinna porównywać wartość i zwracać True lub False. (Innymi słowy porównuje wartość)

dla ludzi Javy:

• W Javie, aby określić, czy dwie zmienne łańcuchowe odwołują się do tego samego lokalizacja pamięci fizycznej przez używając str1 = = str2 . (tzw. obiekt identity, i jest napisany w Pythonie jako str1 to str2 ).

• Aby porównać wartości łańcuchowe w Javie, usestr1.equals (str2) ; in Python, użyj str1 = = str2 .

Przykład:

class A():
    ...:     def __init__(self,a):
    ...:         self.a = a
    ...:     def __repr__(self):
    ...:         return str(self.a)
    ...:     def __cmp__(self, value):
    ...:         print self.a
    ...:         print value.a
    ...:         return cmp(self.a, value.a)

Wyjście powłoki Pythona:

O = A (2) o1 = o

O = = o1 2 2 True

O jest o1 True

O1 = A (2)

O jest o1 False

Jako, że inne osoby w tym poście odpowiadają na pytanie szczegółowo, chciałbym podkreślić głównie porównanie is i == dla ciągów , które mogą dawać różne wyniki i zachęcam programistów do uważnego ich używania.

Dla porównania łańcuchów, upewnij się, że używasz == zamiast is:

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

Out:

str is hello
str == hello

Ale W poniższym przykładzie == i is otrzymają różne wyniki:

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

Out:

str == hello sam

Wniosek:

Użyj is ostrożnie, aby porównać między strunami

Tak, jest różnica między nimi.

• '==' : porównuje obiekt według wartości.

• 'W": porównuje obiekt przez odniesienie.

  a = [1,2,3]  
  b = a # both pointing to same object (memory location)
  
  a == b:  
  True  
  a in b:   
  True  #because a and b are pointing to same object
  

Rozważmy teraz tę sprawę:

a = [1,2,3]
b = list(a)  # creating copy of object a

a == b:  
True  # as values are same
a in b:   
False  # because they are pointing to different object.

Podczas gdy wszystkie te odpowiedzi, które opierają się na implementacji porównania wskaźnika sprzeciwu względem wartości, są prawdopodobnie poprawne, istnieje głębszy powód składniowy, aby użyć is do określenia, czy wartość zmiennej jest None (w logice logicznej często reprezentowana jako NULL).

W relacyjnej bazie danych i innych systemach logicznych, NULL oznacza, że rzeczywista wartość jest "nieznana". Tak więc wyrażenie logiczne xx == NULL musi zawsze oceniać do NULL samego siebie, ponieważ nie jest możliwe poznanie Jeśli xx, niezależnie od wartości, jaką może mieć, jest taka sama jak nieznana wartość. W językach programowania, które ściśle przestrzegają zasad logiki boolowskiej, xx == NULL (lub Pythonicznie xx == None) poprawnie ocenia się na NULL i należy podać alternatywne środki, aby określić, czy wartość zmiennej wynosi NULL. Python jest odstający pod tym względem, ze względu na unitarny charakter odniesienia obiektu do None. Ale dla jasności i logicznej poprawności, użycie operatora porównania Python is wydaje mi się bardzo praktyka sounder.