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

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

is тесты на идентичность == тесты на равенство

Каждому (маленькому) целочисленному значению сопоставляется одно значение, поэтому каждые 3 идентичны и равны. Это деталь реализации, а не часть спецификации языка.

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

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

В вашем случае второй тест работает только потому, что Python кэширует небольшие целочисленные объекты, что является деталью реализации. Для больших целых чисел это не работает:

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

То же самое верно и для строковых литералов:

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

См. Также этот вопрос.

Ваш ответ правильный. Оператор is сравнивает идентичность двух объектов. Оператор == сравнивает значения двух объектов.

Идентичность объекта никогда не меняется после того, как он был создан; вы можете думать об этом как об адресе объекта в памяти.

Вы можете контролировать поведение сравнения значений объекта, определяя метод __cmp__ или метод богатое сравнение, например __eq__.

Это полностью отличается. is проверяет идентичность объекта, а == проверяет равенство (понятие, которое зависит от типов двух операндов).

То, что is, похоже, правильно работает с маленькими целыми числами (например, 5 == 4 + 1), является счастливым совпадением. Это потому, что CPython оптимизирует хранение целых чисел в диапазоне (от -5 до 256), делая их одиночными. Это поведение полностью зависит от реализации и не гарантируется, что оно будет сохранено при любых второстепенных операциях преобразования.

Например, Python 3.5 также создает синглтоны для коротких строк, но их разрезание нарушает это поведение:

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

Взгляните на вопрос о переполнении стека Оператор Python «is» неожиданно ведет себя с целыми числами..

В основном это сводится к тому, что «is» проверяет, являются ли они одним и тем же объектом, а не просто равны друг другу (числа ниже 256 являются особым случаем).

Существует простое практическое правило, которое подскажет, когда использовать == или is.

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

В общем, когда вы сравниваете что-то с простым типом, вы обычно проверяете равенство ценностей, поэтому вам следует использовать ==. Например, цель вашего примера, вероятно, состоит в том, чтобы проверить, имеет ли x значение, равное 2 (==), а не то, действительно ли x ссылается на тот же объект, что и 2.

Еще кое-что на заметку: из-за того, как работает эталонная реализация CPython, вы получите неожиданные и противоречивые результаты, если по ошибке используете is для сравнения эталонного равенства целых чисел:

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

Это в значительной степени то, что мы ожидали: a и b имеют одинаковое значение, но являются разными объектами. Но как насчет этого?

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

Это несовместимо с предыдущим результатом. Что тут происходит? Оказывается, эталонная реализация Python кэширует целочисленные объекты в диапазоне -5..256 как одноэлементные экземпляры из соображений производительности. Вот пример, демонстрирующий это:

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

Это еще одна очевидная причина не использовать is: поведение остается на усмотрение реализаций, когда вы ошибочно используете его для равенства значений.

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

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

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

Истины и Ложь также (сейчас) синглтоны, но нет варианта использования для foo == True и нет варианта использования для foo is True.

Is there a difference between == and is in Python?

Да, у них есть очень важное отличие.

==: проверка на равенство - семантика такова, что эквивалентные объекты (которые не обязательно являются одним и тем же объектом) будут проверяться как равные. Как документация говорит:

The operators <, >, ==, >=, <=, and != compare the values of two objects.

is: проверка идентичности - семантика такова, что объект (хранящийся в памяти) является объект. Опять же, документация говорит:

The operators is and is not test for object identity: x is y is true if and only if x and y are the same object. Object identity is determined using the id() function. x is not y yields the inverse truth value.

Таким образом, проверка идентичности аналогична проверке совпадения идентификаторов объектов. То есть,

a is b

такой же как:

id(a) == id(b)

где id - встроенная функция, которая возвращает целое число, которое «гарантированно уникально среди одновременно существующих объектов» (см. help(id)), а a и b - любые произвольные объекты.

Другие направления использования

Вы должны использовать эти сравнения для их семантики. Используйте is для проверки идентичности и == для проверки равенства.

В общем, мы используем is для проверки личности. Обычно это полезно, когда мы проверяем объект, который должен существовать в памяти только один раз, в документации это называется «синглтоном».

Сценарии использования is включают:

• None
• значения перечисления (при использовании перечислений из модуля перечисления)
• обычно модули
• обычно объекты класса, возникающие из определений классов
• обычно функциональные объекты, возникающие из определений функций
• все остальное, что должно существовать в памяти только один раз (как правило, все синглтоны)
• конкретный объект, который вам нужен по личности

Обычные варианты использования == включают:

• числа, в том числе целые
• струны
• списки
• наборы
• словари
• настраиваемые изменяемые объекты
• другие встроенные неизменяемые объекты, в большинстве случаев

Общий вариант использования, опять же, для ==: объект, который вам нужен, может не быть объектом такой же, вместо этого он может быть объектом эквивалент.

PEP 8 направлений

PEP 8, официальное руководство по стилю Python для стандартной библиотеки, также упоминает два варианта использования is:

Comparisons to singletons like None should always be done with is or is not, never the equality operators.

Also, beware of writing if x when you really mean if x is not None -- e.g. when testing whether a variable or argument that defaults to None was set to some other value. The other value might have a type (such as a container) that could be false in a boolean context!

Вывод равенства из идентичности

Если is истинно, можно сделать вывод о равенстве как правило - логически, если объект является самим собой, то он должен тестироваться как эквивалентный самому себе.

В большинстве случаев эта логика верна, но она зависит от реализации специального метода __eq__. Как говорят документы,

The default behavior for equality comparison (== and !=) is based on the identity of the objects. Hence, equality comparison of instances with the same identity results in equality, and equality comparison of instances with different identities results in inequality. A motivation for this default behavior is the desire that all objects should be reflexive (i.e. x is y implies x == y).

и в интересах последовательности рекомендует:

Equality comparison should be reflexive. In other words, identical objects should compare equal:

x is y implies x == y

Мы видим, что это поведение по умолчанию для настраиваемых объектов:

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

Контрапозитив также обычно верен - если что-то оказывается не равным, обычно можно сделать вывод, что это не один и тот же объект.

Поскольку тесты на равенство могут быть настроены, этот вывод не всегда верен для всех типов.

Исключение

Заметным исключением является nan - он всегда проверяется как не равный самому себе:

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

Проверка идентичности может быть намного более быстрой проверкой, чем проверка на равенство (которая может потребовать рекурсивной проверки членов).

Но он не может быть заменен равенством, когда вы можете найти более одного объекта в качестве эквивалента.

Обратите внимание, что сравнение равенства списков и кортежей предполагает, что идентичность объектов равна (потому что это быстрая проверка). Это может привести к противоречиям, если логика непоследовательна - как в случае с nan:

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

Поучительная история:

Вопрос пытается использовать is для сравнения целых чисел. Вы не должны предполагать, что экземпляр целого числа является тем же экземпляром, что и экземпляр, полученный по другой ссылке. Эта история объясняет, почему.

У комментатора был код, основанный на том факте, что маленькие целые числа (от -5 до 256 включительно) являются одиночными числами в Python вместо проверки на равенство.

Wow, this can lead to some insidious bugs. I had some code that checked if a is b, which worked as I wanted because a and b are typically small numbers. The bug only happened today, after six months in production, because a and b were finally large enough to not be cached. – gwg

Это сработало в разработке. Возможно, он прошел некоторые юнит-тесты.

И это работало в производстве - до тех пор, пока код не проверил целое число больше 256, после чего он отказал в производстве.

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

Подчеркну: не используйте is для сравнения целых чисел.

В чем разница между is и ==?

== и is - разные сравнения! Как уже говорили другие:

• == сравнивает значения объектов.
• is сравнивает ссылки на объекты.

В Python имена относятся к объектам, например, в этом случае value1 и value2 относятся к экземпляру int, хранящему значение 1000:

value1 = 1000
value2 = value1

Поскольку value2 относится к одному и тому же объекту, is и == выдаст True:

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

В следующем примере имена value1 и value2 относятся к разным экземплярам int, даже если оба хранят одно и то же целое число:

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

Поскольку сохраняется одно и то же значение (целое число), == будет True, поэтому его часто называют «сравнением значений». Однако is вернет False, потому что это разные объекты:

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

Когда какой использовать?

В целом is - намного более быстрое сравнение. Вот почему CPython кэширует (или, может быть, повторно использует был бы лучшим термином) определенные объекты, такие как маленькие целые числа, некоторые строки и т. д. Но это следует рассматривать как детали реализации, который может (даже если маловероятно) измениться в любой момент без предупреждения.

Вам следует используйте только is, если вы:

• хотите проверить, действительно ли два объекта являются одним и тем же объектом (а не одним и тем же «значением»). Одним из примеров может быть использование ты одноэлементного объекта в качестве константы.

• хотите сравнить значение с Python постоянный. Константы в Python:

  • None
  • True¹
  • False¹
  • NotImplemented
  • Ellipsis
  • __debug__
  • классы (например, int is int или int is float)
  • могут быть дополнительные константы во встроенных модулях или сторонних модулях. Например np.ma.masked из модуля NumPy)

В в остальных случаях следует использовать == для проверки равенства.

Могу ли я настроить поведение?

Есть один аспект ==, который еще не упоминался в других ответах: это часть Питоны "Модель данных". Это означает, что его поведение можно настроить с помощью метода __eq__. Например:

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

Это просто искусственный пример, чтобы проиллюстрировать, что метод действительно вызывается:

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

Обратите внимание, что по умолчанию (если в классе или суперклассах нет другой реализации __eq__) __eq__ использует is:

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

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

Поэтому на самом деле важно реализовать __eq__, если вы хотите «большего», чем просто сравнение ссылок для пользовательских классов!

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

Всегда ли эти сравнения возвращают логическое значение?

Поскольку __eq__ может быть повторно реализован или отменен, он не ограничивается возвратом True или False. мог возвращает что угодно (но в большинстве случаев должно возвращать логическое значение!).

Например, с массивами NumPy == вернет массив:

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

Но проверки is всегда возвращают True или False!

¹ Как упомянул Аарон Холл в комментариях:

Как правило, вам не следует выполнять какие-либо проверки is True или is False, потому что обычно эти «проверки» используются в контексте, который неявно преобразует условие в логическое значение (например, в операторе if). Таким образом, при сравнении is Trueи неявное логическое приведение выполняет больше работы, чем просто выполнение логического преобразования, и вы ограничиваете себя логическими значениями (что не считается питоническим).

Как упоминает PEP8:

Don't compare boolean values to True or False using ==.

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

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

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

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

Из:

str is hello
str == hello

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

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

Из:

str2 == hello sam

Заключение и анализ:

Осторожно используйте is для сравнения строк. Начиная с is для сравнения объектов и поскольку в Python 3+ каждая переменная, такая как строка, интерпретируется как объект, давайте посмотрим, что произошло в приведенных выше абзацах.

В python есть функция id, которая показывает уникальную константу объекта во время его жизни. Этот идентификатор используется во внутренней части интерпретатора Python для сравнения двух объектов с использованием ключевого слова is.

str = 'hello'
id('hello')
> 140039832615152
id(str)
> 140039832615152

Но

str2 = 'hello sam'
id('hello sam')
> 140039832615536
id(str2)
> 140039832615792

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

== if the objects referred to by the variables are equal

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

== if the objects referred to by the variables are equal and objects belonging to the same type/class

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

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)

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

Вкратце, 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 

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

The is operator may seem like the same as the equality operator but they are not same.

The is checks if both the variables point to the same object whereas the == sign checks if the values for the two variables are the same.

So if the is operator returns True then the equality is definitely True, but the opposite may or may not be 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.