Есть ли разница между "==" и "есть"?

Question

Мой Google-фу подвел меня.

В Python следующие два теста на равенство эквивалентны?

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

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

Применимо ли это к объектам, где вы будете сравнивать экземпляры (скажем, list)?

Хорошо, вот такой ответ на мой вопрос:

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

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

Итак, == проверяет значение, где is проверяет, являются ли они одним и тем же объектом?

Answer 1

В двух словах, is проверяет, указывают ли две ссылки на один и тот же объект. == проверяет, имеют ли два объекта одинаковое значение или нет.

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 

Answer 2

Большинство из них уже ответили на вопрос. Как дополнительная заметка (основываясь на моем понимании и экспериментах, но не на документированном источнике), утверждение

== если объекты, на которые ссылаются переменные, равны

сверху ответы следует читать как

== если объекты, на которые ссылаются переменные, равны и объекты принадлежат к одному типу / классу

. Я пришел к такому выводу на основе теста ниже:

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)

Здесь содержимое списка и кортежа одинаковы, но тип / класс различны.

Answer 3

Как сказал Джон Феминелла, большую часть времени вы будете использовать == и! =, Потому что ваша цель - сравнить значения. Я просто хотел бы классифицировать то, что вы будете делать в остальное время:

Существует один и только один экземпляр NoneType, т. Е. Ни один не является синглтоном. Следовательно, foo == None и foo is None означают одно и то же. Однако тест is выполняется быстрее, и в соглашении Pythonic используется foo is None.

Если вы занимаетесь самоанализом или разбираетесь со сборкой мусора или проверяете, работает ли ваш пользовательский встроенный гаджет для интернирования строк и т.

True и False также (в настоящее время) синглтоны, но для foo == True нет сценария использования и для foo is True нет сценария использования.

Answer 4

На самом деле я хотел добавить это как комментарий, но не мог легко его украсить, поэтому добавив в качестве ответа, пожалуйста, не рассматривайте это как ответ.

Это то, что я сделал, чтобы понять -

выполнить следующее по очереди и понимать вывод на каждом шаге

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

Answer 5

Поскольку другие люди в этом посте подробно ответят на этот вопрос, я бы подчеркнул в основном сравнение между is и == для строк , которые могут дать разные результаты Я призываю программистов тщательно их использовать.

Для сравнения строк обязательно используйте == вместо is:

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

Из:

str is hello
str == hello

Но в приведенном ниже примере == и is получат разные результаты:

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

Из:

str == hello sam

Вывод:

Тщательно используйте is для сравнения строк

Answer 6

Да, есть разница между обоими.

• '==' : сравнивает объект по значению.

• 'in' : сравнивает объект по ссылке.

  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
  

Теперь давайте рассмотрим этот случай:

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.

Answer 7

Хотя все эти ответы, которые основаны на реализации сравнения указателей возражений и сравнения значений, скорее всего, правильны, существует более глубокая синтаксическая причина использования is для определения, является ли значение переменной None (в булевой логике, часто представляемой как NULL).

В реляционной базе данных и других логических системах NULL подразумевает, что фактическое значение «неизвестно». Таким образом, логическое выражение xx == NULL всегда должно принимать само значение NULL, поскольку невозможно узнать, совпадает ли xx, какое бы значение оно ни имело, с неизвестным значением. В языках программирования, которые более строго придерживаются правил булевой логики, xx == NULL (или Pythonically xx == None) правильно оценивается как NULL, и должны быть предоставлены альтернативные средства, чтобы определить, является ли значение переменной NULL. В этом отношении Python выделяется из-за унитарного характера ссылки на объект None. Но для ясности и логической корректности использование оператора сравнения Python is кажется мне более разумной практикой.

Answer 8

o1 равно o2 => сравнивает, если o1 и o2 оба указывают на одно и то же физическое местоположение в памяти (другими словами, если они являются одним и тем же объектом)

o1 == o2 => здесь Python вызывает метод __cmp __ (o2) o1, который в идеале должен сравнивать значение и возвращать значение True или False. (Другими словами, он сравнивает значение)

Для людей JAVA:

• В Java, чтобы определить, ссылаются ли две строковые переменные на одинаковые расположение физической памяти с помощью str1 == str2 . (вызываемый объект идентичность, и это написано в Python как str1 это str2 ).

• Для сравнения строковых значений в Java, usestr1.equals (str2) ; в Python, используйте str1 == str2 .

Пример:

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)

Выход Python Shell:

o = A (2) o1 = o

o == o1 2 2 Правда

о1 Правда

o1 = A (2)

о1 Ложные

Answer 9

Разница Python между is и equals (==)

Оператор is может выглядеть как оператор равенства, но они не одинаковы.

is проверяет, указывают ли обе переменные на один и тот же объект, тогда как знак == проверяет, совпадают ли значения двух переменных.

Так что, если оператор is возвращает True, то равенство определенно Верно, но обратное может быть или не быть Верным.

Вот пример, демонстрирующий сходство и различие.

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

Answer 10

Если вы сравните его с JavaScript (однако не рекомендуется сравнивать один язык с другим):

• Используйте is для строгого сравнения. Эквивалент JavaScript (===)
• Используйте == для сравнения на равенство.