Gibt es einen Unterschied zwischen "==" und "ist"?

Gibt es eine einfache Faustregel, um zu sagen, Wann Sie zu verwenden == oder is.

• == ist für Wert der Gleichheit. Verwenden Sie es, wenn Sie wissen möchten, ob zwei Objekte den gleichen Wert haben.
• is ist für Referenz-Gleichheit. Verwenden Sie es, wenn Sie wissen möchten, ob zwei Referenzen auf das gleiche Objekt beziehen.

Im Allgemeinen, wenn Sie vergleichen etwas auf eine einfache Art, Sie sind in der Regel die Prüfung für Wert der Gleichheit, so dass Sie verwenden sollten ==. Zum Beispiel, die Absicht, Ihr Beispiel ist wahrscheinlich, um zu überprüfen, ob x einen Wert hat, der gleich 2 (==), nicht, ob x ist buchstäblich verweisen auf das gleiche Objekt wie 2.

Etwas anderes zu beachten: aufgrund der Art und Weise der Referenz CPython-Implementierung funktioniert, erhalten Sie unerwartete und inkonsistente Ergebnisse, wenn Sie Sie versehentlich benutzen is vergleichen für Referenz-Gleichheit auf ganzen zahlen:

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

Das ist ziemlich viel, was wir erwartet hatten: a und b haben den gleichen Wert, aber unterschiedliche Entitäten. Aber was ist das?

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

Dies ist unvereinbar mit dem früheren Ergebnis. Was ist denn hier Los? Es stellt sich heraus, die Referenz-Implementierung von Python caches integer-Objekte im Bereich -5..256 als singleton-Instanzen für performance-Gründen. Hier ist ein Beispiel verdeutlicht dies:

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

Dies ist ein weiterer offensichtlicher Grund, nicht zu verwenden is: das Verhalten ist von Links bis zu Implementierungen, wenn Sie fälschlicherweise mit es für den Wert der Gleichheit.

InformationsquelleAutor John Feminella

Gibt es einen Unterschied zwischen == und is in Python?

Ja, Sie haben einen sehr wichtigen Unterschied.

==: Prüfung auf Gleichheit der Semantik, äquivalente Objekte (das sind nicht unbedingt das gleiche Objekt) zu testen, wird als gleich. Als die die Dokumentation sagt:

Den Operatoren <, >, ==, >=, <=, und != vergleichen Sie die Werte der beiden Objekte.

is: überprüfen der Identität - die Semantik ist, dass das Objekt (wie im Speicher) ist das Objekt. Wieder, die die Dokumentation sagt:

Den Betreibern is und is not test-für-Objekt-id: x is y wahr ist
wenn, und nur wenn x und y sind das gleiche Objekt. Objekt-Identität ist
ermittelt die id() Funktion. x is not y liefert die inverse
Wahrheit Wert.

So, die Prüfung auf Identität ist die gleiche wie die überprüfung für die Gleichheit der IDs der Objekte. Das ist,

a is b

ist das gleiche wie:

id(a) == id(b)

wo id ist die eingebaute Funktion, die eine Ganzzahl zurückgibt, die "garantiert einzigartig unter den gleichzeitig vorhandenen Objekte" (siehe help(id)) und wo a und b sind beliebige Objekte.

Andere Nutzung Richtungen

Verwenden Sie diese Vergleiche für Ihre Semantik. Verwenden is zu überprüfen, Identität und == zu überprüfen Gleichheit.

PEP 8, die offizielle Python style guide für die standard-Bibliothek auch erwähnt zwei use-cases für :

Vergleiche zu singletons wie None sollte immer durchgeführt werden, mit is oder
is not nie die gleichheitsoperatoren.

Auch, Vorsicht vor schreiben if x wenn Sie wirklich meinen if x is not None --
z.B. bei der Prüfung, ob eine variable oder argument, das standardmäßig auf None
war einen anderen Wert. Der andere Wert könnte haben einen Typ (Z
wie ein container), die falsch sein könnte in einem booleschen Kontext!

Herleitung der Gleichheit aus der Identität

Wenn is wahr ist, kann die Gleichheit in der Regel abgeleitet werden - logisch, wenn ein Objekt selbst ist, dann sollte es test als gleichwertig zu sich selbst.

In den meisten Fällen ist diese Logik wahr, aber es stützt sich auf die Umsetzung der __eq__ spezielle Methode. Als die docs sagen,

Das Standardverhalten für die Gleichstellung Vergleich (== und !=) basiert auf
die Identität der Objekte. Daher, Gleichheit Vergleich der Instanzen
mit der gleichen Identität Ergebnisse in der Gleichheit, und Gleichheit Vergleich von
Instanzen mit unterschiedlichen Identitäten Ergebnisse in der Ungleichheit. Ein
die motivation für dieses Verhalten ist der Wunsch, dass alle Objekte
sollte reflexive (D. H. x ist y impliziert x == y).

sind und im Interesse der Einheitlichkeit empfiehlt:

Gleichheit Vergleich sollte reflexiv. In anderen Worten, identisch
Objekte vergleichen sollte gleich:

x is y impliziert x == y

Können wir sehen, dass dies ist das Standardverhalten für benutzerdefinierte Objekte:

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

Den contrapositive ist in der Regel auch wahr - wenn überhaupt etwas-test als nicht gleich, Sie können in der Regel ableiten, dass Sie nicht das gleiche Objekt.

Da tests für Gleichheit können angepasst werden, diese Annahme nicht immer zutrifft, für alle Typen.

Eine Ausnahme

Eine Bemerkenswerte Ausnahme ist die nan - es ist immer tests, die nicht gleich als an sich selbst:

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

Überprüfung auf Identität kann viel schneller überprüfen, als die überprüfung der Gleichheit (die möglicherweise erfordern rekursiv überprüfung der Mitglieder).

Aber es kann nicht ersetzt werden, für Gleichheit, wo können Sie mehr als ein Objekt als gleichwertig.

Beachten Sie, dass der Vergleich der Gleichheit von Listen und Tupeln wird davon ausgegangen, dass die Identität der Objekte gleich sind (denn dies ist ein schneller check). Dies kann zu Widersprüchen, wenn die Logik inkonsistent ist - wie für nan:

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

Ein Warnendes Beispiel:

Die Frage ist der Versuch, mit is zu vergleichen ganze zahlen. Sie sollten nicht davon ausgehen, dass eine Instanz für ein integer ist, der gleichen Instanz, da man die durch eine andere Referenz. Diese Geschichte erklärt, warum.

Kommentator hatte code, stützte sich auf die Tatsache, dass kleine Ganzzahlen (-5 bis 256) sind singletons in Python, anstelle der überprüfung auf Gleichheit.

Wow, das kann dazu führen, dass einige heimtückische Fehler. Ich hatte einigen code, der überprüft, ob ein b, was auch geklappt hat, wie ich wollte, denn a und b sind in der Regel kleine zahlen. Der Fehler passiert erst heute, nach sechs Monaten in der Produktion, denn a und b waren schließlich groß genug, um nicht zwischengespeichert werden. – gwg

Er arbeitete in der Entwicklung. Kann es vergangen einige unittests.

Und es hat in der Produktion -, bis der code aktiviert, der für eine ganze Zahl größer als 256 ist, an welcher Stelle es gescheitert in der Produktion.

Dies ist ein Produktion Fehler sein könnte gefangen wurden, im code-review oder möglicherweise eine Stil-checker.

Lassen Sie mich betonen: verwenden Sie nicht zum vergleichen von ganzen zahlen.

InformationsquelleAutor Aaron Hall

Was ist der Unterschied zwischen is und ==?

== und is sind verschiedene Vergleich! Wie andere schon sagten:

• == vergleicht die Werte der Objekte.
• is vergleicht die Referenzen der Objekte.

In Python Namen beziehen sich auf Objekte, zum Beispiel in diesem Fall value1 und value2 beziehen sich auf eine int Instanz speichern der Werte 1000:

value1 = 1000
value2 = value1

Weil value2 bezieht sich auf das gleiche Objekt is und == geben True:

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

Im folgenden Beispiel werden die Namen value1 und value2 beziehen sich auf verschiedene int Instanzen, auch wenn beide Speicher die gleichen integer:

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

Weil Sie den gleichen Wert (integer) gespeichert ist == wird True, das ist, warum es oft als "Vergleichswert". Allerdings is zurück False denn diese sind verschiedene Objekte:

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

, Wann welcher zu benutzen?

In der Regel is ist ein sehr schneller Vergleich. Das ist, warum CPython-caches (oder vielleicht wiederverwendet wäre der bessere Begriff) bestimmte Objekte wie kleine ganze zahlen, Zeichenfolgen usw. Dies sollte aber behandelt werden, als detail könnte (wenn auch unwahrscheinlich) ändern, jederzeit, ohne Warnung.

Sollten Sie verwenden Sie nur is wenn Sie:

• wollen, um zu überprüfen, ob zwei Objekte wirklich das gleiche Objekt (nicht nur den gleichen "Wert"). Ein Beispiel kann sein, wenn Sie Verwendung eines singleton-Objekt als konstant.

• vergleichen wollen, einen Wert zu einer Python Konstante. Die Konstanten in Python sind:

  • None
  • True¹
  • False¹
  • NotImplemented
  • Ellipsis
  • __debug__
  • Klassen (zum Beispiel int is int oder int is float)
  • es könnten zusätzliche Konstanten in built-in Module oder 3rd-party-Module. Zum Beispiel np.ma.maskierte aus dem NumPy-Modul)

In jedem anderen Fall sollten Sie == zu prüfen, für die Gleichheit.

Kann ich das Verhalten anpassen?

Gibt es einige Aspekte zu ==, die noch nicht erwähnt wurden bereits in den anderen Antworten: Es ist ein Teil von Pythons "Datenmodell". Das bedeutet, dass das Verhalten angepasst werden kann mit der __eq__ Methode. Zum Beispiel:

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

Dies ist nur ein künstliches Beispiel, um zu illustrieren, dass die Methode wirklich aufgerufen:

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

Beachten Sie, dass standardmäßig (wenn keine andere Umsetzung __eq__ gefunden werden kann in der Klasse oder der Oberklassen) __eq__ verwendet is:

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

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

Also ist es eigentlich wichtig, zu implementieren __eq__ wenn Sie wollen "mehr" als nur Referenz-Vergleich für benutzerdefinierte Klassen!

Auf der anderen Seite können Sie nicht anpassen is überprüft. Es wird immer vergleichen nur wenn Sie den gleichen Verweis.

Werden diese Vergleiche immer wieder ein boolean?

Weil __eq__ werden können, neu implementiert oder überschrieben, es beschränkt sich nicht zurück True oder False. Es könnte etwas zurückzugeben (aber in den meisten Fällen sollte es ein boolean zurückgibt!).

Beispielsweise mit NumPy-arrays die == wird ein array zurückgeben:

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

Aber is prüft immer wieder True oder False!

¹ Als Aaron Hall erwähnt in den Kommentaren:

Generell sollte man nicht jede is True oder is False Prüfungen, weil man in der Regel nutzt diese "Kontrollen" in einem Kontext, der implizit konvertiert die Zustand auf einen booleschen Wert (zum Beispiel in einem if - Anweisung). Damit die is True Vergleich und die implizite boolean cast ist mehr Arbeit als einfach nur tun, der boolean cast - und Sie beschränken sich auf Boolesche Werte (das ist nicht als pythonic).

Wie PEP8 erwähnt:

Nicht vergleichen Boolesche Werte True oder False mit ==.

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

InformationsquelleAutor MSeifert

Ihre Antwort richtig ist. Die is operator vergleicht die Identität zweier Objekte. Die == operator vergleicht die Werte der beiden Objekte.

Ein-Objekt-Identität, die sich nie ändert, sobald es erstellt wurde; Sie können denken, es als das Objekt Adresse im Speicher.

Können Sie Steuern, Vergleich Verhalten von Objekt-Werte durch die Definition einer __cmp__ Methode oder ein Reich-Vergleich Methode wie __eq__.

InformationsquelleAutor Dave Webb

Den == operator vergleicht die Werte der beiden Operanden und prüft auf Wert-Gleichheit. In der Erwägung, dass is - operator prüft, ob die beiden Operanden auf das gleiche Objekt beziehen oder nicht.

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

Aber wenn wir das tun

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

Grundsätzlich is gedacht werden kann als Kurzformel für id(a) == id(b). Aber darüber Hinaus gibt es Macken des run-time-Umgebung, die weiter die Dinge zu komplizieren. Kurze strings und kleine Ganzzahlen zurück True, wenn im Vergleich mit is aufgrund der Python-Maschine, versuchen Sie es mit weniger Speicher für identische Objekte.

a = 'python'
b = 'python'

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

InformationsquelleAutor iNet

Meisten von Ihnen schon beantwortet auf den Punkt. Nur als zusätzliche Anmerkung (basierend auf meinem Verständnis und zu Experimentieren, aber nicht aus einer Quelle dokumentiert), wird die Anweisung

== wenn die Objekte bezeichnet, die durch die Variablen sind gleich,

oben Antworten sollte gelesen werden als

== wenn die Objekte bezeichnet, die von der Variablen gleich sind und die Gegenstände des gleichen Typs/Klasse

. Ich kam zu dieser Schlussfolgerung auf der Grundlage der unter 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)

Hier der Inhalt der Liste und Tupel sind gleich, aber der Typ/Klasse unterschiedlich sind.

InformationsquelleAutor Sandeep

Eigentlich wollte ich hinzufügen, dass diese als Kommentar, konnte aber nicht verschönern es einfach daher hinzufügen eine Antwort, bitte halte nicht dies als eine Antwort.

Dies ist, was ich Tat, zu verstehen, --

führen Sie die folgenden eins nach dem anderen und verstehen-Ausgabe auf jedem Schritt

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

InformationsquelleAutor Pranav

Python Differenz zwischen ist-gleich(==)

Dem is-operator können scheinen, wie der gleiche wie der Gleichheits-operator, aber
Sie sind nicht ein und dasselbe.

Das ist prüft, ob beide Variablen auf das gleiche Objekt zeigen in der Erwägung, dass
der = = - Zeichen überprüft, ob die Werte für die beiden Variablen gleich sind.

Also, wenn Sie den is-operator gibt True zurück, dann wird die Gleichheit ist definitiv
Stimmt, aber das Gegenteil kann oder kann nicht Wahr sein.

Hier ist ein Beispiel zur Demonstration der ähnlichkeit und der Differenz.

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

InformationsquelleAutor Projesh Bhoumik

"==" vergleicht die Werte

"" vergleicht die zugrunde liegenden Objekte

# 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

InformationsquelleAutor

Während alle diese Antworten, die sich auf die Durchführung von Widerspruchs-Zeiger-Vergleich vs-Wert-Vergleich sind wahrscheinlich richtig, da ist eine tiefere syntaktische Grund für die Verwendung is zu bestimmen, ob ein Wert der variable ist None (in der booleschen Logik oft vertreten wie NULL).

In relationalen Datenbank-und andere Logik-Systeme NULL impliziert, dass der tatsächliche Wert "unbekannt". So ist die logische Ausdruck xx == NULL muss immer bewerten zu NULL selbst, wie es unmöglich ist, jemals zu wissen, wenn xx beliebigen Wert haben kann, ist die gleiche wie die unbekannten Wert. In Programmiersprachen, die sich eher strikt an die Regeln der booleschen Logik xx == NULL (oder Pythonically xx == None) korrekt ausgewertet NULL, und alternative Mittel bereitgestellt werden müssen, um festzustellen, ob eine variable ein Wert ist NULL. Python ist ein Ausreißer in dieser Hinsicht, aufgrund der einheitlichen Natur der Referenz auf das Objekt None. Aber für Klarheit und logische Richtigkeit, die Verwendung der Python - is Vergleichsoperator scheint mir wesentlich fundierter Praxis.

InformationsquelleAutor Jimbopdx