Типы данных

list изменяемый — можно append, insert или удалять; tuple неизменяемый после создания. Различаются и в CPython: list выделяет память с запасом, поэтому append амортизированно O(1), а tuple фиксированного размера, компактнее и кэшируется через free list.

Отображение даёт доступ к значениям по ключам через методы вроде get, keys, values, items. Канонический пример — dict; стандартная библиотека добавляет defaultdict, OrderedDict, Counter. Ключи должны быть хешируемыми, значения — любыми.

set — неупорядоченная коллекция уникальных хешируемых элементов без индексов и срезов, с быстрой проверкой in и операциями |, & и -. set изменяемый (add, remove); frozenset — его неизменяемый хешируемый вариант, годный как ключ dict.

Возвращает новую подпоследовательность от start (включительно) до stop (не включая), беря каждый step-й элемент. Все три необязательны; отрицательные индексы отсчитываются с конца, а s[:] делает поверхностную копию. Выход за границы обрезается, а не падает с ошибкой.

Нет — str неизменяемый. s[0] = 'x' бросает TypeError; любая «правка» вроде replace или + создаёт новый строковый объект и переназначает имя, оставляя исходную строку нетронутой. Именно неизменяемость делает строки хешируемыми и пригодными как ключи dict.

Ключом может быть любой хешируемый объект: int, str, хешируемый tuple, даже функция или модуль. list, dict, set нельзя — они изменяемы и нехешируемы. Хеш tuple рекурсивен, поэтому tuple с dict внутри тоже нехешируем.

zero

0 None False

2 avocado

3.5 3 -4 2

C

False True

3x3.14=9.4

2 8 3.0

4 3

Выведет start, затем ошибка TypeError

n p 6

[[5, 0], [5, 0]]

True False 1

zero 4 True

6 5

Последовательность — упорядоченный итерируемый объект с доступом по целочисленному индексу через __getitem__ и длиной через __len__. Встроенные: list, tuple, range, str, bytes. Поддерживает индексацию, срезы, in, len() и итерацию.

4 2 [1]

bcd ace ef

None 1

[2, 3] 2 3

Выведет hello, затем ошибка TypeError

Ошибка TypeError

(1) default — or возвращает первый истинный операнд (пустой список ложен). (2) 5 — первое истинное значение. (3) '' — and возвращает первый ложный операнд или последний, если все истинны. or/and возвращают один из операндов, а не bool — основа идиомы x = val or default.

False True False True

Правая часть итерируется и позиционно привязывается к целям; количество должно совпадать, иначе будет ValueError. Одна звёздная цель вроде a, *rest = seq собирает излишек в list, поэтому может стоять где угодно. Работает с любым итерируемым.

range(n) лениво выдаёт целые 0..n-1; enumerate(seq) выдаёт пары (индекс, элемент); zip(a, b) выдаёт кортежи, объединяя элементы, пока не кончится самый короткий вход. Все три — ленивые итераторы в Python 3; оберни в list(), чтобы материализовать. zip(*rows) транспонирует.

Они возвращают динамические объекты-представления, а не списки. Представление отражает изменения dict вживую, поддерживает len(), итерацию и in, а ключи и пары ведут себя как множества. В Python 2 возвращались списки; в Python 3 умолчанием стали представления.

Объект хешируемый, если у него есть стабильный __hash__ (не меняется в течение жизни) и __eq__, причём равные объекты обязаны хешироваться одинаково. Неизменяемые встроенные (int, str, хешируемый tuple) подходят; изменяемые list, dict, set — нет.

True False, затем True True. CPython кэширует малые целые от −5 до 256, поэтому a и b — один объект (is → True); 257 вне этого диапазона, поэтому c и d — разные объекты (is → False). == сравнивает значение и всегда True. Используйте is лишь для тождества (например, x is None).

dict и set — хеш-таблицы: поиск в среднем O(1) — Python хеширует ключ и переходит к ячейке. У list и tuple нет индекса по значениям, поэтому x in seq сканирует линейно за O(n). Цена: нужны хешируемые элементы и больше памяти.

Поэлементно, слева направо (лексикографически). == истинно, только если длины равны и каждая пара равна. Для < Python сравнивает элементы на первом отличии; если одна сторона кончилась раньше, короткая считается меньшей. Элементы должны быть сравнимы, иначе TypeError.

str — неизменяемая последовательность кодовых точек Unicode; bytes — последовательность сырых октетов 0–255. encode превращает str в bytes через кодек вроде UTF-8; decode делает обратное. Их смешивание или неверный кодек бросает UnicodeError; неявного преобразования в Python 3 нет.

Выводит 5, 2, 2. В Python bool — подкласс int, где True == 1, а False == 0, поэтому булевы значения участвуют в арифметике напрямую. True + 4 — это 1 + 4, а sum булевых считает количество True. Поэтому суммирование списка условий подсчитывает, сколько из них истинны.

Все три печатают True. Python связывает сравнения неявным and: (1) это 1 < 2 and 2 < 3; (2) это 3 > 2 and 2 == 2; (3) это (False == False) and (False in [False]) → True and True. Третья удивляет, ведь == и in связываются вместе.

Коллизия хеша — это два разных ключа, дающих одно хеш-значение или попадающих в одну ячейку таблицы. dict и set разрешают её пробированием других ячеек, поэтому коллизия стоит скорости поиска, а не корректности — неверное значение не вернётся.

Оба выводят {1: 1, 2: 2, 3: 3}. b = a связывает второе имя с тем же объектом-словарём — не копирует его, поэтому правки через любое имя видны через оба. Для независимого словаря используйте a.copy() или dict(a) (поверхностная копия). a is b здесь True.

Выводит [1, 2, 3, 'a', 'b', 'c']. extend перебирает свой аргумент и добавляет каждый элемент; строка итерируется по символам, поэтому каждый символ добавляется отдельно. Чтобы добавить всю строку одним элементом, используйте l.append('abc'), дающий [1, 2, 3, 'abc'].

Берём первый элемент каждого кортежа: [t[0] for t in data]. Одноэлементный кортеж записывается ('x',) с запятой в конце, поэтому индексация [0] достаёт единственное значение. Эквивалентные формы — [v for (v,) in data] (распаковка кортежа в цели цикла) или list(map(lambda t: t[0], data)).

False. 0.1 + 0.2 равно 0.30000000000000004, потому что эти значения не представимы точно в двоичной плавающей точке, поэтому сумма отличается от литерала 0.3. Сравнивайте с допуском — math.isclose(0.1 + 0.2, 0.3).

Удвойте скобки: print(f'Curly brackets: {{}}') печатает Curly brackets: {}. В f-строке {{ — экранированная литеральная {, а }} — литеральная }; одиночные {...} — поле подстановки, требующее выражения, поэтому пустые {} возбуждают SyntaxError на этапе компиляции.

Выводит z, затем y. Отрицательный индекс отсчитывается с конца: -1 — последний элемент, -2 — предпоследний. Это эквивалентно var[len(var) - 1]. Работает на любой последовательности — str, list, tuple — а выход за диапазон возбуждает IndexError.

[1, 2, 3, 4], затем [1, 2, 3]. += для списка вызывает __iadd__, изменяя объект на месте, поэтому b (тот же объект) это видит. a = a + [4] строит новый список и переназначает a, оставляя b на исходном — изменение против переназначения.

[[1, 0, 0], [1, 0, 0], [1, 0, 0]]. Внешнее * 3 копирует ссылку на один и тот же внутренний список трижды, поэтому изменение одной строки меняет все. Решение — включение, строящее независимые строки: grid = [[0] * 3 for _ in range(3)].

(1) проходит → ([1, 99], 2): кортеж неизменяем, но список, на который он ссылается, изменяем. (2) — знаменитая ловушка: += изменяет список И пытается переназначить t[0], поэтому возникает TypeError — но список всё равно изменяется до [1, 99, 100]. Операция выполняется наполовину.

// — это деление с округлением вниз, поэтому average([1, 2]) возвращает 1, а не 1.5. Пустой список также вызывает ZeroDivisionError. Решение: использовать / для истинного деления и защитить пустой случай: return sum(nums) / len(nums) if nums else 0.

counts[w] += 1 читает counts[w] до того, как ключ существует → KeyError при первой встрече каждого слова. Решение: counts[w] = counts.get(w, 0) + 1, либо collections.defaultdict(int), либо просто collections.Counter(text.split()).

Удаление элементов при итерации сдвигает индексы под итератором, поэтому он пропускает элементы. Никогда не изменяйте список, по которому идёте. Решение: итерировать копию (for n in nums[:]:) или пересобрать включением: nums = [n for n in nums if n % 2].

Строки неизменяемы, поэтому каждое s += ... строит совершенно новую строку — O(n²) для n слов, медленно на больших данных. Функционально верно, но сложность и есть ошибка. Решение: return ' '.join(words), что даёт O(n) и идиоматично.

CPython dict — разреженная хеш-таблица; ячейка хранит хеш ключа плюс ссылки на ключ и значение. Поиск берёт младшие биты хеша как смещение ячейки и пробирует при коллизии. Около трети ячеек держится пустыми; при заполнении таблица растёт, и записи вставляются заново.

Вычисляется в {True: 'c'}. True, 1, 1.0 равны (True == 1 == 1.0) и хешируются одинаково, поэтому это один ключ. Первый вставленный ключ (True) сохраняется, но каждое присваивание перезаписывает значение — итог 'c'.