is против ==: одно спрашивает про тождество, второе вызывает метод — и половина известных сюрпризов вообще не про них

База: один и тот же объект — или одинаковое содержимое

Прежде чем говорить о кешах и интернировании, стоит назвать обычными словами, что спрашивает каждый из двух операторов. Вопроса ровно два, и они разные:

• a is b спрашивает — это тот же самый объект?
• a == b спрашивает — считаются ли эти значения равными?

Разницу видно на трёх переменных, где два имени указывают на один объект, а третье — на отдельный объект с тем же содержимым:

first = [1, 2, 3]
second = first              # второе имя для того же самого объекта
third = [1, 2, 3]           # отдельный объект, содержимое такое же
 
print(first is second)      # True  — объект один
print(first is third)       # False — объекта два
print(first == third)       # True  — содержимое одинаковое

Третья строка и есть вся суть: first и third равны и при этом не тождественны. Проверить это можно и с другой стороны — дописать элемент в first: second изменится вместе с ним, потому что это один объект, а third останется прежним.

И вот главный вопрос урока: почему тогда два одинаковых литерала иногда оказываются одним объектом? Написали 1000 дважды — а is отвечает True, хотя по смыслу это должно быть два разных объекта, как first и third.

Этого уже достаточно, чтобы ответить на базовый вопрос собеседования: is — про тождество, == — про равенство значений, и подменять один другим нельзя. Всё дальнейшее — про то, откуда берётся это лишнее True, почему причин у него три разных и почему ни на одну из них нельзя опираться в коде.

Механизм 1: что делает каждый из двух

Определение is в справочнике занимает одно предложение, и в нём нет ни слова про значения.

А что такое тождество — сказано в модели данных; там оно названо идентичностью, слово то же самое: An object's identity never changes once it has been created; you may think of it as the object's address in memory (Идентичность объекта никогда не меняется после его создания; можно считать её адресом объекта в памяти). Для CPython это не «можно считать», а буквально так и есть — там же стоит пометка о реализации.

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

Из этого следуют три вещи сразу:

• is нельзя переопределить. Нет метода __is__. В CPython оператор компилируется в инструкцию IS_OP, которая сравнивает два указателя, — но это деталь реализации, а не определение оператора.
• is не зависит от типа и размера. Сравнить два стомегабайтных объекта ровно так же дёшево, как два числа.
• == — противоположность в каждом: его переопределяют, и он зависит и от типа, и от размера. Это вызов __eq__, который может вернуть не-булево значение, обойти миллион элементов или уйти в сеть.

Механизм 2: где is — правильный инструмент

Правило «пишите is только с None» короткое, но неверное: оно не про None, а про тождество как контракт. Есть объекты, у которых API обещает единственность, и спрашивать про них нужно именно is — сравнение по значению здесь либо лишнее, либо опасное. Прогон bench/identity/contract.py, блок 3:

None is None                                   True
NotImplemented is NotImplemented               True
Ellipsis is ...                                True
Color.RED is Color(1)                          True

Тот же список продолжается собственным часовым — и это тот случай, где is не заменить ничем:

MISSING = object()
 
def find(mapping, key):
    got = mapping.get(key, MISSING)
    return "ключа нет" if got is MISSING else got
 
find({"k": None}, "k")      # None — ключ есть, значение None
find({}, "k")               # 'ключа нет'

== MISSING тут не годится по той же причине, по которой не годится == None: равенство спрашивает у чужого объекта, а часовой — про тождество.

Важно, где проходит граница правила. Она не по списку из четырёх строк выше: None, NotImplemented, Ellipsis и члены Enum — это примеры, а не полный перечень. Правило общее: is уместен у любого объекта, который существует в единственном экземпляре, и у любой метки, заведённой специально ради сравнения по тождеству. Собственный MISSING = object() в этот список входит ровно на тех же правах, что и None, — и точно так же туда войдёт любой другой часовой, который вы заведёте завтра.

А вот is True и is False в этот список НЕ входят, хотя тоже одиночки: проверка x is True отклонит 1, непустую строку и всё прочее истинное. Это не вопрос о тождестве, это вопрос об истинности, заданный не тем оператором.

Механизм 3: где is даёт True не потому, что вы так написали

Вот тут и живёт настоящая путаница. Ответ «is сравнивает объекты» не объясняет, почему 1000 is 1000 даёт True — а объясняют это три РАЗНЫХ механизма, и они разной прочности.

Под каждой строкой картинки стоит пометка, на чём держится ответ: на обещании справочника, на устройстве CPython или на том, попали ли литералы в одну компиляцию. В код переносится только первое.

Разберём каждый.

Кеш малых чисел. Числа от −5 до 256 создаются при старте интерпретатора и раздаются готовыми. Проверять это нужно осторожно — числами, которые компилятор не может посчитать заранее:

print(int("256") is int("256"))     # True
print(int("257") is int("257"))     # False

Границы одинаковы на 3.11, 3.12, 3.13 и 3.14.7. Но это деталь CPython, а не обещание языка.

Объединение констант. А вот это уже не про числа вовсе:

def first():  return 1000
def second(): return 1000
 
print(first() is second())          # True

Компилятор объединяет равные константы в пределах одной компиляции — даже когда они лежат в разных функциях. Перенесите одну функцию в другой файл, и тот же код даст False. То есть первое True — свойство того, как СОБРАН исходник, а не свойство чисел.

Интернирование строк. Правило простое: литерал, похожий на идентификатор, интернируется — один объект на всю программу, включая другие файлы. На автоматическое интернирование строки, собранной во время выполнения, полагаться нельзя — даже если по виду она идентификатор. Обратное тоже верно: is иногда даёт True и без интернирования, когда операция вернула тот же объект. Проверено: "".join([s]) с одним элементом, полный срез s[:] и str(s) возвращают исходную строку, а пустая строка и односимвольные latin-1 — вообще кешированные синглтоны.

import sys
 
ident = "hello_world"
built = "".join(["hello", "_", "world"])
 
print(built is ident)               # False
print(sys.intern(built) is ident)   # True

Документация говорит и зачем это сделано: the key comparisons (after hashing) can be done by a pointer compare instead of a string compare (сравнение ключей (после хеширования) может выполняться сравнением указателей вместо сравнения строк). Интернирование существует ради скорости словарей, а не ради того, чтобы вы писали is со строками.

Компилятор, кстати, предупреждает об этом сам, и с 3.8:

SyntaxWarning: "is" with 'str' literal. Did you mean "=="?

Механизм 4: nan — единственное значение, где расходится всё

nan = float("nan")
 
print(nan == nan)          # False
print(nan is nan)          # True
print(nan in [nan])        # True
print([nan] == [nan])      # True

Первая строка — требование стандарта с плавающей точкой. Третью объясняет справочник — он даёт точную эквивалентность для проверки вхождения.

Тождество проверяется первым — это записано прямо в порядке операндов or. Поэтому тот же самый nan в списке находится, а другой nan с тем же значением — нет:

print(float("nan") in [nan])    # False

Четвёртая строка держится на том же порядке: список сравнивает элементы сначала по тождеству и только потом по равенству. Но это уже устройство CPython, а не обещание языка — справочник описывает так проверку вхождения, а не сравнение списков.

То же правило объясняет, почему nan работает ключом словаря: положили и достали одним и тем же объектом — сработало тождество.

Механизм 5: is None, а не == None

Правило известное, а причина у него ровно одна: == — это вызов метода, и метод может соврать.

class AlwaysEqual:
    def __eq__(self, other):
        return True
 
obj = AlwaysEqual()
print(obj == None)      # True
print(obj is None)      # False

Причём __eq__ не обязан возвращать даже булево значение:

class Weird:
    def __eq__(self, other):
        return "не булево значение"
 
print(bool(Weird() == 1))       # True — непустая строка истинна

if x == None: в такой ситуации молча уйдёт не в ту ветку. is None перехватить нечем: он спрашивает про тождество, а метода для этого вопроса нет.

То же касается is True и is False, но с обратным выводом: писать так не надо. Проверка x is True отклонит 1, непустую строку и всё остальное истинное — почти всегда это ошибка, а не намерение.

Механизм 6: id уникален не всегда

print(id([]) == id([]))     # True

Никакого чуда: первый список умирает до того, как создаётся второй, и адрес достаётся второму. Документация оговаривает это прямо.

Практический вывод: id(a) == id(b) — не замена a is b, а его худшая версия. Она даёт тот же ответ, только когда оба объекта живы; сохранённый в переменную id не значит ничего.

Глубже: что это стоит

Картинка говорит не «пишите is» — она показывает, как устроена цена каждого из двух.

is — постоянная цена: в CPython сравниваются два указателя, и делается это одинаково, идёт ли речь о числе или о строке в двести тысяч символов. == растёт вместе с длиной, потому что равные строки приходится дочитать до конца: различия, на котором можно остановиться, у них нет. Строки, различающиеся с первого символа, сравниваются быстрее равных — 19,58 против 24,62 нс. В таблице роста то же сравнение дало 24,29: числа сравнимы только внутри своего блока, а разница в четверть процента между блоками — шум машины.

Отдельно стоит объект со своим __eq__ на Python: 101,83 нс против 24,68 нс у объекта без него, то есть вчетверо. Метод на Python дороже сравнения, которое интерпретатор делает сам, и это стоит помнить в горячем цикле — но чинится это не заменой на is, а тем, чтобы не сравнивать в цикле лишнего.

Как отвечать на собеседовании

Короткий ответ: is спрашивает, один ли это объект; его нельзя переопределить, и его цена не зависит от объекта. == вызывает __eq__, обычный метод, который может вернуть что угодно. is уместен там, где контракт API именно про тождество: у любого объекта-одиночки и у любой метки, заведённой ради такого сравнения, — None, NotImplemented, Ellipsis, члены Enum, собственный часовой object().

Этого достаточно, чтобы ответить верно. Дальше — то, что добавляют, если собеседник копает.

Если интервьюер копает глубже

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

Если спросят про 1000 is 1000, правильный ответ — назвать все три механизма и не перепутать их: кеш малых чисел кончается на 256, объединение констант работает в пределах одной компиляции, интернирование — про строки, похожие на идентификаторы. И добавить, что компилятор с 3.8 предупреждает об этом сам, формулируя ровно так: These can often work by accident in CPython, but are not guaranteed by the language spec (В CPython они часто работают случайно, но спецификацией языка не гарантированы).

И одна вещь, на которой легко переусердствовать, — цена. Сказать «is в четыреста раз дешевле» значит выдать один замер за общее правило: четыреста получились на равных строках по двести тысяч символов и на одной машине, а на коротких строках разница всего вдвое. Правило пишется не от числа, а от границы: is стоит одинаково всегда, == растёт вместе с длиной, и выбирают между ними не по цене, а по тому, какой вопрос задан.

Дальше спросят

Частые заблуждения

История версий

Практика

Две задачи. Сначала ответьте, потом сверьтесь с настоящим выводом: в обеих правильный ответ взят из прогона скрипта, а не назначен.

a = int("257")
b = int("257")
x = int("255")
y = int("255")

print(a == b)
print(a is b)
print(x is y)

True
False
True

True
True
True

True
False
False

False
False
True

Проверьте себя

Чем измерено

Числа этой статьи получены этими скриптами. Каждый открывается прямо отсюда — вместе с записью прогона: на чём считали, что получилось и с каким разбросом.

• bench/identity/cost.py
• bench/identity/contract.py
• bench/identity/traps.py