Question 1

Как работают декораторы? Можно ли навешивать несколько декораторов на одну функцию?

Accepted Answer

Развернутое объяснениеБазовая идея работы декоратора: «взять готовую функцию и добавить к ней расширенное поведение, не меняя её исходный код».def log_call(func):
   def wrapper(*args, **kwargs):
       print(f"Calling {func.__name__}")
       result = func(*args, **kwargs)
       print(f"{func.__name__} finished")
       return result
   return wrapper
   
@log_call
def process_order(order_id):
   print(f"Processing {order_id}")Строка @log_call эквивалентна:process_order = log_call(process_order)То есть декоратор:принимает исходную функцию func;создаёт wrapper, который вызывает func и добавляет дополнительную логику до/после/вокруг вызова;возвращает wrapper вместо оригинальной функции.В контексте backend‑разработки через декораторы часто реализуют логирование, кэширование, авторизацию, ретраи и т.п.Можно ли навешивать несколько декораторов?Да, можно. Python позволяет «складывать» декораторы над функцией:@auth_required
@log_call
def get_user_profile(user_id):
   ...
# Это эквивалентно:
def get_user_profile(user_id):
   ...
get_user_profile = auth_required(log_call(get_user_profile))То есть порядок такой: сначала log_call оборачивает исходную функцию, а потом auth_required оборачивает уже результат log_call.Порядок выполнения декораторовВажно различать:Порядок применения (при определении): если на функцию навешано несколько декораторов, они применяются снизу вверх.Порядок вызовов при исполнении: при выполнении несколько декораторов работают как вложенные обёртки: сначала вызывается внешний декоратор (верхний в списке), затем следующий, и в конце — исходная функция, получается «матрёшка».def deco1(func):
   def wrapper(*args, **kwargs):
       print("deco1 before")
       result = func(*args, **kwargs)
       print("deco1 after")
       return result
   return wrapper
   
def deco2(func):
   def wrapper(*args, **kwargs):
       print("deco2 before")
       result = func(*args, **kwargs)
       print("deco2 after")
       return result
   return wrapper
   
@deco1
@deco2
def f():
   print("func")
   
f()Результат будет таким:deco1 before
deco2 before
func
deco2 after
deco1 afterТо есть deco2 ближе к функции, deco1 — внешняя обёртка.На собеседовании можно сформулироватьНесколько декораторов на одной функции работают как вложенные обёртки. Они применяются снизу вверх, а выполняются как матрёшка: внешний декоратор вызывается первым, потом внутренний и сама функция, затем коды «после вызова» идут от внутреннего к внешнему.На TeoBrain мы показываем это на примерах логирования, авторизации и измерения времени выполнения, чтобы вы видели живой эффект комбинации декораторов и могли уверенно объяснить порядок их работы на собеседовании.

Question 2

Что такое генераторы и yield? Чем они отличаются от итераторов?

Accepted Answer

Развернутое объяснениеИтератор — это объект, который умеет возвращать элементы по одному при вызове встроенной функции next() и «знает», где он сейчас находится в последовательности. Формально итератор реализует два метода:метод __iter__, возвращающий сам итератор;метод __next__, который возвращает очередное значение или выбрасывает StopIteration, когда значения закончились.Пример простого итератора:class CountDown:
   def __init__(self, start):
       self.current = start
   def __iter__(self):
       return self
   def __next__(self):
       if self.current <= 0:
           raise StopIteration
       value = self.current
       self.current -= 1
       return value
for n in CountDown(3):
   print(n)  # 3, 2, 1Такой класс полностью реализует итераторный протокол.Что такое генератор и yield?Генератор — это функция (или выражение), которая использует yield и при вызове возвращает объект‑генератор — специальный итератор.Пример генератора:def countdown(start):
   while start > 0:
       yield start
       start -= 1
for n in countdown(3):
   print(n)  # 3, 2, 1Особенности yield:При первом вызове next() код выполняется до первого yield, возвращает значение и «замораживает» состояние функции.Следующий next() продолжает выполнение сразу после yield, сохраняя локальные переменные.Когда функция доходит до конца или return, выбрасывается StopIteration.То есть генератор хранит своё состояние «внутри» функции, без явной реализации __next__ и __iter__.Чем генератор отличается от обычного итератора?Способ создания. Итератор чаще всего реализуется как класс определенными в нем методами __iter__ и __next__. Генератор же представляет собой  функцию с оператором yield или генераторное выражение ((expr for ... in ...)).Удобство и объём кода. Итератор требует явного хранения состояния и явной реализации методов. Генератор автоматически запоминает состояние между yield: локальные переменные и позицию в коде.Отношение между понятиямиВсе генераторы — итераторы (поддерживают __next__ и __iter__).Не все итераторы — генераторы (они могут быть реализованы обычными классами).Память и ленивостьИ генераторы, и итераторы обычно выдают значения по одному (лениво), что экономит память по сравнению со списками. Генераторы особенно удобны для больших или бесконечных последовательностей (чтение файла построчно, генерация событий). Проще говоря, генератор — это удобный способ написать итератор через функцию и yield.Формулировка для собеседованияИтератор — это объект, у которого есть методы __iter__ и __next__, он возвращает элементы по одному и выбрасывает StopIteration, когда элементы заканчиваются. Генератор — это частный случай итератора: он создаётся функцией с yield и сам управляет своим состоянием между вызовами next(). Генераторы удобно использовать, когда нужно лениво генерировать последовательности без хранения всех данных в памяти.

Question 3

Как работают list comprehension, dict comprehension, set comprehension?

Accepted Answer

Развернутое объяснениеComprehension заменяет цикл с накоплением результата на одно выражение:list comprehension[expression for item in iterable if condition]set comprehension:{expression for item in iterable if condition}dict comprehension:{key_expr: value_expr for item in iterable if condition}Это даёт более короткий и читаемый код, а также явное отделение «что хотим получить» от «как накапливаем в цикле».List comprehensionСоздаёт новый список, проходясь по итерируемому объекту и применяя выражение к каждому элементу (с опциональной фильтрацией).Пример: получить квадраты чётных чисел:nums = [1, 2, 3, 4, 5, 6]
squares = [x * x for x in nums if x % 2 == 0]
# [4, 16, 36]Это эквивалентно:squares = []
for x in nums:
   if x % 2 == 0:
       squares.append(x * x)Set comprehensionСоздаёт множество (уникальные значения) по аналогичному принципу:words = ["apple", "Apple", "banana", "banana", "pear"]
unique = {w.lower() for w in words}
# {'apple', 'banana', 'pear'}Полезно, когда нужно избавиться от дублей и при этом преобразовать значения.Dict comprehensionСоздаёт словарь, формируя пары «ключ–значение» в одном выражении:nums = [1, 2, 3, 4]
squares = {n: n * n for n in nums}
# {1: 1, 2: 4, 3: 9, 4: 16}С фильтрацией:data = {"a": 1, "b": 0, "c": 3}
non_zero = {k: v for k, v in data.items() if v != 0}
# {'a': 1, 'c': 3}Это короче, чем писать цикл и вручную заполнять словарь.Как это кратко сформулировать на собеседовании?Comprehension — это краткий синтаксис для создания коллекций. List comprehension строит список [expr for item in iterable if cond], dict comprehension — словарь {k: v for ... if ...}, set comprehension — множество {expr for ... if ...}. Они заменяют циклы с накоплением и делают код короче и нагляднее.

Question 4

Что такое поверхностная и глубокая копия (shallow copy vs deep copy)?

Accepted Answer

Развернутое объяснениеДля изменяемых структур (списки, словари, вложенные коллекции) важно различать:простое присваивание b = a — не копия, обе переменные указывают на один и тот же объект;поверхностная копия — копируется только внешний контейнер;глубокая копия — копируется и контейнер, и все вложенные объекты.Поверхностная копия (shallow copy)При поверхностной копии создаётся новый контейнер, но его элементы — это те же объекты, что и внутри оригинала.Способы сделать shallow copy:import copy
a = [[1, 2], [3, 4]]
b = a.copy()         # для списка
# или
b = list(a)
# или
b = copy.copy(a)Поведение:a = [[1, 2], [3, 4]]
b = a.copy()
b[0][0] = 99
print(a)  # [[99, 2], [3, 4]]
print(b)  # [[99, 2], [3, 4]]Мы создали новый список b, но внутренние списки те же самые, поэтому изменение вложенного элемента отражается и в a.Если же переопределить элемент верхнего уровня — поведение уже другое:a = [[1, 2], [3, 4]]
b = a.copy()
b[0] = [99, 2]
print(a)  # [[1, 2], [3, 4]]
print(b)  # [[99, 2], [3, 4]]Здесь мы заменили ссылку в b[0] на новый список — оригинал не изменился.Глубокая копия (deep copy)При глубокой копии создаётся новый контейнер и рекурсивные копии всех вложенных объектов, так что копия полностью независима от оригинала.Создание:import copy
a = [[1, 2], [3, 4]]
c = copy.deepcopy(a)
c[0][0] = 99
print(a)  # [[1, 2], [3, 4]]
print(c)  # [[99, 2], [3, 4]]Изменения в c не затрагивают a, потому что вложенные списки тоже скопированы.Как объяснить на собеседовании?Поверхностная копия создаёт новый контейнер, но вложенные объекты остаются общими — копируются только ссылки. Поэтому изменение вложенных элементов видно и в оригинале, и в копии. Глубокая копия рекурсивно копирует всю структуру: и контейнер, и все вложенные объекты. В результате копия полностью независима, и изменения в ней не влияют на исходные данные.

Question 5

Что такое mutable и immutable объекты?

Accepted Answer

Развернутое объяснениеImmutable (неизменяемый) объект — после создания его значение поменять нельзя; можно только создать новый объект и переназначить ссылку.Mutable (изменяемый) объект — его состояние можно изменять без создания нового объекта: добавлять/удалять элементы, менять содержимое.В Python всё — объект, у каждого есть тип, идентичность (адрес в памяти) и значение; именно тип решает, допускает ли он изменения значения.К встроенным неизменяемым типам (immutable) относятся:числа: int, float, complex, bool;строки: str;кортежи: tuple;неизменяемые множества: frozenset.Пример со строкой:s = "hi"
t = s
s += "!"
# здесь s уже ссылается на НОВУЮ строку "hi!"
# t по‑прежнему ссылается на "hi"Строка не меняется «внутри»: операция создаёт новый объект, а переменная переназначается на него.К изменяемым (mutable) встроенным типам относятся:списки: list;словари: dict;множества: set;многие пользовательские классы.Пример со списком:items = [1, 2, 3]
other = items
items.append(4)
# и items, и other теперь указывают на один и тот же список [1, 2, 3, 4]Мы не создавали новый список, а изменили существующий; все ссылки на него видят изменения.Почему это важно для поведения кода?Совместное использование объектов.Для mutable: если две переменные указывают на один и тот же объект и вы его меняете, изменения видны через обе переменные. Для immutable: переназначение одной переменной не влияет на другие — создаётся новый объект, старый остаётся как есть.Аргументы функций.Если передать в функцию mutable‑объект (например, список) и изменить его внутри, изменения будут видны снаружи. Если передать immutable‑объект (например, число) и «изменить» его внутри, на самом деле вы создадите новый объект, и внешняя переменная не изменится. Пример:def add_item(lst):
   lst.append(1)
   
data = []
add_item(data)

# data == [1]  — список изменили в функции

def add_one(x):
   x += 1
   
n = 10
add_one(n)

# n по-прежнему 10 — число не изменилосьОшибки с параметрами по умолчаниюИз‑за изменяемости списков и словарей их опасно использовать как значения по умолчанию: список живёт между вызовами и накапливает данные. Это классический вопрос собеседований, и он напрямую связан с mutable‑поведением.

Question 6

Разница между is и ==?

Accepted Answer

Развернутое объяснениеКогда вы пишете:a == bPython спрашивает у объектов: «Вы представляете одно и то же значение?» — и вызывает под капотом метод __eq__. Поэтому:два разных списка [1, 2] и [1, 2] равны по значению;две разные строки "hi" и "hi" равны по содержимому и т.п.Когда вы пишете:a is bPython вообще не смотрит на содержимое, он сравнивает адреса объектов: «эти переменные указывают на один и тот же объект в памяти или нет?». Пример:x = [1, 2, 3]
y = [1, 2, 3]
z = x
x == y   # True  (значения совпадают)
x is y   # False (разные объекты)
x is z   # True  (это один и тот же объект)[x == y → True, x is y → False] — классический пример, который любят приводить на собеседованиях.Почему is нельзя использовать вместо ==?Иногда is «случайно» даёт True при сравнении чисел или коротких строк — из‑за кеширования и интернирования объектов в CPython. Это деталь реализации, а не гарантированное поведение. Опасный пример:a = 256
b = 256
a is b      # часто True, но это не то, на что стоит опираться
a = 257
b = 257
a is b      # может быть FalseПоэтому для сравнения чисел, строк, списков, словарей и т.д. всегда используем ==; is применяем только там, где реально важно, один ли это объект, — практически это сводится к проверкам is None и работе с синглтонами.Когда использовать каждый оператор?На собеседовании полезно явно сформулировать «правило»: Использовать == когда нужно сравнить значения: числа, строки, структуры данных. Примеры: сравнение идентификаторов, статусов, содержимого коллекций. Использовать is при проверке на None:if value is None:
   ...Такой стиль прямо рекомендуется PEP 8 и отраслевыми гайдлайнами. Также is нужен, когда мы заведомо имеем дело с синглтоном (например, объектом‑маркером) и нам важно отличить «тот самый объект» от любых других.Если сформулировать в одну фразу: == — «равны ли по смыслу», is — «это точно один и тот же объект?».На курсах TeoBrain мы закрепляем это на практических примерах: от простых сравнений значений до ситуаций, где ошибка выбора между == и is приводит к трудноуловимым багам — именно такие кейсы часто разбирают на собеседованиях уровня Junior.

Question 7

"Как работает import? Что такое модуль и пакет?"

Accepted Answer

Развернутое объяснениеКогда интерпретатор встречает строку вида:import mathон делает несколько шагов: Проверяет кеш загруженных модулей sys.modules: если модуль уже импортирован ранее, повторно он не загружается, используется уже существующий объект модуля. Ищет модуль по имени в путях из sys.meta_path / sys.path: стандартная библиотека, установленные пакеты, текущий проект и т.д. Создаёт объект модуля и выполняет его код один раз при первом импорте.Привязывает модуль к имени в текущем пространстве имён: после import math имя math становится доступно, и можно писать math.sqrt(4).Комбинации импорта:import module           # module.name
import module as m      # m.name
from module import name # name напрямую
from pkg import submod  # импорт из пакетаНа собеседовании важно показать, что вы понимаете: импорт — это не «подтянуть текст файла», а именно однократное выполнение модуля и дальнейшее использование его объектов.Что такое модуль?Модуль — это отдельный файл с расширением .py, содержащий функции, классы, константы и т.д. Примеры: math.py, utils.py, models.py — ваши файлы, которые можно импортировать; стандартные модули вроде os, sys, json и т.п.Каждый модуль — это отдельное пространство имён: всё, что объявлено внутри файла, живёт под его именем при импорте (utils.parse(), models.User). Код модуля выполняется один раз при первом импорте, дальше используется из кеша sys.modules.Что такое пакет?Пакет — это каталог (папка с файлами), который Python может импортировать как модуль и в котором лежат другие модули и подпакеты.Классическая структура:myapp/          # пакет
   __init__.py
   models.py   # модуль
   utils.py    # модуль
   api/        # вложенный пакет
       __init__.py
       v1.pyИмпорт верхнего уровня:import myapp
from myapp import models
from myapp.api import v1Пакет является пространством имён для своих подмодулей: myapp.models.User, myapp.api.v1.router. Для backend‑разработки пакеты — основа структурирования проекта: вы группируете код по доменным областям (users, billing, auth), а модули внутри содержат конкретные реализации.Как грамотно сформулировать на собеседовании?Оператор import находит модуль по имени, один раз загружает и выполняет его код, а затем привязывает объект модуля к имени в текущем пространстве имён. Модуль — это отдельный .py‑файл с кодом, который можно импортировать. Пакет — это каталог, который играет роль пространства имён и содержит модули и подпакеты, обычно с файлом __init__.py.В курсах TeoBrain мы уделяем этому отдельный блок: учим собирать backend‑проект из модулей и пакетов, работать с абсолютными и относительными импортами и избегать типичных проблем с путями, чтобы на собеседовании вы могли уверенно объяснять и демонстрировать структуру кода.

Question 8

Что такое исключения? Как работает try / except / finally?

Accepted Answer

Развернутое объяснениеВо время работы программы могут происходить ситуации, при которых обычное выполнение кода невозможно (деление на ноль, неверный индекс, ошибки ввода‑вывода и т.д.). Вместо немедленного «падения» Python создаёт объект‑исключение и поднимает его (raise). Если исключение не перехватить, программа завершится с ошибкой (трассировкой стека). Если перехватить — можно аккуратно обработать ошибку: вывести сообщение, вернуть заглушку, записать лог и продолжить выполнение.Как работает try / except?Блок try / except позволяет перехватывать и обрабатывать исключения:try:
   result = 10 / x
except ZeroDivisionError:
   result = None
   print("Деление на ноль недопустимо")Сначала выполняется код внутри try. Если ошибки нет — блок except пропускается. Если внутри try выброшено исключение соответствующего типа, выполнение try прерывается, и управление переходит в подходящий except. Если подходящего except нет — исключение «поднимается» дальше вверх по стеку; при отсутствии обработчика программа падает. Можно указать несколько except под разные типы ошибок или перехватывать несколько типов в одном except (Type1, Type2):.Зачем нужен finally?finally — это блок, который всегда выполняется после try/except: и когда всё прошло успешно, и когда произошло исключение, даже если внутри был return. Типичный пример — гарантированное освобождение ресурсов:file = open("data.txt")
try:
   data = file.read()
except OSError:
   print("Ошибка чтения файла")
finally:
   file.close()  # выполняется всегдаСхема здесь такова:try — «пробуем выполнить код, который может упасть»;except — «если упал именно так — обработаем»;finally — «в любом случае сделаем уборку: закроем файл, соединение с БД, освободим блокировку».В современном коде освобождение ресурсов часто делегируют контекстным менеджерам (with), но понимание try / except / finally всё равно проверяют на собеседованиях.Как ответить на собеседовании?Исключения — это механизм обработки ошибок в Python: при проблеме поднимается объект‑исключение. Блок try определяет код, где ошибка может возникнуть, в except мы перехватываем и обрабатываем конкретные типы исключений, а finally выполняется всегда и обычно используется для очистки ресурсов — закрытия файлов, соединений и т.п.В TeoBrain мы закрепляем это на практических задачах: от обработки ошибок ввода и деления до работы с сетью и файлами, чтобы к моменту собеседования вы умели не только объяснить конструкцию, но и применять её в реальных сценариях backend‑разработки.

Question 9

Что такое with (контекстный менеджер)?

Accepted Answer

Развернутое объяснениеКонтекстный менеджер — это объект, который умеет настраивать некоторый контекст перед выполнением блока кода и гарантированно его «убирать» после, независимо от того, завершился блок успешно или с исключением. Конструкция with как раз и используется для работы с такими объектами:with open("data.txt") as f:
   contents = f.read()
# здесь файл уже закрытВ этом примере при входе в блок with у объекта файла вызывается __enter__, возвращаемое значение попадает в переменную f;при выходе (даже если read() бросит исключение) будет вызван __exit__, который закроет файл. with — это «синтаксический сахар» над типичной конструкцией try/finally, упрощающий правильную работу с ресурсами.Как это выглядит внутри? Любой объект можно сделать контекстным менеджером, реализовав два метода:class MyContext:
   def __enter__(self):
       # код при входе в контекст (настройка ресурса)
       return self  # то, что попадёт в переменную после as
   def __exit__(self, exc_type, exc_val, exc_tb):
       # код при выходе (освобождение ресурса, логирование и т.п.)
       # вернуть True, чтобы «поглотить» исключение, или False/None, чтобы пробросить
       ...Использование:with MyContext() as ctx:
   # код внутри контекста
   ...На собеседовании обычно достаточно сказать, что контекстный менеджер — это объект с методами __enter__ и __exit__, а with гарантирует вызов __exit__ при выходе из блока.Практические примеры использования withТипичные сценарии использования контекстного менеджера, о которых полезно упомянуть:Работа с файлами:with open("log.txt", "a") as log_file:
   log_file.write("New event
")
# файл закрыт автоматическиБлокировки и потоки:from threading import Lock
lock = Lock()
with lock:
   # критическая секция
   ...Временное изменение окружения, таймеры и т.п.import time
class Timer:
   def __enter__(self):
       self.start = time.time()
       return self
   def __exit__(self, exc_type, exc_val, exc_tb):
       self.end = time.time()
       print(f"Elapsed: {self.end - self.start:.3f}s")
with Timer():
   do_something()Такие примеры часто спрашивают на интервью, чтобы проверить, понимаете ли вы идею «автоматической уборки».

Question 10

Как писать комментарии и docstrings?

Accepted Answer

Развернутое объяснениеКомментарии в Python начинаются с символа # и продолжаются до конца строки. Интерпретатор их игнорирует, они нужны только людям, читающим код.Основные принципы написания комментариев:Комментарий должен объяснять зачем написан данный код, а не повторять то, что и так видно из кода.\Строка комментария начинается с # и пробела, написана как связное предложение с заглавной буквы.Длина строки комментария — до ~72 символов, чтобы текст удобно читался в редакторах и терминалах.Примеры:# Пересчитываем баланс с учетом отменённых транзакций
balance = calculate_balance(transactions)
x = x + 1  # Компенсируем погрешность округленияНе стоит писать очевидное:i = 0  # устанавливаем i в ноль  # лишний комментарийТакие практики мы сразу внедряем в учебных проектах TeoBrain: студенты учатся писать комментарии там, где они реально помогают следующему разработчику.Docstrings: документация прямо в кодеDocstring — это строковый литерал в тройных кавычках """...""" (или '''...'''), который находится сразу после объявления модуля, функции, класса или метода.Пример для функции:def send_email(to, subject, body):
   """Send email message to specified recipient.
   Parameters:
       to (str): Recipient email address.
       subject (str): Email subject line.
       body (str): Plain text message body.
   """
   ...Docstring отвечает на вопрос что в целом делает объект, а не как это пошагово реализовано. Его можно увидеть при вызове функции интерактивной помощи (help(send_email)) или через атрибут __doc__, поэтому он является частью публичного интерфейса. PEP 8 рекомендует писать docstring’и для всех публичных модулей, классов, функций и методов. PEP 257 описывает структуру:Однострочный docstring — краткая фраза, заканчивающаяся точкой.Многострочный — первая строка‑резюме, затем пустая строка и более подробное описание, включая параметры, возвращаемые значения, возможные исключения.Это критически важно для больших backend‑проектов: docstring’и используются генераторами документации, IDE и коллегами, которые читают ваш код.Комментарии и docstring’и: когда что использовать?Docstring описывает интерфейс: модуль, функцию, класс, метод — что делает, какие аргументы принимает, что возвращает, какие есть ограничения и побочные эффекты. Комментарий поясняет конкретный участок реализации, если из кода это неочевидно: почему выбран такой алгоритм, какие есть особенности, временные обходные решения. Публичные функции и классы обязательно снабжаются docstring, сложная логика внутри — при необходимости дополняется комментариями.

Question 11

Что такое PEP 8?

Accepted Answer

Развернутое объяснениеPEP 8 — это документ из серии PEP (Python Enhancement Proposal), в котором описано, как правильно оформлять код на Python: какие отступы использовать, как называть переменные, где ставить пробелы, как разбивать длинные строки и как писать импорты. Он не меняет поведение языка, а задаёт «правила хорошего тона» — что‑то вроде орфографии и пунктуации, только для Python‑кода. Следование PEP 8 повышает читаемость, упрощает совместную разработку и часто является негласным требованием к коду в командах.На собеседовании обычно ожидают, что кандидат назовёт несколько ключевых принципов:Отступы: 4 пробела на уровень вложенности, табы не используются.Длина строки: рекомендуется не более 79 символов для кода и около 72–79 для комментариев и docstring’ов.Именование:переменные и функции — snake_case (строчные буквы с подчёркиваниями);классы — CamelCase;константы — UPPER_SNAKE_CASE.Пробелы: нет пробелов вокруг скобок вызова функции, нет лишних пробелов перед запятыми и двоеточиями, по одному пробелу вокруг бинарных операторов (=, +, == и т.д.).Пустые строки: две пустых строки между верхнеуровневыми функциями и классами, одна пустая строка между методами внутри класса.Импорты: сначала стандартная библиотека, затем сторонние пакеты, затем локальные модули; внутри группы — по алфавиту; каждый импорт — отдельной строкой.Всё это проверяют и автоматически: flake8, black, isort и другие инструменты форматирования ориентируются на PEP 8.Как об этом рассказать на собеседованииPEP 8 — это официальный стиль‑гайд Python, набор рекомендаций по оформлению кода. Он определяет отступы, максимальную длину строки, правила именования переменных, функций и классов, использование пробелов и порядок импортов. Соблюдение PEP 8 делает код единообразным и читаемым, а большинство линтеров и форматтеров ориентируются именно на него.На TeoBrain мы сразу вводим PEP 8 в учебных проектах: студенты привыкают писать код «как в продакшене», а не только «чтобы работало», что помогает чувствовать себя увереннее на настоящих собеседованиях.

Question 12

Как устроено управление памятью в Python (приватная куча, GC)?

Accepted Answer

Развернутое объяснениеПри создании объектов (числа, строки, списки, свои классы) память под них берётся не напрямую у операционной системы, а из специальной области — приватной кучи Python. Это внутренняя область памяти, в которой живут все Python‑объекты и структуры данных. Ей управляет Python memory manager: он отвечает за выделение, перераспределение и освобождение памяти. Разработчик на уровне обычного Python‑кода не управляет напрямую кучей (нет malloc/free), он работает только с объектами, а интерпретатор делает всё остальное. На собеседовании достаточно сказать, что «объекты хранятся в приватной куче, которой управляет интерпретатор, а не мы».Подсчёт ссылокОсновной механизм управления памятью в CPython — подсчёт ссылок (reference counting). У каждого объекта есть счётчик того, сколько на него ссылается переменных и других объектов: создаём новую ссылку → счётчик увеличивается; удаляем ссылку или переназначаем переменную → счётчик уменьшается; когда счётчик становится равным 0, объект уничтожается сборщиком мусора (garbage collector или GC), а память освобождается. Это даёт немедленную очистку ненужных объектов и предсказуемое поведение — понятно, когда конкретный объект будет удалён. Но есть ограничение: подсчёт ссылок не умеет сам по себе находить циклические ссылки, когда объекты ссылаются друг на друга, но больше нигде не используются. Чтобы справиться с циклическими ссылками, Python использует генерационный сборщик мусора. Объекты разделены на поколения (0, 1, 2) по «возрасту» — чем дольше объект живёт, тем реже его проверяют. GC периодически просматривает объекты, пытаясь обнаружить циклы ссылок, которые больше недостижимы из остальной программы. Найденные «мёртвые» циклические ссылки удаляются, освобождая память. Разработчик может при необходимости взаимодействовать с GC через модуль gc (например, gc.collect()), но в обычном backend‑коде это почти никогда не требуется.Как сформулировать ответ на собеседовании:В Python объекты живут в приватной куче, которой управляет встроенный менеджер памяти интерпретатора. Основной механизм — подсчёт ссылок: когда на объект больше никто не ссылается, память, занятая им, освобождается. Для циклических ссылок дополнительно используется генерационный garbage collector, который периодически находит и удаляет такие «зависшие» объекты.

Question 13

Что такое lambda-функция?

Accepted Answer

Развернутое объяснениеLambda‑функция (или анонимная функция) — это функция без имени, определяемая выражением вида:lambda параметры: выражениеТакое выражение создаёт объект функции; при вызове он вычисляет указанное выражение и возвращает его результат. Пример простейшей lambda‑функции:square = lambda x: x * x
square(5)  # 25По сути это эквивалентно:def square(x):
   return x * xРазница не в «типе функции», а в формате записи: lambda — краткая запись одноразовой функции.Основные свойства, которые важно озвучить на собеседовании:Анонимность. Lambda‑функция не имеет имени и часто передаётся сразу как аргумент другой функции, без предварительного объявления.Одно выражение. Внутри lambda нельзя писать несколько операторов, циклы и return; допускается только одно выражение, результат которого возвращается автоматически.Синтаксическая компактность. Удобна, когда полноценный def выглядит избыточно.Где lambda‑функции применяются на практике?Классические примеры, которые любят в вопросах и задачах:В сортировке (ключ сортировки):users = [
   {"name": "Анна", "age": 30},
   {"name": "Олег", "age": 25},
]
# сортируем по возрасту
sorted_users = sorted(users, key=lambda u: u["age"])В map, filter, sorted и других функциях высшего порядка:numbers = [1, 2, 3, 4]
# возвести все числа в квадрат
squares = list(map(lambda x: x * x, numbers))
# оставить только чётные
evens = list(filter(lambda x: x % 2 == 0, numbers))Вместо небольших одноразовых функций‑заглушек (например, в конфигурации):handlers = {
   "ping": lambda: "pong",
}В бэкенде такие конструкции встречаются реже, чем обычные def, но ты часто увидишь их при конфигурировании маршрутов, написании простых ключей сортировки и мини‑выражений для обработки коллекций.Lambda против обычной функции - краткое сравнение, которое ожидают услышать на собеседовании:Lambda‑функция:определяется через lambda;обычно не имеет имени;может содержать только одно выражение;используется для коротких, простых операций «на месте».Обычная функция (def):имеет имя;может содержать несколько строк кода, условия, циклы, return;подходит для любой нетривиальной логики и повторного использования.На курсах в TeoBrain мы показываем, где lambda‑функция помогает сделать код компактнее (например, при сортировке), а где использование def даёт гораздо более читаемый и поддерживаемый код, что особенно важно в продакшн‑бэкенде.

Question 14

Как работают циклы for и while? Что делают break, continue, pass?

Accepted Answer

Развернутое объяснениеЦикл forfor в Python — это «для каждого элемента в коллекции». Он сам берёт по очереди элементы из итерируемого объекта и завершает работу, когда элементы заканчиваются. Пример:numbers = [1, 2, 3]
for n in numbers:
   print(n)Особенности, которые важно понимать:Работает с любыми итерируемыми объектами (списки, строки, словари, множества, range и т.д.).Не нужно вручную управлять индексом: за этим стоит итератор, который for использует «под капотом».Для backend‑разработчика это базовый способ пройтись по коллекции данных: запросы, записи из БД, строки файла логов.Цикл whilewhile повторяет блок кода, пока условие истинно. Пример:count = 0
while count < 3:
   print(count)
   count += 1Особенности: Вы сами отвечаете за изменение состояния внутри цикла (иначе можно получить бесконечный цикл).Уместен там, где важно именно условие (например, ждать, пока придёт ответ или пока соединение не будет установлено).Оператор breakbreak немедленно завершает текущий цикл (for или while), управление переходит на первую строку после цикла. Пример:for n in range(10):
   if n == 5:
       break
   print(n)
# выведет 0, 1, 2, 3, 4Используется, когда условие завершения известно только внутри цикла (поиск элемента, проверка ограничения, обработка первой подходящей записи).Оператор continuecontinue прерывает текущую итерацию, но не завершает цикл — управление переходит к следующей итерации. Пример:for n in range(5):
   if n == 2:
       continue
   print(n)
# выведет 0, 1, 3, 4Это помогает пропустить «ненужные» случаи без вложенных if и держать тело цикла чище.Оператор passpass — это «пустая» инструкция, которая ничего не делает. Она нужна там, где синтаксически требуется тело блока, но логики пока нет. Примеры:for n in range(5):
   if n == 3:
       pass  # пока просто пропускаем этот случай
   print(n)
def stub_handler(request):
   pass  # заглушка обработчика, реализуем позжеВажно не путать:break — завершает цикл;continue — перескакивает на следующую итерацию;pass — просто стоИт на месте, управление идёт дальше по коду внутри блока.

Question 15

Что такое *args и **kwargs?

Accepted Answer

Развернутое объяснениеЗачем нужны *args и **kwargs? Иногда заранее неизвестно, сколько аргументов понадобится функции: два, три или десять. В таких случаях используют переменное число аргументов. Python даёт для этого два специальных механизма:*args — для дополнительного списка позиционных аргументов;**kwargs — для дополнительного набора именованных аргументов (пара имя=значение).На собеседованиях важно показать, что вы понимаете именно идею: «сделать функцию более гибкой по количеству входных параметров».Что такое *args? *args в определении функции означает: «Собери все дополнительные позиционные аргументы в один кортеж с именем args». Пример:def avg(*args):
   return sum(args) / len(args)
avg(1, 2, 3)      # 2.0
avg(10, 20, 30, 40)  # 25.0Особенности, которые полезно озвучить:Внутри функции args — это кортеж. Можно комбинировать обычные параметры и *args, но обычные параметры должны идти до *args.def log(prefix, *messages):
   for msg in messages:
       print(prefix, msg)
log("[INFO]", "start", "processing", "done")Что такое **kwargs?**kwargs в определении функции означает: «Собери все дополнительные именованные аргументы в словарь с именем kwargs». Пример:def create_user(**kwargs):
   # kwargs — словарь
   return kwargs
create_user(name="Alex", age=30, role="admin")
# {'name': 'Alex', 'age': 30, 'role': 'admin'}Важные моменты:Внутри функции kwargs — это словарь. Имена ключей совпадают с именами аргументов, переданных при вызове. Частый практический сценарий в backend: проксировать параметры дальше, например, в конструктор или базовую функцию:def wrapped_request(url, **options):
   options.setdefault("timeout", 5)
   return http_request(url, **options)Совместное использование и порядок аргументовВ одной функции можно использовать и *args, и **kwargs, но порядок параметров важен. Правило таково: сначала обычные позиционные параметры, далее *args. Далее именованные параметры (если есть) и наконец **kwargs. Пример:def handle_request(method, url, *args, retry=3, **kwargs):
   ...Такое объявление позволяет функции быть гибкой и по количеству обычных аргументов, и по набору именованных настроек.Как сформулировать ответ на собеседовании?*args и **kwargs позволяют функции принимать переменное число аргументов. *args собирает дополнительные позиционные аргументы в кортеж, а **kwargs — дополнительные именованные аргументы в словарь. Это удобно, когда заранее неизвестно, сколько параметров придёт в функцию или когда нужно прозрачно прокинуть аргументы дальше.Такой ответ показывает, что ты понимаешь не только синтаксис, но и практический смысл — именно это мы отрабатываем в задачах и проектах на TeoBrain, где *args и **kwargs часто используются в декораторах, обёртках и общих инфраструктурных функциях.

Question 16

Что такое функция? Как объявить функцию с параметрами по умолчанию?

Accepted Answer

Развернутое объяснениеФункция позволяет вынести повторяющийся или логически цельный фрагмент кода в отдельный блок с именем. Это даёт несколько преимуществ:Не дублируется код — одна функция может вызываться из разных мест программы;Код становится более понятным и структурированным;Проще тестировать и изменять поведение программы, не трогая все места вызова.Базовый синтаксис объявления функции:def function_name(parameters):
   # тело функции
   ...
   return result  # необязательноКлючевые части: def, имя функции, круглые скобки с параметрами и двоеточие, после чего следует блок с отступом.Для backend‑разработчика функция — базовый строительный блок: ей оформляют работу с базой данных, валидацию данных, бизнес‑логику. На курсах TeoBrain мы постепенно двигаемся от маленьких учебных функций к полноценным обработчикам запросов в веб‑приложениях.Параметры по умолчанию: как объявить и как это работаетПараметр по умолчанию — это параметр, которому в определении функции сразу задано стандартное значение. Если при вызове функции аргумент для него не передан, используется это значение; если передан — оно его переопределяет.Синтаксис:def greet(name, greeting="Hello"):
   print(greeting, name)
greet("Аня")                 # Hello Аня
greet("Максим", "Привет")   # Привет МаксимЗдесь важно помнить два правила, которые часто проверяют на собеседовании:Параметры с значениями по умолчанию должны идти после обязательных.def func(a, b=10):   # корректно
   ...
# def func(a=10, b):  # так нельзя — вызовет SyntaxErrorИначе Python не сможет корректно сопоставить позиционные аргументы с параметрами. При передаче в качестве значения по умолчанию изменяемых объектов (например, списков) нужно быть осторожным. Часто на собеседовании дают пример с «липким» списком: значение по умолчанию вычисляется один раз при определении функции, а не при каждом вызове. Это тонкость, которую мы подробно разбираем в блоке о функциях нашего курса TeoPython, но для уровня trainee достаточно знать, что по умолчанию чаще ставят простые неизменяемые значения — числа, строки, None.Как ответить на собеседовании?Функция в Python — это именованный блок кода, который можно вызывать с аргументами и, при необходимости, возвращать результат. Объявляется через def. Параметры по умолчанию задаются прямо в определении функции через =: def func(a, b=10). Если при вызове аргумент b не передан, используется значение 10.

Question 17

Как работают операторы in, not in, is, is not?

Accepted Answer

Развернутое объяснениеОператоры in и not in — проверка принадлежности. Операторы in и not in используются, чтобы узнать, содержится ли значение внутри другой сущности: списка, кортежа, строки, множества, словаря и т.п.x in s возвращает True, если x является элементом s (или ключом для словаря).x not in s возвращает True, если x не содержится в s.Примеры:numbers = [1, 2, 3]
3 in numbers       # True
5 in numbers       # False
5 not in numbers   # True
text = "hello"
"h" in text        # True
"x" not in text    # True
data = {"id": 1, "name": "TeoBrain"}
"id" in data       # True  (проверяются ключи словаря)
"TeoBrain" in data # FalseНа собеседовании важно подчеркнуть, что для словаря in проверяет именно ключи, а не значения. В реальном backend‑коде это постоянно используется при проверке наличия полей в данных запроса, конфиге или JSON‑объекте.Операторы is и is not — проверка тождестваis и is not — это операторы тождественности (identity). Они отвечают на вопрос: «Эти две переменные указывают на один и тот же объект в памяти или нет?»x is y — True, если x и y ссылаются на один и тот же объект.x is not y — True, если это разные объекты.Пример:a = [1, 2, 3]
b = [1, 2, 3]
c = a
a == b   # True  (значения равны)
a is b   # False (разные объекты)
a is c   # True  (это один и тот же объект)
a is not b  # TrueНа практике is чаще всего используют для сравнения с None (рекомендация стиля):value = None
if value is None:
   ...Именно это ожидают услышать интервьюеры, когда спрашивают про разницу == и is.Как не перепутать операторы на собеседовании?Краткое правило, которое уместно проговорить: Для проверки принадлежности в коллекции — in / not in. Для проверки тождественности (один и тот же объект) — is / is not. Для проверки равенства значений — ==, а не is.Типичная ошибка, о которой любят спрашивать: использование is вместо == для чисел и строк. Это может давать «случайно правильный» результат из‑за внутренних оптимизаций, но считается неправильной практикой.На курсах TeoBrain мы отдельно отрабатываем это на задачах: когда вы пишете проверки входных данных, валидируете JSON или сравниваете объекты доменной модели, важно на автомате выбирать правильный оператор и уметь объяснить, почему выбран именно он.

Question 18

Что такое индексирование и отрицательные индексы?

Accepted Answer

Развернутое объяснениеЧто такое индексирование? В Python многие типы данных являются последовательностями: строки (str), списки (list), кортежи (tuple), иногда диапазоны (range) и другие. Индексирование — это способ получить конкретный элемент такой последовательности по его позиции.Базовые правила:Индексация в Python начинается с 0: первый элемент — индекс 0, второй — 1, третий — 2 и т.д.Доступ к элементу осуществляется через квадратные скобки:items = ["a", "b", "c"]
items[1]  # "b"Если обратиться к индексу за пределами длины последовательности, будет IndexError. На собеседовании от вас ждут, что вы уверенно объясните нумерацию с нуля и покажете, что умеете работать с индексами в списках и строках.Что такое отрицательные индексы?Кроме положительных индексов, Python поддерживает отрицательное индексирование. Это удобный способ обратиться к элементам с конца последовательности, не рассчитывая вручную её длину.Правила отрицательных индексов:-1 — последний элемент;-2 — предпоследний;-3 — третий с конца и так далее до -len(seq).Пример:numbers = [10, 20, 30, 40, 50]
numbers[-1]  # 50, последний элемент
numbers[-2]  # 40, предпоследний элемент
numbers[-3]  # 30Это особенно полезно в backend‑коде, когда вы работаете с динамическими списками (записи логов, история операций, последние элементы очереди) и хотите взять «последний» элемент, не зная точную длину.Индексы и срезыОт индексов логично перейти к срезам, потому что на собеседованиях эти темы часто идут вместе. Индекс: возвращает один элемент, например items[2]. Срез возвращает подпоследовательность, например, items[1:4] — элементы с индексами 1, 2, 3.Отрицательные индексы работают и в срезах:numbers = [10, 20, 30, 40, 50]
numbers[-2:]   # [40, 50] — последние два элемента
numbers[:-1]   # [10, 20, 30, 40] — всё, кроме последнегоВажно помнить об общем правиле срезов: правая граница не включается, независимо от того, положительный или отрицательный индекс используется.Как сформулировать ответ на собеседовании?Хороший устный ответ может звучать так. Индексирование — это доступ к элементу последовательности по его позиции через квадратные скобки, при этом Python использует нумерацию с нуля. Отрицательные индексы позволяют обращаться к элементам с конца: -1 — последний элемент, -2 — предпоследний и так далее. Это удобно, когда заранее неизвестна длина списка или строки.На TeoBrain мы закрепляем эту тему через задачи: от простого доступа к элементам и разворота строк до более практичных сценариев — работы с последними записями логов, очередями запросов и обрезкой данных по концам списка.

Question 19

В чём разница между list и tuple?

Accepted Answer

Развернутое объяснениеГлавное различие: изменяемость. И list, и tuple — это последовательности: они хранят элементы по порядку, поддерживают индексацию, срезы и перебор в цикле. Но принципиальное отличие одно:Список (list) изменяемый (mutable).Можно менять существующие элементы, добавлять новые, удалять старые (методы append, extend, insert, remove, pop);Присвоение по индексу items[0] = ...;Изменение части списка срезом items[1:3] = [...].Кортеж (tuple) неизменяемый (immutable).После создания кортеж нельзя изменить;нельзя присвоить t[0] = ...;нельзя удалить элемент del t[0];Любые «изменения» на самом деле создают новый кортеж. Именно этот аспект — изменяемость — чаще всего ожидают услышать первым в ответе на собеседовании.Есть и другие отличия, которые стоит упомянуть. Когда рекрутер уточняет: «А кроме изменяемости что-то ещё?», полезно назвать ещё несколько моментов.Сценарии использованияlist логично использовать для коллекций, которые меняются, фильтруются, сортируются — например, список пользователей, задачи в очереди, результаты выборки из базы. tuple хорошо подходит для фиксированных структур: координата (x, y), дата (год, месяц, день), результат функции, возвращающей сразу несколько значений.Методы и операцииУ списков больше методов для изменения содержимого (append, sort, reverse и т.п.). У кортежей набор методов минимален, так как их изменять нельзя.Производительность и памятьКортежи, как правило, занимают немного меньше памяти и могут итерироваться чуть быстрее за счёт своей неизменяемости. На уровне собеседования достаточно упомянуть, что tuple — более «лёгкая» структура для постоянных данных, а list — более гибкая, но эта гибкость дается немного большей ценой в виде затрат памяти и скорости работы.Сильный ответ может звучать так:Оба типа — упорядоченные последовательности, но список — изменяемый, а кортеж — нет. Список используют там, где данные нужно добавлять, удалять или обновлять, кортеж — для фиксированных наборов, например, возврат нескольких значений из функции. Кортежи обычно немного легче по памяти и безопаснее, потому что их нельзя случайно поменять.Именно вокруг таких формулировок мы строим тренажёры и занятия на курсах TeoBrain: ты сначала отрабатываешь краткий «интервью‑ответ», а затем на практических задачах видишь, где в реальном backend‑коде разумно выбирать list, а где — tuple.

Question 20

Какие встроенные типы данных есть в Python (int, str, list, tuple, dict, set)?

Accepted Answer

Развернутое объяснениеНа собеседованиях по Python практически всегда проверяют понимание встроенных типов данных, потому что на них держится любой backend‑код. Официальная документация Python группирует типы по категориям: числовые, последовательности, отображения, множества и т.д., но от кандидата обычно ждут уверенного объяснения именно int, str, list, tuple, dict, set.Ниже — кратко по каждому типу в том виде, как это рекомендуется формулировать на собеседовании.int — целые числаint представляет целые числа: положительные, отрицательные, ноль. В Python нет ограничения по разрядности int в привычном смысле: число может быть сколь угодно большим, пока хватает памяти.
Примеры: 0, -5, 42, 10_000_000.
В backend‑разработке int используют для идентификаторов, счётчиков, статусов, размеров и т.д.
str — строкиstr — это неизменяемая (immutable) последовательность символов Unicode. Строки применяются для хранения текста: имён, email‑адресов, JSON‑фрагментов, логов.Важно понимать два момента, которые любят уточнять на интервью:Строки неизменяемы: любая «изменяющая» операция на самом деле создаёт новый объект.Строка — это последовательность, к ней применимы операции индексирования, срезов, конкатенации и проверки вхождения (in).list — списокlist — изменяемая упорядоченная коллекция элементов. В список можно добавлять, удалять и изменять элементы по индексу.Характерные свойства, которые важно озвучить:Сохраняет порядок добавления элементов.Может содержать элементы разных типов, но в реальном коде лучше придерживаться однородности.Поддерживает операции срезов, итерацию, методы append, extend, insert, remove и т.д.Иногда на интервью отдельно спрашивают о различиях list и tuple, поэтому важно связно сравнивать именно их.tuple — кортежtuple — упорядоченная неизменяемая последовательность элементов. Основное отличие от списка: после создания кортеж нельзя изменить (нельзя добавить/удалить элементы или изменить по индексу).Где это важно? Кортежи часто используют для хранения фиксированной структуры (например, координата (x, y)), а также как ключи в словарях. Неизменяемость делает tuple более безопасным в ситуациях, где данные не должны случайно меняться.dict — словарьdict — отображение «ключ–значение». Ключи обычно должны быть хешируемыми и неизменяемыми (строки, числа, кортежи из неизменяемых типов), а значение может быть любым объектом.Свойства, о которых важно упомянуть на собеседовании:Быстрый доступ по ключу (через хеш‑таблицу).Начиная с Python 3.7 словари сохраняют порядок добавления элементов, что часто используется в веб‑разработке. В backend‑коде dict лежит в основе работы с JSON, конфигами, параметрами запросов и внутренними структурами данных.set — множество уникальных элементовset — неупорядоченное множество уникальных элементов. Как и в dict, элементы множества должны быть хешируемыми.Ключевые моменты:Автоматически устраняет дубликаты.Поддерживает операции теории множеств: объединение, пересечение, разность.Обеспечивает быстрый поиск «принадлежит / не принадлежит» (in).На собеседованиях часто дают практические задачи: «убрать дубликаты из списка», «найти общие элементы двух коллекций» — это как раз прямой повод использовать set.Как ответить на собеседовании?Кратко перечислить типы и назначение: int, str, list, tuple, dict, set. Отдельно подчеркнуть изменяемость (list, dict, set — изменяемые; int, str, tuple — неизменяемые). По необходимости — привести пример использования для одного‑двух типов (например, dict для JSON‑ответов API, set для удаления дублей).Именно в таком стиле мы строим тренажёры собеседований на TeoBrain: сначала вы отрабатываете короткий ответ для собеседования, а затем в задачах и мини‑проектах закрепляете, как эти типы работают в реальном backend‑коде — от простых списков до вложенных словарей с конфигурациями и телами запросов.

Question 21

Что такое Python? Чем он отличается от компилируемых языков?

Accepted Answer

Что такое Python и почему его так любят?Python — один из самых популярных языков для веб‑разработки, анализа данных, автоматизации, машинного обучения и DevOps. Он относится к высокоуровневым языкам: разработчик работает с понятными сущностями (файлы, строки, объекты, запросы), а детали работы процессора и памяти скрыты под абстракциями.Ключевые свойства Python, которые часто отмечают на собеседованиях:Читаемый, лаконичный синтаксис, который снижает порог входа.Богатая стандартная библиотека и огромная экосистема сторонних пакетов.Автоматическое управление памятью (garbage collector, счётчик ссылок), что снимает с разработчика часть рутинных задач.Интерпретируемый язык с шагом компиляцииВ источниках по подготовке к собеседованиям вопрос формулируют по‑разному: «Python — интерпретируемый или компилируемый язык?» Корректно отвечать так, чтобы показать понимание внутреннего устройства: В реализации CPython (эталонный варинат виртуальной машины Python) -  Python компилируется в байткод, а затем этот байткод интерпретируется виртуальной машиной Python.Когда вы запускаете файл script.py, интерпретатор сначала создаёт байткод (обычно сохраняется как .pyc в __pycache__), а потом пошагово выполняет его. Именно поэтому в большинстве учебных материалов Python относят к интерпретируемым языкам — основной способ работы с ним через интерпретатор, а не через отдельный бинарный файл.Чем Python отличается от компилируемых языков?Если сравнить с типичными компилируемыми языками (C, C++, Rust), то разница в следующем:Где происходит перевод кода. В компилируемых языках код заранее переводится компилятором в машинный код, и результатом является исполняемый файл или библиотека. В Python же основная работа происходит во время запуска: интерпретатор сам компилирует исходный код в байткод и тут же интерпретирует его, без явного шага «сборки» для разработчика.Скорость выполнения. Машинный код, полученный компилятором C/C++, как правило, выполняется быстрее, чем байткод, который обрабатывает виртуальная машина. Вот почему на собеседованиях могут спрашивать, как вы компенсируете это в backend‑разработке на Python? Компенсация достигается за счёт правильной архитектуры, вынесения тяжёлых вычислений в нативные библиотеки, кэширования и горизонтального масштабирования.Скорость разработки и отладки. В Python проще цикл «написал → запустил → изменил»: нет отдельного явного этапа линковки и сборки, быстро видны ошибки и результат. Это ценят работодатели, Python часто выбирают там, где важна скорость вывода продукта на рынок.Портируемость. В компилируемых языках исполняемый бинарный файл обычно собирается под конкретную платформу. В Python тот же исходный код запускается на разных ОС при наличии нужной версии интерпретатора, что удобно для кроссплатформенных backend‑систем.На собеседованиях, как правило, именно эти акценты и ожидают услышать от кандидата: понимание не только того, что «Python интерпретируемый», но и как именно он исполняется и чем это отличается от классической модели компиляции.Как дать сильный ответ на собеседовании?Хорошая формулировка, которая укладывается в 20–30 секунд и демонстрирует глубину: Python — высокоуровневый язык общего назначения с автоматическим управлением памятью. В реализации CPython он сначала компилируется в байткод, а затем выполняется виртуальной машиной, поэтому его обычно относят к интерпретируемым языкам. В отличие от C/C++ мы не получаем отдельный бинарный файл, перевод и выполнение происходят «на лету» интерпретатором, что упрощает разработку, но даёт дополнительные накладные расходы по сравнению с нативным машинным кодом.

Вопросы для собеседований с группировкой по стеку и уровню

Собери свой маршрут подготовки к собеседованию!

Выбери технологию, по которой готовишься к собеседованию

Выбери уровень экспертности, на который рассчитываешь

Начни сфокусированную подготовку к собеседованию