«Что выведет код?»: каверзные задачи

Значение по умолчанию вычисляется один раз — при выполнении def. Все вызовы без acc работают с одним списком. Обратите внимание: print получает ссылки на объекты, поэтому первый, второй и четвёртый аргумент печатаются в финальном состоянии.

def f(x, acc=[]):
    acc.append(x)
    return acc

print(f(1), f(2), f(3, []), f(4))
print(f.__defaults__)

Замыкание хранит ссылку на переменную, а не на значение. Все три лямбды видят одну i, которая после цикла равна 2. Исправления: аргумент по умолчанию (lambda i=i: ...) или functools.partial.

fs = [lambda: i * 10 for i in range(3)]
print([f() for f in fs])
fs = [lambda i=i: i * 10 for i in range(3)]
print([f() for f in fs])

Компилятор видит присваивание x = 20 и считает x локальной во всей функции. На момент print(x) локальная x ещё не связана → UnboundLocalError.

x = 10
def show():
    print(x)
    x = 20
show()

finally выполняется перед выходом из функции, поэтому finally! печатается раньше результата. return внутри finally отменяет исключение — ZeroDivisionError молча исчезает. Никогда так не пишите.

def g():
    try:
        return "try"
    finally:
        print("finally!")

def h():
    try:
        1 / 0
    finally:
        return "подавлено"

print(g(), h())

board = [[0] * 2] * 2
print(board[0] is board[1])
board[0][0] = 5
print(board)
board = [[0] * 2 for _ in range(2)]
board[0][0] = 5
print(board)

[0] * 2 безопасно: числа неизменяемы. Внешнее * 2 копирует ссылку на один список.

Итератор списка идёт по индексам. После удаления элементы сдвигаются влево, и следующий элемент пропускается. Обходите копию или стройте новый список.

nums = [1, 2, 2, 3, 4]
for n in nums:
    if n % 2 == 0:
        nums.remove(n)
print(nums)
nums = [1, 2, 2, 3, 4]
print([n for n in nums if n % 2])

d = {"a": 1, "b": 2}
try:
    for k in d:
        d["c"] = 3
except RuntimeError as e:
    print(e)

t[1] += [3] раскладывается на tmp = t[1]; tmp = tmp.__iadd__([3]); t[1] = tmp. __iadd__ списка меняет его на месте, а потом присваивание в кортеж падает. Итог: и ошибка, и изменение.

t = (1, [2])
try:
    t[1] += [3]
except TypeError as e:
    print(e)
print(t)

a += [3] меняет список на месте (b — тот же объект). c = c + [3] создаёт новый список и перепривязывает имя c; d смотрит на старый.

a = [1, 2]; b = a; a += [3]
c = [1, 2]; d = c; c = c + [3]
print(b, d, a is b, c is d)

1 == 1.0 == True и их хеши равны, поэтому это один ключ. Ключ остаётся первым (1), значение — последним.

d = {1: "int", 1.0: "float", True: "bool"}
print(d, hash(1) == hash(1.0) == hash(True))
print({0, False, 0.0, ""})

print(1 < 2 < 3, 1 < 3 > 2, (1 < 2) < 1, 3 > 2 == 2)
print(False == False in [False])     # (False == False) and (False in [False])

a op1 b op2 c — это a op1 b and b op2 c, причём b вычисляется один раз. Так же цепляются == и in, отсюда второй сюрприз.

Ленивое вычисление: or останавливается на первом истинном, and — на первом ложном. [] and 1/0 не делит на ноль: правая часть не вычисляется.

print(0 or [] or "x" or 5, 3 and 0 and 7, [] and 1/0, None or {} or 0)
name = "" or "Гость"
print(name)

Числа от -5 до 256 закешированы. Для больших результат is зависит от того, как и где созданы объекты (константы в одном блоке кода компилятор может объединить). Вывод: числа и строки сравнивают только через ==.

a = 256; b = 256
print(a is b, int("257") is int("257"), int("256") is int("256"))

items — атрибут класса, общий для всех экземпляров. self.items.append находит его через класс и меняет. Изменяемое состояние экземпляра создают в __init__. А вот присваивание a.count = 1 создаст атрибут экземпляра, «затеняющий» классовый.

class Cart:
    items = []
    count = 0
    def add(self, x):
        self.items.append(x)
        self.count += 1          # читает Cart.count, записывает в экземпляр

a, b = Cart(), Cart()
a.add("кофе")
print(b.items, a.count, b.count, Cart.count, a.__dict__)

self.__secret внутри класса A превращается в self._A__secret, а внутри B — в self._B__secret. Атрибута _B__secret нет → AttributeError.

class A:
    def __init__(self):
        self.__secret = 1

class B(A):
    def reveal(self):
        try:
            return self.__secret
        except AttributeError as e:
            return f"AttributeError: {e}"

print(B().reveal(), B().__dict__)

MRO класса D: D → B → C → A. super() в B вызывает следующий класс в MRO объекта — это C, а не A.

class A:
    def hi(self): return "A"
class B(A):
    def hi(self): return "B" + super().hi()
class C(A):
    def hi(self): return "C" + super().hi()
class D(B, C):
    def hi(self): return "D" + super().hi()
print(D().hi(), [k.__name__ for k in D.mro()])

map, filter, zip, генераторы и файлы — итераторы, они исчерпываются за один проход. 2 in nums тоже потребляет элементы.

nums = map(int, ["1", "2", "3"])
print(sum(nums), sum(nums), 2 in nums)

gen = (x for x in range(5))
print(3 in gen, list(gen))       # поиск съел 0..3

В генераторном выражении первый итерируемый объект (items) вычисляется сразу — это старый список [1, 2, 3]. Всё остальное (factor) вычисляется лениво, при обходе, — к тому моменту factor уже 10.

items = [1, 2, 3]
factor = 1
gen = (x * factor for x in items)
factor = 10
items = [7, 8, 9]
print(list(gen))

*middle собирает «всё остальное» в список. Цепочка присваиваний a, b = b, a = 1, 2 выполняется слева направо: сначала a, b = (1, 2), затем b, a = (1, 2).

first, *middle, last = "Python"
a, b = b, a = 1, 2
print(first, middle, last, a, b)

list.sort() сортирует на месте и возвращает None (как и append, reverse, random.shuffle) — чтобы никто не думал, что получил копию. Сортировка устойчива: элементы с равным ключом сохраняют исходный порядок (bb перед dd). Для новой отсортированной копии — sorted().

words = ["bb", "a", "ccc", "dd", "e"]
result = words.sort(key=len)
print(result, words)
print(sorted(["bb", "a", "ccc", "dd", "e"], key=len, reverse=True))