Имя, объект, ссылка

Потому что вопрос не про is, а про то, сколько объектов создал компилятор. Оператор всегда честно сравнивает идентичность; меняется то, один перед ним объект или два.

Два разных механизма дают ложное ощущение, что «маленькие значения сравниваются по значению». Первый — кеш малых целых: числа от −5 до 256 создаются при старте и переиспользуются. Второй — свёртка констант: одинаковые литералы внутри одного объекта кода компилятор кладёт в co_consts один раз.

def f():
    a = "hello"
    b = "hello"
    return a is b
print(f())          # → True   одна константа на всю функцию

x = "hel"
print(x + "lo" is "hello")   # → False  строка собрана в рантайме

Оба механизма — 🔧 деталь реализации, и границы обоих менялись между версиями. Правило без исключений: is только для None, True, False и собственных синглтонов-часовых. Для всего остального ==.

Если хочется гарантии совпадения объектов для строк — она есть и называется sys.intern. Урок 02 показывает, что на миллионе повторяющихся строк это даёт 21.2 → 2.6 МБ.

Потому что += — не одна операция, а вопрос объекту: «умеешь меняться на месте?»

Интерпретатор вызывает __iadd__, если он есть, и __add__, если нет. Затем — и это главное — результат присваивается обратно имени слева. Для неизменяемого числа __iadd__ отсутствует, создаётся новый объект, и имя y перепривязывается к нему. Имя x не трогали, оно смотрит туда же, куда смотрело.

x = [1]; y = x
y += [2]
print(x)            # → [1, 2]   список менялся на месте

x = 1; y = x
y += 1
print(x)            # → 1        число неизменяемо, y перепривязано

Отсюда неочевидное следствие: y += [2] и y = y + [2] — разные операции. Первая меняет объект и видна через все остальные имена, вторая создаёт новый и не видна нигде. Для чисел они неразличимы, для списков — нет, и на этом регулярно ловятся.

Потому что чинить пришлось бы не ловушку, а само правило — и оно правильное.

Дефолт вычисляется один раз при выполнении def, потому что def — исполняемая инструкция, создающая объект функции. Значения по умолчанию хранятся в __defaults__ этого объекта. Альтернатива — вычислять выражение при каждом вызове — означала бы, что def f(x=expensive()) платит за expensive() на каждом вызове, а def f(x=SOME_CONST) перестал бы видеть значение на момент определения.

def f(x=[]): x.append(1); return x
print(f.__defaults__)     # → ([],)  объект существует и живёт с функцией
f(); f()
print(f.__defaults__)     # → ([1, 1],)

Дальше вступает R9: на текущее поведение опирается слишком много кода, включая идиому кеширования через дефолт и трюк с ранним связыванием def f(_cache={}). Поэтому язык не тронули, а проблему обошли точечно — dataclass просто запрещает изменяемый дефолт и требует field(default_factory=list).

Правильный вывод отсюда не «остерегайся списка в дефолте», а «дефолт — это объект, живущий столько же, сколько функция». Из него ловушка выводится, а не запоминается.

Потому что он обязан решать задачу об изоморфизме графа объектов, а не просто копировать байты.

deepcopy обходит весь достижимый граф, ведёт словарь уже скопированных объектов по id (иначе циклическая структура зациклила бы его), для каждого типа ищет подходящий способ копирования — __deepcopy__, __reduce_ex__, протокол pickle. Это интерпретируемый обход с диспетчеризацией на каждом узле.

Практический вывод: если структура сериализуема, обычно быстрее сделать круг через сериализацию, чем звать deepcopy — потому что сериализатор написан на C. Но проверять надо замером на своих данных: у pickle свои накладные расходы, и на мелких объектах он проигрывает.

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

Lib/copy.py — сорок строк, которые стоит прочитать целиком: там видно и словарь memo, и таблицу диспетчеризации.