ITМоя статистика
Тест по Python
410 вопросов по Python в 43 темах (Junior — 151, Middle — 173, Senior — 86). Выберите темы, уровень и количество вопросов — к каждому ответу есть объяснение.
Типы и коллекции, срезы, функции и аргументы, генераторы и итераторы, ООП, декораторы, исключения и тонкости Python 3.
Все вопросы по Python 410
Нажмите на вариант ответа, чтобы проверить себя, или «Показать ответ».
Учите по урокам: Python: от установки до профи150 уроков · теория, примеры и заданияИзучить тему по урокам курса (42)
- Инструменты и окружение: 7. pip и виртуальные окружения venv, 8. Комментарии и стиль кода: PEP 8, 112. Свой пакет: pyproject.toml и публикация, 113. pip, Poetry и uv
- Типы и операторы: 11. Переменные и именование, 14. bool и None, 15. Арифметика и приоритет операций, 16. Сравнения и цепочки сравнений
- Числа: 12. Числа: int, float, Decimal, Fraction, 15. Арифметика и приоритет операций, 18. Приведение типов
- Строки: 13. Строки и f-строки, 51. Методы строк, 52. Форматирование: f-строки, format, %, 53. Юникод и кодировки
- Модель данных: 19. Всё в Python — объект, 67. __eq__ и __hash__, 69. __slots__, 99. Динамические атрибуты: __getattr__
- Изменяемость, копирование: 20. Изменяемые и неизменяемые типы, 68. Копирование: copy и deepcopy
- Условия и циклы: 21. if, elif, else, 22. Условное выражение и оператор :=, 24. Цикл while, 25. Цикл for
- Pattern matching: 23. match / case: первое знакомство, 101. Pattern matching: match / case, 104. Современный синтаксис: |, :=, positional-only
- Списки: 31. Списки: создание и доступ, 32. Методы списков, 38. Сортировка: sorted, sort, key, 39. Срезы и распаковка
- Множества и кортежи: 33. Кортежи, 35. Множества
- Словари: 34. Словари, 40. Практикум: частотный словарь
- Встроенные функции: 36. enumerate, zip и обход коллекций, 38. Сортировка: sorted, sort, key, 49. Встроенные функции: map, filter, any, all
- Comprehensions: 37. Comprehensions: списки, словари, множества
- itertools и collections: 40. Практикум: частотный словарь, 78. Enum и namedtuple
- Функции: 41. Определение функций, 42. Аргументы по умолчанию и именованные, 43. *args и **kwargs, 44. Возвращаемые значения
- Функциональный стиль: 45. lambda-функции, 48. Функции как объекты
- Области видимости: 46. Области видимости: LEGB, global и nonlocal
- Типизация: 50. Аннотации типов: первое знакомство, 77. Утиная типизация и Protocol, 102. Аннотации типов и mypy, 103. Generics, Protocol и TypedDict
- Стандартная библиотека: 54. Регулярные выражения: основы, 56. Чтение и запись файлов, 57. pathlib и работа с путями, 58. Работа с CSV
- Стандартная библиотека 2: 55. Регулярные выражения: группы и lookaround, 60. Практикум: парсер логов, 86. Логирование
- Контекстные менеджеры: 56. Чтение и запись файлов, 96. Контекстные менеджеры
- Классы и объекты: 61. Классы и экземпляры, 62. Конструктор __init__ и self, 63. Атрибуты экземпляра и класса, 64. Методы: обычные, classmethod, staticmethod
- Магические методы: 66. __str__ и __repr__, 67. __eq__ и __hash__, 76. Перегрузка операторов
- Наследование и MRO: 71. Наследование и super(), 72. MRO: порядок разрешения методов, 73. Множественное наследование и миксины, 79. Композиция против наследования
- Dataclasses и ABC: 74. Абстрактные классы (abc), 75. Dataclasses, 80. Практикум: иерархия фигур
- Исключения: 81. Исключения: try / except, 82. Собственные исключения, 83. finally и else в try, 84. raise from и цепочки исключений
- Найдите ошибку: 85. Отладка: pdb и breakpoint(), 148. Код-ревью
- Производительность: 87. Профилирование: cProfile и timeit, 110. Новое в Python: free-threading и JIT, 142. Производительность и бенчмарки
- pytest: 88. unittest, 89. pytest, 90. TDD на примере
- Декораторы: 91. Декораторы, 92. Декораторы с аргументами и functools
- Замыкания: 93. Замыкания
- Генераторы и итераторы: 94. Генераторы, 95. Итераторы и протокол итерации
- Дескрипторы и метаклассы: 97. Дескрипторы, 98. Метаклассы
- Асинхронность: 105. asyncio: основы, 106. async / await: паттерны и gather
- Потоки и процессы: 107. Потоки: threading, 108. Процессы: multiprocessing
- Память и GC: 109. GIL, память и сборщик мусора, 143. Поиск утечек памяти
- Модули и пакеты: 111. Модули и пакеты, 112. Свой пакет: pyproject.toml и публикация
- SQLAlchemy и базы данных: 122. SQLite из Python, 123. SQLAlchemy Core, 124. SQLAlchemy ORM, 125. Миграции: Alembic
- Django и FastAPI: 131. HTTP, WSGI и ASGI, 136. Обзор Django: MTV и конвенции, 137. FastAPI
- Flask и FastAPI: 132. Flask, 133. Шаблоны Jinja2, 137. FastAPI, 138. Проектирование REST API
- Django: 136. Обзор Django: MTV и конвенции
- Алгоритмы на Python: 141. Архитектура: слои, сервисы и паттерны
Типы и операторы10
Что выведет этот код?
x = 10
x = "десять"
print(type(x).__name__)- str
- int
- Ошибка TypeError
- Ошибка NameError
Python — язык с динамической типизацией: тип есть у объекта, а не у переменной, поэтому имя
x можно связать сначала с int, потом со str. Никакой ошибки нет, type(x) возвращает тип текущего объекта — str.Что выведет этот код в CPython?
a = int("256")
b = int("256")
c = int("257")
d = int("257")
print(a is b, c is d)- True True
- True False
- False False
- False True
В CPython целые от -5 до 256 закэшированы:
int("256") всегда возвращает один и тот же объект, поэтому a is b — True. 257 в кэш не входит, и два вызова int("257") создают разные объекты, так что c is d — False. Это деталь реализации: числа и строки всегда сравнивайте через ==.Чем оператор
is отличается от ==?isсравнивает значения, а==проверяет, что это один и тот же объектisсравнивает ещё и типы, а==приводит типы перед сравнениемisпроверяет, что это один и тот же объект, а==сравнивает значения- Ничем,
is— просто более читаемый синоним==
a is b истинно, только если a и b ссылаются на один объект (то же, что id(a) == id(b)), а == вызывает __eq__ и сравнивает значения. Например, [1] == [1] — True, а [1] is [1] — False. is используют для синглтонов: x is None.Какое из значений истинно (truthy) в условии
if?0.0""set()[0]
Ложны
None, False, нули любых числовых типов и пустые коллекции/строки. [0] — непустой список (в нём один элемент), поэтому он истинный, хотя сам элемент 0 ложный.Что выведет
print(0 or [] or "x", 1 and "a" and 0)?- x 0
- True False
- x False
- True 0
or и and возвращают не bool, а один из операндов. or возвращает первый истинный операнд (или последний, если все ложны) — "x"; and возвращает первый ложный операнд (или последний, если все истинны) — 0.Что выведет этот код?
x = 5
print(1 < x < 10, 10 > x > 7)- True True
- True False
- False False
- Ошибка TypeError
Цепочка сравнений
a < b < c в Python означает a < b and b < c (средний операнд вычисляется один раз). 1 < 5 < 10 — True, 10 > 5 > 7 — 10 > 5 and 5 > 7, то есть False. Это не (1 < x) < 10, как в C.Что выведет
print(False == False in [False])?- False
- Ошибка TypeError
- True
- [True]
== и in — операторы сравнения одного приоритета, поэтому выражение — это цепочка: False == False and False in [False], то есть True and True → True. Ответ False получился бы при группировке (False == False) in [False] → True in [False], но Python так не считает.Что выведет
print("5" + 5)?- 55
- 10
- "55"
- Ошибка TypeError
Типизация в Python динамическая, но строгая: неявного приведения
str ↔ int нет, поэтому "5" + 5 бросает TypeError: can only concatenate str (not "int") to str. Нужно явно: "5" + str(5) или int("5") + 5.Что выведет этот код?
data = [1, 5, 8, 3]
if (n := len(data)) > 3:
print(f"длинный: {n}")
else:
print("короткий")- длинный: 4
- длинный: True
- короткий
- Ошибка SyntaxError
Моржовый оператор
:= (Python 3.8+) присваивает значение и возвращает его в том же выражении: n получает 4, затем сравнивается 4 > 3. Скобки важны: без них n := len(data) > 3 присвоил бы n результат сравнения True.Что выведет этот код?
print(True + True, sum([True, False, True]), isinstance(True, int))2 2 TrueTrue 2 FalseTypeError: нельзя складывать значенияbool
bool — подкласс int, где True равно 1, а False — 0. Поэтому True + True даёт 2, а sum() по списку булевых значений считает количество истинных — это частый приём вроде sum(x > 0 for x in data).Строки13
Что верно про интернирование строк в CPython?
- Все строки с одинаковым содержимым всегда являются одним объектом
- Короткие строки-литералы, похожие на идентификаторы, обычно интернируются, но
isдля сравнения строк использовать нельзя - Интернирование гарантировано языком, поэтому строки можно сравнивать через
is - Интернирование отключено в Python 3, поэтому
isдля строк всегда даётFalse
CPython интернирует часть строк (литералы-идентификаторы, имена атрибутов, явно через
sys.intern), но строки, собранные во время выполнения ("".join(...), ввод, конкатенация переменных), обычно — разные объекты. Поэтому результат is для строк непредсказуем, а Python 3.8+ даже выдаёт SyntaxWarning на x is "literal". Содержимое сравнивают только через ==.Что выведет этот код?
pi = 3.14159
print(f"{pi:.2f}")- 3.14159
- 3.1
- 3.14
- 3.15
Спецификатор
.2f форматирует число с фиксированной точкой и двумя знаками после запятой (с округлением): 3.14159 → 3.14. .2 без f означало бы две значащие цифры — 3.1.Что выведет этот код?
total = 1234567.891
print(f"{total:,.2f}")- 1234567.89
- 1 234 567.89
- 1,234,567.891
- 1,234,567.89
В спецификаторе
, включает разделитель тысяч (запятая), а .2f — два знака после точки. Разделитель пробелом format-spec не умеет; для _ есть отдельная опция {total:_.2f}.Что выведет этот код?
width = 3
x = 5
print(f"{x=}", f"{x:0{width}}")- x=5 005
- 5 005
- x=5 500
- x=5 5
f"{x=}" (Python 3.8+) печатает выражение и его значение: x=5. Спецификатор может содержать вложенные поля: {x:0{width}} превращается в {x:03} — ширина 3, дополнение нулями слева → 005.Что выведет этот код?
s = "hello"
s[0] = "H"
print(s)- Hello
- Ошибка TypeError
- hello
- Ошибка IndexError
Строки в Python неизменяемы: присваивание по индексу бросает
TypeError: 'str' object does not support item assignment. Чтобы «изменить» строку, создают новую: s = "H" + s[1:] или s.capitalize().Что выведет этот код?
s = "Python"
print(s[::-1])- Python
- n
- nohtyP
- Ошибка ValueError
Срез
[::-1] проходит всю строку с шагом -1, то есть с конца к началу, — это идиоматичный способ развернуть строку. Исходная строка при этом не меняется: срез возвращает новую.Что выведет этот код?
s = "abcdef"
print(s[4:1:-1])- edcb
- dcb
- (пустая строка)
- edc
При отрицательном шаге срез идёт от
start вниз до stop, не включая stop: индексы 4, 3, 2 → e, d, c. Пустая строка была бы при s[1:4:-1] — когда при шаге -1 start меньше stop.Что выведет
print("a,b,,c".split(","))?- ['a', 'b', '', 'c']
- ['a', 'b', 'c']
- ['a', 'b', None, 'c']
- ['a,b,,c']
split с явным разделителем не склеивает подряд идущие разделители: между двумя запятыми получается пустая строка ''. Пустые элементы отбрасывает только split() без аргументов (он режет по любым пробельным символам).Что выведет этот код?
s = " a b "
print(s.split(), len(s.split(" ")))- ['a', 'b'] 2
- ['a', 'b'] 6
- ['', 'a', 'b'] 6
- ['a', 'b'] 4
split() без аргументов режет по любым последовательностям пробельных символов и отбрасывает пустые части → ['a', 'b']. split(" ") режет по каждому одиночному пробелу и сохраняет пустые строки: ['', '', 'a', '', 'b', ''] — 6 элементов.Что выведет этот код?
nums = [1, 2, 3]
print("-".join(nums))- 1-2-3
- [1, 2, 3]
- Ошибка TypeError
- -1-2-3-
str.join принимает итерируемое только из строк и не приводит элементы автоматически: на int будет TypeError: sequence item 0: expected str instance, int found. Правильно: "-".join(map(str, nums)).Что выведет
print("xxhixyx".strip("xy"))?- hixyx
- xxhi
- xxhixyx
- hi
Аргумент
strip — это набор символов, а не подстрока: с обоих концов удаляются любые символы из множества {'x', 'y'}, пока не встретится другой символ. Чтобы удалить именно префикс/суффикс-подстроку, есть removeprefix/removesuffix (3.9+).Что выведет
print("ell" in "hello", "hello".find("z"))?- True -1
- True None
- False -1
- True ValueError
Для строк оператор
in проверяет вхождение подстроки, а не одного символа: "ell" in "hello" — True. find при отсутствии подстроки возвращает -1; исключение ValueError бросает похожий метод index.Что выведет этот код?
s = "a-b-c"
print(s.split("-", 1), s.rsplit("-", 1))['a', 'b-c'] ['a', 'b-c']['a'] ['c']['a', 'b-c'] ['a-b', 'c']['a', 'b', 'c'] ['a', 'b', 'c']
Второй аргумент
maxsplit ограничивает число разрезов: строка делится не более чем на maxsplit + 1 частей, а остаток целиком попадает в крайний элемент. split режет слева, rsplit — справа, поэтому rsplit("-", 1) удобно отделяет последний фрагмент, например расширение в name.rsplit(".", 1).Числа8
Что выведет
print(7 / 2, 7 // 2)?- 3 3
- 3.5 3
- 3.5 3.5
- 3.5 4
В Python 3 оператор
/ — всегда «истинное» деление и возвращает float: 3.5. // — целочисленное деление с округлением вниз (к минус бесконечности): 3. В Python 2 7 / 2 давало бы 3, отсюда частая путаница.Что выведет
print(-7 // 2, -7 % 2)?- -3 -1
- -3 1
- -4 1
- -4 -1
// округляет вниз, к минус бесконечности: -3.5 → -4 (а не к нулю, как в C/Java). Остаток согласован с этим: a == (a // b) * b + a % b, то есть -7 - (-8) = 1. Знак % в Python совпадает со знаком делителя.Что выведет
print(round(2.5), round(3.5), round(0.5))?- 3 4 1
- 2 3 0
- 3 4 0
- 2 4 0
round в Python 3 использует банковское округление: точная половина округляется к ближайшему чётному. Поэтому 2.5 → 2, 3.5 → 4, 0.5 → 0. «Школьное» округление вверх даёт другой результат, для него используют decimal с ROUND_HALF_UP.Что выведет
print(round(2.675, 2))?- 2.67
- 2.68
- 2.7
- 2.675
Дело не в банковском округлении: литерал
2.675 в двоичном float хранится как 2.67499999999999982236431605997495353221893310546875, то есть чуть меньше половины, и округляется вниз — 2.67. Для точной десятичной арифметики используйте decimal.Decimal("2.675").Что выведет
print(0.1 + 0.2 == 0.3)?- True
- False
- Ошибка TypeError
- 0.3
0.1 и 0.2 не представимы в двоичном float точно, их сумма равна 0.30000000000000004, поэтому сравнение даёт False. Числа с плавающей точкой сравнивают с допуском: math.isclose(0.1 + 0.2, 0.3).Что выведет
print(int("3.5"))?- 3
- 4
- Ошибка ValueError
- 3.5
int() из строки принимает только запись целого числа, поэтому int("3.5") бросает ValueError: invalid literal for int() with base 10. Из float (int(3.5)) преобразование работает — отбрасывает дробную часть; из строки нужно int(float("3.5")).Что выведет
print(int(3.9), int(-3.9))?- 3 -4
- 4 -4
- 4 -3
- 3 -3
int() для float отбрасывает дробную часть, то есть округляет к нулю: 3 и -3. Округление вниз (к минус бесконечности) — это math.floor (-4), и оно же используется в //.Что выведет этот код (Python 3.6+)?
print(int("1_000"), int("ff", 16), int("0b101", 0))1000 255 5ValueError: подчёркивание в строке недопустимо1000 255 101ValueError: основание 0 недопустимо
Начиная с Python 3.6
int() принимает подчёркивания между цифрами — так же, как литералы вида 1_000. Второй аргумент задаёт основание системы счисления, а base=0 означает «определить по префиксу», как в исходном коде: 0b — двоичное, 0o — восьмеричное, 0x — шестнадцатеричное.Условия и циклы9
Что выведет этот код?
for i in range(3):
if i == 5:
break
else:
print("else")
print("end")- else, затем end
- Только end
- Ошибка SyntaxError
- 0 1 2, затем end
Блок
else у цикла for выполняется, если цикл завершился естественно, без break. Здесь break не срабатывает ни разу, поэтому печатается else, затем end. else при этом не означает «если цикл не выполнился ни разу».Что выведет этот код?
n = 0
while n < 5:
n += 1
if n == 3:
break
else:
n = 100
print(n)- 100
- 3
- 5
- 103
else у while выполняется, только если условие стало ложным, а цикл не был прерван break. Здесь цикл прерывается при n == 3, поэтому else пропускается и печатается 3.Что выведет
print(list(range(2, 10, 3)))?- [2, 5, 8, 11]
- [3, 6, 9]
- [2, 5, 8]
- [2, 4, 6, 8]
range(start, stop, step) начинает с start и идёт с шагом step, не включая stop: 2, 5, 8 (следующее, 11, уже ≥ 10). range ленивый, поэтому для печати значений его оборачивают в list.Что выведет
print(list(enumerate("ab", start=1)))?- [(0, 'a'), (1, 'b')]
- [('a', 1), ('b', 2)]
- [1, 2]
- [(1, 'a'), (2, 'b')]
enumerate выдаёт пары (индекс, элемент), а параметр start задаёт начальный индекс — здесь 1. Индекс идёт первым, элемент вторым.Что выведет
print(list(zip([1, 2, 3], "ab")))?- [(1, 'a'), (2, 'b')]
- [(1, 'a'), (2, 'b'), (3, None)]
- Ошибка ValueError
- [(1, 2, 3), ('a', 'b')]
zip останавливается на самой короткой последовательности, лишний элемент 3 молча отбрасывается. Чтобы дополнить короткую последовательность, используют itertools.zip_longest, а чтобы получить ошибку при разной длине — zip(..., strict=True) (3.10+).Что выведет этот код?
total = 0
for i in range(6):
if i % 2 == 0:
continue
if i > 4:
break
total += i
print(total)- 9
- 4
- 1
- 6
continue пропускает чётные i, остаются 1, 3, 5. К total прибавляются 1 и 3, а при i = 5 срабатывает break раньше сложения, поэтому итог 4. 9 получилось бы, если бы break стоял после total += i.Найдите ошибку: что выведет этот код?
x = 5
if x == 1 or 2:
print("один или два")
else:
print("другое")- другое
- Ошибка TypeError
- один или два
- Ничего не выведет
Условие разбирается как
(x == 1) or 2. x == 1 ложно, но 2 — истинное значение, поэтому условие всегда истинно. Правильно писать x == 1 or x == 2 или x in (1, 2).Что выведет этот код (Python 3.10+)?
def check(cmd):
match cmd.split():
case ["go", direction]:
return f"идём {direction}"
case ["quit" | "exit"]:
return "выход"
case _:
return "?"
print(check("go north"), check("exit"), check("go"))- идём direction выход ?
- идём north ? ?
- идём north выход идём
- идём north выход ?
Паттерн-последовательность
["go", direction] совпадает со списком ровно из двух элементов, первый равен "go", а второй связывается с именем direction. ["quit" | "exit"] — OR-паттерн для одного элемента. ["go"] из одного элемента не подходит под первый case и попадает в case _.Что выведет этот код (Python 3.10+)?
RED = "red"
color = "blue"
match color:
case RED:
print("красный", RED)- красный blue
- Ничего не выведет
- красный red
- Ошибка NameError
Голое имя в
case — это capture-паттерн, а не сравнение с константой: он совпадает с чем угодно и присваивает значение этому имени. Поэтому ветка срабатывает, а RED перезаписывается на "blue". Для сравнения с константой нужно точечное имя (Color.RED) или guard: case c if c == RED.Функции6
Что выведет этот код?
def double(x):
x * 2
print(double(3))- 6
- None
- 3
- Ошибка SyntaxError
Значение выражения
x * 2 вычисляется и отбрасывается: без return функция неявно возвращает None. В отличие от Ruby, последнее выражение в Python не становится результатом функции.Что выведет этот код?
def add(item, bucket=[]):
bucket.append(item)
return bucket
add(1)
print(add(2))- [2]
- [1]
- [1, 2]
- Ошибка TypeError
Значения по умолчанию вычисляются один раз — при определении функции, и список
bucket общий для всех вызовов без аргумента. Первый вызов добавил 1, второй — 2. Правильный приём: bucket=None и внутри if bucket is None: bucket = [].Что выведет этот код?
def f(a, b=2, *args, c, **kwargs):
print(a, b, args, c, kwargs)
f(1, 3, 4, c=5, d=6)- 1 2 (3, 4) 5 {'d': 6}
- 1 3 [4] 5 {'d': 6}
- Ошибка TypeError
- 1 3 (4,) 5 {'d': 6}
Позиционные аргументы заполняют
a, затем b (значение по умолчанию заменяется на 3), остаток уходит в кортеж args → (4,). c стоит после *args, поэтому он keyword-only и передаётся только по имени; неизвестный именованный d попадает в словарь kwargs.Что выведет этот код?
def connect(host, *, port=80):
return f"{host}:{port}"
print(connect("localhost", 8080))- Ошибка TypeError
- localhost:8080
- localhost:80
- Ошибка SyntaxError
Одиночная
* в списке параметров делает всё, что после неё, keyword-only: port можно передать только как port=8080. Позиционный вызов с двумя аргументами даёт TypeError: connect() takes 1 positional argument but 2 were given.Что выведет этот код?
def f(a, /, **kwargs):
print(a, kwargs)
f(1, a=2)- Ошибка TypeError: multiple values for argument 'a'
- 1 {'a': 2}
- 2 {}
- Ошибка SyntaxError
Параметры перед
/ (Python 3.8+) — positional-only: их нельзя передать по имени, поэтому имя a в вызове не связывается с параметром a, а попадает в **kwargs. Без / вызов f(1, a=2) действительно дал бы TypeError: got multiple values for argument 'a'.Что выведет этот код?
funcs = [lambda: i for i in range(3)]
print([f() for f in funcs])- [0, 1, 2]
- [0, 0, 0]
- [2, 2, 2]
- Ошибка NameError
Замыкания в Python связываются поздно: лямбда запоминает не значение
i, а переменную, и читает её в момент вызова — когда цикл уже закончился и i == 2. Чтобы зафиксировать значение, используют параметр по умолчанию: lambda i=i: i или functools.partial.Области видимости7
В каком порядке Python ищет имя переменной (правило LEGB)?
- Global → Local → Enclosing → Built-in
- Built-in → Global → Enclosing → Local
- Local → Global → Enclosing → Built-in
- Local → Enclosing → Global → Built-in
Сначала локальная область функции (Local), затем области объемлющих функций (Enclosing), затем глобальная область модуля (Global) и в конце встроенные имена (Built-in, например
len). Поиск останавливается на первом найденном имени.Что выведет этот код?
x = 10
def f():
print(x)
x = 20
f()- Ошибка UnboundLocalError
- 10
- 20
- 10, затем 20
Область видимости определяется при компиляции: раз внутри
f есть присваивание x = 20, x — локальная переменная во всей функции, включая строку с print. На момент print(x) локальная x ещё не связана → UnboundLocalError. Глобальная x = 10 не используется; чтобы читать/менять её, нужно global x.Что выведет этот код?
x = 1
def f():
global x
x = 2
f()
print(x)- 1
- 2
- None
- Ошибка SyntaxError
Объявление
global x говорит, что x внутри функции — это глобальная переменная модуля, поэтому присваивание меняет её, и печатается 2. Без global присваивание создало бы новую локальную x, и вывелось бы 1.Что выведет этот код?
def counter():
n = 0
def inc():
nonlocal n
n += 1
return n
return inc
c1 = counter()
c2 = counter()
c1()
print(c1(), c2())- 2 2
- 1 1
- 2 1
- 3 1
nonlocal n позволяет внутренней функции изменять переменную объемлющей функции. Каждый вызов counter() создаёт свою n, поэтому у c1 и c2 независимые счётчики: c1 вызывается второй раз → 2, c2 первый → 1.Что выведет этот код?
list = [1, 2]
print(list("ab"))- ['a', 'b']
- [1, 2, 'a', 'b']
- Ошибка NameError
- Ошибка TypeError
Глобальное имя
list затеняет встроенный тип: по правилу LEGB поиск находит list в Global раньше, чем в Built-in. Вызов списка как функции даёт TypeError: 'list' object is not callable. Не называйте переменные list, dict, str, id, type.Что выведет этот код?
x = "a"
squares = [x * x for x in range(3)]
print(x)- a
- 2
- 4
- Ошибка NameError
В Python 3 у генератора списка своя область видимости, и переменная цикла
x из него не «утекает» наружу. Глобальная x остаётся "a". В Python 2 здесь вывелось бы 2.Что выведет этот код?
values = [y for x in range(5) if (y := x * 2) > 4]
print(values, y)- [6, 8] Ошибка NameError
- [6, 8] 8
- [0, 2, 4, 6, 8] 8
- [6, 8] 4
Переменная цикла
x в генераторе локальна, но цель моржового оператора := внутри comprehension связывается в объемлющей области (PEP 572). Поэтому y доступна после генератора и хранит последнее присвоенное значение — 8 (при x = 4).Списки8
Чему будет равно
len(a) после a = [1, 2] и a.append([3, 4])?- 2
- 3
- 4
- Ошибка TypeError
append добавляет переданный объект целиком как ОДИН элемент — в конец попадает вложенный список [3, 4]. Чтобы добавить элементы по отдельности (и получить длину 4), нужен extend.Что выведет этот код?
a = ['x']
a.extend('ab')
print(a)- Ошибка TypeError
- ['x', 'ab']
- ['xab']
- ['x', 'a', 'b']
extend принимает любой итерируемый объект и добавляет его элементы по одному. Строка итерируется по символам, поэтому добавятся 'a' и 'b', а не строка 'ab' целиком (так сделал бы append).Что выведет этот код?
nums = [3, 1, 2]
result = nums.sort()
print(result, nums)- [1, 2, 3] [3, 1, 2]
- None [1, 2, 3]
- [1, 2, 3] [1, 2, 3]
- None [3, 1, 2]
list.sort() сортирует список на месте и возвращает None — поэтому result равен None, а сам nums уже отсортирован. Новый отсортированный список возвращает функция sorted(nums).Каким станет список после
a = [1, 2, 3, 2, 1] и a.remove(2)?- [1, 3, 1]
- [1, 2, 3, 1]
- [1, 2, 2, 1]
- [1, 3, 2, 1]
remove(x) удаляет только ПЕРВОЕ вхождение значения x (и бросает ValueError, если его нет). Это удаление по значению, а не по индексу — по индексу удаляют del a[i] или a.pop(i).Чем
list.sort() отличается от sorted()?sorted()работает только со списками, аsort()— с любым итерируемымsort()меняет список на месте и возвращаетNone,sorted()возвращает новый списокsort()возвращает новый список, аsorted()меняет исходный- Ничем,
sorted()— просто псевдоним методаsort()
list.sort() — метод только списков, сортирует на месте и возвращает None. sorted() принимает любой итерируемый объект (строку, кортеж, словарь, генератор) и всегда возвращает новый список, не трогая исходные данные.Что выведет этот код?
a = [1]
a += 'xy'
print(a)
a = a + 'z'- [1, 'x', 'y'] и ошибок не будет
- [1, 'xy'], затем TypeError
- [1, 'x', 'y'], затем TypeError
- Сразу TypeError на строке
a += 'xy'
a += ... для списка вызывает __iadd__, который работает как extend и принимает любой итерируемый объект — строка разбивается на символы. А a + 'z' вызывает __add__, который требует именно список, поэтому list + str даёт TypeError.Что выведет этот код?
a = [1, 2, 3]
for x in a:
a.remove(x)
print(a)- RuntimeError: list changed size during iteration
- [2]
- [1, 3]
- []
Удаление из списка во время итерации по нему сдвигает элементы: после удаления
1 итератор переходит к индексу 1, где уже стоит 3, и 2 пропускается. Для списков Python не бросает ошибку (в отличие от словарей и множеств) — баг просто тихий. Итерируйтесь по копии a[:] или стройте новый список.Что выведет этот код?
a = [1, 2, 3, 4, 5]
a[1:3] = ["x"]
print(a, len(a))[1, 'x', 3, 4, 5] 5[1, 'x', 4, 5] 4[1, ['x'], 4, 5] 4ValueError: при присваивании срезу длины должны совпадать
Присваивание срезу заменяет весь отрезок
a[1:3] (элементы 2 и 3) элементами итерируемого объекта справа, и длины совпадать не обязаны: список может и сжаться, и вырасти. Требование равной длины действует только для расширенных срезов с шагом, отличным от 1, например a[::2] = ..., — там несовпадение даёт ValueError.Изменяемость, копирование6
Что выведет этот код?
a = [1, 2]
b = a
a += [3]
a = a + [4]
print(a, b)- [1, 2, 3, 4] [1, 2]
- [1, 2, 3, 4] [1, 2, 3]
- [1, 2, 3, 4] [1, 2, 3, 4]
- [1, 2, 3] [1, 2, 3]
a += [3] для списка изменяет объект на месте, а b ссылается на тот же объект — поэтому b тоже видит 3. a = a + [4] создаёт НОВЫЙ список и перепривязывает имя a, а b остаётся указывать на старый.Что выведет этот код?
grid = [[0] * 3] * 3
grid[0][0] = 1
print(grid)- Ошибка TypeError
- [[1, 0, 0], [0, 0, 0], [0, 0, 0]]
- [[1, 0, 0], [1, 0, 0], [1, 0, 0]]
- [[1, 1, 1], [0, 0, 0], [0, 0, 0]]
Умножение
[row] * 3 копирует ССЫЛКИ, а не сами списки: все три строки — один и тот же объект. Правильно создавать матрицу так: [[0] * 3 for _ in range(3)] — тогда каждая строка будет отдельным списком.Какой из способов НЕ создаёт копию списка
a?b = ab = list(a)b = a[:]b = a.copy()
Присваивание
b = a не копирует данные — оно просто даёт второе имя тому же объекту, и изменения через b видны в a. Срез a[:], list(a) и a.copy() создают новый список (поверхностную копию).Что выведет этот код?
import copy
a = [[1], [2]]
b = copy.copy(a)
c = copy.deepcopy(a)
a[0].append(9)
print(b[0], c[0])- [1, 9] [1, 9]
- [1] [1, 9]
- [1] [1]
- [1, 9] [1]
copy.copy делает поверхностную копию: внешний список новый, но вложенные списки — те же объекты, поэтому b[0] видит изменение. copy.deepcopy рекурсивно копирует и вложенные объекты, поэтому c[0] остаётся [1].Что выведет этот код?
import copy
inner = [1]
a = [inner, inner]
b = copy.deepcopy(a)
b[0].append(2)
print(b[1], a[1])- [1] [1, 2]
- [1] [1]
- [1, 2] [1, 2]
- [1, 2] [1]
deepcopy ведёт словарь memo уже скопированных объектов, поэтому сохраняет структуру ссылок: a[0] и a[1] были одним объектом — и в копии b[0] и b[1] тоже один (новый) объект. Значит, b[1] видит добавленную 2, а оригинал a не затронут.Что выведет этот код?
a = b = []
a.append(1)
x = y = 0
x += 1
print(b, y)[] 0[1] 0[1] 1[] 1
Цепочка
a = b = [] создаёт один список и связывает с ним оба имени, поэтому append через a виден и через b. С числами иначе: int неизменяем, и x += 1 создаёт новый объект и перепривязывает только x, а y остаётся равным 0.Множества и кортежи9
Какие типы у выражений
(1) и (1,)?- tuple и list
- tuple и tuple
- int и tuple
- int и int
Круглые скобки сами по себе лишь группируют выражение, поэтому
(1) — это просто int. Кортеж создаёт запятая: (1,) или даже 1, — кортеж из одного элемента.Что выведет этот код?
t = (1, [2, 3])
t[1].append(4)
print(t)- (1, [2, 3])
- (1, [2, 3, 4])
- Ошибка TypeError: кортеж неизменяем
- Ошибка AttributeError
Неизменяемость кортежа означает, что нельзя заменить его элементы (ссылки), но сами объекты внутри могут быть изменяемыми.
t[1] — обычный список, и append меняет его без проблем. Из-за этого такой кортеж, кстати, нехэшируем.Что выведет этот код?
t = (1, [2])
try:
t[1] += [3]
except TypeError:
print('TypeError', t)- AttributeError (1, [2])
- TypeError (1, [2])
- TypeError (1, [2, 3])
- Ничего: операция успешна, исключения нет
t[1] += [3] выполняется в два шага: сначала list.__iadd__ расширяет список на месте (успешно), затем результат присваивается в t[1] — и это присваивание падает с TypeError. В итоге исключение есть, но список внутри кортежа уже изменён — известная ловушка.Что выведет этот код?
first, *rest = [1, 2, 3, 4]
print(first, rest)- [1] [2, 3, 4]
- 1 (2, 3, 4)
- 1 [2, 3, 4]
- 1 2
Переменная со звёздочкой при распаковке собирает «остаток» и всегда получает СПИСОК — даже если распаковывали кортеж или другой итерируемый объект.
Какие типы у
{} и set()?- dict и set
- dict и frozenset
- set и dict
- set и set
Литерал
{} создаёт пустой СЛОВАРЬ — так исторически сложилось. Пустое множество можно создать только вызовом set(); непустое — литералом {1, 2}.Что произойдёт при выполнении
s = {1, 2} и затем s.add([3, 4])?- s станет {1, 2, [3, 4]}
- Ничего: add молча проигнорирует список
- s станет {1, 2, 3, 4}
- TypeError: unhashable type: 'list'
Элементы множества (как и ключи словаря) должны быть хэшируемыми, а изменяемый
list хэша не имеет. Добавить несколько элементов можно через s.update([3, 4]), а составной элемент — как кортеж (3, 4).Что выведет этот код?
a = {1, 2, 3}
b = {2, 3, 4}
print(a - b, a ^ b)- {1, 4} {1}
- {4} {1, 4}
- {1} {1, 4}
- {1} {2, 3}
a - b — разность: элементы a, которых нет в b, то есть {1}. a ^ b — симметрическая разность: элементы, входящие ровно в одно из множеств, то есть {1, 4}. Пересечение {2, 3} дал бы оператор &.Какой объект можно использовать как ключ словаря?
{1, 2}(1, [2])[1, 2]frozenset({1, 2})
Ключ должен быть хэшируемым.
frozenset — неизменяемое множество, у него есть хэш. set и list изменяемы и нехэшируемы, а кортеж хэшируем, только если хэшируемы все его элементы — (1, [2]) содержит список.Какова средняя сложность проверки
x in s, если s — множество (set), и если s — список?- O(log n) для set, O(n) для списка
- O(1) для обоих
- O(1) для set, O(n) для списка
- O(n) для обоих
Множество — это хэш-таблица: поиск идёт по хэшу и в среднем занимает O(1). Список просматривается последовательно — O(n). Поэтому для частых проверок принадлежности большой коллекции выгодно перевести её в
set.Словари8
Что произойдёт, если ключа
'k' нет в словаре d?d['k']вернётNone, аd.get('k')броситKeyError- Оба выражения бросят
KeyError d['k']броситKeyError, аd.get('k')вернётNone- И
d['k'], иd.get('k')вернутNone
Обращение по
[] к отсутствующему ключу бросает KeyError. get возвращает значение по умолчанию — None или второй аргумент: d.get('k', 0). (Исключение — defaultdict и подклассы с __missing__.)Что верно о порядке ключей в обычном
dict в Python 3.7+?- Порядок не определён и может меняться между запусками
- Порядок вставки сохраняется только в
OrderedDict, а не вdict - Ключи всегда хранятся отсортированными
- Гарантированно сохраняется порядок вставки
Начиная с Python 3.7, сохранение порядка вставки — часть спецификации языка для
dict (в CPython 3.6 это было деталью реализации). Отсортированными ключи не бывают; OrderedDict сейчас нужен лишь ради move_to_end и сравнения с учётом порядка.Что выведет этот код?
d = {}
for word in ['a', 'b', 'a']:
d.setdefault(word, []).append(1)
print(d)- Ошибка KeyError
- {'a': None, 'b': None}
- {'a': [1], 'b': [1]}
- {'a': [1, 1], 'b': [1]}
setdefault(key, default) возвращает значение по ключу, а если ключа нет — сначала записывает default и возвращает его. Поэтому для повторного a возвращается уже существующий список, и append дописывает в него.Что выведет этот код?
d = dict.fromkeys(['x', 'y'], [])
d['x'].append(1)
print(d)- {'x': [1], 'y': []}
- Ошибка TypeError
- {'x': 1, 'y': None}
- {'x': [1], 'y': [1]}
dict.fromkeys(keys, value) присваивает всем ключам ОДИН И ТОТ ЖЕ объект value. Изменяемый список общий, поэтому изменение через x видно и через y. Для отдельных списков используйте {k: [] for k in keys} или defaultdict(list).Что выведет этот код (Python 3.9+)?
a = {'x': 1, 'y': 2}
b = {'y': 20, 'z': 30}
print(a | b)- {'x': 1, 'y': 2, 'z': 30}
- {'x': 1, 'y': 20, 'z': 30}
- Ошибка TypeError: unsupported operand
- {'y': 20, 'z': 30, 'x': 1}
Оператор
| (Python 3.9+) объединяет словари в новый; при совпадении ключей побеждает значение из правого операнда. Порядок — сначала ключи левого словаря, затем новые ключи правого. |= делает то же на месте, как update.Что выведет этот код?
d = {'a': 1}
keys = d.keys()
d['b'] = 2
print(list(keys))- ['b']
- Ошибка RuntimeError
- ['a', 'b']
- ['a']
keys(), values() и items() возвращают ПРЕДСТАВЛЕНИЯ (views), а не копии: они динамически отражают текущее состояние словаря. Нужен «снимок» — делайте list(d.keys()) сразу. Ошибки здесь нет: словарь меняется не во время итерации по нему.Что произойдёт при выполнении этого кода?
d = {'a': 1, 'b': 2}
for k in d:
if d[k] == 1:
del d[k]- RuntimeError: dictionary changed size during iteration
- Цикл не выполнится ни разу
- KeyError: 'a'
- Из словаря удалится ключ
'a', ошибок не будет
Нельзя менять размер словаря (добавлять/удалять ключи), пока по нему идёт итерация — на следующем шаге итератор бросит
RuntimeError. Итерируйтесь по копии ключей for k in list(d): или постройте новый словарь через comprehension.Что выведет этот код?
d = {1: 'a', True: 'b', 1.0: 'c'}
print(d)- {1.0: 'c'}
- {1: 'a', True: 'b', 1.0: 'c'}
- {1: 'a'}
- {1: 'c'}
1, True и 1.0 равны друг другу и имеют одинаковый хэш, поэтому для словаря это ОДИН ключ. При повторной записи значение обновляется, но сам ключ остаётся первым вставленным объектом — 1, а значение — последним, 'c'.Comprehensions7
Что вернёт
[x * x for x in range(6) if x % 2]?- [0, 4, 16]
- [1, 9, 25]
- [1, 9, 25, 49]
- [0, 1, 4, 9, 16, 25]
range(6) даёт 0..5, условие x % 2 истинно для нечётных (1, 3, 5) — их квадраты 1, 9, 25. 0 от x % 2 ложен, поэтому чётные отбрасываются; верхняя граница range не включается, так что 49 не будет.Что выведет этот код?
pairs = [(i, j) for i in range(2) for j in range(i, 2)]
print(pairs)- [(0, 0), (0, 1), (1, 1)]
- [(0, 0), (0, 1), (1, 0), (1, 1)]
- [(0, 0), (1, 0), (1, 1)]
- Ошибка NameError: i
Несколько
for в comprehension читаются слева направо, как вложенные циклы: первый for — внешний. Поэтому внутренний цикл может использовать i: для i=0 — j 0 и 1, для i=1 — только j=1.Какое выражение превращает
m = [[1, 2], [3, 4]] в [1, 2, 3, 4]?[x for row in m for x in row][[x for x in row] for row in m]list(row for row in m)[x for x in row for row in m]
Порядок
for в плоском comprehension такой же, как во вложенных циклах: сначала внешний (for row in m), потом внутренний (for x in row). Обратный порядок даст NameError (row ещё не определён), а вложенный comprehension вернёт список списков.Что выведет этот код?
gen = (x * 2 for x in range(3))
print(sum(gen), sum(gen))- 6 6
- 0 6
- 6 0
- 6, затем TypeError
Генераторное выражение ленивое и одноразовое: первый
sum вычерпывает его до конца. Второй sum получает уже исчерпанный генератор — пустую последовательность — и возвращает 0 без ошибки. Для повторного обхода нужен список.Что выведет этот код?
words = ['apple', 'kiwi', 'fig']
print({w: len(w) for w in words if len(w) > 3})- {'apple': 5, 'kiwi': 4}
- {'apple': 5, 'kiwi': 4, 'fig': 3}
- {5: 'apple', 4: 'kiwi'}
- [('apple', 5), ('kiwi', 4)]
Dict comprehension
{ключ: значение for ... if ...} строит словарь; условие отсекает fig (длина 3 не больше 3). Ключ — слово, значение — его длина, порядок — порядок обхода.Что выведет этот код?
funcs = [lambda: i for i in range(3)]
print([f() for f in funcs])- [0, 0, 0]
- [0, 1, 2]
- [2, 2, 2]
- Ошибка NameError: i
Лямбды захватывают ПЕРЕМЕННУЮ
i, а не её значение в момент создания (позднее связывание). Вызываются они после завершения цикла, когда i == 2. Чтобы зафиксировать значение, используют аргумент по умолчанию: lambda i=i: i.Что выведет этот код?
data = [1, 2, 3]
gen = (x for x in data)
data = [10, 20]
print(list(gen))- Ошибка NameError
- []
- [1, 2, 3]
- [10, 20]
В генераторном выражении итерируемый объект САМОГО ПЕРВОГО
for вычисляется сразу при создании генератора. Поэтому генератор держит ссылку на исходный список [1, 2, 3]; перепривязка имени data на него не влияет (а вот data.append(...) повлиял бы).Встроенные функции7
Что вернут
all([]) и any([])?- True и True
- False и False
- False и True
- True и False
all истинно, если нет ни одного ложного элемента — для пустой последовательности это так, поэтому True. any истинно, если найдётся хотя бы один истинный элемент — в пустой их нет, поэтому False.Что вернёт
sum([[1], [2, 3]], [])?- 6
- [1, 2, 3]
- Ошибка TypeError: нельзя суммировать списки
- [[1], [2, 3]]
Второй аргумент
sum — стартовое значение (по умолчанию 0). С [] в качестве старта списки складываются через +, получая [1, 2, 3]. Без [] было бы 0 + [1] и TypeError. Для длинных списков так делать неэффективно (квадратичная сложность) — лучше itertools.chain.Что выведет этот код?
m = map(lambda x: x + 1, [1, 2, 3])
print(list(m), list(m))- [2, 3, 4] [2, 3, 4]
- [2, 3, 4] []
- [2, 3, 4] None
- <map object ...> [2, 3, 4]
В Python 3
map (как и filter, zip) возвращает ленивый одноразовый итератор. Первый list(m) вычерпывает его полностью, второй получает пустой результат. Нужен многократный доступ — сохраните list(map(...)).Что вернут
max(words, key=len) и min(words, key=len) для words = ['pear', 'fig', 'banana']?- 6 и 3
- 'banana' и 'fig'
- 'fig' и 'banana'
- 'pear' и 'banana'
key задаёт, по какому признаку сравнивать, но возвращается сам элемент, а не значение ключа. Самое длинное слово — banana, самое короткое — fig. Без key строки сравнивались бы лексикографически.Что выведет этот код?
people = [('Ann', 30), ('Bob', 25), ('Cid', 30), ('Dan', 25)]
print([n for n, a in sorted(people, key=lambda p: p[1])])- ['Bob', 'Dan', 'Cid', 'Ann']
- ['Dan', 'Bob', 'Ann', 'Cid']
- ['Bob', 'Dan', 'Ann', 'Cid']
- ['Ann', 'Bob', 'Cid', 'Dan']
Сортировка в Python стабильна: элементы с равными ключами сохраняют исходный относительный порядок. Возраст 25 у Bob и Dan (в этом порядке), 30 — у Ann и Cid. Стабильность позволяет сортировать по нескольким признакам несколькими проходами.
Что выведет этот код?
m = [[1, 2, 3], [4, 5, 6]]
print(list(zip(*m)))- [(1, 2, 3), (4, 5, 6)]
- [(1, 4, 2, 5, 3, 6)]
- [(1, 4), (2, 5), (3, 6)]
- [[1, 4], [2, 5], [3, 6]]
zip(*m) распаковывает строки матрицы как отдельные аргументы zip, и тот собирает элементы с одинаковыми индексами — это транспонирование. zip выдаёт кортежи, а не списки.Что выведет этот код?
nums = [1, 2, 3]
print(*nums, sep="-", end="!\n")[1, 2, 3]!1 2 3-!-1-2-3!1-2-3!
*nums распаковывает список в три отдельных аргумента print(1, 2, 3). Параметр sep задаёт строку между аргументами (по умолчанию пробел), а end — что напечатать в конце (по умолчанию "\n").itertools и collections8
Что вернёт
Counter('banana').most_common(2)?- [('b', 1), ('a', 3)]
- {'a': 3, 'n': 2}
- ['a', 'n']
- [('a', 3), ('n', 2)]
Counter подсчитывает элементы итерируемого объекта, а most_common(n) возвращает СПИСОК пар (элемент, количество) по убыванию частоты. В banana три a, две n и одна b.Что выведет этот код?
from collections import defaultdict
d = defaultdict(int)
for ch in 'abca':
d[ch] += 1
print(d['a'], d['z'], len(d))- 2 0 3
- 2 0 4
- 2 None 4
- Ошибка KeyError: 'z'
defaultdict(int) при обращении к отсутствующему ключу вызывает фабрику int() (это 0) и ЗАПИСЫВАЕТ ключ в словарь. Поэтому простое чтение d['z'] добавляет четвёртый ключ, и len(d) равен 4, а не 3. Проверяйте наличие через in или get, чтобы не создавать ключи.Почему для очереди (FIFO) лучше
collections.deque, а не list?deque.popleft()работает за O(1), аlist.pop(0)— за O(n)dequeхранит элементы отсортированнымиlistне поддерживает удаление первого элементаdequeпотокобезопасна, а больше отличий нет
list — динамический массив: удаление с начала сдвигает все остальные элементы, это O(n). deque — двусторонняя очередь, добавление и удаление с обоих концов работают за O(1). Зато доступ по индексу в середину у deque медленнее.Что верно про
namedtuple?- Это обычный класс-словарь, доступ только через
p['x'] - Это изменяемая структура, аналог
dataclassпо умолчанию - Поля можно менять присваиванием:
p.x = 5 - Это подкласс
tuple: поля читаются по имени и индексу, но изменить их нельзя — для «изменения» естьp._replace(x=5)
namedtuple создаёт подкласс tuple с именованными полями: p.x и p[0] — одно и то же, распаковка работает. Он неизменяем, поэтому p.x = 5 бросит AttributeError; _replace возвращает новый экземпляр.Что выведет этот код?
from itertools import groupby
data = 'aabaa'
print([(k, len(list(g))) for k, g in groupby(data)])- [('a', 4), ('b', 1)]
- [('a', 2), ('b', 1)]
- [('a', 2), ('b', 1), ('a', 2)]
- [('b', 1), ('a', 4)]
groupby группирует только ПОДРЯД идущие одинаковые ключи — как утилита uniq. Встретив a после b, он открывает новую группу. Чтобы сгруппировать все одинаковые значения вместе, данные нужно сначала отсортировать по тому же ключу.Что выведет этот код?
from itertools import groupby
saved = [g for k, g in groupby('aabb')]
print([list(g) for g in saved])- [['a', 'a'], ['b', 'b']]
- Ошибка RuntimeError
- [[], []]
- [['a'], ['b']]
Группы, которые выдаёт
groupby, — это итераторы поверх общего исходного итератора. Когда groupby переходит к следующему ключу, предыдущая группа становится недействительной и дальше пуста. Если группы нужны позже, материализуйте их сразу: [list(g) for k, g in groupby(...)].Что выведет этот код?
from itertools import chain, islice
it = chain([1, 2], (3, 4), range(5, 8))
print(list(islice(it, 2, 5)))- Ошибка TypeError: итератор нельзя срезать
- [3, 4, 5]
- [3, 4, 5, 6]
- [2, 3, 4]
chain склеивает несколько итерируемых объектов в один поток: 1, 2, 3, 4, 5, 6, 7. islice(it, 2, 5) работает как срез [2:5] для любого итератора: элементы с индексами 2, 3, 4. Обычный срез it[2:5] для итератора действительно дал бы TypeError.Сколько элементов выдаст
itertools.product('ab', repeat=3)?- 8
- 3
- 9
- 6
product — декартово произведение, эквивалент вложенных циклов. С repeat=3 это product('ab', 'ab', 'ab'): 2 × 2 × 2 = 8 кортежей, от ('a', 'a', 'a') до ('b', 'b', 'b'). 6 было бы у перестановок permutations для трёх различных элементов.Классы и объекты7
Что выведет этот код?
class Cart:
items = []
def add(self, x):
self.items.append(x)
a = Cart()
b = Cart()
a.add(1)
b.add(2)
print(a.items)- [1]
- [2]
- []
- [1, 2]
items = [] — атрибут класса: один список на все экземпляры. self.items.append(...) не создаёт атрибут экземпляра, а изменяет общий список, поэтому a и b видят оба элемента. Изменяемые значения по умолчанию нужно создавать в __init__ (self.items = []).Что выведет этот код?
class Counter:
count = 0
a = Counter()
b = Counter()
a.count += 1
print(a.count, b.count, Counter.count)- 1 1 1
- 1 0 1
- 1 0 0
- 1 1 0
a.count += 1 — это a.count = a.count + 1: значение читается из класса (0), а результат записывается в новый атрибут экземпляра a. Атрибут класса и b.count остаются 0. В отличие от append у списка, присваивание никогда не меняет атрибут класса через экземпляр.Что такое
self в методе экземпляра?- Зарезервированное ключевое слово, которое нельзя переименовать
- Обычный первый параметр, в который Python передаёт экземпляр; имя
self— лишь соглашение - Глобальная ссылка на текущий класс, доступная в любом методе
- Неявная переменная, которую не нужно указывать в параметрах метода
Вызов
obj.method(x) превращается в Class.method(obj, x), поэтому экземпляр приходит первым позиционным аргументом. Назвать его можно как угодно (this, me), но PEP 8 требует self. В отличие от this в Java/JS, он не неявный — его обязательно объявлять в сигнатуре.Что выведет этот код?
class Base:
@classmethod
def create(cls):
return cls.__name__
@staticmethod
def helper():
return "helper"
class Child(Base):
pass
print(Child.create(), Child.helper())- Base helper
- Child helper
- Child Child
- TypeError: create() missing 1 required positional argument
@classmethod получает первым аргументом класс, через который его вызвали, — здесь Child, поэтому cls.__name__ == 'Child'. @staticmethod не получает ни класса, ни экземпляра и ведёт себя как обычная функция в пространстве имён класса. Именно поэтому фабричные методы делают classmethod: они корректно создают объекты подклассов.Что произойдёт при выполнении
Temp(-300)?class Temp:
def __init__(self, c):
self.celsius = c
@property
def celsius(self):
return self._c
@celsius.setter
def celsius(self, value):
if value < -273.15:
raise ValueError("too cold")
self._c = value
Temp(-300)- Будет выброшено
ValueError: too cold - Объект создастся,
_cбудет равен -300 AttributeError: у объекта нет атрибута_c- Объект создастся без атрибута
_c
В
__init__ написано self.celsius = c — это присваивание свойству, поэтому вызывается сеттер со всей его валидацией. Проверка срабатывает уже при создании объекта. Если бы в __init__ писали напрямую self._c = c, валидация была бы обойдена — частая ошибка.Во что Python превращает имя атрибута
self.__balance, записанного внутри класса Account?__balance— имя не меняется, просто доступ запрещён_balanceAccount.__balance_Account__balance
Это name mangling: имена вида
__x (без двух подчёркиваний в конце) внутри тела класса переписываются в _ИмяКласса__x. Настоящей приватности нет — acc._Account__balance доступен снаружи. Цель механизма — избежать случайных конфликтов имён с подклассами, а не защитить данные.Что выведет этот код?
class A:
def __init__(self):
self.__x = 1
class B(A):
def get(self):
return self.__x
print(B().get())- 1
- AttributeError: 'B' object has no attribute '__x'
- AttributeError: 'B' object has no attribute '_B__x'
- None
Name mangling выполняется по классу, в теле которого написан код: в
A.__init__ создаётся _A__x, а в B.get обращение self.__x превращается в _B__x. Такого атрибута нет, поэтому AttributeError. Именно так __x защищает от конфликтов между родителем и наследником.Наследование и MRO3
В классе
Child(Base) определён свой __init__, который не вызывает super().__init__(). Что будет с атрибутами, которые задаёт Base.__init__?- Python сначала вызовет
Base.__init__, а потомChild.__init__ - Python вызовет
Base.__init__послеChild.__init__ - Они не будут созданы — родительский
__init__автоматически не вызывается - Будет
TypeErrorпри созданииChild
В Python, в отличие от конструкторов C++/Java, переопределённый
__init__ полностью заменяет родительский. Если не вызвать super().__init__(), атрибуты базового класса не появятся, и первое обращение к ним даст AttributeError. Ошибки при создании объекта при этом нет.Что выведет этот код?
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):
pass
print(D().hi())- BA
- BCA
- BAC
- BACA
MRO класса
D — D, B, C, A, object (C3-линеаризация: общий предок A идёт после всех своих наследников). super() в B ищет следующий класс по MRO *объекта*, а это C, а не A. Поэтому A.hi вызывается ровно один раз — в этом и смысл кооперативного super() в ромбе.Что произойдёт при выполнении этого кода?
class X:
pass
class Y:
pass
class A(X, Y):
pass
class B(Y, X):
pass
class C(A, B):
passTypeError: невозможно построить согласованный MRO- Создастся класс
Cс MROC, A, B, X, Y, object - Создастся класс
Cс MROC, A, X, Y, B, object - Класс создастся, но
TypeErrorбудет при создании экземпляра
C3-линеаризация должна сохранить локальный порядок баз каждого класса:
A требует X раньше Y, а B — Y раньше X. Эти требования противоречат друг другу, поэтому Python отказывается создавать класс уже на этапе выполнения инструкции class: Cannot create a consistent method resolution order (MRO).Магические методы10
Чем
__new__ отличается от __init__?__init__создаёт объект, а__new__вызывается после него для валидации- Это синонимы: Python вызывает тот, что определён в классе
__new__вызывается один раз на класс,__init__— на каждый объект__new__создаёт и возвращает объект,__init__лишь инициализирует уже созданный
__new__ — статический метод, принимающий cls и возвращающий новый экземпляр; затем, если он вернул экземпляр этого класса, вызывается __init__(self, ...) и должен вернуть None. __new__ переопределяют для неизменяемых типов (наследники int, str, tuple) и для синглтонов. Он вызывается при каждом создании объекта, а не один раз.Что выведет этот код?
class Singleton:
_inst = None
def __new__(cls):
if cls._inst is None:
cls._inst = super().__new__(cls)
return cls._inst
def __init__(self):
print("init", end=" ")
a = Singleton()
b = Singleton()
print(a is b)- init True
- init init False
- True
- init init True
__new__ возвращает один и тот же объект, но __init__ всё равно вызывается при каждом Singleton(), потому что возвращённый объект — экземпляр этого класса. Поэтому init печатается дважды. Это классическая ловушка синглтона через __new__: повторная инициализация может затереть состояние.Что выведет этот код?
class P:
def __repr__(self):
return "P-repr"
def __str__(self):
return "P-str"
p = P()
print(p, [p], f"{p!r}")- P-str [P-str] P-repr
- P-repr [P-repr] P-repr
- P-str [P-repr] P-repr
- P-str [P-str] P-str
print(p) использует str() → __str__. Контейнеры (список) при выводе вызывают repr() для элементов, поэтому внутри списка — P-repr. !r в f-строке явно требует repr. Если __str__ не определён, str() откатывается к __repr__, но не наоборот.Класс определяет
__eq__, но не определяет __hash__. Что верно?- Python сгенерирует
__hash__на основе полей, используемых в__eq__ - Экземпляры становятся нехешируемыми: их нельзя класть в
setили использовать как ключиdict - Остаётся унаследованный от
objectхеш поid() - Класс нельзя будет создать — будет
TypeError
Определение
__eq__ без __hash__ неявно ставит __hash__ = None, и hash(obj) даёт TypeError: unhashable type. Это защита: равные объекты обязаны иметь равные хеши, а хеш по id() это правило нарушил бы. Если объект неизменяем, нужно определить __hash__ явно, например hash((self.id,)).Что выведет этот код?
class A:
pass
class B:
def __len__(self):
return 0
def __bool__(self):
return True
print(bool(A()), bool(B()))- True True
- True False
- False True
- False False
A не определяет ни __bool__, ни __len__, поэтому любой его экземпляр истинен. У B есть оба метода, и __bool__ имеет приоритет — __len__ при проверке истинности даже не вызывается. Ошибка — думать, что __len__() == 0 всегда делает объект ложным.Что выведет этот код?
class Squares:
def __getitem__(self, i):
if i >= 3:
raise IndexError
return i * i
print(list(Squares()), 4 in Squares())- [0, 1, 4] True
- TypeError: 'Squares' object is not iterable
- [0, 1, 4] False
- [] False
Если нет
__iter__, iter() использует старый протокол последовательностей: вызывает __getitem__(0), __getitem__(1), ... до IndexError. Так же работает и in при отсутствии __contains__ — перебором. Поэтому объект итерируем и 4 in Squares() находит 4.Что выведет этот код?
class Adder:
def __init__(self, n):
self.n = n
def __call__(self, x):
return x + self.n
add5 = Adder(5)
print(add5(10), callable(add5))- 15 False
- TypeError: 'Adder' object is not callable
- 5 True
- 15 True
__call__ делает экземпляр вызываемым: add5(10) — это add5.__call__(10), то есть 10 + 5. callable() возвращает True для любого объекта, у типа которого есть __call__. Так часто делают «функции с состоянием» вместо замыканий.Что должен сделать
__add__, если он не умеет складывать объект с переданным типом other?- Выбросить
NotImplementedError - Вернуть
None - Вернуть
NotImplemented, чтобы Python попробовалother.__radd__ - Вернуть
False
Синглтон
NotImplemented — сигнал интерпретатору «попробуй отражённую операцию»: для a + b Python вызовет b.__radd__(a), а если и он вернёт NotImplemented — выбросит TypeError. NotImplementedError — исключение для абстрактных методов, оно прервёт операцию сразу и не даст другой стороне шанса. None просто станет результатом сложения.Что выведет этот код?
class Money:
def __init__(self, v):
self.v = v
def __add__(self, other):
if isinstance(other, Money):
return Money(self.v + other.v)
return NotImplemented
def __radd__(self, other):
return Money(self.v + other)
print(sum([Money(1), Money(2)]).v)- TypeError: unsupported operand type(s) for +: 'int' and 'Money'
- 3
- TypeError: unsupported operand type(s) for +: 'Money' and 'Money'
- 1
sum() начинает с 0, поэтому первым считается 0 + Money(1): int.__add__ возвращает NotImplemented, и Python вызывает Money(1).__radd__(0) → Money(1). Дальше Money(1) + Money(2) идёт через __add__ → Money(3). Без __radd__ здесь был бы TypeError.Что даёт объявление
__slots__ = ("x", "y") в классе?- Атрибуты
xиyстановятся приватными - Экземпляры не получают
__dict__: экономится память, а присвоить атрибут вне списка нельзя - Атрибуты
xиyстановятся неизменяемыми после__init__ - Python проверяет типы значений, присваиваемых
xиy
Вместо словаря атрибутов создаются компактные дескрипторы-слоты, поэтому объекты занимают меньше памяти и доступ чуть быстрее. Побочный эффект —
obj.z = 1 даёт AttributeError. Ни приватности, ни неизменяемости, ни проверки типов __slots__ не даёт.Dataclasses и ABC5
Как правильно объявить в
@dataclass поле-список, чтобы у каждого экземпляра был свой список?tags: list = field(default_factory=list)tags: list = []tags: list = list()tags: list = Noneи больше ничего
dataclass запрещает изменяемые значения по умолчанию list, dict, set — tags: list = [] даёт ValueError: mutable default ... use default_factory уже при объявлении класса. list() тоже вычисляется один раз, а default_factory вызывается при создании каждого объекта. Вариант с None возможен, но тогда список нужно создавать самому в __post_init__.Что выведет этот код?
from dataclasses import dataclass, field
@dataclass
class Order:
id: int
tags: list = field(default_factory=list)
a = Order(1)
b = Order(1)
a.tags.append("x")
print(a == b, b.tags)- True []
- False ['x']
- True ['x']
- False []
default_factory=list создаёт новый список для каждого объекта, поэтому b.tags остаётся пустым. Сгенерированный __eq__ сравнивает все поля как кортеж: (1, ['x']) != (1, []), отсюда False.Что произойдёт при выполнении этого кода?
from dataclasses import dataclass
@dataclass(frozen=True)
class Point:
x: int
y: int
p = Point(1, 2)
print(hash(p) == hash(Point(1, 2)))
p.x = 10- Сразу
TypeError: unhashable type: 'Point' - Выведется
True,p.xстанет 10 - Выведется
True, затем будетFrozenInstanceError - Выведется
False, затем будетFrozenInstanceError
frozen=True вместе с eq=True (по умолчанию) генерирует __hash__ по полям, поэтому равные точки имеют равные хеши. Присваивание полю замороженного dataclass запрещено переопределённым __setattr__ и даёт dataclasses.FrozenInstanceError. Без frozen обычный @dataclass как раз был бы нехешируемым.Что выведет этот код?
from dataclasses import dataclass, field
@dataclass(order=True)
class Version:
major: int
minor: int
label: str = field(default="", compare=False)
vs = [Version(1, 10, "b"), Version(1, 2, "a"), Version(0, 99, "c")]
print([v.label for v in sorted(vs)])- ['a', 'b', 'c']
- ['c', 'b', 'a']
- ['c', 'a', 'b']
- TypeError: '<' not supported between instances of 'Version' and 'Version'
order=True генерирует <, > и т. д., сравнивая поля как кортеж в порядке объявления: (major, minor). Поле с compare=False не участвует. Получаем (0, 99) < (1, 2) < (1, 10) — числа сравниваются численно, а не как строки. Без order=True был бы TypeError.Класс
Square наследует Shape(ABC) с методом area, помеченным @abstractmethod, но не реализует его. Что произойдёт?- Ошибка возникнет при объявлении класса
Square Square(2)выброситTypeError: Can't instantiate abstract class ...- Объект создастся, а
NotImplementedErrorбудет при вызовеarea() - Объект создастся,
area()вернётNone
Проверка абстрактных методов выполняется в момент создания экземпляра: пока в классе остаются нереализованные
@abstractmethod, ABCMeta запрещает инстанцирование. Само объявление подкласса допустимо — он просто тоже остаётся абстрактным. NotImplementedError — это ручной подход без abc, когда ошибка всплывает лишь при вызове.Декораторы5
Когда выполняется код функции-декоратора (не обёртки), применённой через
@deco к функции на уровне модуля?- Один раз при выполнении инструкции
def, то есть обычно при импорте модуля - При каждом вызове декорированной функции
- При первом вызове декорированной функции
- Только при запуске модуля как скрипта, но не при импорте
@deco над def f — это сахар для f = deco(f), который выполняется сразу после создания функции. Поэтому print в теле декоратора срабатывает при импорте, даже если функцию ни разу не вызвали. При каждом вызове выполняется только возвращённая декоратором обёртка.Что выведет этот код?
def log(func):
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper
@log
def total(a, b):
"""Сумма"""
return a + b
print(total.__name__, total.__doc__)- total Сумма
- total None
- wrapper Сумма
- wrapper None
Декоратор вернул функцию
wrapper, и имя total теперь ссылается на неё, а у неё свои __name__ и пустой __doc__. Это ломает отладку, логи и документацию. Решение — @functools.wraps(func) над wrapper: он копирует __name__, __doc__, __qualname__, __module__ и добавляет __wrapped__.Что выведет этот код?
def bold(f):
return lambda: "<b>" + f() + "</b>"
def italic(f):
return lambda: "<i>" + f() + "</i>"
@bold
@italic
def text():
return "hi"
print(text())- <i><b>hi</b></i>
- <b>hi</b>
- <i>hi</i>
- <b><i>hi</i></b>
Декораторы применяются снизу вверх:
text = bold(italic(text)). Поэтому italic оборачивает исходную функцию, а bold — уже результат, и внешний тег — <b>. Порядок важен, например, для @staticmethod/@property вместе с собственными декораторами.Что выведет этот код?
def repeat(n):
def deco(func):
def wrapper(*args):
return [func(*args) for _ in range(n)]
return wrapper
return deco
@repeat(3)
def ping():
return "p"
print(ping())- p
- <function repeat.<locals>.deco.<locals>.wrapper>
- ['p', 'p', 'p']
- TypeError: repeat() missing 1 required positional argument
Декоратор с аргументами — это фабрика:
repeat(3) возвращает настоящий декоратор deco, который затем применяется к ping. Отсюда три уровня вложенности. Вызов ping() выполняет wrapper, который трижды вызывает исходную функцию и собирает список.Что выведет этот код?
def mark(tag):
print("make", tag, end=" ")
def deco(f):
print("wrap", tag, end=" ")
return f
return deco
@mark("A")
@mark("B")
def f():
pass- make A wrap A make B wrap B
- make A make B wrap B wrap A
- make B wrap B make A wrap A
- make B make A wrap B wrap A
Выражения декораторов вычисляются сверху вниз в момент выполнения
def: сначала mark("A"), затем mark("B"). А применяются полученные декораторы снизу вверх: f = decoA(decoB(f)), поэтому сначала wrap B, потом wrap A. Всё это происходит без единого вызова f.Замыкания2
Что выведет этот код?
funcs = [lambda: i for i in range(3)]
print([f() for f in funcs])- [2, 2, 2]
- [0, 1, 2]
- [0, 0, 0]
- NameError: name 'i' is not defined
Замыкание хранит ссылку на переменную, а не её значение на момент создания (позднее связывание). Все три лямбды читают
i при вызове, когда цикл уже закончился и i == 2. Исправление — зафиксировать значение аргументом по умолчанию: lambda i=i: i.Что выведет этот код?
def counter():
count = 0
def inc():
count += 1
return count
return inc
c = counter()
print(c())- UnboundLocalError
- 1
- 0
- NameError: name 'count' is not defined
Присваивание
count += 1 делает count локальной переменной inc на этапе компиляции, поэтому чтение перед записью даёт UnboundLocalError. Чтобы изменять переменную объемлющей функции, нужно объявить nonlocal count. Просто читать её можно и без nonlocal.Генераторы и итераторы6
Что выведет этот код?
gen = (x * 2 for x in range(3))
print(list(gen), list(gen))- [0, 2, 4] [0, 2, 4]
- [] []
- [0, 2, 4], затем StopIteration
- [0, 2, 4] []
Генераторное выражение — одноразовый итератор: первый
list() исчерпывает его. Второй list() сразу получает StopIteration и молча возвращает пустой список — исключение наружу не выходит. Если данные нужны дважды, сохраните их в список или создайте генератор заново.Что выведет этот код?
def acc():
total = 0
while True:
x = yield total
total += x
g = acc()
next(g)
print(g.send(5), g.send(10))- 0 5
- None None
- 5 15
- 5 10
next(g) доводит генератор до первого yield total (отдаёт 0). send(5) возобновляет его: выражение yield возвращает 5, total становится 5, цикл доходит до следующего yield и отдаёт 5. Затем send(10) даёт 15. send одновременно передаёт значение внутрь и возвращает следующее отданное.Что выведет этот код?
def inner():
yield 1
yield 2
return "done"
def outer():
result = yield from inner()
yield result
print(list(outer()))- [1, 2]
- [1, 2, 'done']
- [1, 2, None]
- ['done']
yield from inner() пробрасывает все значения inner наружу, а значением самого выражения становится то, что inner вернул через return (оно передаётся в StopIteration.value). Затем outer отдаёт его ещё одним yield. Сам return в генераторе значение в итерацию не добавляет.Что выведет этот код?
def gen():
yield 1
raise StopIteration
print(list(gen()))- [1]
- RuntimeError: generator raised StopIteration
- StopIteration
- [1, None]
Начиная с Python 3.7 (PEP 479)
StopIteration, вылетевший из тела генератора, превращается в RuntimeError — чтобы случайный StopIteration (например, от next() во вложенном коде) не обрывал итерацию молча. Для завершения генератора нужно писать просто return.Что выведет этот код?
class CountDown:
def __init__(self, n):
self.n = n
def __iter__(self):
return self
def __next__(self):
if self.n <= 0:
raise StopIteration
self.n -= 1
return self.n + 1
c = CountDown(3)
print(list(c), list(c))- [3, 2, 1] []
- [3, 2, 1] [3, 2, 1]
- [2, 1, 0] []
- [3, 2, 1], затем StopIteration
__iter__ возвращает self, поэтому объект — сам себе итератор и хранит состояние в self.n. Первый list(c) уменьшает n до 0, второй сразу получает StopIteration и возвращает []. Чтобы объект перебирался многократно, __iter__ должен каждый раз возвращать новый итератор (например, быть генератором).Что выведет этот код?
it = iter([1])
print(next(it), next(it, "end"))1 None1 1- Исключение
StopIterationна втором вызовеnext 1 end
next() берёт следующий элемент итератора. Когда элементы закончились, без второго аргумента он бросает StopIteration, а со вторым — возвращает это значение по умолчанию. Это удобно для поиска первого подходящего элемента: next((x for x in xs if x > 0), None).Контекстные менеджеры5
Что окажется в переменной
r в конструкции with CM() as r:?- Всегда сам объект
CM() - Значение, которое вернёт
__exit__ None, если__enter__ничего не вернул, иначе объектCM()- Значение, которое вернул
CM().__enter__()
as связывает результат __enter__, а не сам менеджер. Например, open() возвращает из __enter__ self, поэтому кажется, что это «тот же объект», но у threading.Lock или decimal.localcontext значения другие. Если __enter__ ничего не вернул, в r будет None.Какие аргументы получает
__exit__, если блок with завершился без исключения?- Ни одного —
__exit__вызывается без аргументов __exit__в этом случае не вызываетсяNone, None, NoneFalse, None, None
__exit__(self, exc_type, exc_value, traceback) вызывается всегда — и при нормальном выходе, и при исключении, и при return/break из блока. Без исключения все три аргумента равны None. Поэтому сигнатура всегда должна принимать три параметра, даже если они не используются.Что выведет этот код?
class CM:
def __enter__(self):
print("enter", end=" ")
return "res"
def __exit__(self, exc_type, exc, tb):
print("exit", end=" ")
with CM() as r:
print(r, end=" ")- res enter exit
- enter exit res
- enter res exit
- enter res
with сначала вызывает __enter__ и связывает его результат с r, затем выполняет тело, а при выходе из блока — __exit__. Порядок всегда такой; __exit__ выполнится, даже если в теле будет исключение.Что выведет этот код?
class Quiet:
def __enter__(self):
return self
def __exit__(self, exc_type, exc, tb):
return True
with Quiet():
1 / 0
print("после деления")
print("дальше")- после деления дальше
- дальше
- ZeroDivisionError: division by zero
- после деления
Если
__exit__ возвращает истинное значение, исключение из блока подавляется, и выполнение продолжается после with. Но остаток блока после места ошибки уже не выполнится — после деления не печатается. Возврат None/False пропустил бы исключение дальше; именно так работает contextlib.suppress.Что выведет этот код?
from contextlib import contextmanager
@contextmanager
def opened():
print("open", end=" ")
yield
print("close", end=" ")
try:
with opened():
raise ValueError
except ValueError:
print("caught")- open caught
- open close caught
- open caught close
- caught
В
@contextmanager исключение из блока with выбрасывается внутрь генератора в точке yield. Так как yield не обёрнут в try/finally, строка close не выполняется, и исключение уходит наружу. Код очистки в таких менеджерах всегда нужно писать в finally после yield.Исключения10
Что выведет этот код?
try:
print("try", end=" ")
except Exception:
print("except", end=" ")
else:
print("else", end=" ")
finally:
print("finally")- try finally
- try finally else
- try except finally
- try else finally
Блок
else выполняется, только если в try не было исключения, и до finally. finally выполняется всегда последним. Код в else удобен тем, что его исключения не перехватываются except этого же try.Что выведет этот код?
def f():
try:
return "try"
finally:
return "finally"
print(f())- try
- try finally
- SyntaxError
- finally
finally выполняется после того, как return "try" вычислил значение, но до фактического выхода из функции. return в finally заменяет это значение (и даже проглатывает активное исключение). Поэтому return внутри finally считается плохой практикой, а в Python 3.14 он даёт SyntaxWarning.Чем
raise ValueError(...) from e внутри except отличается от просто raise ValueError(...)?- Без
fromисходное исключениеeполностью теряется from eзаменяет traceback нового исключения на tracebackefrom eзаписываетeв__cause__(«direct cause»); безfromeпопадает только в__context__- Разницы нет,
from— устаревший синтаксис Python 2
Python всегда связывает исключение, брошенное при обработке другого, через
__context__ («During handling of the above exception...»). Явный from e ставит __cause__ = e и __suppress_context__ = True, и в трейсбеке будет «The above exception was the direct cause...». raise X from None скрывает исходное исключение из вывода.Почему голый
except: без указания типа считается плохой практикой?- Это синтаксическая ошибка в Python 3
- Он перехватывает всё, включая
KeyboardInterruptиSystemExit, и маскирует ошибки - Он перехватывает только
Exception, но не его подклассы - Он замедляет код, даже если исключение не возникло
except: эквивалентен except BaseException: — программа перестаёт реагировать на Ctrl+C и sys.exit(), а реальные баги (NameError, TypeError) молча проглатываются. Синтаксически это допустимо. Лучше ловить конкретные исключения или хотя бы Exception с логированием.В каком порядке нужно писать
except FileNotFoundError и except OSError в одном try?- Сначала
FileNotFoundError, потомOSError— иначе первый блок никогда не сработает - Сначала
OSError, потомFileNotFoundError - Порядок не важен: Python выбирает самое точное совпадение
- Их нельзя использовать в одном
try
Блоки
except проверяются сверху вниз, и срабатывает первый подходящий, а не самый точный. FileNotFoundError — подкласс OSError, поэтому при обратном порядке все такие ошибки попадут в except OSError. Правило: от частного к общему.Что выведет этот код?
class AppError(Exception):
pass
class DbError(AppError):
def __init__(self, table):
super().__init__(f"table {table} failed")
self.table = table
try:
raise DbError("users")
except AppError as e:
print(e, e.table)- table users failed users
- DbError users
- users users
- ('table users failed',) users
except AppError ловит и подклассы, поэтому DbError перехватывается. str(e) для исключения с одним аргументом — сам этот аргумент, переданный в super().__init__. Дополнительный атрибут table доступен как обычное поле объекта.Что происходит с инструкциями
assert при запуске python -O script.py?- Они выполняются, но выводят предупреждение вместо исключения
- Они превращаются в
ifсraise RuntimeError - Ничего не меняется —
-Oвлияет только на скорость - Они удаляются при компиляции и не выполняются
С флагом
-O __debug__ равен False, и компилятор выбрасывает все assert. Поэтому assert нельзя использовать для проверки пользовательского ввода или прав доступа — в оптимизированном режиме проверка исчезнет. Для этого нужен явный if ...: raise ValueError(...).Что выведет этот код?
e = "init"
try:
1 / 0
except ZeroDivisionError as e:
pass
print(e)- init
- division by zero
- NameError: name 'e' is not defined
- None
По окончании блока
except ... as e Python выполняет del e, чтобы разорвать цикл ссылок «исключение → traceback → кадр → исключение». Даже существовавшая до этого переменная e удаляется, и print(e) даёт NameError. Если исключение нужно позже, сохраните его в другую переменную.Что выведет этот код (Python 3.11+)?
try:
raise ExceptionGroup("batch", [ValueError(1), TypeError(2), ValueError(3)])
except* ValueError as e:
print("V", len(e.exceptions))
except* TypeError as e:
print("T", len(e.exceptions))- Только
V 2— срабатывает первый подходящий блок, как у обычногоexcept V 2, затемT 1V 1,T 1,V 1— каждый вложенный exception обрабатывается отдельно по очереди- Необработанная
ExceptionGroup:except*не ловит группы
except* разбирает ExceptionGroup по типам: каждый блок получает подгруппу из подходящих исключений, и могут сработать несколько блоков. Первый получает группу из двух ValueError, второй — из одного TypeError. Если бы какие-то исключения остались без обработчика, они были бы проброшены дальше в новой группе.Что выведет этот код?
d = {}
try:
d["user"]
except KeyError as e:
print(f"нет ключа {e}")нет ключа userнет ключа 'user'нет ключа KeyError: userнет ключа KeyError('user')
У большинства исключений
str(e) — это просто сообщение, но KeyError — особый случай: его __str__ возвращает repr ключа, поэтому строка печатается в кавычках. Так сделано, чтобы отличать, например, пустой ключ '' от отсутствия сообщения. Сам ключ можно получить через e.args[0].Асинхронность8
Что выведет этот код в stdout?
import asyncio
async def greet():
print("hello")
greet()
print("done")- hello, затем done
- Только done (а в stderr — RuntimeWarning: coroutine 'greet' was never awaited)
- done, затем hello
- Ошибка TypeError: coroutine is not callable
Вызов
greet() у async def-функции не выполняет её тело, а лишь создаёт объект корутины. Без await (или asyncio.run/create_task) он так и не запустится, поэтому hello не печатается, а при уничтожении корутины Python выдаёт предупреждение coroutine ... was never awaited.Сколько секунд (округлённо) выведет программа?
import asyncio
import time
async def work():
await asyncio.sleep(1)
async def main():
start = time.perf_counter()
await asyncio.gather(work(), work(), work())
print(round(time.perf_counter() - start))
asyncio.run(main())- 3
- 0
- 1
- 2
asyncio.gather запускает все три корутины конкурентно: пока одна ждёт asyncio.sleep(1), цикл событий переключается на другие, поэтому ожидания перекрываются и общее время ≈ 1 с. 3 секунды получилось бы при последовательных await work().Сколько секунд (округлённо) выведет программа?
import asyncio
import time
async def main():
start = time.perf_counter()
t1 = asyncio.create_task(asyncio.sleep(1))
t2 = asyncio.create_task(asyncio.sleep(1))
await t1
await t2
print(round(time.perf_counter() - start))
asyncio.run(main())- 2
- 1
- 0
- 3
asyncio.create_task сразу планирует корутину в цикле событий, поэтому обе задачи начинают спать одновременно. await t1 ждёт ~1 с, за это время t2 тоже завершается, и await t2 возвращается мгновенно. Последовательность await не означает последовательного выполнения уже созданных задач.Сколько секунд (округлённо) выведет программа?
import asyncio
import time
async def work():
time.sleep(1)
async def main():
start = time.perf_counter()
await asyncio.gather(work(), work(), work())
print(round(time.perf_counter() - start))
asyncio.run(main())- 1
- 0
- 3
- Ошибка: time.sleep нельзя вызывать в async def
time.sleep — блокирующий вызов: он останавливает весь поток вместе с циклом событий и не отдаёт управление другим корутинам, поэтому три вызова идут друг за другом (≈ 3 с). Внутри корутин нужно использовать await asyncio.sleep(...) или выносить блокирующий код в asyncio.to_thread. Ошибки при этом нет — код просто медленный.Что делает
asyncio.run(main())?- Создаёт новый цикл событий, выполняет корутину
main()до завершения и закрывает цикл - Запускает
main()в отдельном потоке и сразу возвращает управление - Добавляет
main()в уже работающий цикл событий и не ждёт результата - Выполняет
main()синхронно, игнорируя всеawaitвнутри
asyncio.run — точка входа асинхронной программы: создаёт новый цикл событий, ждёт завершения переданной корутины, возвращает её результат и закрывает цикл. Вызывать его из уже работающего цикла нельзя (будет RuntimeError) — внутри корутин используют await или asyncio.create_task.Что выведет этот код?
import asyncio
async def worker(name):
print(name, 1)
await asyncio.sleep(0)
print(name, 2)
async def main():
await asyncio.gather(worker("a"), worker("b"))
asyncio.run(main())- a 1, a 2, b 1, b 2 (по строке на каждый print)
- a 1, b 1, a 2, b 2 (по строке на каждый print)
- b 1, b 2, a 1, a 2 (по строке на каждый print)
- a 1, b 1, b 2, a 2 (по строке на каждый print)
gather оборачивает корутины в задачи, и они стартуют в порядке передачи. Задача a печатает a 1 и на await asyncio.sleep(0) уступает управление, затем b печатает b 1 и тоже уступает; после этого цикл возобновляет a (a 2) и b (b 2). Ответ «a 1, a 2, …» был бы верен без await внутри: sleep(0) — как раз способ отдать управление циклу событий.Что выведет этот код?
async def f():
return 42
c = f()
print(type(c).__name__)
c.close()- 42
- function
- coroutine
- Task
Вызов асинхронной функции возвращает объект корутины (
coroutine), а не результат: чтобы получить 42, корутину надо дождаться через await или asyncio.run. Task получается только при явной обёртке через asyncio.create_task. c.close() здесь нужен, чтобы не было предупреждения о корутине, которую так и не дождались.Что выведет этот код?
import asyncio
async def job(n):
if n == 2:
raise ValueError("boom")
return n
async def main():
print(await asyncio.gather(job(1), job(2), return_exceptions=True))
asyncio.run(main())- [1, ValueError('boom')]
- Исключение ValueError: boom
- [1, None]
- [1]
С
return_exceptions=True gather не пробрасывает исключение, а кладёт объект исключения в список результатов на место соответствующей корутины, сохраняя порядок. Без этого флага await gather(...) выбросил бы ValueError из первой упавшей корутины.Потоки и процессы6
Нужно ускорить чисто вычислительную (CPU-bound) задачу на Python-коде за счёт нескольких ядер. Что подойдёт в стандартной сборке CPython 3.12?
threading.Thread— по потоку на ядроasyncio.gatherдля параллельного запускаconcurrent.futures.ThreadPoolExecutormultiprocessing/concurrent.futures.ProcessPoolExecutor
Из-за GIL в одном процессе CPython байт-код Python одновременно исполняет только один поток, поэтому потоки и asyncio не дают выигрыша на CPU-bound задачах. Отдельные процессы имеют собственные интерпретаторы и GIL и действительно работают параллельно на разных ядрах.
Что верно о GIL в стандартной сборке CPython 3.12?
- GIL запрещает создавать больше одного потока в процессе
- Байт-код Python одновременно исполняет только один поток, но во время блокирующего I/O GIL отпускается
- GIL делает любые операции над общими данными потокобезопасными
- GIL есть в каждом процессе multiprocessing, поэтому процессы тоже не работают параллельно
GIL (Global Interpreter Lock) — блокировка интерпретатора: потоков может быть сколько угодно, но Python-код исполняет один из них за раз. При ожидании сети, диска или
time.sleep GIL отпускается, поэтому для I/O-bound задач потоки полезны. GIL не гарантирует атомарность составных операций, а у каждого процесса он свой.Почему
counter += 1 из нескольких потоков без Lock может терять инкременты, хотя в CPython есть GIL?- GIL отключается, когда потоков больше двух
- Целые числа в Python изменяемые, и потоки портят один объект
+=— это несколько операций байт-кода (прочитать, сложить, записать), и поток может переключиться между ними- Не может: благодаря GIL
counter += 1всегда атомарен
GIL защищает внутренние структуры интерпретатора, но не делает атомарной последовательность «прочитать значение — прибавить — записать обратно». Если переключение потоков произойдёт между чтением и записью, два потока запишут одно и то же значение. Для общих счётчиков нужен
threading.Lock.Что выведет этот код?
import time
from concurrent.futures import ThreadPoolExecutor
def task(n):
time.sleep(0.1 * (3 - n))
return n
with ThreadPoolExecutor() as ex:
print(list(ex.map(task, [0, 1, 2])))- [2, 1, 0]
- [0, 1, 2]
- Порядок случайный, зависит от планировщика
- [0, 2, 1]
Executor.map возвращает результаты в порядке входных данных, независимо от того, какая задача завершилась раньше (здесь быстрее всех закончит task(2)). Получать результаты по мере готовности позволяет concurrent.futures.as_completed с submit.Зачем при использовании
multiprocessing на Windows и macOS (метод запуска spawn) оборачивать запуск процессов в if __name__ == "__main__":?- Без этого процессы будут разделять общую память с родителем
- Это ускоряет сериализацию аргументов через pickle
- Без этого дочерние процессы не смогут вернуть результат
- Дочерний процесс заново импортирует главный модуль, и без защиты он снова начнёт создавать процессы
При
spawn дочерний процесс стартует новый интерпретатор и импортирует главный модуль, чтобы найти целевую функцию. Код верхнего уровня без защиты выполнится повторно и попытается порождать процессы рекурсивно — multiprocessing в этом случае выбрасывает RuntimeError. Общую память процессы не разделяют в любом случае.Что произойдёт при запуске этого кода?
from concurrent.futures import ProcessPoolExecutor
if __name__ == "__main__":
with ProcessPoolExecutor() as ex:
future = ex.submit(lambda: 1)
print(future.result())- Выведется 1
- Выведется None
- Ошибка: lambda нельзя сериализовать через pickle для передачи в процесс
- Программа зависнет навсегда
ProcessPoolExecutor передаёт функцию и аргументы в другой процесс через pickle, а функции сериализуются по имени модуля и функции. У lambda нет имени, по которому её можно найти, поэтому future.result() выбрасывает PicklingError. С ThreadPoolExecutor такой код бы сработал, потому что потоки работают в общей памяти.Типизация8
Что выведет этот код?
def add(a: int, b: int) -> int:
return a + b
print(add("2", "3"))- 5
- 23
- TypeError: аргументы должны быть int
- Код не запустится из-за ошибки аннотаций
Аннотации типов в Python во время выполнения не проверяются: интерпретатор просто сохраняет их в
__annotations__. Строки складываются конкатенацией, получается '23'. Ошибку несоответствия типов найдёт только статический анализатор вроде mypy.Какая аннотация эквивалентна
Optional[str]?- Параметр со значением по умолчанию типа
str str | Anystr | NoneUnion[str, ...]
Optional[X] — это ровно Union[X, None], в Python 3.10+ записывается как X | None. Важно: Optional не означает «необязательный аргумент» — параметр с Optional[str] без значения по умолчанию всё равно нужно передать.Что такое mypy?
- Встроенный режим интерпретатора, который проверяет типы при каждом вызове функции
- Компилятор Python в машинный код с использованием аннотаций
- Статический анализатор, который проверяет аннотации типов, не запуская код
- Модуль стандартной библиотеки для приведения типов во время выполнения
mypy (как и pyright) анализирует исходный код и аннотации до запуска и сообщает о несоответствиях типов. Сам интерпретатор CPython аннотации не проверяет, поэтому без такого инструмента подсказки типов служат лишь документацией и подсказками для IDE.
Что выведет этот код в Python 3.12?
print(isinstance(5, int | str))- True
- False
- TypeError: isinstance() arg 2 must be a type or tuple
- SyntaxError
Начиная с Python 3.10 запись
int | str создаёт объект types.UnionType, который можно использовать и в аннотациях, и прямо в isinstance/issubclass. В более ранних версиях нужно было писать кортеж (int, str) или Union[int, str].Что выведет этот код?
from typing import TypedDict
class User(TypedDict):
name: str
age: int
u = User(name="Ann", age="x")
print(type(u).__name__, u["age"])- User x
- TypeError: age должен быть int
- User 0
- dict x
TypedDict существует только для статической проверки: во время выполнения вызов User(...) создаёт обычный dict, а типы значений не проверяются. Поэтому строка 'x' спокойно сохраняется в age; ошибку заметит только mypy/pyright.Чем отличаются аннотации
Any и object с точки зрения mypy?- Ничем,
Any— просто псевдоним дляobject - С
Anyразрешена любая операция без проверки, сobject— только то, что есть у любого объекта objectотключает проверку типов, аAnyтребует явныхisinstanceAnyможно использовать только для возвращаемых значений,object— только для аргументов
Any «выключает» проверку: значение совместимо с любым типом, и над ним можно делать что угодно (x.foo(), x + 1). object — честный супертип всего, поэтому принять можно что угодно, но использовать его можно только через методы object; для остального нужно сузить тип через isinstance. Для «какое угодно значение» безопаснее object.Что выведет этот код?
from typing import Protocol, runtime_checkable
@runtime_checkable
class Closer(Protocol):
def close(self) -> None: ...
class File:
def close(self, force):
pass
print(isinstance(File(), Closer))- False — у
closeдругая сигнатура - TypeError: File не наследуется от Closer
- True
- TypeError: Protocol нельзя использовать в isinstance
Protocol реализует структурную типизацию: наследование не нужно, важно лишь наличие членов. С @runtime_checkable isinstance проверяет только то, что у объекта есть атрибут close, — сигнатуры и типы во время выполнения не сравниваются. Несовместимость сигнатуры поймает лишь статический анализатор.Какой синтаксис объявления обобщённой (generic) функции появился в Python 3.12 (PEP 695)?
def first<T>(items: list[T]) -> T:def first[T](items: list[T]) -> T:@generic(T)надdef first(items: list[T]) -> T:def first(items: list[T]) -> T:без каких-либо объявленийT
PEP 695 добавил параметры типов в квадратных скобках после имени:
def first[T](...) и class Box[T]:. Раньше нужно было явно объявлять T = TypeVar("T"); без этого объявления T в аннотации — просто неизвестное имя. Угловые скобки, как в Java/TypeScript, в Python не используются.Модули и пакеты6
Зачем в модуле пишут
if __name__ == "__main__":?- Чтобы код внутри выполнялся только при запуске файла как скрипта, а не при его импорте
- Чтобы запретить импорт модуля из других файлов
- Чтобы код выполнялся только один раз, даже при повторных запусках
- Это обязательная точка входа, без неё скрипт не запустится
При запуске файла (
python app.py) его __name__ равен "__main__", а при импорте — имени модуля. Поэтому код под этой проверкой (запуск CLI, тесты, демо) не выполняется, когда модуль импортируют, а функции и классы остаются доступными. Обязательной эта конструкция не является.В
config.py есть строка print("loaded"), helper.py тоже делает import config. Что выведет запуск main.py?# main.py
import config
import helper
import config
print("main")- loaded, loaded, helper, loaded, main
- loaded, helper, loaded, main
- loaded, helper, main
- helper, main — print при импорте не выполняется
Модуль выполняется только при первом импорте, после чего объект модуля кешируется в
sys.modules. Все последующие import config (в любом файле программы) просто берут готовый объект из кеша, поэтому loaded печатается один раз. Для повторного выполнения нужен importlib.reload.Что произойдёт при
import a (файлы a.py и b.py лежат рядом)?# a.py
from b import g
def f():
return "f"
# b.py
from a import f
def g():
return "g"- Всё импортируется: Python сначала читает все определения в обоих файлах
- ImportError: cannot import name 'f' from partially initialized module 'a'
- RecursionError из-за бесконечного взаимного импорта
fвbполучит значение None до окончания импортаa
Модули выполняются сверху вниз.
a начинает выполняться, на первой строке импортирует b, а b пытается взять f из a, который уже есть в sys.modules, но выполнен лишь частично — f ещё не определена. Бесконечной рекурсии нет именно благодаря кешу. Лечится переносом общего кода в третий модуль, import a с обращением a.f внутри функции или отложенным импортом.Что верно про файл
__init__.py в Python 3?- Без него каталог вообще нельзя импортировать
- Он обязан содержать список
__all__ - Его код выполняется при каждом импорте любого модуля пакета заново
- Его код выполняется при первом импорте пакета; без него каталог импортируется как namespace-пакет
__init__.py делает каталог обычным пакетом, а его код выполняется один раз при первом импорте пакета (дальше работает кеш sys.modules). Начиная с Python 3.3 каталог без него тоже импортируется — как namespace-пакет (PEP 420), но для обычных проектов __init__.py по-прежнему рекомендуют. __all__ необязателен.Файл
pkg/app.py содержит from . import utils. Что будет при запуске python pkg/app.py из корня проекта?- Всё сработает:
.означает текущий каталог - ImportError: attempted relative import with no known parent package
- ModuleNotFoundError: No module named 'pkg'
- Импорт сработает, только если в
pkgнет__init__.py
Относительный импорт отсчитывается от пакета модуля (
__package__), а не от каталога файла. При запуске файла как скрипта он становится модулем __main__ без родительского пакета, поэтому . не к чему привязать. Правильно запускать как модуль: python -m pkg.app.Свой скрипт назвали
random.py. Что произойдёт при python random.py?# random.py
import random
print(random.randint(1, 6))- Выведется случайное число от 1 до 6
- ModuleNotFoundError: No module named 'random'
- AttributeError: partially initialized module 'random' has no attribute 'randint'
- RecursionError: скрипт бесконечно импортирует сам себя
Каталог запускаемого скрипта стоит первым в
sys.path, поэтому import random находит не стандартный модуль, а этот же файл и начинает выполнять его как модуль random. Внутри повторный import random берёт из sys.modules недоинициализированный модуль, где randint нет. Рекурсии нет благодаря кешу; решение — не называть свои файлы как модули стандартной библиотеки.Стандартная библиотека9
Что выведет этот код?
import json
data = {"point": (1, 2)}
print(json.loads(json.dumps(data)))- {'point': (1, 2)}
- {'point': [1, 2]}
- TypeError: Object of type tuple is not JSON serializable
- {'point': '(1, 2)'}
В JSON нет кортежей, поэтому
json.dumps сериализует tuple как массив, а json.loads превращает массив обратно в list. Кортеж «теряется» при круговой сериализации, ошибки же нет — tuple входит в список поддерживаемых типов.Что выведет этот код?
import json
d = {1: "a"}
restored = json.loads(json.dumps(d))
print(restored == d, restored)- True {1: 'a'}
- TypeError: keys must be str
- False {'1': 'a'}
- True {'1': 'a'}
Ключи объектов JSON всегда строки, поэтому
json.dumps приводит ключи int/float/bool/None к строкам. После loads ключ становится '1', а {'1': 'a'} != {1: 'a'}. TypeError возникает только для ключей неподдерживаемых типов, например кортежей.Что произойдёт при выполнении этого кода?
from datetime import datetime, timezone
a = datetime.now()
b = datetime.now(timezone.utc)
print(a - b)- Выведется разница во времени, равная смещению локального пояса
- Выведется 0:00:00 (с точностью до микросекунд)
- Выведется отрицательный timedelta
- TypeError: can't subtract offset-naive and offset-aware datetimes
datetime.now() возвращает «наивный» объект без часового пояса, а datetime.now(timezone.utc) — «осведомлённый» (aware) с tzinfo. Сравнивать по < и вычитать naive и aware нельзя — Python не знает, в каком поясе наивное время. Лучше везде работать с aware-датами в UTC.Что выведет этот код?
from pathlib import PurePosixPath
p = PurePosixPath("/var/log") / "app" / "error.log"
print(p.name, p.suffix, p.parent)- error.log .log /var/log/app
- error .log /var/log
- error.log log /var/log/app
- TypeError: unsupported operand type(s) for /
Объекты
pathlib перегружают оператор / для склеивания путей. name — последний компонент целиком, suffix — расширение вместе с точкой, parent — путь без последнего компонента. Имя без расширения дал бы атрибут stem.Что выведет этот код?
from functools import lru_cache
calls = []
@lru_cache(maxsize=None)
def square(n):
calls.append(n)
return n * n
for n in (2, 3, 2):
square(n)
print(len(calls), square.cache_info().hits)- 3 0
- 2 1
- 3 1
- 2 0
lru_cache запоминает результат для каждого набора аргументов: square(2) и square(3) выполняют тело функции (в calls два элемента), а повторный square(2) берёт результат из кеша — это одно попадание (hits = 1). Побочные эффекты кешированной функции при попадании в кеш не повторяются.Что выведет этот код?
from functools import lru_cache
@lru_cache
def total(items):
return sum(items)
print(total((1, 2)))
print(total([1, 2]))- 3, затем 3
- 3, затем TypeError: unhashable type: 'list'
- TypeError уже на первом вызове
- 3, затем 3 — список автоматически приводится к кортежу
lru_cache строит ключ кеша из аргументов, поэтому они должны быть хешируемыми. Кортеж хешируется, а список — нет, и вызов с ним падает с TypeError ещё до выполнения функции. Автоматического преобразования в кортеж нет.Что выведет этот код?
from functools import partial
def power(base, exp):
return base ** exp
f = partial(power, 2)
print(f(10))- 100
- 1024
- TypeError: power() missing 1 required argument
- 1000
partial(power, 2) фиксирует первый позиционный аргумент, то есть base=2. Вызов f(10) превращается в power(2, 10) = 2**10 = 1024. Чтобы получить квадрат или куб, нужно зафиксировать именованный аргумент: partial(power, exp=2).Что выведет этот код?
import re
s = "<b>bold</b>"
print(re.findall(r"<.*>", s))
print(re.findall(r"<.*?>", s))- ['<b>', '</b>'], затем ['<b>bold</b>']
- ['<b>', '</b>'], затем ['<b>', '</b>']
- ['<b>bold</b>'], затем ['<b>', '</b>']
- ['<b>bold</b>'], затем ['<b>bold</b>']
Квантификатор
* жадный: .* захватывает как можно больше символов, поэтому совпадение тянется до последнего > в строке. *? — ленивый вариант: он берёт минимум символов и останавливается на первом подходящем >, поэтому находятся отдельные теги.Что выведет этот код (в stderr), если логирование нигде не настраивалось?
import logging
logging.debug("debug")
logging.info("info")
logging.warning("warn")
logging.error("err")- WARNING:root:warn и ERROR:root:err
- Все четыре сообщения
- INFO:root:info, WARNING:root:warn и ERROR:root:err
- Ничего — без basicConfig логирование выключено
По умолчанию корневой логгер имеет уровень
WARNING, поэтому debug и info отбрасываются. Функции logging.warning() и т. п. при отсутствии обработчиков сами вызывают basicConfig() с форматом УРОВЕНЬ:имя_логгера:сообщение. Чтобы видеть info, нужно logging.basicConfig(level=logging.INFO).Инструменты и окружение6
Зачем нужно виртуальное окружение (
python -m venv .venv)?- Чтобы запускать Python-код в изолированной виртуальной машине
- Чтобы у проекта были свои пакеты и версии, не конфликтующие с другими проектами и системным Python
- Чтобы ускорить выполнение кода за счёт предкомпиляции
- Чтобы установить другую версию самого интерпретатора Python
venv создаёт каталог со своим
site-packages и ссылкой на существующий интерпретатор: pip install после активации ставит пакеты только туда. Это изолирует зависимости проектов друг от друга. Другую версию Python venv не устанавливает — он использует тот интерпретатор, которым создан.Чем lock-файл (например,
poetry.lock, uv.lock) отличается от типичного requirements.txt с прямыми зависимостями?- Lock-файл содержит только пакеты для разработки
- Lock-файл нужен только для публикации пакета на PyPI
- Ничем, это одно и то же в разных форматах
- Lock-файл фиксирует точные версии всех зависимостей, включая транзитивные (часто с хешами)
Lock-файл описывает полное разрешённое дерево зависимостей с точными версиями (и обычно хешами), поэтому установка воспроизводима на любой машине. В
requirements.txt часто перечисляют только прямые зависимости с диапазонами версий, и транзитивные пакеты могут поменяться между установками.Для чего используется файл
pyproject.toml?- Это замена
requirements.txt, используемая только pip - Единое место для метаданных проекта, системы сборки и настроек инструментов (pytest, ruff, mypy и др.)
- Конфигурация виртуального окружения, создаваемая
python -m venv - Файл, который Python читает при каждом запуске интерпретатора
pyproject.toml стандартизирован PEP 518 (секция [build-system]) и PEP 621 (секция [project] с именем, версией и зависимостями). Многие инструменты хранят в нём настройки в секциях [tool.*]. Интерпретатор сам его не читает — его используют сборщики, установщики и линтеры.Какие имена соответствуют PEP 8?
- Класс
user_account, функцияgetUserName - Класс
USER_ACCOUNT, функцияGetUserName - Класс
UserAccount, функцияget_user_name - Класс
userAccount, функцияget-user-name
По PEP 8 классы именуются в стиле CapWords (
UserAccount), функции и переменные — snake_case, константы — UPPER_CASE. Отступ — 4 пробела. camelCase для функций — частая привычка из JavaScript/Java, но в Python это не по стандарту.Сколько тестов запустит pytest и сколько из них упадёт?
import pytest
@pytest.mark.parametrize("a, b, expected", [
(1, 2, 3),
(2, 2, 4),
(0, 0, 1),
])
def test_add(a, b, expected):
assert a + b == expected- 1 тест, он упадёт
- 3 теста, 1 упадёт
- 3 теста, все пройдут
- 1 тест, он пройдёт: проверяется только первый набор
@pytest.mark.parametrize генерирует отдельный тест для каждого набора параметров (test_add[1-2-3] и т. д.), и они проходят или падают независимо. Здесь 0 + 0 == 1 ложно, поэтому упадёт один из трёх тестов, а остальные два пройдут.Как работает такая фикстура pytest?
import pytest
@pytest.fixture
def db():
conn = connect()
yield conn
conn.close()- Соединение создаётся один раз на всю сессию тестов
conn.close()никогда не выполнится, потому что послеyieldфункция не возобновляется- Тест получит генератор, и ему нужно самому вызвать
next(db) - Для каждого теста, запросившего
db, код доyield— подготовка, послеyield— очистка
Область действия фикстуры по умолчанию —
function: она создаётся заново для каждого теста. pytest выполняет код до yield, передаёт значение в тест как аргумент db, а после теста (даже упавшего) выполняет код после yield. Для одного соединения на все тесты нужен scope="session".Django и FastAPI7
В базе 100 книг. Сколько SQL-запросов выполнит этот код Django и как это исправить?
for book in Book.objects.all():
print(book.author.name) # author = ForeignKey- 1 запрос — Django сам подгружает связанные объекты
- 101 запрос (N+1); исправляется
Book.objects.select_related("author") - 2 запроса; исправлять не нужно
- 101 запрос; исправляется только вызовом
list()перед циклом
Первый запрос получает книги, а каждое обращение к
book.author для ещё не загруженного автора делает отдельный запрос — классическая проблема N+1. select_related("author") добавляет JOIN и загружает авторов в том же запросе. list() лишь вычисляет QuerySet книг, но не подгружает авторов.Чем
prefetch_related отличается от select_related в Django ORM?select_relatedделает JOIN (для ForeignKey/OneToOne),prefetch_related— отдельный запрос и связывание в Python (подходит для ManyToMany и обратных связей)prefetch_relatedделает JOIN, аselect_related— отдельный запрос для каждой строки- Они взаимозаменяемы, отличаются только синтаксисом
select_relatedкеширует данные между HTTP-запросами, аprefetch_related— нет
select_related расширяет SQL через JOIN и работает только для связей «одно значение» (FK, OneToOne). prefetch_related выполняет отдельный запрос вида WHERE id IN (...) на каждую связь и соединяет данные в Python, поэтому годится для ManyToMany и обратных FK, где JOIN размножил бы строки.Чем отличаются команды Django
makemigrations и migrate?makemigrationsприменяет изменения к базе,migrateсоздаёт файлы миграций- Это синонимы,
makemigrations— устаревшее название makemigrationsсоздаёт файлы миграций по изменениям моделей,migrateприменяет их к базе данныхmigrateпереносит данные между базами,makemigrationsменяет модели
makemigrations сравнивает модели с состоянием, описанным в существующих миграциях, и генерирует новые файлы в каталоге migrations/ — их коммитят в репозиторий. migrate выполняет ещё не применённые миграции и отмечает их в таблице django_migrations. Перепутать порядок — частая ошибка новичков.Что вернёт FastAPI на запрос
GET /items/abc?from fastapi import FastAPI
app = FastAPI()
@app.get("/items/{item_id}")
def get_item(item_id: int):
return {"id": item_id}- 200 и
{"id": "abc"} - 500 Internal Server Error из-за ValueError
- 404 Not Found
- 422 с описанием ошибки валидации:
item_idдолжен быть целым числом
FastAPI использует аннотации параметров для валидации через Pydantic:
"abc" нельзя привести к int, поэтому функция даже не вызывается, а клиент получает 422 Unprocessable Entity с подробностями. В отличие от обычного Python, здесь аннотации действительно проверяются — это делает фреймворк, а не интерпретатор.Что делает
Depends(get_db) в этом эндпоинте FastAPI?def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
@app.get("/users")
def list_users(db: Session = Depends(get_db)):
return db.query(User).all()- Создаёт одну сессию при старте приложения и передаёт её во все запросы
- На каждый запрос вызывает
get_db, передаёт полученную сессию вdb, а после ответа выполняет код послеyield - Ожидает, что клиент передаст параметр
dbв query-строке - Вызывает
get_dbтолько еслиdbне передан явно, иначе игнорирует
Depends — механизм внедрения зависимостей: FastAPI сам вызывает зависимость для каждого запроса и подставляет результат в параметр. Для зависимостей с yield код после yield (здесь закрытие сессии) выполняется после обработки запроса. Параметр с Depends не берётся из query-строки.Почему этот эндпоинт FastAPI под нагрузкой «подвешивает» и остальные запросы, и что поможет?
import time
@app.get("/report")
async def report():
time.sleep(5) # блокирующий вызов
return {"ok": True}- FastAPI обрабатывает запросы строго по одному; поможет только увеличение числа воркеров
async defвыполняется прямо в цикле событий иtime.sleepблокирует его; сделать эндпоинт обычнымdef(он пойдёт в пул потоков) или использоватьawait asyncio.sleeptime.sleepвasync defвызывает ошибку, которую FastAPI скрывает- Нужно добавить
awaitпередtime.sleep(5)
Эндпоинты
async def FastAPI запускает прямо в цикле событий, и блокирующий вызов останавливает обработку всех запросов этого процесса. Обычные def-эндпоинты FastAPI сам выполняет в пуле потоков, поэтому блокирующий код безопаснее писать в них (или через run_in_threadpool/asyncio.to_thread). await time.sleep(5) — ошибка: time.sleep возвращает None, а не awaitable.Сколько SQL-запросов выполнит этот код Django?
qs = Book.objects.all()
print(len(qs))
print(len(qs))
print(Book.objects.all().count())- 3
- 1
- 0 — QuerySet ленивый
- 2
Создание QuerySet запросов не делает (он ленивый). Первый
len(qs) вычисляет его и кеширует результаты в объекте qs, второй len(qs) берёт данные из кеша. Book.objects.all() в последней строке — новый QuerySet, и .count() выполняет отдельный SELECT COUNT(*). Итого 2 запроса.Дескрипторы и метаклассы18
Что такое дескриптор в Python?
- Объект с методами
__get__/__set__/__delete__, лежащий в атрибуте класса и перехватывающий доступ к этому атрибуту у экземпляров - Любой атрибут экземпляра, у которого есть геттер и сеттер
- Специальный словарь
__dict__, в котором класс хранит методы - Декоратор, который делает атрибут доступным только для чтения
Дескриптор работает, только когда он атрибут КЛАССА: тогда
obj.attr превращается в type(obj).__dict__['attr'].__get__(obj, type(obj)). Положенный в __dict__ экземпляра, он остаётся обычным объектом. На дескрипторах построены property, методы, classmethod и staticmethod.Что выведет этот код?
class Desc:
def __get__(self, obj, objtype=None):
return "desc"
class A:
x = Desc()
a = A()
a.__dict__["x"] = "inst"
print(a.x)- desc
- AttributeError
- None
- inst
У дескриптора есть только
__get__ — это non-data дескриптор, и запись в __dict__ экземпляра имеет над ним приоритет. Порядок поиска: data-дескриптор класса → __dict__ экземпляра → non-data дескриптор/атрибут класса. Ровно так обычный метод можно «затенить» атрибутом экземпляра.Что выведет этот код?
class Desc:
def __get__(self, obj, objtype=None):
return "desc"
def __set__(self, obj, value):
pass
class A:
x = Desc()
a = A()
a.__dict__["x"] = "inst"
print(a.x)- inst
- AttributeError
- desc
- set inst
Наличие
__set__ делает дескриптор data-дескриптором, а он имеет приоритет над __dict__ экземпляра. Значение 'inst' в словаре лежит, но при чтении a.x Python сначала находит data-дескриптор в классе и вызывает его __get__.Что выведет этот код?
class A:
@property
def x(self):
return 1
a = A()
a.__dict__["x"] = 2
print(a.x)- 2
- 1
- AttributeError: property 'x' of 'A' object has no setter
- TypeError
property — data-дескриптор, даже если сеттер не задан: у класса property всегда есть __set__ (без fset он просто бросает AttributeError). Поэтому запись прямо в __dict__ проходит, но при чтении a.x property побеждает и возвращает 1.Как устроен встроенный
property?- Это класс-дескриптор: объект хранит
fget/fset/fdelи вызывает их из своих__get__/__set__/__delete__ - Это метакласс, который генерирует геттеры и сеттеры при создании класса
- Это синтаксис интерпретатора, превращающий метод в поле экземпляра
- Это функция-обёртка, кэширующая результат метода в
__dict__экземпляра
@property заменяет функцию объектом property(fget), а @x.setter создаёт копию этого объекта с добавленным fset. Кэширует результат в __dict__ как раз functools.cached_property — это non-data дескриптор, в отличие от property.Что выведет этот код?
class Field:
def __set_name__(self, owner, name):
self.name = name
print("set_name", owner.__name__, name)
class User:
email = Field()
age = Field()
print("done")- done
- done, затем set_name User email, затем set_name User age
- set_name User email, затем done
- set_name User email, затем set_name User age, затем done
__set_name__(owner, name) вызывается автоматически сразу при создании класса — для каждого атрибута-дескриптора в порядке объявления. Так дескриптор узнаёт имя, под которым его записали, и может хранить данные в obj.__dict__[name]. Создавать экземпляры User для этого не нужно.Что выведет этот код?
class Positive:
def __set__(self, obj, value):
if value <= 0:
raise ValueError("must be > 0")
self.value = value
def __get__(self, obj, objtype=None):
return self.value
class Item:
price = Positive()
def __init__(self, price):
self.price = price
a = Item(10)
b = Item(20)
print(a.price, b.price)- 10 20
- ValueError
- 20 20
- AttributeError
Дескриптор — один объект на весь класс, поэтому
self.value = value сохраняет значение в общем дескрипторе, и второй экземпляр перезаписывает первый. Правильно хранить данные в самом экземпляре: obj.__dict__[self.name] = value (имя берут из __set_name__) или в WeakKeyDictionary.Что выведет этот код?
class A:
def f(self):
return "method"
a = A()
a.f = lambda: "instance"
print(a.f(), A.f(a))- method method
- instance method
- instance instance
- TypeError: <lambda>() takes 0 positional arguments but 1 was given
Функция в классе — non-data дескриптор:
a.f через __get__ создаёт bound method. Атрибут в __dict__ экземпляра такой дескриптор перекрывает, поэтому a.f() вызывает лямбду без self. А A.f(a) берёт функцию из класса и передаёт экземпляр явно.Что выведет этот код?
class A:
x = 1
def __getattr__(self, name):
return f"missing {name}"
a = A()
print(a.x, a.y)- 1 missing y
- missing x missing y
- 1 AttributeError
- AttributeError
__getattr__ вызывается только как запасной вариант — когда обычный поиск (__getattribute__) не нашёл атрибут. x есть в классе, поэтому возвращается 1; y нет — срабатывает __getattr__. Перехватывать ВСЕ обращения умеет __getattribute__.Что выведет этот код?
class Logged:
def __init__(self):
self.value = 1
def __getattribute__(self, name):
return self.__dict__[name]
print(Logged().value)- 1
- KeyError: 'value'
- AttributeError: 'Logged' object has no attribute '__dict__'
- RecursionError
__getattribute__ вызывается для ЛЮБОГО доступа к атрибуту, включая self.__dict__ внутри него самого — получается бесконечная рекурсия. Внутри __getattribute__ нужно обращаться к атрибутам через базовую реализацию: object.__getattribute__(self, name) или super().__getattribute__(name).Что выведет этот код?
Point = type("Point", (), {"x": 1, "show": lambda self: self.x * 10})
p = Point()
print(Point.__name__, p.show())- Point 1
- type 10
- Point 10
- TypeError: type() takes 1 or 3 arguments
type(name, bases, namespace) с тремя аргументами создаёт новый класс — ровно то же делает инструкция class. Словарь становится атрибутами класса, и лямбда в нём — обычный метод, получающий self. С одним аргументом type(obj) возвращает тип объекта.Что выведет этот код?
class Plugin:
registry = []
def __init_subclass__(cls, **kwargs):
super().__init_subclass__(**kwargs)
Plugin.registry.append(cls.__name__)
class A(Plugin):
pass
class B(A):
pass
print(Plugin.registry)- ['A']
- ['A', 'B']
- ['Plugin', 'A', 'B']
- []
__init_subclass__ вызывается при создании каждого подкласса — и прямого, и «внуков», ведь B наследует этот метод от Plugin через A. Для самого Plugin он не вызывается. Это лёгкая альтернатива метаклассу для реестров плагинов.Что выведет этот код?
class Singleton(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super().__call__(*args, **kwargs)
return cls._instances[cls]
class Config(metaclass=Singleton):
def __init__(self, name):
self.name = name
a = Config("dev")
b = Config("prod")
print(a is b, b.name)- True dev
- False prod
- True prod
- False dev
Вызов
Config(...) — это type(Config).__call__, то есть Singleton.__call__. Он создаёт объект только при первом вызове и дальше возвращает сохранённый, при этом __init__ второй раз не вызывается — поэтому имя остаётся dev. Это классическая реализация синглтона через метакласс.Что выведет этот код?
class Meta(type):
def __new__(mcls, name, bases, ns):
print("create", name)
return super().__new__(mcls, name, bases, ns)
class Base(metaclass=Meta):
pass
class Child(Base):
pass
print("end")- create Base, затем end
- end
- create Child, затем end
- create Base, затем create Child, затем end
Метакласс наследуется:
Child — подкласс Base, поэтому его тип тоже Meta, и Meta.__new__ выполняется при создании обоих классов. Происходит это в момент выполнения инструкции class, ещё до print('end'), а не при создании экземпляров.Что выведет этот код?
print(type(int), type(type))- <class 'int'> <class 'type'>
- <class 'type'> <class 'object'>
- <class 'type'> <class 'type'>
- <class 'class'> <class 'type'>
Классы — тоже объекты, и их тип — метакласс, по умолчанию
type. type является экземпляром самого себя. Не путайте с наследованием: базовый класс int — object, а тип int — type.Что произойдёт при выполнении этого кода?
class M1(type):
pass
class M2(type):
pass
class A(metaclass=M1):
pass
class B(metaclass=M2):
pass
class C(A, B):
passCполучит метаклассM1— первого базового классаTypeError: metaclass conflictпри создании классаCCполучит метаклассtype- Ошибка возникнет только при создании экземпляра
C()
Метакласс производного класса должен быть подклассом метаклассов всех баз.
M1 и M2 не связаны наследованием, поэтому Python не может выбрать и бросает TypeError прямо при выполнении class C. Решение — общий метакласс class M3(M1, M2) и class C(A, B, metaclass=M3).Что выведет этот код?
def add_repr(cls):
cls.__repr__ = lambda self: f"<{cls.__name__}>"
return cls
@add_repr
class Box:
pass
print(Box(), [Box()])- <Box> [<Box>]
- <__main__.Box object at 0x...> [<Box>]
- None [None]
- TypeError: 'NoneType' object is not callable
Декоратор класса — обычная функция, которая получает класс и возвращает (обычно его же) класс. Здесь он дописывает
__repr__; print и вывод списка используют __repr__, так как __str__ не задан и по умолчанию делегирует в __repr__.Что выведет этот код?
class Box:
def __class_getitem__(cls, item):
return f"Box of {item.__name__}"
print(Box[int])- TypeError: 'type' object is not subscriptable
- <class 'Box'>
- Box[int]
- Box of int
Box[int] на самом классе вызывает __class_getitem__ (он неявно является classmethod). Так работают list[int] и dict[str, int], возвращая types.GenericAlias. Без этого метода было бы TypeError: type 'Box' is not subscriptable; __getitem__ для этого не подходит — он работает у экземпляров.Модель данных17
Что выведет этот код?
class Key:
def __init__(self, v):
self.v = v
def __eq__(self, other):
return self.v == other.v
def __hash__(self):
return hash(self.v)
k = Key(1)
s = {k}
k.v = 2
print(k in s, Key(1) in s)- True True
- True False
- False False
- False True
Хеш объекта вычислился при добавлении в
set (от v=1). После k.v = 2 поиск k идёт в корзину hash(2) — там пусто. Key(1) попадает в нужную корзину, но сравнение с k (2 == 1) ложно. Мораль: поля, участвующие в __hash__/__eq__, не должны меняться, пока объект лежит в set/dict.Какое правило должны соблюдать
__eq__ и __hash__?- Если
hash(a) == hash(b), то обязательноa == b - Если
a == b, то обязательноhash(a) == hash(b); обратное не требуется __hash__должен возвращать уникальное число для каждого объекта__hash__должен использовать все атрибуты, которые использует__eq__, и никакие другие
dict и set сначала ищут по хешу, а потом проверяют ==, поэтому равные объекты обязаны попадать в одну корзину. Коллизии (равные хеши у неравных объектов) допустимы — они лишь замедляют поиск. В хеш можно брать подмножество полей из __eq__, но не поля, которых в __eq__ нет.Что выведет этот код?
from functools import total_ordering
@total_ordering
class Version:
def __init__(self, n):
self.n = n
def __eq__(self, other):
return self.n == other.n
def __lt__(self, other):
return self.n < other.n
print(Version(2) >= Version(1), Version(1) > Version(1))- True False
- True True
- False False
- TypeError: '>=' not supported between instances of 'Version' and 'Version'
@functools.total_ordering достраивает недостающие <=, >, >= по __eq__ и одному из методов порядка. 2 >= 1 → True, 1 > 1 → False. Без декоратора >= дал бы TypeError: Python не выводит >= из __lt__ и __eq__ сам.Что выведет этот код?
class Task:
def __init__(self, p):
self.p = p
def __lt__(self, other):
return self.p < other.p
def __repr__(self):
return f"T{self.p}"
print(sorted([Task(3), Task(1), Task(2)]))- [T3, T1, T2]
- TypeError: '<' not supported between instances of 'Task' and 'Task'
- [T3, T2, T1]
- [T1, T2, T3]
sorted() и list.sort() сравнивают элементы только оператором <, поэтому для сортировки достаточно определить __lt__. Остальные операторы сравнения для этого не нужны.Что выведет этот код?
class Task:
def __init__(self, p):
self.p = p
def __lt__(self, other):
return self.p < other.p
print(Task(2) > Task(1))
print(Task(1) <= Task(2))- TypeError на первой строке
- True, затем True
- True, затем TypeError на второй строке
- False, затем TypeError на второй строке
Для
a > b при отсутствии __gt__ Python пробует отражённую операцию b.__lt__(a) — то есть Task(1) < Task(2) → True. А <= отражается в >=, которого тоже нет, и из < Python его не выводит — TypeError. Достроить всё автоматически умеет functools.total_ordering.Что выведет этот код?
class Evens:
def __contains__(self, x):
return x % 2 == 0
print(4 in Evens(), 3 not in Evens())- True False
- True True
- TypeError: argument of type 'Evens' is not iterable
- False True
Оператор
in вызывает __contains__, а not in — тот же метод с отрицанием результата. Объекту не обязательно быть итерируемым: __contains__ может описывать бесконечное множество, как здесь все чётные числа.Что выведет этот код?
class Two:
def __index__(self):
return 2
items = ["a", "b", "c", "d"]
print(items[Two()], bin(Two()), items[:Two()])- c 0b10 ['a', 'b']
- TypeError: list indices must be integers or slices, not Two
- c 0b10 TypeError
- b 0b10 ['a']
__index__ объявляет, что объект — «настоящее целое без потерь», и тогда его можно использовать везде, где нужен индекс: в [], срезах, bin(), hex(), range(). __int__ для этого не подходит — его определяет и float, а items[2.0] запрещено.Что выведет этот код?
class Money:
def __init__(self, amount):
self.amount = amount
def __format__(self, spec):
if spec == "rub":
return f"{self.amount} ₽"
return format(self.amount, spec)
m = Money(1500)
print(f"{m:rub} | {m:,}")- 1500 ₽ | 1500
- ValueError: Invalid format specifier
- <__main__.Money object> | 1,500
- 1500 ₽ | 1,500
f-строка
{m:spec} вызывает format(m, spec) → m.__format__(spec), и спецификация после двоеточия передаётся как строка. Свой __format__ может понимать собственные коды (rub), а остальное делегировать встроенному format числа — отсюда 1,500.Что верно про метод
__del__?__del__вызывается при каждом выполненииdel obj__del__гарантированно вызывается для всех объектов при завершении интерпретатора- Исключение, брошенное в
__del__, не доходит до вызывающего кода — Python лишь печатает предупреждение в stderr - Объекты в циклических ссылках с
__del__никогда не удаляются сборщиком мусора
del obj удаляет лишь имя; __del__ срабатывает, когда объект реально уничтожается, и его ошибки игнорируются с выводом Exception ignored in .... При выходе из интерпретатора вызов не гарантирован. Циклы с __del__ с Python 3.4 (PEP 442) собираются нормально. Для освобождения ресурсов надёжнее with или weakref.finalize.Что выведет этот код?
class P:
__slots__ = ("x",)
class Q(P):
pass
q = Q()
q.y = 1
print(q.y, hasattr(P(), "__dict__"))- AttributeError: 'Q' object has no attribute 'y'
- 1 False
- 1 True
- AttributeError: 'P' object has no attribute '__dict__'
__slots__ действует только в классе, где объявлен. Подкласс без своих __slots__ снова получает __dict__, поэтому q.y = 1 работает — и экономия памяти теряется. У экземпляра P словаря нет, hasattr возвращает False. В подклассе тоже надо писать __slots__ = () или новые имена.Что выведет этот код?
class Frozen:
def __init__(self, x):
object.__setattr__(self, "x", x)
def __setattr__(self, name, value):
raise AttributeError(f"{name} is read-only")
f = Frozen(1)
try:
f.x = 2
except AttributeError as e:
print(f.x, e)- 1 x is read-only
- 2 x is read-only
- RecursionError
- AttributeError: x is read-only
__setattr__ перехватывает КАЖДОЕ присваивание атрибута, включая присваивания в __init__. Поэтому в конструкторе значение записывают в обход перехватчика — через object.__setattr__(self, 'x', x). Попытка f.x = 2 попадает в __setattr__, исключение перехватывается, а значение остаётся прежним.Что выведет этот код?
class Seq:
def __getitem__(self, key):
return key
s = Seq()
print(s[1], s[1:3], s[::2, 0])- 1 [1, 2] TypeError
- 1 (1, 3) (None, None, 2, 0)
- TypeError: 'Seq' object is not subscriptable
- 1 slice(1, 3, None) (slice(None, None, 2), 0)
__getitem__ получает «сырой» ключ: срез 1:3 передаётся объектом slice(1, 3, None), а запятая в скобках создаёт кортеж. Так NumPy реализует многомерную индексацию a[::2, 0]. Разбирать slice объект должен сам, например через key.indices(len(self)).Что выведет этот код?
class Vec:
def __init__(self, x):
self.x = x
def __add__(self, other):
return Vec(self.x + other.x)
a = Vec(1)
b = a
a += Vec(2)
print(a.x, b.x, a is b)- 3 3 True
- 3 1 True
- 3 1 False
- TypeError: unsupported operand type(s) for +=: 'Vec' and 'Vec'
Если у класса нет
__iadd__, оператор += откатывается к a = a + b через __add__, создавая новый объект и перепривязывая имя a. b по-прежнему указывает на старый объект. Изменение «на месте» происходит, только если __iadd__ определён и возвращает self (как у list).Что выведет этот код?
class Defaults(dict):
def __missing__(self, key):
return key.upper()
d = Defaults(a=1)
print(d["a"], d["b"], d.get("b"), len(d))- 1 B B 2
- 1 B None 1
- 1 B B 1
- KeyError: 'b'
__missing__ у подкласса dict вызывается из __getitem__, когда ключа нет, и его результат возвращается без сохранения в словарь (в отличие от defaultdict). Метод get() __missing__ не вызывает и возвращает None. Поэтому длина остаётся 1.Что выведет этот код?
class Weird:
def __len__(self):
return -1
print(len(Weird()))- ValueError: __len__() should return >= 0
- -1
- 0
- TypeError: 'Weird' has no len()
len() проверяет результат __len__: он должен быть целым неотрицательным числом, иначе ValueError (а для нецелого — TypeError). Возврат -1 как признак «неизвестно» не работает — для этого есть __length_hint__.Что выведет этот код?
class P:
def __init__(self, x):
self.x = x
print(P(1) == P(1), P(1) != P(1))- True False
- True True
- False False
- False True
Без своего
__eq__ объекты сравниваются по идентичности (is), а два вызова P(1) создают разные объекты. != по умолчанию инвертирует результат __eq__. Чтобы сравнивать по значению, определите __eq__ или используйте @dataclass.Какой специальный метод вызывается при выполнении
del d[key]?__del____delattr____delitem____missing__
Операции с индексом соответствуют тройке
__getitem__/__setitem__/__delitem__. __delattr__ отвечает за del obj.attr, а __del__ — финализатор, который вызывается при уничтожении объекта и к del d[key] отношения не имеет.Память и GC15
Как CPython в основном управляет памятью объектов?
- Только трассирующим сборщиком мусора, который периодически обходит всю кучу
- Подсчётом ссылок плюс отдельный циклический сборщик мусора для ссылочных циклов
- Программист сам освобождает память через
del - Только подсчётом ссылок, поэтому циклы никогда не освобождаются
Каждый объект хранит счётчик ссылок; когда он падает до нуля, объект удаляется сразу. Подсчёт ссылок не видит циклы (
a.b = b; b.a = a), поэтому модуль gc периодически ищет недостижимые циклы. del удаляет только имя, а не объект.Что выведет этот код?
a = [1, 2]
b = a
del a
print(b)- [1, 2]
- NameError: name 'b' is not defined
- None
- []
del a удаляет имя a, а не сам список: он жив, пока на него ссылается b. Объект освобождается лишь тогда, когда пропадает последняя ссылка.Что выведет этот код?
import sys
a = []
b = a
print(sys.getrefcount(a))- 2
- 1
- 4
- 3
Ссылки на список: имя
a, имя b и временная ссылка из аргумента самой getrefcount — итого 3. Поэтому sys.getrefcount всегда показывает на единицу больше, чем «видно» в коде. Значение — деталь реализации CPython.Что выведет этот код?
import gc
class Node:
pass
gc.collect()
a = Node()
b = Node()
a.other = b
b.other = a
del a, b
print(gc.collect() > 0)- False
- 0
- True
- RecursionError
После
del a, b у узлов остаются ссылки друг на друга, поэтому счётчики не падают до нуля и подсчёт ссылок их не освобождает. Это делает циклический сборщик: gc.collect() находит недостижимый цикл и возвращает число собранных объектов (> 0).Что выведет этот код?
import weakref
class Obj:
pass
o = Obj()
r = weakref.ref(o)
print(r() is o)
del o
print(r())- True, затем <__main__.Obj object at ...>
- True, затем None
- False, затем None
- True, затем ReferenceError
Слабая ссылка не увеличивает счётчик ссылок, поэтому после
del o объект уничтожается сразу (в CPython). Вызов r() возвращает объект, пока он жив, и None — после. ReferenceError бросает не weakref.ref, а прокси weakref.proxy при обращении к мёртвому объекту.Что выведет этот код?
import weakref
data = [1, 2]
r = weakref.ref(data)
print(r())- TypeError: cannot create weak reference to 'list' object
- <weakref at ...; to 'list'>
- None
- [1, 2]
Встроенные
list, dict, int, str, tuple не поддерживают слабые ссылки (у них нет слота __weakref__). Обходной путь — подкласс: class MyList(list): pass уже можно передать в weakref.ref. У классов с __slots__ нужно явно добавить '__weakref__' в слоты.Что выведет этот код?
import weakref
class Img:
pass
cache = weakref.WeakValueDictionary()
img = Img()
cache["logo"] = img
print(len(cache))
img = None
print(len(cache))- 1 1
- 0 0
- TypeError
- 1 0
WeakValueDictionary хранит значения по слабым ссылкам: как только на объект не остаётся обычных ссылок, запись исчезает сама. Это удобно для кэшей, которые не должны удерживать объекты в памяти. После img = None последняя сильная ссылка пропала — длина 0.Что верно про
id(obj) в CPython?- Он уникален за всё время работы программы и никогда не повторяется
- Это хеш содержимого объекта, поэтому у равных списков
idсовпадает - Он уникален только среди одновременно живущих объектов: после удаления объекта его
idможет получить новый объект - Он меняется, когда объект изменяется на месте, например при
append
В CPython
id — адрес объекта в памяти. Освобождённая память переиспользуется, поэтому id([1]) == id([2]) часто даёт True: первый временный список уже удалён. Сравнивать сохранённые id удалённых объектов бессмысленно; изменение объекта на месте id не меняет.Что выведет этот код?
import sys
a = "".join(["hello", " world!"])
b = "hello world!"
print(a == b, a is b, sys.intern(a) is sys.intern(b))- True True True
- True False True
- True False False
- False False True
a собрана во время выполнения — это новый объект, не интернированный, поэтому a is b ложно, хотя строки равны. sys.intern() возвращает единственный канонический экземпляр строки из таблицы интернирования, и для равных строк он один и тот же объект. Сравнивать строки нужно через ==.Что выведет этот код?
import sys
lst = [x for x in range(100_000)]
gen = (x for x in range(100_000))
print(sys.getsizeof(lst) > 100_000, sys.getsizeof(gen) < 1_000)- True True
- True False
- False True
- False False
Список хранит все 100 000 ссылок (около 800 КБ), а генератор — только своё состояние (около 200 байт) независимо от длины последовательности. Поэтому для одноразового прохода по большим данным (
sum(x for x in ...)) генератор экономит память.Что выведет этот код?
import sys
a = [0] * 3
b = [list(range(1000))] * 3
print(sys.getsizeof(a) == sys.getsizeof(b))- False
- TypeError
- Зависит от размера вложенных списков
- True
sys.getsizeof измеряет только сам объект, а не то, на что он ссылается. Оба списка содержат по 3 ссылки, поэтому их размер одинаков, хотя во втором лежит список из 1000 чисел. Для «глубокого» размера нужен рекурсивный обход (например, tracemalloc или сторонние библиотеки).Что изменится после вызова
gc.disable()?- Память перестанет освобождаться вообще, пока не вызвать
gc.enable() - Перестанут работать слабые ссылки
- Объекты без циклических ссылок по-прежнему освобождаются сразу через подсчёт ссылок; не будут автоматически собираться только циклы
- Ничего:
gc.disable()отключает только вывод отладочной статистики
Модуль
gc управляет только циклическим сборщиком. Подсчёт ссылок встроен в интерпретатор и не отключается. Иногда gc.disable() используют в коде без циклов ради производительности; ручной gc.collect() при этом продолжает работать.Что выведет этот код в CPython?
class R:
def __del__(self):
print("del")
r = R()
r2 = r
del r
print("A")
del r2
print("B")- A, затем B, затем del
- A, затем del, затем B
- del, затем A, затем B
- A, затем B
del r убирает одно из двух имён — счётчик ссылок падает с 2 до 1, объект жив. После del r2 счётчик становится 0, и в CPython __del__ вызывается немедленно, до print('B'). В PyPy и других реализациях момент вызова не гарантирован.Что выведет этот код?
import gc
class Node:
def __del__(self):
print("del", self.name)
gc.disable()
a = Node()
a.name = "a"
a.self_ref = a
del a
print("before collect")
gc.collect()
print("after")- before collect, затем del a, затем after
- del a, затем before collect, затем after
- before collect, затем after
- before collect, затем after, затем del a
Объект ссылается сам на себя, поэтому после
del a счётчик не обнуляется и подсчёт ссылок его не удаляет. При отключённом автоматическом GC объект живёт до явного gc.collect(), который находит цикл и вызывает __del__. Со времён PEP 442 (Python 3.4) циклы с __del__ собираются нормально.Что выведет этот код?
import weakref
class Res:
pass
r = Res()
weakref.finalize(r, print, "cleanup")
print("start")
del r
print("end")- start, затем end, затем cleanup
- cleanup, затем start, затем end
- start, затем end
- start, затем cleanup, затем end
weakref.finalize(obj, func, *args) регистрирует вызов при уничтожении объекта, не удерживая его. В CPython после del r счётчик ссылок обнуляется и финализатор срабатывает сразу. В отличие от __del__, finalize гарантированно вызывается и при выходе из интерпретатора, если объект ещё жив.Pattern matching13
Что выведет этот код?
from enum import Enum
class Color(Enum):
RED = 1
GREEN = 2
match Color.GREEN:
case Color.RED:
print("red")
case Color.GREEN:
print("green")
case _:
print("other")- red
- green
- other
- SyntaxError
Имя с точкой (
Color.RED) — это value pattern: субъект сравнивается с ним через ==. А «голое» имя (case RED:) было бы capture pattern — оно ловит что угодно и присваивает значение. Поэтому константы в case берут из enum или класса через точку.Что выведет этот код?
class Point:
__match_args__ = ("x", "y")
def __init__(self, x, y):
self.x = x
self.y = y
match Point(0, 5):
case Point(0, y):
print("on Y axis at", y)
case Point(x, 0):
print("on X axis at", x)- on Y axis at 5
- on X axis at 0
- Ничего не выведет
- TypeError: Point() accepts 0 positional sub-patterns (2 given)
__match_args__ задаёт, каким атрибутам соответствуют позиционные подшаблоны: Point(0, y) значит x == 0, а y захватывается. Первый case совпадает, второй не проверяется. Без __match_args__ позиционные подшаблоны дали бы TypeError.Что выведет этот код?
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
match Point(0, 5):
case Point(0, y):
print("on Y axis at", y)- on Y axis at 5
- Ничего не выведет
- SyntaxError
- TypeError: Point() accepts 0 positional sub-patterns (2 given)
У обычного класса нет
__match_args__, поэтому Python не знает, каким атрибутам соответствуют позиционные подшаблоны, и падает во время сопоставления. Решения: добавить __match_args__, использовать @dataclass (он генерирует его сам) или писать по ключевым словам: case Point(x=0, y=y).Что выведет этот код?
from dataclasses import dataclass
@dataclass
class Order:
id: int
status: str
def describe(o):
match o:
case Order(status="paid"):
return "оплачен"
case Order(_, "new"):
return "новый"
case _:
return "?"
print(describe(Order(1, "new")), describe(Order(2, "paid")))- ? оплачен
- новый ?
- новый оплачен
- TypeError: Order() accepts 0 positional sub-patterns (2 given)
@dataclass автоматически создаёт __match_args__ = ('id', 'status'), поэтому Order(_, 'new') работает позиционно. Шаблон с ключевым словом Order(status='paid') проверяет только указанный атрибут, остальные игнорирует.Что выведет этот код?
event = {"type": "click", "x": 10, "y": 20}
match event:
case {"type": "click", "x": x}:
print("click", x)
case {"type": "click", "x": x, "y": y}:
print("click", x, y)- click 10 20
- click 10
- Ничего не выведет
- KeyError: 'y'
Mapping-шаблон требует наличия перечисленных ключей, но лишние ключи игнорирует (в отличие от sequence-шаблонов, где длина должна совпадать). Поэтому первый
case уже совпадает, а более конкретный второй не достигается. Специфичные шаблоны нужно ставить выше общих.Что выведет этот код?
match {"a": 1, "b": 2, "c": 3}:
case {"a": 1, **rest}:
print(rest)- {'b': 2, 'c': 3}
- {'a': 1, 'b': 2, 'c': 3}
- ['b', 'c']
- SyntaxError
**rest в mapping-шаблоне собирает в новый словарь все ключи, которые не перечислены явно. Сопоставленный ключ 'a' в rest не попадает. Писать **_ нельзя — это и так поведение по умолчанию (лишние ключи игнорируются).Что выведет этот код?
def classify(n):
match n:
case int(x) if x < 0:
return "neg"
case 0:
return "zero"
case int():
return "pos"
case _:
return "nan"
print(classify(-3), classify(0.0), classify(7), classify("7"))- neg nan pos pos
- neg nan pos nan
- neg zero pos pos
- neg zero pos nan
int(x) if x < 0 — class-шаблон с захватом и guard. Литерал 0 сравнивается через ==, а 0.0 == 0 истинно, поэтому 0.0 даёт zero. Шаблон int() проверяет isinstance, поэтому строка '7' до него не доходит и попадает в _.Что произойдёт при запуске этого кода?
match [1]:
case [x] | [y]:
print(x)- Выведется
1 - Выведется
None SyntaxError: альтернативы в OR-шаблоне должны связывать одинаковые именаNameError: name 'x' is not defined
В OR-шаблоне
p1 | p2 каждая альтернатива обязана захватывать один и тот же набор имён, иначе после совпадения было бы непонятно, какие переменные определены. Ошибка выявляется при компиляции, до выполнения. Правильно: case [x] | [x, _]:.Что выведет этот код?
x = 5
match x:
case 1:
print("one")
case 2:
print("two")
print("done")- MatchError, затем done
- done
- SyntaxError: no case matched
- None, затем done
Если ни один
case не совпал, match просто ничего не делает — исключения нет (в отличие от match в Rust или Scala). Чтобы обработать «всё остальное», добавляют case _:.Что выведет этот код?
match "ab":
case [a, b]:
print("seq", a, b)
case str():
print("str")- str
- seq a b
- seq ab
- TypeError
Sequence-шаблоны намеренно не совпадают со строками,
bytes и bytearray, хотя те технически последовательности, — иначе строки неожиданно разбирались бы по символам. Поэтому 'ab' проходит мимо [a, b] и попадает в str().Что выведет этот код?
match (1, 2):
case [a, b]:
print("list-like", a + b)
case (a, b):
print("tuple", a + b)- tuple 3
- Ничего не выведет
- SyntaxError
- list-like 3
В шаблонах
[a, b] и (a, b) — одно и то же: sequence-шаблон, который совпадает с любой последовательностью нужной длины, в том числе с кортежем. Скобки не проверяют тип. Чтобы различать типы, пишут case list([a, b]): или case tuple((a, b)):.Что выведет этот код?
match [1, 2, 3, 4]:
case [first, *middle, last] as whole:
print(first, middle, last, len(whole))- 1 (2, 3) 4 4
- 1 [2, 3] 4 2
- 1 [2, 3] 4 4
- 1 2 4 4
*middle собирает «середину» в список (всегда list, даже если субъект — кортеж). as whole привязывает весь сопоставленный объект к имени. В sequence-шаблоне может быть только одна звёздочка.Что выведет этот код?
for v in (1, True):
match v:
case True:
print("True-pattern", v)
case 1:
print("1-pattern", v)- True-pattern 1, затем True-pattern True
- 1-pattern 1, затем True-pattern True
- 1-pattern 1, затем 1-pattern True
- True-pattern 1, затем 1-pattern True
Литералы
True, False и None сравниваются через is, а остальные литералы — через ==. Поэтому 1 не совпадает с case True (хотя 1 == True) и уходит в case 1, а True совпадает с case True первым.Стандартная библиотека 219
Что выведет этот код?
from decimal import Decimal
print(Decimal("0.1") + Decimal("0.2"), Decimal(0.1) == Decimal("0.1"))- 0.3 False
- 0.3 True
- 0.30000000000000004 False
- 0.30000000000000004 True
Decimal из строки хранит десятичное значение точно, поэтому 0.1 + 0.2 даёт ровно 0.3. А Decimal(0.1) из float переносит двоичную погрешность: 0.1000000000000000055511151231257827.... Денежные значения нужно создавать из строк.Что выведет этот код?
from decimal import Decimal, ROUND_HALF_UP
price = Decimal("2.665")
cent = Decimal("0.01")
print(price.quantize(cent), price.quantize(cent, rounding=ROUND_HALF_UP))- 2.67 2.67
- 2.66 2.66
- 2.67 2.66
- 2.66 2.67
quantize по умолчанию использует банковское округление ROUND_HALF_EVEN: ровно половина округляется к чётной цифре, 2.665 → 2.66. С ROUND_HALF_UP половина идёт вверх → 2.67. Для чеков и бухгалтерии режим округления нужно указывать явно.Что выведет этот код?
from fractions import Fraction
print(Fraction(1, 3) + Fraction(1, 6), Fraction("0.75"))- 0.5 0.75
- 3/6 3/4
- 1/2 3/4
- 1/2 0.75
Fraction хранит точную рациональную дробь и автоматически сокращает её: 1/3 + 1/6 = 3/6 = 1/2. Из строки '0.75' получается точная 3/4; print выводит дробь в виде числитель/знаменатель.Что выведет этот код?
from enum import Enum
class Mode(Enum):
READ = 1
R = 1
WRITE = 2
print(Mode.R is Mode.READ, len(Mode), [m.name for m in Mode])- False 3 ['READ', 'R', 'WRITE']
- True 2 ['READ', 'WRITE']
- ValueError: duplicate values found
- True 3 ['READ', 'R', 'WRITE']
Член enum с уже существующим значением становится псевдонимом (alias) первого:
Mode.R is Mode.READ. Псевдонимы не считаются в len() и не выдаются при итерации. Запретить их можно декоратором @enum.unique — тогда при объявлении класса будет ValueError.Что выведет этот код?
from enum import Flag, auto
class Perm(Flag):
R = auto()
W = auto()
X = auto()
p = Perm.R | Perm.W
print(Perm.W in p, Perm.X in p, p.value)- True False 3
- True False 2
- False False 3
- TypeError: unsupported operand type(s) for |
В
Flag значения auto() — степени двойки (1, 2, 4), поэтому их можно комбинировать через |. Оператор in проверяет, входят ли биты флага в комбинацию: R | W = 3 содержит W, но не X. Обычный Enum комбинировать через | нельзя.Что выведет этот код?
from dataclasses import dataclass, field
@dataclass
class User:
name: str
password: str = field(repr=False)
session: dict = field(init=False, default_factory=dict)
print(User("ann", "secret"))- User(name='ann', password='secret', session={})
- User(name='ann')
- TypeError: User.__init__() missing 1 required positional argument: 'session'
- User(name='ann', session={})
field(repr=False) убирает поле из __repr__ (удобно для паролей), но не из __init__. field(init=False, default_factory=dict) не становится параметром конструктора, а заполняется фабрикой. Отсюда вызов с двумя аргументами и вывод без пароля.Почему
@functools.cache (или lru_cache) на методе экземпляра может привести к утечке памяти?- Кэш копирует каждый экземпляр целиком при каждом вызове
- Кэш на методах отключает сборщик мусора для класса
- Кэш живёт на уровне класса и хранит
selfв ключах, поэтому экземпляры не освобождаются, пока жив кэш - Утечки нет: при удалении объекта его записи удаляются из кэша автоматически
Декоратор оборачивает функцию класса один раз, и
self становится частью ключа кэша — это сильная ссылка. Объекты остаются в памяти, пока их не вытеснит maxsize (у cache его нет вовсе). Решения: кэш на уровне экземпляра, cached_property для вычисляемых атрибутов или кэширование функции без self.Что выведет этот код?
from functools import singledispatch
@singledispatch
def show(x):
return "obj"
@show.register
def _(x: int):
return "int"
@show.register
def _(x: list):
return "list"
print(show(True), show([1]), show("s"))- obj list obj
- int list obj
- bool list obj
- TypeError: Invalid first argument to
register()
singledispatch выбирает реализацию по типу ПЕРВОГО аргумента с учётом MRO. Для bool отдельной регистрации нет, а bool — подкласс int, поэтому срабатывает версия для int. Для str подходящей нет — вызывается базовая. Тип для register берётся из аннотации параметра.Что выведет этот код?
from functools import reduce
print(reduce(lambda acc, x: acc * 10 + x, [1, 2, 3], 0))- 123
- 6
- 321
- TypeError
reduce сворачивает последовательность слева: ((0 * 10 + 1) * 10 + 2) * 10 + 3 = 123. Третий аргумент — начальное значение аккумулятора. Без него на пустой последовательности reduce бросит TypeError.Что выведет этот код?
from operator import itemgetter
rows = [("bob", 25), ("ann", 30), ("cid", 25)]
print(sorted(rows, key=itemgetter(1, 0)))- [('ann', 30), ('bob', 25), ('cid', 25)]
- [('cid', 25), ('bob', 25), ('ann', 30)]
- TypeError: itemgetter expected 1 argument, got 2
- [('bob', 25), ('cid', 25), ('ann', 30)]
itemgetter(1, 0) возвращает функцию, которая выдаёт кортеж (row[1], row[0]): сортировка сначала по возрасту, при равенстве — по имени. Это быстрее и короче, чем lambda r: (r[1], r[0]).Что выведет этот код?
from itertools import accumulate
print(list(accumulate([3, 1, 4, 1, 5], max)),
list(accumulate([1, 2, 3], initial=10)))- [3, 4, 8, 9, 14] [11, 13, 16]
- 5 [10, 11, 13, 16]
- [3, 3, 4, 4, 5] [10, 11, 13, 16]
- [3, 3, 4, 4, 5] [11, 13, 16]
accumulate выдаёт все промежуточные результаты свёртки; функция по умолчанию — сложение, но можно передать любую, например max (бегущий максимум). initial=10 добавляет стартовое значение первым элементом результата, поэтому элементов на один больше, чем во входе.Что выведет этот код?
from itertools import pairwise
temps = [20, 22, 21, 25]
print([b - a for a, b in pairwise(temps)])- [2, 1, 4]
- [2, -1, 4]
- [22, 21, 25]
- [-2, 1, -4]
itertools.pairwise (Python 3.10+) выдаёт соседние пары (20, 22), (22, 21), (21, 25). Это замена ручному zip(xs, xs[1:]), работающая и с итераторами, а не только со списками.Что выведет этот код в Python 3.12?
from itertools import batched
print(list(batched("abcdefg", 3)))- [('a', 'b', 'c'), ('d', 'e', 'f'), ('g',)]
- [('a', 'b', 'c'), ('d', 'e', 'f')]
- ['abc', 'def', 'g']
- [('a', 'b', 'c'), ('d', 'e', 'f'), ('g', None, None)]
itertools.batched (Python 3.12+) режет итерируемое на кортежи по n элементов; последний кортеж может быть короче. Отбрасывает хвост или дополняет None другое — zip(*[iter(s)] * 3) и zip_longest соответственно.Что выведет этот код?
import heapq
h = []
for x in [5, 1, 8, 3]:
heapq.heappush(h, x)
print(h[0], heapq.nsmallest(2, [5, 1, 8, 3]), heapq.heappop(h), h[0])- 1 [1, 3] 5 1
- 5 [1, 3] 5 1
- 1 [1, 3] 1 5
- 1 [1, 3] 1 3
heapq поддерживает min-кучу в обычном списке: h[0] — всегда наименьший элемент, heappop извлекает его и восстанавливает кучу, после чего наверху оказывается следующий минимум (3). Остальной порядок элементов в списке не отсортирован. Max-кучу делают, кладя -x.Что произойдёт при выполнении этого кода?
import heapq
h = []
heapq.heappush(h, (1, {"task": "a"}))
heapq.heappush(h, (1, {"task": "b"}))- Задачи лягут в кучу в порядке добавления
- Вторая задача заменит первую, так как приоритеты равны
TypeError: '<' not supported between instances of 'dict' and 'dict'heapqсравнит словари по ключам
Кортежи сравниваются поэлементно: при равных приоритетах Python сравнивает вторые элементы — словари, а
< для них не определён. Классическое решение — добавить уникальный счётчик между приоритетом и данными: (priority, next(counter), task).Что выведет этот код?
import bisect
grades = [60, 70, 80, 90]
print(bisect.bisect_left(grades, 70), bisect.bisect_right(grades, 70),
bisect.bisect(grades, 85))- 1 1 3
- 1 2 3
- 2 2 3
- 1 2 4
bisect_left возвращает позицию ПЕРЕД равными элементами (1), bisect_right — ПОСЛЕ них (2); bisect — синоним bisect_right. 85 встал бы между 80 и 90, позиция 3. Так по отсортированному списку порогов быстро (O(log n)) находят категорию.Что выведет этот код?
from string import Template
t = Template("Привет, $name! Баланс: ${amount}₽")
print(t.safe_substitute(name="Аня"))- Привет, Аня! Баланс: ${amount}₽
- KeyError: 'amount'
- Привет, Аня! Баланс: ₽
- Привет, Аня! Баланс: None₽
safe_substitute оставляет неизвестные плейсхолдеры как есть, а substitute в такой ситуации бросает KeyError. Форма ${name} нужна, когда сразу за именем идут символы, которые могли бы стать его частью. Template удобен для шаблонов от пользователей: он не выполняет выражения, в отличие от f-строк.Что выведет этот код?
import textwrap
print(textwrap.shorten("Python is a great language", width=15,
placeholder="..."))- Python is a gr...
- Python is...
- Python is a great...
- Python is a...
textwrap.shorten сжимает пробелы и обрезает текст по границам слов так, чтобы результат вместе с placeholder уложился в width. «Python is a» (11) + «...» = 14 ≤ 15, а со словом «great» уже не влезает. Слова посередине он не режет.Что выведет этот код?
from functools import cached_property
class Report:
def __init__(self):
self.calls = 0
@cached_property
def data(self):
self.calls += 1
return [1, 2, 3]
r = Report()
r.data
r.data
del r.data
r.data
print(r.calls)132AttributeErrorнаdel r.data: у свойства нет deleter
cached_property вычисляет значение при первом обращении и кладёт его в __dict__ экземпляра под тем же именем, поэтому второе r.data берётся из кэша. del r.data удаляет запись из __dict__, и следующее обращение вычисляет значение заново. Итого функция вызвана дважды.Функциональный стиль9
Что выведет этот код?
handlers = []
for name in ["save", "load"]:
handlers.append(lambda name=name: f"run {name}")
name = "oops"
print([h() for h in handlers])- ['run oops', 'run oops']
- ['run load', 'run load']
- ['run save', 'run load']
- TypeError: <lambda>() missing 1 required positional argument: 'name'
Значение по умолчанию вычисляется в момент создания лямбды, поэтому
name=name фиксирует текущее значение переменной цикла — классический способ обойти позднее связывание замыканий. Последующие присваивания name на них не влияют. Альтернатива — functools.partial.Что выведет этот код?
def make():
x = 1
def get():
return x
x = 2
return get
print(make()())- 1
- 2
- None
- UnboundLocalError
Замыкание хранит ссылку на ячейку переменной, а не значение в момент определения функции. К моменту вызова
get() в ячейке уже 2. Это то же позднее связывание, что и у лямбд в цикле.Что выведет этот код?
nums = [1, 2, 3, 4]
evens = filter(lambda n: n % 2 == 0, nums)
nums.append(6)
print(list(evens))- [2, 4, 6]
- [2, 4]
- []
- TypeError
filter и map ленивы: они ничего не вычисляют, пока их не начнут перебирать, и читают исходный список по ходу итерации. Элемент 6 добавлен до list(evens), поэтому тоже проходит фильтр. List comprehension, наоборот, вычисляется сразу.Какое выражение эквивалентно
list(map(str.upper, filter(str.isalpha, words)))?[w.upper() if w.isalpha() for w in words][w.isalpha() for w in words if w.upper()][w.upper() for w in words if w.upper().isalpha][w.upper() for w in words if w.isalpha()]
Фильтр в comprehension пишется в конце (
if ...), а преобразование — в начале. Форма x if cond for ... — синтаксическая ошибка: тернарный оператор требует else. В современном Python comprehension обычно читается легче, чем map + filter + lambda.Что выведет этот код?
print(list(map(pow, [2, 3, 4], [3, 2])))- [8, 9, 4]
- [8, 9, None]
- [8, 9]
- TypeError: pow expected 2 arguments, got 1
map с несколькими итерируемыми передаёт функции по элементу из каждого и останавливается на самом коротком — как zip. Третий элемент 4 не используется: pow(2, 3), pow(3, 2).Что выведет этот код?
from types import MappingProxyType
cfg = {"debug": False}
view = MappingProxyType(cfg)
cfg["debug"] = True
print(view["debug"])
view["debug"] = False- False, затем TypeError
- True, затем TypeError
- True, затем False
- False, затем False
MappingProxyType — неизменяемое ПРЕДСТАВЛЕНИЕ словаря, а не копия: изменения исходного cfg сразу видны через view, но записать через сам прокси нельзя (TypeError: 'mappingproxy' object does not support item assignment). Так отдают наружу конфиг только для чтения.Что выведет этот код?
def make_counter():
count = 0
def inc():
nonlocal count
count += 1
return count
def get():
return count
return inc, get
inc, get = make_counter()
inc()
inc()
print(get(), inc.__closure__[0] is get.__closure__[0])- 2 True
- 0 False
- 2 False
- 1 True
Обе вложенные функции замыкаются на ОДНУ ячейку (
cell) переменной count, что видно по __closure__. nonlocal в inc меняет содержимое этой ячейки, и get видит новое значение. Каждый вызов make_counter() создаёт новую ячейку.Что выведет этот код?
from functools import reduce
def compose(*fns):
return reduce(lambda f, g: lambda x: g(f(x)), fns)
pipeline = compose(str.strip, str.lower, len)
print(pipeline(" HeLLo "))- 8
- hello
- TypeError
- 5
reduce склеивает функции слева направо: результат — len(str.lower(str.strip(x))). ' HeLLo '.strip() → 'HeLLo', .lower() → 'hello', длина 5. Без strip получилось бы 8.Что выведет этот код?
def check(x):
print("check", x)
return x > 1
print(any(check(x) for x in [1, 2, 3]))- check 1, check 2, check 3, True
- True
- check 1, check 2, True
- check 1, True
any останавливается на первом истинном значении, а генератор вычисляет элементы по требованию, поэтому check(3) не вызывается. Со списком any([check(x) for x in ...]) сначала выполнились бы все три проверки.Найдите ошибку10
Найдите ошибку: что произойдёт при запуске?
def register(cls):
REGISTRY[cls.__name__] = cls
REGISTRY = {}
@register
class User:
pass
print(User())- Выведется
<__main__.User object at ...> TypeError: 'NoneType' object is not callable— декоратор не вернул классNameError: name 'REGISTRY' is not definedKeyError: 'User'
Декоратор обязан вернуть объект, который займёт место класса.
register ничего не возвращает, поэтому после @register имя User указывает на None. REGISTRY к моменту применения декоратора уже определён — декоратор вызывается при выполнении class, а не при определении register. Исправление: return cls.Найдите ошибку: что выведет код?
import time
from datetime import datetime
def log(msg, at=datetime.now()):
return at
a = log("a")
time.sleep(0.01)
b = log("b")
print(a == b)- True
- False
- TypeError
- Зависит от скорости машины
Значение по умолчанию вычисляется один раз — при определении функции, поэтому все вызовы получают одно и то же время. Правильно:
at=None и внутри at = at or datetime.now(). Это та же ловушка, что и с изменяемым списком по умолчанию.Найдите ошибку: что выведет код?
def read_ids():
yield from [1, 2, 3]
ids = read_ids()
if 2 in ids:
print("found", list(ids))- found [1, 2, 3]
- found []
- Ничего не выведет
- found [3]
ids — генератор, а in перебирает его до первого совпадения и «съедает» элементы 1 и 2. list(ids) получает только остаток. Если данные нужно проходить несколько раз, их сохраняют в список: ids = list(read_ids()).Найдите ошибку: что выведет код?
name = " Alice "
name.strip()
name.replace("A", "a")
print(f"[{name}]")- [alice]
- [Alice]
- [ Alice ]
- [ alice ]
Строки неизменяемы:
strip() и replace() возвращают НОВЫЕ строки, а результат здесь выбрасывается. Нужно присваивать: name = name.strip().replace('A', 'a').Найдите ошибку: что произойдёт при запуске?
class Point:
def __init__(self, x):
self.x = x
def __eq__(self, other):
return self.x == other.x
print(Point(1) == Point(1))
print(Point(1) == 1)True, затемFalseTrue, затемAttributeError: 'int' object has no attribute 'x'True, затемTypeErrorTrue, затемNotImplemented
__eq__ без проверки типа падает при сравнении с объектом другого класса. Правильно: if not isinstance(other, Point): return NotImplemented — тогда Python попробует отражённое сравнение, а затем вернёт False по идентичности. Это ломает, например, point in [1, 'a', point].Найдите ошибку: что выведет код?
parts = ["a", "b"]
print(sum(parts, ""))TypeError: sum() can't sum strings [use ''.join(seq) instead]ab['a', 'b']0ab
sum намеренно запрещает строки (квадратичная сложность конкатенации) и прямо подсказывает ''.join(seq). Для списков sum(..., []) работает, но тоже медленно — там лучше itertools.chain.from_iterable.Найдите ошибку: что произойдёт при запуске?
class Temp:
def __init__(self):
self._c = 0
@property
def celsius(self):
return self._c
@celsius.setter
def set_celsius(self, value):
self._c = value
t = Temp()
t.celsius = 10t.celsiusстанет 10RecursionErrorNameError: name 'celsius' is not definedAttributeError: property 'celsius' of 'Temp' object has no setter
@celsius.setter создаёт НОВЫЙ объект property с сеттером, и он записывается под именем функции — set_celsius. Исходное celsius осталось без сеттера. Функция-сеттер должна называться так же, как свойство: def celsius(self, value).Найдите ошибку: что выведет код?
config = {"retries": 0, "timeout": None}
retries = config.get("retries") or 3
timeout = config.get("timeout", 30)
print(retries, timeout)- 0 None
- 0 30
- 3 None
- 3 30
or подставляет значение по умолчанию для ЛЮБОГО ложного значения, включая законный 0. А get(key, default) возвращает default, только если ключа нет; ключ timeout есть со значением None. Корректно: config.get('retries', 3) и явная проверка is None.Найдите ошибку: что выведет код?
import os
os.environ["DEBUG"] = "False"
debug = bool(os.environ["DEBUG"])
print(debug)- False
- True
- None
- ValueError
bool() от непустой строки всегда True, даже от 'False' или '0'. Переменные окружения — строки, их нужно разбирать явно: os.environ.get('DEBUG', '').lower() in ('1', 'true', 'yes').Найдите ошибку: что выведет код?
items = ["a", "b", "c"]
for i in range(1, len(items)):
print(items[i], end=" ")- b c
- a b c
- a b
- IndexError
range(1, len(items)) начинается с 1, поэтому первый элемент пропускается. Индексы списков начинаются с 0; ещё лучше перебирать элементы напрямую (for item in items) или через enumerate.NumPy и pandas13
Какой будет форма (shape) результата (NumPy 2.x)?
import numpy as np
a = np.arange(3) # shape (3,)
b = np.arange(3).reshape(3, 1) # shape (3, 1)
print((a + b).shape)- (3,)
- (3, 3)
- (3, 1)
- ValueError: operands could not be broadcast together
Broadcasting выравнивает формы по правому краю:
(3,) трактуется как (1, 3), а оси размера 1 растягиваются — (1, 3) и (3, 1) дают (3, 3). Ошибка была бы, только если бы размеры осей различались и ни один не был равен 1.Что выведет этот код (NumPy 2.x)?
import numpy as np
a = np.arange(5)
b = a[1:3]
b[0] = 99
print(a)- [ 0 99 2 3 4]
- [0 1 2 3 4]
- [ 0 1 99 3 4]
- [99 1 2 3 4]
Базовый срез в NumPy возвращает представление (view) на те же данные, поэтому запись в
b меняет a. В отличие от срезов списков Python, копии здесь нет — если нужна независимая копия, пишут a[1:3].copy().Что выведет этот код (NumPy 2.x)?
import numpy as np
a = np.arange(5)
b = a[[1, 2]] # индексирование списком
b[0] = 99
c = a[a > 2] # булева маска
c[0] = 77
print(a)- [ 0 99 2 77 4]
- [ 0 99 2 3 4]
- [ 0 1 2 77 4]
- [0 1 2 3 4]
«Продвинутое» индексирование (массивом индексов или булевой маской) всегда возвращает копию, поэтому изменения
b и c не затрагивают a. Представление дают только базовые срезы вида a[1:3]. А вот присваивание прямо через такой индекс — a[a > 2] = 77 — изменило бы исходный массив.Что выведет этот код (NumPy 2.x)?
import numpy as np
a = np.array([200, 100], dtype=np.uint8)
print(a + a)- [400 200]
- [255 200]
- [144 200]
- OverflowError
Операции над массивами фиксированного dtype выполняются в этом dtype:
uint8 хранит 0..255, и 400 «заворачивается» по модулю 256 → 144, без исключения и без предупреждения. В отличие от int в Python, целые NumPy имеют ограниченную разрядность — для сумм заранее приводят тип, например a.astype(np.int64).Что выведет этот код (NumPy 2.x)?
import numpy as np
a = np.array([[1, 2, 3],
[4, 5, 6]])
print(a.sum(axis=0), a.sum(axis=1))- [ 6 15] [5 7 9]
- [5 7 9] [ 6 15]
- 21 21
- [[5 7 9]] [[ 6 15]]
axis=0 — свёртка вдоль строк (ось 0 «исчезает»), получаем сумму по каждому столбцу: [5 7 9]. axis=1 схлопывает столбцы — сумма по каждой строке: [6 15]. Без axis получилась бы общая сумма 21.Что выведет этот код (pandas 2.2)?
import pandas as pd
s = pd.Series([10, 20, 30], index=[2, 0, 1])
print(s.loc[0], s.iloc[0])- 20 10
- 10 10
- 10 20
- 20 20
loc работает по меткам индекса: метка 0 стоит у значения 20. iloc — по позиции: первый элемент 10. С целочисленным индексом путаница особенно частая, поэтому лучше всегда явно писать loc/iloc, а не s[0].Что выведет этот код (pandas 2.2)?
import pandas as pd
df = pd.DataFrame({"x": range(10, 15)}) # индекс 0..4
print(len(df.loc[1:3]), len(df.iloc[1:3]))- 2 2
- 3 3
- 2 3
- 3 2
Срез в
loc идёт по меткам и включает правую границу: метки 1, 2, 3 → 3 строки. iloc режет по позициям как обычный Python — правая граница не включается: позиции 1 и 2 → 2 строки.Что выведет этот код (pandas 2.2, Copy-on-Write не включён)?
import pandas as pd
df = pd.DataFrame({"a": [1, -2, 3], "b": [0, 0, 0]})
df[df["a"] > 0]["b"] = 1
print(df["b"].tolist())- [1, 0, 1]
- [1, 1, 1]
- [0, 0, 0] и предупреждение SettingWithCopyWarning
- KeyError: 'b'
Это цепочечное присваивание:
df[mask] с булевой маской возвращает копию, и ["b"] = 1 меняет временный объект, а не df — pandas предупреждает об этом SettingWithCopyWarning. Правильно делать одной операцией: df.loc[df["a"] > 0, "b"] = 1. В режиме Copy-on-Write (по умолчанию с pandas 3.0) цепочечное присваивание не работает никогда.Что выведет этот код (pandas 2.2)?
import pandas as pd
df = pd.DataFrame({"k": ["a", "b", "a"], "v": [1, 2, 3]})
r = df.groupby("k")["v"].agg(["sum", "count"])
print(r.loc["a"].tolist())- [1, 3]
- [4, 2]
- [4, 1]
- [6, 3]
groupby("k") собирает группы по ключу: для "a" это значения 1 и 3. agg(["sum", "count"]) даёт DataFrame с колонками sum и count, индексированный ключом группы, поэтому r.loc["a"] — это строка sum=4, count=2.Что выведет этот код (pandas 2.2)?
import pandas as pd
left = pd.DataFrame({"id": [1, 2, 3], "x": ["a", "b", "c"]})
right = pd.DataFrame({"id": [2, 3, 4], "y": ["B", "C", "D"]})
print(len(left.merge(right, on="id", how="inner")),
len(left.merge(right, on="id", how="outer")))- 2 4
- 3 4
- 2 6
- 2 3
how="inner" оставляет только совпавшие ключи (2 и 3). how="outer" берёт объединение ключей 1, 2, 3, 4, заполняя отсутствующие значения NaN. По умолчанию merge использует именно inner; how="left" дал бы 3 строки.Что выведет этот код (pandas 2.2)?
import numpy as np
import pandas as pd
s = pd.Series([1, None, 3])
print(s.mean(), s.isna().sum(), (s == np.nan).sum())- nan 1 1
- 1.3333333333333333 1 0
- 2.0 1 1
- 2.0 1 0
None в числовой Series становится NaN, а mean() по умолчанию пропускает пропуски (skipna=True): (1 + 3) / 2 = 2.0. NaN не равен ничему, даже самому себе, поэтому сравнение == np.nan всегда даёт False — пропуски ищут только через isna().Что выведет этот код (pandas 2.2)?
import pandas as pd
df = pd.DataFrame({"a": [1, None, 3]})
df = df.dropna(inplace=True)
print(df)- DataFrame из двух строк (1.0 и 3.0)
- DataFrame из трёх строк — dropna без присваивания не работает
- None
- TypeError: dropna() got an unexpected keyword argument 'inplace'
С
inplace=True метод меняет объект на месте и возвращает None, поэтому df = ... затирает DataFrame. Нужно выбрать один стиль: df.dropna(inplace=True) или df = df.dropna(); второй предпочтительнее — inplace обычно не экономит память и не ускоряет код.Почему строка
df["c"] = df.apply(lambda r: r["a"] + r["b"], axis=1) работает медленно на миллионе строк и чем её заменить?- apply выполняется в одном потоке; нужно передать parallel=True
- apply с axis=1 вызывает Python-функцию для каждой строки, создавая для неё Series; замена — векторно: df["a"] + df["b"]
- Медленная именно lambda: обычная def-функция в apply работает как векторная операция
- apply копирует весь DataFrame на каждой строке; помогает inplace=True
apply(axis=1) — по сути цикл на Python: на каждую строку создаётся объект Series и вызывается функция. Векторная операция df["a"] + df["b"] выполняется в C над целыми массивами и обычно быстрее на порядки. Параметра parallel у apply нет, а def вместо lambda ничего не меняет.Django15
Что в архитектуре MTV Django делает View (представление)?
- Принимает HttpRequest, выполняет логику (в т.ч. работу с моделями) и возвращает HttpResponse
- Отвечает только за HTML-разметку — это аналог View из MVC
- Описывает структуру таблиц базы данных
- Сопоставляет URL-адреса с обработчиками
В Django: Model — данные и работа с БД, Template — представление в виде HTML, View — обработчик запроса, ближе всего к Controller в MVC. Разметкой занимаются шаблоны, а сопоставлением URL —
urls.py (URLconf).Что произойдёт, если
Book.objects.get(author="Толстой") найдёт в базе две книги?- Вернётся первая найденная книга
- Вернётся QuerySet из двух книг
- Вернётся None
- Будет выброшено исключение Book.MultipleObjectsReturned
get() ожидает ровно одну строку: при нуле записей бросает DoesNotExist, при нескольких — MultipleObjectsReturned. Если запись может отсутствовать или их несколько, используют filter(...) (QuerySet) или filter(...).first(), который возвращает объект или None.Зачем писать
Product.objects.filter(pk=pk).update(stock=F("stock") - 1) вместо p = Product.objects.get(pk=pk); p.stock -= 1; p.save()?- F() автоматически делает SELECT ... FOR UPDATE на всё время транзакции
- Так вызывается сигнал post_save и сбрасывается кэш модели
- Вычитание выполняется в самой БД одним UPDATE, и параллельные запросы не затирают изменения друг друга
- Разницы нет, F() — просто сокращённая запись
Вариант с
get/save читает значение в Python и записывает его обратно: два одновременных запроса прочитают 10 и оба запишут 9 (lost update). F("stock") - 1 превращается в SET stock = stock - 1 и считается базой атомарно. Учтите: QuerySet.update() не вызывает save() и сигналы pre_save/post_save.Что выведет этот код (Django 5.x), если изначально
stock = 10?from django.db.models import F
p = Product.objects.get(pk=1)
p.stock = F("stock") - 1
p.save()
p.save()
p.refresh_from_db()
print(p.stock)- 9
- 8
- 10
- TypeError: нельзя присвоить F() полю модели
Выражение
F(), присвоенное полю, остаётся в атрибуте после save() и применяется при каждом следующем сохранении — значит, уменьшение произошло дважды. После такого присваивания нужно вызывать refresh_from_db() сразу после первого save(), иначе в атрибуте остаётся объект выражения, а не число.Какой запрос вернёт книги, у которых цена меньше 100 ИЛИ автор не «Иванов»?
- Book.objects.filter(Q(price__lt=100) | ~Q(author="Иванов"))
- Book.objects.filter(price__lt=100, author__ne="Иванов")
- Book.objects.filter(Q(price__lt=100) & ~Q(author="Иванов"))
- Book.objects.filter(price__lt=100).exclude(author="Иванов")
Несколько условий в
filter() и цепочка filter().exclude() объединяются через AND. Для OR нужны объекты Q и оператор |, а ~Q(...) — отрицание. Лукапа __ne в Django нет.Что получится в
r1 и r2?from django.db.models import Avg, Count
r1 = Author.objects.aggregate(Avg("age"))
r2 = Author.objects.annotate(n=Count("book"))- Оба — QuerySet авторов с дополнительными полями
- r1 — QuerySet с полем age__avg у каждого автора, r2 — словарь {'n': ...}
- r1 — число float, r2 — список чисел
- r1 — словарь {'age__avg': ...}, r2 — QuerySet авторов, у каждого есть атрибут n
aggregate() — терминальная операция: считает итог по всему QuerySet и возвращает dict (ключ по умолчанию <поле>__<функция>). annotate() добавляет вычисляемое значение к каждому объекту и возвращает QuerySet (в SQL — GROUP BY по автору).Что произойдёт при вызове
reserve(1) вне transaction.atomic() (Django 5.x, PostgreSQL, ATOMIC_REQUESTS выключен)?def reserve(pk):
seat = Seat.objects.select_for_update().get(pk=pk)
seat.taken = True
seat.save()- Строка будет заблокирована до конца обработки HTTP-запроса
- Блокировка возьмётся и сразу снимется: код работает, но без защиты
- TransactionManagementError: select_for_update нельзя выполнять в режиме autocommit
- Django молча проигнорирует select_for_update
SELECT ... FOR UPDATE держит блокировку до конца транзакции, а в autocommit транзакция закончилась бы сразу после SELECT. Поэтому Django явно запрещает такое использование и бросает TransactionManagementError. Правильно: обернуть чтение и сохранение в with transaction.atomic():.Что произойдёт, если в базе 50 пользователей?
users = User.objects.only("id", "username")
for u in users:
print(u.username, u.email)- AttributeError: поле email не загружено
- Код сработает, но каждое обращение к u.email сделает отдельный запрос — всего 51
- u.email будет None для всех пользователей
- Django заметит обращение и догрузит email у всех одним запросом
only()/defer() откладывают загрузку полей, но не запрещают к ним обращаться: при первом доступе к отложенному полю Django делает дополнительный запрос для этого конкретного объекта. Поэтому only полезен, только когда лишние поля действительно не используются, иначе он ухудшает ситуацию.Что окажется в БД после вызова
checkout(user) (исключение снаружи не перехватывается)?from django.db import transaction
def checkout(user):
with transaction.atomic():
Order.objects.create(user=user, total=100)
user.balance -= 100
user.save()
raise ValueError("платёж отклонён")- Ни заказа, ни изменения баланса — транзакция откатится
- Заказ создан, баланс не изменился
- И заказ, и новый баланс: create() и save() коммитят сразу
- И заказ, и новый баланс: ValueError не связан с базой данных
Если блок
atomic() завершается любым исключением, Django откатывает всю транзакцию, а исключение летит дальше. Внутри atomic create() и save() не коммитят по отдельности — коммит происходит только при успешном выходе из внешнего блока.На модель
Order подписан обработчик сигнала post_save. Для какого вызова он НЕ сработает?- order.save(update_fields=["status"])
- Order.objects.create(status="new")
- order.status = "paid"; order.save()
- Order.objects.filter(status="new").update(status="paid")
QuerySet.update() выполняет один SQL UPDATE и не вызывает save() у объектов, поэтому pre_save/post_save не отправляются (то же с bulk_create/bulk_update). create() и save() с update_fields вызывают сигналы. Логику, которая обязана выполняться при любом изменении, опасно держать только в сигналах.В каком порядке middleware обработают запрос и ответ?
MIDDLEWARE = [
"app.mw.A",
"app.mw.B",
"app.mw.C",
]- И запрос, и ответ: A → B → C
- Запрос: C → B → A → view; ответ: A → B → C
- Запрос: A → B → C → view; ответ: C → B → A
- Порядок не гарантируется
Middleware — это «луковица»: на входе запрос проходит слои сверху вниз по списку, ответ возвращается в обратном порядке. Поэтому порядок в
MIDDLEWARE важен: например, SessionMiddleware должен стоять выше AuthenticationMiddleware, которому нужна сессия.В шаблоне POST-формы забыли
{% csrf_token %}, CsrfViewMiddleware включён. Что получит пользователь при отправке формы?- Форма отправится, просто без защиты
- Ответ 403 Forbidden (CSRF verification failed)
- 500 Internal Server Error
- Django сам подставит токен при рендеринге
Для «небезопасных» методов (POST, PUT, DELETE…) middleware сверяет токен из формы или заголовка
X-CSRFToken с cookie, и при отсутствии токена отвечает 403. Отключать проверку через @csrf_exempt стоит только для эндпоинтов, которые защищены иначе (например, API с токенами в заголовке).Чем опасен
DEBUG = True на боевом сервере?- При ошибке пользователь видит подробную страницу с трассировкой, кодом и настройками
- Только тем, что сайт работает медленнее — данные не утекают
- Django отключает CSRF-защиту
- Ничем, если заполнен ALLOWED_HOSTS
Отладочная страница показывает стек вызовов, локальные переменные, часть настроек и SQL — это готовая разведка для атакующего (маскируются лишь ключи с «опасными» именами). Кроме того, в режиме DEBUG Django копит выполненные SQL-запросы в памяти. В продакшене
DEBUG = False, а ALLOWED_HOSTS обязательно заполняют.В двух ветках созданы миграции
0005_add_price и 0005_add_color, обе зависят от 0004. После слияния migrate пишет «Conflicting migrations detected». Как это стандартно исправить?- Удалить одну из миграций и выполнить migrate --fake
- Переименовать одну в 0006_add_color — номер в имени задаёт порядок
- Выполнить migrate --run-syncdb
- python manage.py makemigrations --merge — создаст миграцию, зависящую от обеих
Порядок миграций определяется не номерами в именах файлов, а списком
dependencies, поэтому переименование конфликт не устранит: у приложения по-прежнему два «листа». makemigrations --merge создаёт merge-миграцию с двумя зависимостями, после чего граф снова линеен.Почему в
urls.py пишут path("books/", BookListView.as_view()), а не просто BookListView?- as_view() создаёт один экземпляр на всё приложение, чтобы экономить память
- Без as_view() Django не найдёт шаблон
- as_view() возвращает функцию-view, которая на каждый запрос создаёт новый экземпляр класса и вызывает dispatch()
- as_view() нужен только для GET; для POST указывают класс напрямую
URLconf ожидает вызываемый объект
(request, *args, **kwargs). as_view() строит такую функцию: на каждый запрос она создаёт свежий экземпляр view (состояние не делится между запросами) и вызывает dispatch(), который выбирает метод get/post по HTTP-методу.Flask и FastAPI11
Что произойдёт при запуске этого модуля (Flask 3.x)?
from flask import Flask, request
app = Flask(__name__)
print(request.args)- Выведется пустой ImmutableMultiDict([])
- RuntimeError: Working outside of request context
- Выведется None
- NameError: name 'request' is not defined
request — прокси на объект текущего запроса, который существует только внутри контекста запроса (во время обработки или в app.test_request_context()). На уровне модуля запроса нет, поэтому Flask бросает RuntimeError.Что верно про объект
flask.g?- Он живёт в контексте приложения одного запроса: данные из одного запроса не видны в следующем
- Это глобальный словарь процесса, общий для всех запросов — удобен как кэш
- Он хранится в cookie и переживает перезагрузку страницы, как session
- Он общий для всех потоков воркера
g создаётся заново для каждого контекста приложения, а он в Flask поднимается на каждый запрос. Туда кладут то, что нужно в пределах запроса: текущего пользователя, соединение с БД. Для данных между запросами — session (cookie) или внешнее хранилище.Что произойдёт при запуске этого скрипта (Flask 3.x, create_app — фабрика приложения)?
from flask import current_app
from myapp import create_app
app = create_app()
print(current_app.config["DEBUG"])- Выведется значение DEBUG: current_app указывает на последнее созданное приложение
- KeyError: конфиг доступен только через app.config
- ImportError: current_app нельзя импортировать до create_app()
- RuntimeError: Working outside of application context — нужно with app.app_context():
current_app — прокси на приложение активного контекста, а в обычном скрипте или CLI-утилите контекст сам не создаётся. Нужно with app.app_context(): ... (так же работают расширения вроде Flask-SQLAlchemy вне запроса). Flask не хранит «последнее приложение» глобально — их может быть несколько.По какому URL будет доступна
users_list и какое имя endpoint нужно передать в url_for?bp = Blueprint("users", __name__)
@bp.get("/list")
def users_list(): ...
app.register_blueprint(bp, url_prefix="/api/users")- /list и url_for("users_list")
- /users/list и url_for("users.users_list")
- /api/users/list и url_for("users.users_list")
- /api/users/list и url_for("users_list")
url_prefix при регистрации добавляется ко всем маршрутам blueprint, а имена endpoint получают префикс с именем blueprint: "users.users_list". Внутри самого blueprint можно писать сокращённо url_for(".users_list").Что вернёт FastAPI на запрос
GET /users/me?@app.get("/users/{user_id}")
def get_user(user_id: int): ...
@app.get("/users/me")
def get_me(): ...- Ответ get_me(): FastAPI выбирает самый конкретный маршрут
- 422: запрос попал в первый маршрут, и "me" не прошло валидацию как int
- 404 Not Found
- 500: конфликт маршрутов при старте
Маршруты проверяются в порядке объявления, а шаблон
/users/{user_id} подходит под любой сегмент, включая me. Дальше FastAPI валидирует user_id: int и возвращает 422. Фиксированные пути вроде /users/me нужно объявлять раньше параметризованных.Какой HTTP-статус FastAPI вернёт по умолчанию при успешном выполнении
@app.post("/users"), если status_code не указан?- 200 OK
- 201 Created
- 204 No Content
- 202 Accepted
FastAPI не угадывает семантику: любой path operation по умолчанию отвечает 200. Для создания ресурса статус задают явно:
@app.post("/users", status_code=status.HTTP_201_CREATED).Какие методы в Pydantic v2 заменяют
.dict() и parse_obj() из v1?- to_dict() и from_dict()
- dict() и parse_obj() — в v2 они не менялись
- model_json() и model_parse()
- model_dump() и model_validate()
В Pydantic v2 методы моделей получили префикс
model_: model_dump(), model_dump_json(), model_validate(), model_validate_json(). Старые .dict()/.parse_obj() ещё работают, но объявлены устаревшими и выдают предупреждение.Что произойдёт при выполнении (Pydantic v2)?
from pydantic import BaseModel
class Item(BaseModel):
qty: int
print(Item(qty="42").qty + 1)
print(Item(qty="4.5"))- TypeError: can only concatenate str (not "int") to str
- Выведется 43 и qty=4
- Выведется 43, затем ValidationError на второй модели
- ValidationError уже на первой модели: "42" — не int
В режиме по умолчанию (lax) Pydantic приводит строку
"42" к int, поэтому qty — число и + 1 даёт 43. Строку "4.5" привести к целому без потери данных нельзя — ValidationError (отбрасывать дробную часть Pydantic не станет). Строгую проверку типов включают через strict=True.Что вернёт FastAPI на запрос
GET /search?tag=a&tag=b?from fastapi import Query
@app.get("/search")
def search(tag: list[str] | None = Query(default=None)):
return {"tag": tag}- {"tag": "b"}
- {"tag": ["a", "b"]}
- {"tag": "a"}
- 422: параметр tag ожидается в теле запроса
Объявленный через
Query() параметр-список собирает все повторы ключа из строки запроса. Без явного Query() FastAPI посчитал бы параметр типа list телом запроса (body), и из URL он бы не читался. Простые параметры (int, str) без значения в пути становятся query-параметрами автоматически.Сколько раз напечатается
open при одном запросе GET /me (FastAPI)?def get_db():
print("open")
db = SessionLocal()
try:
yield db
finally:
db.close()
def get_user(db=Depends(get_db)): ...
@app.get("/me")
def me(user=Depends(get_user), db=Depends(get_db)): ...- 1
- 2
- 0 — зависимости с yield вызываются только при старте
- Зависит от порядка параметров в me()
В пределах одного запроса FastAPI кэширует результат зависимости:
get_db нужна и get_user, и me, но выполнится один раз, и оба получат одну и ту же сессию. Отключить это можно через Depends(get_db, use_cache=False). Код после yield выполнится при завершении запроса.Что получит клиент в теле ответа на
POST /users?class UserIn(BaseModel):
email: str
password: str
class UserOut(BaseModel):
email: str
@app.post("/users", response_model=UserOut)
def create(user: UserIn):
return user- {"email": ..., "password": ...} — возвращается то, что вернула функция
- 500: функция вернула UserIn вместо UserOut
- 422: ответ не прошёл валидацию по UserOut
- Только {"email": ...} — password отфильтруется
response_model описывает форму ответа: FastAPI прогоняет возвращённые данные через UserOut и отдаёт только его поля. Так можно безопасно вернуть внутренний объект, не раскрывая пароль. Ошибки не будет: у UserIn есть всё, что нужно UserOut.SQLAlchemy и базы данных11
Будет ли пользователь Ann сохранён в базе после этого блока (SQLAlchemy 2.0)?
with Session(engine) as session:
session.add(User(name="Ann"))
session.flush()- Да: flush() — это и есть commit()
- Да: контекстный менеджер Session коммитит при выходе без исключения
- Нет: flush отправил INSERT внутри транзакции, а без commit() при закрытии сессии она откатывается
- Нет: flush() без commit() бросает исключение
with Session(engine) при выходе только закрывает сессию, а незавершённая транзакция откатывается. flush() отправляет SQL в базу, но в рамках текущей транзакции. Автокоммит при выходе даёт другая форма — with Session(engine) as s, s.begin(): или with Session.begin(), либо явный session.commit().У пользователя
posts — relationship с ленивой загрузкой по умолчанию. Сколько SELECT выполнится для 100 пользователей (SQLAlchemy 2.0)?users = session.scalars(select(User)).all()
for u in users:
print(u.name, len(u.posts))- 1
- 101
- 2
- 100
При
lazy="select" коллекция загружается отдельным запросом при первом обращении к атрибуту — для каждого из 100 пользователей, плюс исходный запрос: N+1. Исправляется загрузкой заранее: select(User).options(selectinload(User.posts)) — всего 2 запроса.Чем
selectinload(User.posts) отличается от joinedload(User.posts)?- selectinload делает второй запрос ... WHERE user_id IN (...), joinedload — один запрос с LEFT OUTER JOIN
- selectinload загружает при первом обращении к атрибуту, joinedload — сразу
- Это синонимы, оставленные для совместимости
- joinedload работает только для many-to-one, а selectinload — только для коллекций
Обе стратегии «жадные» (eager) и решают N+1.
joinedload добавляет JOIN, и для коллекций строки родителя дублируются по числу детей; selectinload выполняет отдельный SELECT с IN по первичным ключам загруженных родителей. Документация советует selectinload для коллекций и joinedload — для many-to-one.Что произойдёт при выполнении этого кода (SQLAlchemy 2.0,
posts — коллекция)?stmt = select(User).options(joinedload(User.posts))
users = session.execute(stmt).scalars().all()- Вернутся дубликаты: каждый пользователь столько раз, сколько у него постов
- Всё сработает, дубликаты уберутся автоматически
- Ошибка: joinedload нельзя совмещать с scalars()
- InvalidRequestError: нужно вызвать .unique() — строки пользователей дублируются из-за JOIN
В 2.0 SQLAlchemy не убирает дубликаты молча: при joined eager load коллекций результат требует явного
.unique() — session.execute(stmt).unique().scalars().all() (или session.scalars(stmt).unique().all()). Без него бросается InvalidRequestError. С selectinload такой проблемы нет.Что произойдёт на последней строке (SQLAlchemy 2.0, у email ограничение UNIQUE)?
try:
session.add(User(email="dup@x.io")) # такой email уже есть
session.commit()
except IntegrityError:
pass
session.add(User(email="new@x.io"))
session.commit()- Сохранится new@x.io, а dup@x.io будет отброшен
- Сохранятся обе записи
- PendingRollbackError: после ошибки при flush сначала нужно вызвать session.rollback()
- Снова IntegrityError из-за dup@x.io
Если flush падает, транзакция сессии откатывается, но сессия остаётся в «неактивном» состоянии, пока код явно не вызовет
session.rollback(). Любая следующая операция с БД бросит PendingRollbackError. Правильный шаблон: except IntegrityError: session.rollback().Чем SQLAlchemy Core отличается от SQLAlchemy ORM?
- Core — синхронный API, ORM — асинхронный
- Core строит SQL-выражения над таблицами и возвращает строки; ORM поверх него отображает классы на таблицы и отслеживает объекты в Session
- Core работает только с SQLite, ORM — с любой СУБД
- ORM генерирует SQL сам, а в Core можно писать только сырые строки text()
Core — нижний слой:
Engine, Connection, Table, конструкции select()/insert()/update(). ORM добавляет маппинг классов, Session с identity map и unit of work. Оба слоя поддерживают и sync, и async (AsyncEngine, AsyncSession), и в Core SQL строится из Python-выражений, а не только через text().Что произойдёт на последней строке (SQLAlchemy 2.0, настройки сессии по умолчанию)?
def get_user(user_id):
with Session(engine) as session:
user = session.get(User, user_id)
session.commit()
return user
u = get_user(1)
print(u.name)- DetachedInstanceError: атрибуты истекли после commit, а сессия уже закрыта
- Выведется имя: после commit() атрибуты остаются в объекте
- Выведется None
- Выведется имя, но через новый неявный запрос к БД
По умолчанию
expire_on_commit=True: после commit() все атрибуты объектов помечаются устаревшими и перечитываются при следующем доступе. Здесь объект уже отсоединён от закрытой сессии, перечитать его нечем — DetachedInstanceError. Решения: читать нужные поля до закрытия, Session(engine, expire_on_commit=False) или не делать commit в чисто читающем коде.Что выведет этот код (SQLAlchemy 2.0)?
rows = session.execute(select(User)).all()
print(type(rows[0]).__name__)- User
- tuple
- dict
- Row
session.execute() возвращает Result из строк Row — даже если в SELECT одна ORM-сущность, каждая строка — кортежеподобный Row с объектом User внутри (rows[0][0]). Чтобы получить сами объекты, используют session.scalars(select(User)).all() или .scalars() у результата.Что выведет этот код (SQLAlchemy 2.0, пользователь с id=1 существует)?
with Session(engine) as session:
a = session.get(User, 1)
b = session.get(User, 1)
c = session.scalars(select(User).where(User.id == 1)).one()
print(a is b, a is c)- True False
- False False
- True True
- False True
Session ведёт identity map: одной строке БД в пределах сессии соответствует ровно один Python-объект. Второй
get() вообще не обращается к БД, а select выполнит запрос, но вернёт уже существующий объект из identity map.Когда SQLAlchemy реально отправит INSERT в базу после
session.add(obj) (autoflush включён по умолчанию)?- Сразу при вызове add()
- При flush: явном session.flush(), при commit() или автоматически перед запросом в этой сессии
- Только при commit()
- Только при закрытии сессии
add() лишь помещает объект в сессию (состояние pending). SQL отправляется при flush: его делает commit(), явный flush() и autoflush перед выполнением запросов через сессию — чтобы запрос «видел» несохранённые изменения. Commit затем фиксирует транзакцию.Что выведет этот код (модуль sqlite3, Python 3.12)?
import sqlite3
conn = sqlite3.connect(":memory:")
with conn:
conn.execute("CREATE TABLE t (x INTEGER)")
conn.execute("INSERT INTO t VALUES (1)")
print(conn.execute("SELECT count(*) FROM t").fetchone())- (1,)
- 1
- (0,)
- ProgrammingError: Cannot operate on a closed database.
with conn: управляет транзакцией, а не временем жизни соединения: при успешном выходе делает commit, при исключении — rollback, но соединение не закрывает. fetchone() возвращает кортеж даже для одного столбца. Закрывать соединение нужно отдельно — conn.close() или contextlib.closing.pytest15
Какой scope у фикстуры pytest, если он не указан явно?
- module — одна на файл
- function — фикстура создаётся заново для каждого теста
- session — одна на весь запуск
- class — одна на тестовый класс
По умолчанию
scope="function": каждый тест получает свежий экземпляр, и тесты не влияют друг на друга. Более широкие scope (class, module, package, session) задают явно для дорогих ресурсов вроде подключения к БД.Сколько раз выполнится тело фикстуры
db при запуске этого модуля (pytest 8)?import pytest
@pytest.fixture(scope="module")
def db():
print("connect")
return {}
def test_a(db): ...
def test_b(db): ...
def test_c(): ...- 1
- 2
- 3
- 0 — фикстура без autouse не вызывается
Фикстура со
scope="module" создаётся при первом запросе в модуле и переиспользуется всеми тестами этого модуля, затем финализируется. test_c её не запрашивает, а test_a и test_b получают один и тот же объект.Что верно про файл
conftest.py?- Его нужно импортировать в каждый тестовый файл: from conftest import *
- Он может быть только один — в корне проекта
- Тесты из conftest.py запускаются раньше остальных
- Фикстуры из него доступны тестам в его каталоге и подкаталогах без импорта
pytest сам находит
conftest.py и делает объявленные там фикстуры и хуки видимыми для всех тестов в этом каталоге и ниже. Таких файлов может быть несколько на разных уровнях; импортировать conftest вручную не нужно и не рекомендуется.Сколько тестов соберёт pytest из этой функции?
import pytest
@pytest.mark.parametrize("x", [1, 2])
@pytest.mark.parametrize("y", ["a", "b", "c"])
def test_pair(x, y):
assert x- 5
- 3
- 6
- 2
Несколько декораторов
parametrize комбинируются как декартово произведение: 2 × 3 = 6 тестов (test_pair[a-1], test_pair[a-2], ...). Чтобы получить пары значений, а не все комбинации, используют один parametrize("x,y", [(1, "a"), ...]).Чем закончится этот тест?
import pytest
def test_parse():
with pytest.raises(ValueError):
int("abc")
assert False, "сюда не дойдём"- Упадёт на assert False
- Пройдёт: после исключения в int() остаток блока with не выполняется
- Упадёт: исключение должно возникать в последней строке блока
- Ошибка сбора: внутри pytest.raises нельзя писать assert
Исключение прерывает блок
with сразу, и pytest.raises его перехватывает — строки после int("abc") не выполняются. Поэтому проверки результата нужно писать после блока, а внутрь класть только код, который должен бросить исключение.Как
pytest.raises проверяет параметр match?def test_msg():
with pytest.raises(ValueError, match="invalid literal"):
int("abc")- re.search(match, str(exc)) — регулярка ищется в любом месте сообщения
- Сообщение исключения должно точно совпадать со строкой match
- re.fullmatch по всему сообщению
- match сравнивается с именем класса исключения
match — регулярное выражение, которое ищется через re.search в строковом представлении исключения, поэтому достаточно фрагмента. Спецсимволы нужно экранировать: для текста int() пишут match=re.escape("int()"), иначе скобки станут группой.Что даёт встроенная фикстура
tmp_path?- Строку с путём к общему для всех тестов каталогу /tmp
- Открытый временный файл tempfile.TemporaryFile
- Путь к каталогу проекта для сохранения артефактов
- Объект pathlib.Path на уникальный временный каталог для каждого теста
tmp_path — pathlib.Path на свежий пустой каталог, отдельный для каждого теста, поэтому тесты не мешают друг другу файлами. Для одного каталога на сессию есть tmp_path_factory; старый аналог на py.path — tmpdir.Что будет с переменной окружения
APP_MODE и функцией os.getcwd после завершения теста?import os
def test_env(monkeypatch):
monkeypatch.setenv("APP_MODE", "test")
monkeypatch.setattr(os, "getcwd", lambda: "/fake")
assert os.environ["APP_MODE"] == "test"- Останутся до конца сессии pytest
- Откатится только setattr, переменная окружения останется
- Оба изменения автоматически откатятся
- Откатятся, только если вручную вызвать monkeypatch.undo()
monkeypatch запоминает исходные значения и восстанавливает всё при teardown теста — и атрибуты, и переменные окружения, и элементы словарей, и sys.path. Именно поэтому его предпочитают ручному присваиванию os.environ[...] = ..., которое «протекает» в другие тесты.Что выведет этот код (два файла в одном каталоге)?
# services.py
from time import time
def stamp():
return time()
# main.py
from unittest.mock import patch
import services
with patch("time.time", return_value=0):
print(services.stamp() == 0)- True
- False — нужно патчить services.time
- AttributeError: module 'time' has no attribute 'time'
- TypeError: 'int' object is not callable
from time import time создаёт в модуле services собственное имя time, привязанное к исходной функции ещё до патча. patch("time.time") подменяет атрибут модуля time, но не это имя. Правило: патчить там, где объект ищется — patch("services.time").Что произойдёт при выполнении этого кода?
from unittest.mock import Mock
m = Mock()
m.send(1)
m.send(2)
m.send.assert_called_with(2)
m.send.assert_called_once_with(2)- AssertionError на последней строке
- AssertionError на предпоследней строке
- Обе проверки пройдут
- AttributeError: у Mock нет атрибута send
assert_called_with проверяет только последний вызов — он был send(2), проверка проходит. assert_called_once_with требует, чтобы вызов был ровно один, а их два — AssertionError «Expected 'send' to be called once. Called 2 times.»Что выведет этот код в Python 3.12?
from unittest.mock import Mock
m = Mock()
m.asert_called_once() # опечатка
print("ok")- ok
- AssertionError: Expected to be called once
- NameError
- AttributeError: 'asert_called_once' is not a valid assertion...
Mock создаёт атрибуты на лету, поэтому опечатка в методе-проверке раньше молча «проходила». Для защиты Mock бросает AttributeError на атрибуты, начинающиеся с
assert, assret, а с Python 3.12 — ещё и с asert, aseert, assrt. Надёжнее всего — create_autospec или spec=, тогда несуществующие атрибуты запрещены совсем.Какое значение должно стоять вместо
???, чтобы тест прошёл?def greet(name):
print(f"Привет, {name}")
def test_greet(capsys):
greet("Ann")
out, err = capsys.readouterr()
assert out == ???- "Привет, Ann"
- None — print ничего не возвращает
- "Привет, Ann\n"
- ["Привет, Ann"]
Фикстура
capsys перехватывает sys.stdout/sys.stderr, а readouterr() возвращает накопленный текст как пару строк (out, err) и очищает буфер. print добавляет перевод строки, поэтому в out будет "Привет, Ann\n". Возвращаемое значение greet здесь ни при чём.Что выведет этот код?
from unittest.mock import Mock, MagicMock
print(len(MagicMock()))
print(len(Mock()))- 0 и 0
- 0, затем TypeError: object of type 'Mock' has no len()
- TypeError уже на первой строке
- 1 и 0
MagicMock заранее настраивает магические методы (__len__ возвращает 0, __iter__ — пустой итератор, __bool__ — True и т.д.). Обычный Mock их не определяет, поэтому len() бросает TypeError. Именно MagicMock создаёт patch() по умолчанию.Почему в pytest пишут обычный
assert a == b, а не self.assertEqual(a, b)?- pytest переписывает assert при импорте тестов и при падении показывает значения обеих частей и diff
- Обычный assert в pytest работает быстрее assertEqual
- assertEqual в pytest не поддерживается
- pytest перехватывает AssertionError и перезапускает тест
pytest выполняет assertion rewriting: перед импортом тестовых модулей (и conftest) он переписывает
assert так, чтобы при падении вывести промежуточные значения выражения и подробный diff для списков, словарей, строк. Тесты в стиле unittest.TestCase pytest тоже запускает, но методы assert* там не нужны.Что выведет этот код?
import os
from unittest.mock import patch
@patch("os.getcwd")
@patch("os.listdir")
def check(first, second):
print(first is os.listdir, second is os.getcwd)
check()- False False
- True False
- TypeError: check() missing 2 required positional arguments
- True True
Декораторы применяются снизу вверх, поэтому первым аргументом приходит mock ближайшего к функции декоратора (
os.listdir), вторым — следующего (os.getcwd). Перепутать порядок аргументов — частая ошибка, из-за которой проверки идут не на тот mock.Производительность18
Что содержит
t?import timeit
t = timeit.timeit("sorted(data)",
setup="data = list(range(1000))",
number=1000)- Среднее время одного запуска в секундах
- Минимальное время из 1000 запусков
- Суммарное время в секундах для всех 1000 запусков stmt, без учёта setup
- Время в миллисекундах, включая setup
timeit.timeit возвращает float — общее время всех number повторов; на один запуск — t / number. setup выполняется один раз и в замер не входит. Для устойчивых оценок используют timeit.repeat и берут минимум.Чем в выводе cProfile
tottime отличается от cumtime?- tottime — вместе с вложенными вызовами; cumtime — только собственное время
- tottime — время в самой функции без вложенных вызовов; cumtime — вместе со всеми вызванными ею функциями
- tottime — сумма за все вызовы; cumtime — среднее на один вызов
- tottime — процессорное время; cumtime — реальное (wall clock)
Большой
cumtime при маленьком tottime значит, что функция сама дешёвая, а время тратят её потомки — искать нужно ниже. Большой tottime указывает на «горячий» код внутри самой функции. Отсортировать вывод можно так: python -m cProfile -s cumtime app.py.Какая сложность у
lst.append(x) для списка в CPython?- Амортизированная O(1): память выделяется с запасом и лишь изредка перевыделяется
- O(n): при каждом добавлении копируется весь список
- O(log n)
- Строго O(1) в каждом вызове: перевыделений памяти не бывает
Список — динамический массив с запасом ёмкости (over-allocation). Большинство
append просто пишут в свободную ячейку; когда место кончается, массив перевыделяется с ростом пропорционально размеру и элементы копируются. Отдельный такой вызов O(n), но в среднем на операцию — O(1).Как быстрее всего ускорить этот код?
banned = load_banned() # list из 100 000 строк
for user in users: # 100 000 пользователей
if user.name in banned:
block(user)- Отсортировать banned: оператор in на сортированном списке использует бинарный поиск
- Заменить проверку на banned.index(user.name)
- Заменить проверку на banned.count(user.name) > 0
- Один раз до цикла сделать banned = set(banned)
in для списка — линейный поиск O(n), итого ~10¹⁰ сравнений. set ищет по хэшу за O(1) в среднем, и весь цикл становится O(n + m). Сортировка не помогает: in у списка о ней не знает (для бинарного поиска нужен bisect), а index/count такие же линейные.Почему для сборки большой строки рекомендуют
"".join(parts), а не s += part в цикле?- join выполняется в отдельном потоке и не блокирует GIL
- += для строк в цикле выдаёт SyntaxWarning
- Строки неизменяемы: += может каждый раз копировать накопленное (до O(n²)); join вычисляет размер и копирует один раз
- Разницы нет: CPython всегда оптимизирует += для строк до O(n)
Каждое
s += part в общем случае создаёт новую строку и копирует в неё старую. В CPython есть оптимизация «дописывания на месте», но она срабатывает не всегда (например, если на строку есть другие ссылки) и отсутствует в других реализациях, поэтому опираться на неё нельзя. join гарантированно линейный.Что выведет этот код (Python 3.10+)?
from dataclasses import dataclass
@dataclass(slots=True)
class Point:
x: int
y: int
p = Point(1, 2)
print(hasattr(p, "__dict__"))
p.z = 3- True, и атрибут z добавится
- False, затем AttributeError на p.z = 3
- False, но атрибут z всё равно добавится
- TypeError: dataclass() got an unexpected keyword argument 'slots'
Параметр
slots=True (Python 3.10+) заставляет @dataclass создать класс с __slots__ по списку полей. У экземпляров нет __dict__: они компактнее в памяти и быстрее в доступе к атрибутам, но новые атрибуты добавлять нельзя. Вручную писать __slots__ в датаклассе при этом не нужно.Что не так с этим подсчётом частот?
words = load_words() # 100 000 слов
freq = {w: words.count(w) for w in words}- Сложность O(n²): count каждый раз проходит весь список; Counter(words) считает за один проход
- Код неверен: count считает вхождения подстрок, а не элементов
- Ничего: comprehension выполняется в C и работает за O(n)
- KeyError: в dict comprehension нельзя повторять ключи
words.count(w) — линейный проход, и он вызывается для каждого из n слов (включая повторы): ~10¹⁰ сравнений. collections.Counter(words) или цикл с dict делают один проход O(n). Повторяющиеся ключи в comprehension не ошибка — последнее значение просто перезаписывает предыдущее.Почему замер
timeit может оказаться оптимистичнее реальной работы кода, создающего много объектов?- timeit запускает код в отдельном процессе с JIT-компиляцией
- timeit измеряет только процессорное время, без системных вызовов
- timeit кэширует результат stmt после первого запуска
- timeit по умолчанию отключает сборщик мусора на время замера
По документации
timeit временно выключает циклический сборщик мусора, чтобы замеры были сопоставимы. Если в реальной программе GC заметно влияет на время, его включают в setup: timeit.timeit(stmt, setup="gc.enable()"). Результат stmt timeit не кэширует — код выполняется все number раз.Что выведет этот код?
from functools import lru_cache
@lru_cache
def square(n):
return n * n
for i in range(200):
square(i)
info = square.cache_info()
print(info.maxsize, info.currsize)- None 200
- 200 200
- 128 128
- 128 200
@lru_cache без аргументов использует maxsize=128: при переполнении вытесняются давно не использованные записи, и в кэше остаётся не больше 128 значений. Неограниченный кэш — @lru_cache(maxsize=None) или @functools.cache (3.9+); он быстрее, но растёт без предела.Нужно убрать дубликаты из списка, сохранив порядок первых вхождений. Что выведет код?
items = [3, 1, 3, 2, 1]
print(list(dict.fromkeys(items)), sorted(set(items)))- [1, 2, 3] [1, 2, 3]
- [3, 1, 2] [1, 2, 3]
- [3, 1, 2] [3, 1, 2]
- [3, 1, 3, 2, 1] [1, 2, 3]
Ключи
dict уникальны и хранятся в порядке вставки (с 3.7), поэтому dict.fromkeys удаляет дубликаты за O(n) и сохраняет порядок. set порядок не гарантирует, здесь он отсортирован явно. Наивный вариант if x not in result: result.append(x) даёт O(n²) из-за поиска в списке.Какая сложность поиска ключа в
dict?- O(1) в среднем, O(n) в худшем случае (много коллизий хэшей)
- Всегда O(1)
- O(log n): dict — сбалансированное дерево
- O(n): dict хранит пары в порядке вставки
dict — хэш-таблица с открытой адресацией: при хорошем распределении хэшей поиск занимает O(1) в среднем. Если у многих ключей одинаковый хэш (плохой
__hash__ или атака на коллизии), поиск деградирует до O(n). Порядок вставки dict хранит в отдельном массиве, на сложность поиска это не влияет.Какая операция у
collections.deque из n элементов НЕ выполняется за O(1)?- dq.appendleft(x)
- dq.pop()
- dq[0] и dq[-1]
- dq[n // 2] — доступ по индексу в середине
Документация deque: добавление и удаление с обоих концов — O(1), доступ по индексу — O(1) на концах, но O(n) в середине, потому что deque — связный список блоков, а не массив. Для частого произвольного доступа нужен
list.Когда вариант
try: v = d[k] / except KeyError: v = default медленнее, чем v = d.get(k, default)?- Всегда: блок try замедляет любой код внутри него в несколько раз
- Никогда: исключения в Python ничего не стоят
- Когда ключ часто отсутствует: try дёшев, пока исключения нет, а возбуждение и перехват исключения дорогие
- Только для словарей с числовыми ключами
Вход в
try почти бесплатен (в CPython 3.11+ — «zero-cost» исключения), поэтому стиль EAFP выгоден, когда ошибка — редкость. Но создание объекта исключения, раскрутка стека и поиск обработчика заметно дороже обычной проверки, так что при частых промахах быстрее d.get() или k in d.Какой функцией правильно измерять длительность участка кода (реальное время)?
- time.time()
- time.perf_counter()
- datetime.now()
- time.process_time()
perf_counter() — монотонные часы с максимальным разрешением, не зависящие от перевода системных часов. time.time() может «прыгать» при синхронизации времени, а process_time() считает только процессорное время процесса и не учитывает ожидание (sleep, I/O).Почему 10 млн целых чисел в
array.array("i") занимают в разы меньше памяти, чем в list?- list хранит указатели на отдельные объекты int (каждый ~28 байт), а array — сырые 4-байтовые значения подряд
- array сжимает данные алгоритмом zlib
- list хранит каждое число дважды — для быстрого поиска
- Разницы нет: CPython хранит все int в едином кэше
Элемент списка — 8-байтовый указатель на полноценный объект
int с заголовком и счётчиком ссылок. array (как и массивы NumPy) хранит значения фиксированного C-типа плотно, без объектов. Кэш малых целых в CPython охватывает только диапазон от -5 до 256.Какая средняя сложность пересечения множеств
a & b?- O(len(a) · len(b)): каждый элемент сравнивается с каждым
- O(len(a) + len(b)): оба множества сортируются и сливаются
- O(1): результат вычисляется лениво
- O(min(len(a), len(b))): перебирается меньшее множество, каждый элемент ищется в большем за O(1)
Множество — хэш-таблица, поэтому проверка принадлежности в среднем O(1). CPython обходит меньшее из множеств и проверяет каждый элемент в большем. Отсюда практический приём: вместо вложенных циклов по двум спискам —
set(a) & set(b), итого O(n + m) с учётом построения множеств.Зачем в горячем цикле нужна строка (1)?
import math
def roots(n):
sqrt = math.sqrt # (1)
return [sqrt(i) for i in range(n)]- Без неё math.sqrt вычисляется на Python, а не в C
- Чтобы sqrt закэшировал свои результаты
- Чтобы не искать на каждой итерации глобальное имя math и его атрибут: локальная переменная читается быстрее
- Без неё внутри comprehension имя math не видно
math.sqrt в цикле — это поиск глобального имени math в словаре модуля и поиск атрибута на каждой итерации. Локальная переменная — быстрый доступ по индексу в кадре (LOAD_FAST). Это микрооптимизация: применять её стоит только в действительно горячих местах, найденных профилировщиком.Что выведет этот код и сколько памяти он займёт?
r = range(10**12)
print(len(r), 10**12 - 1 in r)- MemoryError
- 1000000000000 True — мгновенно и почти без памяти
- 1000000000000 True, но проверка in перебирает 10¹² чисел
- 999999999999 True
range — ленивая последовательность: хранит только start, stop, step. len вычисляется арифметически, а проверка in для целых чисел — за O(1) по формуле, без перебора. Это не работает для float или других типов — тогда in идёт перебором.Алгоритмы на Python17
Что выведет этот код?
rows = [("bob", 30), ("amy", 25), ("cat", 30), ("dan", 25)]
rows.sort(key=lambda r: r[0], reverse=True)
rows.sort(key=lambda r: r[1])
print([name for name, _ in rows])- ['dan', 'amy', 'cat', 'bob']
- ['amy', 'dan', 'bob', 'cat']
- ['bob', 'cat', 'amy', 'dan']
- ['dan', 'cat', 'bob', 'amy']
Многопроходная сортировка опирается на стабильность: сначала сортируют по второстепенному ключу (имя по убыванию: dan, cat, bob, amy), затем по главному (возраст). Равные по возрасту сохраняют порядок первого прохода. Так можно комбинировать разные направления сортировки, когда ключ нельзя просто «инвертировать» минусом, например для строк.
Что выведет этот код?
scores = {"bob": 90, "amy": 95, "cat": 90}
print(sorted(scores, key=lambda k: (-scores[k], k)))- ['amy', 'cat', 'bob']
- ['bob', 'cat', 'amy']
- TypeError: bad operand type for unary -
- ['amy', 'bob', 'cat']
Ключ — кортеж, а кортежи сравниваются поэлементно: сначала
-score (по убыванию баллов), при равенстве — имя (по алфавиту). Обход словаря даёт ключи, поэтому сортируются имена. Минус работает только для чисел; для строк в обратном порядке используют двойную сортировку с reverse=True.Сколько элементов отсортированного списка попадает в отрезок [3, 7]? Что выведет код?
from bisect import bisect_left, bisect_right
a = [1, 3, 3, 5, 7, 9]
print(bisect_right(a, 7) - bisect_left(a, 3))- 3
- 5
- 4
- 6
bisect_left(a, 3) = 1 — индекс первого элемента ≥ 3, bisect_right(a, 7) = 5 — индекс первого элемента > 7. Разность — количество элементов в отрезке [3, 7] включительно (3, 3, 5, 7), и считается она за O(log n) без прохода по списку.Что выведет этот код?
from bisect import bisect_left
def find(a, x):
i = bisect_left(a, x)
return i if a[i] == x else -1
print(find([1, 3, 5], 4))
print(find([1, 3, 5], 9))- -1 и -1
- -1, затем IndexError
- IndexError уже на первом вызове
- 2 и 3
Для 9
bisect_left вернёт len(a) = 3 — позицию за концом списка, и a[3] бросит IndexError. Правильная проверка: if i < len(a) and a[i] == x. Для 4 позиция 2 существует, a[2] = 5 ≠ 4, поэтому -1.Что выведет этот код?
from collections import deque
graph = {"A": "BC", "B": "D", "C": "DE", "D": "F", "E": "", "F": ""}
def bfs(start):
seen, q, order = {start}, deque([start]), []
while q:
v = q.popleft()
order.append(v)
for n in graph[v]:
if n not in seen:
seen.add(n)
q.append(n)
return "".join(order)
print(bfs("A"))- ABCDEF
- ABDFCE
- ABCDDEF
- ACEDBF
BFS обходит вершины по слоям: сначала A, затем её соседи B и C, затем D (из B) и E (из C), затем F. D добавляется в очередь один раз — её помечают как посещённую при постановке в очередь. Порядок ABDFCE дал бы обход в глубину (DFS).
Что выведет этот код (CPython 3.12, настройки по умолчанию)?
def depth(n):
return 0 if n == 0 else 1 + depth(n - 1)
print(depth(500))
print(depth(5000))- 500 и 5000
- RecursionError уже на первом вызове
- 500, затем Segmentation fault
- 500, затем RecursionError
Лимит рекурсии по умолчанию — 1000 кадров (
sys.getrecursionlimit()), при его превышении бросается RecursionError. Хвостовую рекурсию Python не оптимизирует, поэтому глубокие рекурсивные алгоритмы (DFS по большому графу, обход длинного списка) переписывают итеративно с явным стеком.Почему первый вызов падает, а после «прогрева» тот же
fib(1000) работает (CPython 3.12)?from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
return n if n < 2 else fib(n - 1) + fib(n - 2)
# fib(1000) -> RecursionError
for k in range(0, 1001, 100):
fib(k) # «прогрев»
print(fib(1000) > 0) # True- lru_cache после первых вызовов отключает проверку лимита рекурсии
- Цикл увеличивает sys.getrecursionlimit() на каждой итерации
- При прогреве каждый вызов уходит вглубь лишь до уже закэшированного значения — глубина ~100, а не 1000
- Прогрев ни при чём: первый вызов падает из-за переполнения int
Мемоизация убирает повторные вычисления, но не глубину рекурсии: «холодный»
fib(1000) спускается до fib(1) через ~1000 кадров и превышает лимит. При прогреве шагами по 100 каждый вызов доходит только до ближайшего закэшированного значения. Надёжнее всего итеративное решение снизу вверх.Что выведет этот код?
from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
return n if n < 2 else fib(n - 1) + fib(n - 2)
fib(30)
info = fib.cache_info()
print(info.misses, info.hits)- 30 30
- 31 28
- 1 30
- 1664079 0
Каждое значение от
fib(0) до fib(30) вычисляется ровно один раз — 31 промах. Для n от 3 до 30 вызов fib(n-2) находит готовое значение (оно посчитано внутри fib(n-1)) — 28 попаданий; у fib(2) вызов fib(0) — первый, это промах. Без кэша было бы 1 664 079 вызовов.Какая сложность у
list.sort() в CPython?- O(n log n) в худшем случае и O(n) на уже отсортированных данных
- O(n²) в худшем случае, как у быстрой сортировки
- Всегда ровно O(n log n), даже на отсортированных данных
- Всегда O(n): используется сортировка подсчётом
CPython использует Timsort (с 3.11 — с политикой слияния powersort): он находит уже упорядоченные участки (runs) и сливает их. Худший случай O(n log n), а на отсортированных или почти отсортированных данных — близко к O(n). Сортировка стабильна.
Что выведет этот код?
import heapq
print(list(heapq.merge([1, 4, 9], [2, 3, 10], [5])))- [1, 4, 9, 2, 3, 10, 5]
- [[1, 2, 5], [4, 3], [9, 10]]
- TypeError: merge() takes exactly 2 arguments
- [1, 2, 3, 4, 5, 9, 10]
heapq.merge лениво сливает любое число уже отсортированных последовательностей, держа в куче по одному текущему элементу от каждой: O(n log k) по времени и O(k) памяти. Входы обязаны быть отсортированы — иначе результат не будет упорядочен. Это основа внешней сортировки больших файлов.Какая сложность у
x in d и у x in d.values() для словаря из n элементов?- Обе O(1)
- Обе O(n)
- O(1) в среднем и O(n)
- O(log n) и O(n)
x in d ищет по хэшу среди ключей — O(1) в среднем. d.values() — представление без индекса по значениям, проверка идёт перебором — O(n). Если нужен частый поиск по значениям, строят обратный словарь или множество значений.Что выведет этот код?
def two_sum(nums, target):
seen = {}
for i, x in enumerate(nums):
if target - x in seen:
return seen[target - x], i
seen[x] = i
print(two_sum([3, 2, 4], 6))- (0, 0)
- (1, 2)
- (2, 1)
- None
Для каждого элемента ищем в словаре «дополнение»
target - x среди уже просмотренных — один проход, O(n). Для 3 дополнения 3 ещё нет (элемент кладётся в словарь после проверки, поэтому (0, 0) невозможно), для 2 нет 4, а для 4 найдено 2 с индексом 1.Что выведет этот код?
words = ["banana", "Cherry", "apple"]
print(sorted(words))
print(sorted(words, key=str.lower))- ['Cherry', 'apple', 'banana'] и ['apple', 'banana', 'Cherry']
- ['apple', 'banana', 'Cherry'] в обоих случаях
- ['apple', 'banana', 'Cherry'] и ['Cherry', 'apple', 'banana']
- ['Cherry', 'apple', 'banana'] в обоих случаях
Строки по умолчанию сравниваются по кодам символов, и все заглавные латинские буквы идут раньше строчных:
'C' < 'a'. key=str.lower сравнивает строки в нижнем регистре, не меняя сами элементы. Для корректной работы с Unicode лучше str.casefold.Что выведет этот код?
from functools import cmp_to_key
nums = ["3", "30", "34", "5", "9"]
nums.sort(key=cmp_to_key(lambda a, b: -1 if a + b > b + a else 1))
print("".join(nums))- 9534303
- 3033459
- TypeError: '<' not supported
- 9534330
Компаратор ставит
a раньше b, если конкатенация a + b больше b + a — так собирается максимальное число. cmp_to_key превращает функцию сравнения в ключ для sort. Обычная обратная сортировка строк дала бы 9534303: "30" встал бы перед "3", хотя "330" > "303".Что выведет этот код?
from itertools import combinations, permutations
print(len(list(combinations("abcd", 2))),
len(list(permutations("abcd", 2))))- 12 6
- 6 6
- 6 12
- 16 12
combinations — неупорядоченные выборки без повторов: C(4, 2) = 6. permutations учитывает порядок: 4 × 3 = 12 (ab и ba — разные). Пары с повторением элемента дали бы product("abcd", repeat=2) — 16.Что выведет этот код?
from itertools import accumulate
a = [3, 1, 4, 1, 5]
pre = [0, *accumulate(a)]
print(pre, pre[4] - pre[1])- [3, 4, 8, 9, 14] 5
- [0, 3, 4, 8, 9, 14] 6
- [0, 3, 4, 8, 9, 14] 9
- [0, 3, 4, 8, 9, 14] 5
accumulate даёт префиксные суммы, а ведущий 0 позволяет считать сумму полуинтервала a[i:j] как pre[j] - pre[i] за O(1). Здесь pre[4] - pre[1] = 9 − 3 = 6 = сумма a[1:4] = 1 + 4 + 1.Какая реальная сложность по времени у этого бинарного поиска для списка длины n?
def bsearch(a, x):
if not a:
return False
mid = len(a) // 2
if a[mid] == x:
return True
if a[mid] < x:
return bsearch(a[mid + 1:], x)
return bsearch(a[:mid], x)- O(n): каждый срез копирует половину списка, n/2 + n/4 + … ≈ n
- O(log n), как у любого бинарного поиска
- O(n log n): log n уровней по n операций
- O(1): срезы списка не копируют данные
Сравнений действительно O(log n), но срез списка создаёт новый список и копирует элементы. Суммарно копируется n/2 + n/4 + … ≈ n элементов, плюс столько же лишней памяти. Правильно передавать границы
lo, hi или использовать модуль bisect.Как проходить тест
- Выберите темы и уровень — Junior проверяет основы, Middle — повседневные детали, Senior — тонкости и неочевидное поведение языка.
- Отвечайте касанием или с клавиатуры: 1–4 или A–D, Enter — следующий вопрос.
- Читайте объяснения — после ошибки разбор открывается сразу, после верного ответа его можно раскрыть кнопкой «Почему».
- Работайте над ошибками — «Повторить ошибки» в конце теста или режим «Только мои ошибки» потом: ответы запоминаются в этом браузере.
Незавершённый тест сохраняется — после перезагрузки страницы можно продолжить с того же вопроса.
Темы теста
- Типы и операторы 10
- Строки 13
- Числа 8
- Условия и циклы 9
- Функции 6
- Области видимости 7
- Списки 8
- Изменяемость, копирование 6
- Множества и кортежи 9
- Словари 8
- Comprehensions 7
- Встроенные функции 7
- itertools и collections 8
- Классы и объекты 7
- Наследование и MRO 3
- Магические методы 10
- Dataclasses и ABC 5
- Декораторы 5
- Замыкания 2
- Генераторы и итераторы 6
- Контекстные менеджеры 5
- Исключения 10
- Асинхронность 8
- Потоки и процессы 6
- Типизация 8
- Модули и пакеты 6
- Стандартная библиотека 9
- Инструменты и окружение 6
- Django и FastAPI 7
- Дескрипторы и метаклассы 18
- Модель данных 17
- Память и GC 15
- Pattern matching 13
- Стандартная библиотека 2 19
- Функциональный стиль 9
- Найдите ошибку 10
- NumPy и pandas 13
- Django 15
- Flask и FastAPI 11
- SQLAlchemy и базы данных 11
- pytest 15
- Производительность 18
- Алгоритмы на Python 17
Другие тесты
Тест по Ruby414 вопросовТест по SQL410 вопросовТест по JavaScript440 вопросовТест по jQuery110 вопросовТест по PHP410 вопросовТест по Symfony64 вопросаТест по Laravel30 вопросовТест по Go410 вопросовТест по TypeScript210 вопросовТест по React410 вопросовТест по Java115 вопросовТест по C#65 вопросовТест по HTML210 вопросовТест по CSS210 вопросовТест по ООП50 вопросовТест по Git50 вопросовТест по QA40 вопросовТест по Zig115 вопросов
