YouTube

• Ну НАСТОЯЩИЙ Senior! 10 лет опыта и экспертиза абсолютно во ВСЁМ? / Техсобес Senior Python Developer
• ТОП 70 ВОПРОСОВ НА СОБЕСЕДОВАНИИ SENIOR PYTHON DEVELOPER
• #33 Собеседование Python 2025 в BIG TECH компанию | Разбор вопросов
• Python разработчик | Собеседование с задачей из Яндекса. Максим Никулин
• «Техническое собеседование python-разработчика уровня мидл»

Рекомендации по подготовке к интервью в разных компаниях

• ТБанк: Как проходит интервью по Python
• Подготовка к алгоритмической секции (Яндекс):
  • https://leetcode.com/explore/featured/card/top-interview-questions-easy/127/strings/885/
  • https://leetcode.com/problems/kth-smallest-element-in-a-bst/
  • https://leetcode.com/problems/group-anagrams/
  • https://leetcode.com/problems/decode-ways/
  • https://leetcode.com/problems/word-break/
  • https://leetcode.com/problems/integer-to-roman/
  • Строки, массивы
  • Хеш-таблицы, словари
  • Обход двоичного дерева
  • Реализация различных примитивов: счётчиков, кешей и т. д.

Подборки задач (Leetcode и другие)

• Blind 75 LeetCode Questions
• neetcode.io
• Best Free Coding Interview Prep Resources in 2026 (Complete List)
• Coding Interview Prep (awesome interview)
• Моя подборка задач Easy уровня на Leetcode:
  • 1. Arrays Easy
  • 2. String Easy
  • 3. Sorting Easy
  • 4. Counting Easy
• Решение задач по алгоритмам «Подготовка к собеседованиям (задачи)»

Сообщение Подготовка к собеседованию Python появились сначала на DataTalks.RU. Data Engineering / DWH / Data Pipeline.

YouTube ролики

• Как работает GIL в Python. Многопоточность. Многопроцессность. IO/CPU-Bound
• Yandex for Developers — 01. Устройство CPython – Егор Овчаренко
• [ZProger] Многопоточность и Многопроцессорность Python. Threading & Multiprocessing Python
• Асинхронность, многопоточность, многопроцессность в python | Библиотека asyncio и асинхронный код
• Threading. Кратко про Python
• Плейлист Асинхронность в Python
• Young&&Yandex ШБР 2023 — Асинхронное программирование (Python) — полный плейлист Python ШБР 2023
• Особенности asyncio.wait_for() в асинхронном Python. Как работает таймаут для корутины
• Плейлист Асинхронность в Python
• Асинхронное программирование на примере Python / asyncio
• Собеседование Python. Разбор вопросов
• Денис Аникин. Вновь ускоряем cpu-bound задачи
• Python: Threads, GIL, asyncio
• Лекция Тимофей Хирьянов — Параллельное программирование на Python
• Yandex Developer (плейлист Школа бэкенд-разработки 2019) — Асинхронное программирование — Лекция 1, Лекция 2, Лекция 3
  • Плейлист Школа бэкенд-разработки 2021
• Плейлист «Конкурентность в Python»
• GIL в Python: зачем он нужен и как с этим жить
• Асинхронный Python-код медленнее обычного кода! Ааа!!1один. Aiohttp VS синхронные фреймворки

YouTube English:

• PlayList: Воспроизвести все import asyncio: Learn Python’s AsyncIO
• CPU Bound vs. I/O Bound | Computer Basics
• threading vs multiprocessing in python
• I/OBound vs CPU Bound Code

Статьи

• CPython простыми словами: всё, что нужно знать начинающему
• Как устроен GIL (Global Interpreter Lock) в Python: влияние на многозадачность и производительность
• Как устроен GIL в Python
• Глобальная блокировка интерпретатора (GIL) и её воздействие на многопоточность в Python
• Всё, что нужно знать о сборщике мусора в Python
• Визуализация управления памятью в Python: что творится внутри?

Введение в Python

Исходный глоссарий

Виртуальное адресное пространство

Виртуальное адресное пространство — это абстракция, предоставляемая ОС, в рамках которой каждый процесс видит собственную непрерывную адресную память, не зная о реальном физическом расположении данных.

Структура виртуального адресного пространства

Высокие адреса
┌─────────────────────────┐
│ Kernel space (отображ.) │  ← недоступен напрямую
├─────────────────────────┤
│ Stack                   │  ← стек потоков
├─────────────────────────┤
│ Heap                    │  ← объекты Python
├─────────────────────────┤
│ Data / BSS              │  ← глобальные переменные
├─────────────────────────┤
│ Code (text segment)     │  ← байткод + C-расширения
└─────────────────────────┘
Низкие адреса

Python не управляет адресным пространством напрямую — он запрашивает память у ОС через malloc, mmap, brk.

Heap & Stack

Стек(stack) и куча(heap) – области в оперативной памяти (ОЗУ, RAM), в которых хранятся данные приложения во время его выполнения. Управление оперативной памятью для приложения Python осуществляется с помощью Python memory manager.

В управлении памятью (Python memory management) существует механизм учёта ссылок (reference counting), который ведет внутренний журнал того, как много ссылок ссылается на объект в куче. Когда на объект не ссылается ни одна ссылка сборщик мусора (Garbage collector) автоматически освобождает память выделенную ранее для этого объекта.

Heap — область памяти процесса, предназначенная для динамического выделения памяти во время выполнения.

В Python:

• все объекты Python живут в heap
• int, list, dict, class, function — всё heap

Stack — область памяти, используемая для хранения локальных переменных, адресов возврата, аргументов функций. Каждый поток имеет собственный стек.

Python stack — это логическая абстракция, а не «настоящий» stack ОС.

Дескрипторы ресурсов (File Descriptors)

File descriptor — это целое число, которое операционная система даёт твоей программе, когда она открывает файл или другое устройство ввода-вывода (например, сокет, pipe). Это как минимальный идентификатор ресурса: Python использует его для низкоуровневых операций с файлами.

• Это не объект Python, это число, под которым ОС видит открытый файл/ресурс.
• С помощью FD можно делать низкоуровневые операции (чтение, запись, дупликация, перемещение позиции и т.п.).
• Отличие от обычного open() в том, что FD используют функции модуля os, а не методы объекта файла.

Каждый FD — ограниченный ресурс. Если ты открыл много файлов или сокетов и не закрыл их, система закончится и новые операции упадут с ошибками вроде Too many open files. Это особенно критично для серверов, которые держат много соединений одновременно.

В Unix-системах всё представляется как файл. Стандартные дескрипторы:

• 0 — stdin
• 1 — stdout
• 2 — stderr

Ты можешь перенаправлять их (например, в скриптах bash или в приложениях), и это тоже работает через FD.

Примеры ресурсов: файлы, сокеты, pipe, eventfd, epoll/kqueue

Глобальные переменные в Python

Глобальные переменные — это имена, привязанные в namespace модуля.

В реальности:

• имя x → указатель
• объект 10 → heap
• namespace модуля → dict в heap

Регистры CPU

Регистры CPU — сверхбыстрая память внутри процессора.

Хранят: указатель инструкции (IP), указатель стека (SP), флаги, временные значения.

Python не управляет регистрами напрямую. Но при context switch ОС сохраняет регистры, при переключении потоков Python → регистры меняются. Это основная стоимость context switch.

User Space

User space — режим выполнения с ограниченными правами.

Python-код выполняется исключительно в user space.

Запрещено:

• прямой доступ к устройствам
• управление памятью
• прерывания

Kernel Space

Kernel space — привилегированный режим выполнения.

Ядро:

• управляет памятью
• планирует процессы
• обрабатывает I/O
• управляет сетевым стеком

Что такое процесс, поток, системный вызов и context switch?

Процесс — это изолированное выполняемое окружение, предоставляемое ОС. Каждый процесс имеет собственное виртуальное адресное пространство, heap, stack, дескрипторы ресурсов (файлы, сокеты).

Поток (Thread) — это единица выполнения внутри процесса. Потоки разделяют одно адресное пространство процесса, каждый поток имеет собственный stack, выполняются псевдопараллельно внутри 1 процесса. Общее у потоков heap, глобальные переменные, объекты Python. Раздельное — stack, регистры CPU.

Системный вызов — это контролируемый переход из user space в kernel space.

Python-код не может напрямую:

• читать диск
• писать в сокет
• создавать процесс
• спать

Что происходит при системном вызове:

• Python вызывает C-функцию
• C-функция делает syscall
• ОС выполняет операцию
• Поток блокируется, пока ОС не закончит

В этот момент:

• GIL может быть освобождён
• другой поток может выполняться

Context switch — это переключение CPU с одной задачи на другую.

Бывает:

• между потоками
• между процессами

Что сохраняется:

• регистры CPU
• указатель стека
• состояние планировщика

Архитектура CPython

CPython — это эталонная реализация языка программирования Python. Это версия Python по умолчанию, наиболее широко используемая и оригинальная реализация, написанная преимущественно на языке C.

Иными словами CPython — это программа, которая принимает ваш код на Python и выполняет его, преобразуя в понятные машине действия.

1. Исходный код (Source code) – mymodule.py преобразуется в байт-код с помощью компилятора (compiler) Python
2. Байт-код (Byte code) сохраняется в определенном формате (.pyc, .pyo, .pyd) – mymodule.pyc
3. Виртуальная машина Python (или PVM) получает байт-код и с помощью интерпретатора преобразует его в бинарный код.
4. Бинарный или машинный код (Binary code)
5. Компьютер читает бинарный код и выполняет программу

Важно понимать разницу между языком Python и интерпретатором CPython. Язык Python — это набор правил и синтаксиса (описанных в документации), а CPython конкретная программа, исполняющая код на этом языке.

Python — язык, а CPython — его основной движок.

Что такое PVM?

Мы знаем, что компьютеры понимают только машинный код, состоящий из нулей и единиц. Поскольку компьютер понимает исключительно машинный код, любой программный код перед выполнением должен быть преобразован в машинный код. Для этого используется компилятор. Обычно компилятор преобразует исходный код программы непосредственно в машинный код.

Компилятор Python выполняет ту же задачу, но несколько иным образом. Он преобразует исходный код программы в другой вид кода, называемый байт-кодом. Каждая инструкция программы на Python преобразуется в набор инструкций байт-кода.

Виртуальная машина Python (Python Virtual Machine, PVM) принимает этот байт-код и преобразует его в машинный код, чтобы компьютер мог выполнить соответствующие инструкции и вывести итоговый результат. Для выполнения этого преобразования PVM оснащена интерпретатором. Интерпретатор преобразует байт-код в машинный код и передаёт этот машинный код процессору компьютера для выполнения. Поскольку именно интерпретатор играет ключевую роль, виртуальную машину Python часто также называют интерпретатором.

Альтернативные реализации

Хотя CPython является стандартной реализацией, существуют и другие реализации Python, созданные для конкретных задач, таких как повышение производительности или интеграция с другими платформами:

• PyPy — использует компиляцию Just-In-Time (JIT), что позволяет во многих случаях выполнять Python-код значительно быстрее, чем в CPython.
• Jython — написан на Java и компилирует Python-код в байткод Java, что позволяет запускать Python на виртуальной машине Java (JVM) и взаимодействовать с библиотеками Java.
• IronPython — реализован для Common Language Infrastructure (CLI), благодаря чему может работать на платформе .NET.
• MicroPython / CircuitPython — оптимизированные реализации, предназначенные для микроконтроллеров и встраиваемых систем.

Производительность

Те, кто имеют опыт работы с компилирующими языками программирования, такими как C и C++, могут заметить несколько отличий в модели выполнения Python.

• Первое, что бросается в глаза, – это отсутствие этапа сборки, или вызова утилиты «make»: программный код может запускаться сразу же, как только будет написан.
• Второе отличие: байт код не является двоичным машинным кодом (например, инструкциями для микропроцессора Intel). Байт код – это внутреннее представление программ на языке Python.

По этой причине программный код на языке Python не может выполняться так же быстро, как программный код на языке C или C++. Обход инструкций выполняет виртуальная машина, а не микропроцессор, и чтобы выполнить байт код, необходима дополнительная интерпретация, инструкции которого требуют на выполнение больше времени, чем машинные инструкции микропроцессора. С другой стороны, в отличие от классических интерпретаторов, здесь присутствует дополнительный этап компиляции – интерпретатору не требуется всякий раз снова и снова анализировать инструкции исходного текста. В результате Python способен обеспечить скорость выполнения где то между традиционными компилирующими и традиционными интерпретирующими языками программирования.

GIL (Global Interpreter Lock)

GIL (Global Interpreter Lock) — интерпретатор Python однопоточный в том смысле, что в каждый момент времени может выполняться только один участок байт-кода, даже если в процессе работает несколько потоков. Глобальная блокировка интерпретатора не позволяет выполнять несколько потоков одновременно.

Python может освободить GIL на время выполнения операций ввода-вывода (I/O Bound), потому что для выполнения ввода-вывода вызывается низкоуровневая функция операционной системы. Эти функции работают за пределами интерпретатора, т. е. никак не могут повредить его внутренние структуры, от чего и призвана защитить GIL.

GIL был введён для упрощения управления памятью в Python, поскольку многие внутренние операции, такие как создание объектов, по умолчанию не являются потокобезопасными. Без GIL нескольким потокам, одновременно обращающимся к общим ресурсам, потребовались бы сложные механизмы блокировок или синхронизации для предотвращения гонок данных и повреждения состояния.

Когда GIL становится узким местом?

• В однопоточных программах GIL не имеет значения, так как поток обладает эксклюзивным доступом к интерпретатору Python.
• В многопоточных I/O-bound программах влияние GIL менее заметно, поскольку потоки освобождают GIL во время ожидания операций ввода-вывода.
• В многопоточных CPU-bound задачах GIL становится серьёзным узким местом. Несколько потоков, конкурируя за GIL, вынуждены по очереди выполнять байткод Python.

Интересный случай, на который стоит обратить внимание, — использование time.sleep. Python фактически рассматривает time.sleep как I/O-операцию. Функция time.sleep не является CPU-bound, поскольку во время сна не происходит активных вычислений или выполнения байткода Python. Вместо этого ответственность за отслеживание прошедшего времени передаётся операционной системе. В течение этого времени поток освобождает GIL, позволяя другим потокам выполняться и использовать интерпретатор.

Когда GIL может освобождать поток?

Ситуация	GIL
time.sleep()	отпущен
I/O	отпущен
lock.acquire() (ожидание)	отпущен
C-расширение без Python API	отпущен
Чистый Python CPU-код
Работа с Python-объектами
Переключение по таймеру	временно

Рассмотрим подробно каждую ситуацию.

1 кейс — блокирующие операции (I/O, sleep, lock wait): Когда поток заходит в операцию, которая может надолго заблокироваться, CPython отпускает GIL.

time.sleep()

I/O:

sock.recv()
sock.send()
open().read()
requests.get()

Ожидание примитивов синхронизации

lock.acquire()      # если lock уже занят
event.wait()
condition.wait()
queue.get()         # если очередь пуста

Кейс 2 — выполнение C-кода, который отпускает GIL: Если поток заходит в C-расширение, где внутри есть:

Py_BEGIN_ALLOW_THREADS
// тяжёлая работа без Python-объектов
Py_END_ALLOW_THREADS

текущий поток временно теряет GIL.

Примеры библиотек:

• numpy
• hashlib
• zlib
• Pillow

C-расширение без Python API: C-код, который во время выполнения не создаёт, не читает и не изменяет Python-объекты (PyObject*).

Пример Python API в C:

PyLong_FromLong(10);      // создаёт Python-объект
PyList_Append(list, x);  // меняет Python-объект
Py_INCREF(obj);          // меняет refcount
PyObject_CallObject(f);  // вызывает Python-функцию
PyErr_SetString(...);    // трогает исключения

CPU-bound vs I/O-bound задачи

I/O-bound

I/O-bound задача — это задача, выполнение которой блокируется ожиданием операций ввода-вывода (I/O), например сетевых запросов, чтения/записи на диск или работы с внешними устройствами, и поэтому большая часть времени тратится не на вычисления, а на ожидание завершения этих операций.

CPU-bound

CPU-bound задача — это задача, выполнение которой ограничено мощностью центрального процессора (CPU), а не ожиданием ввода-вывода. Время её выполнения определяется главным образом количеством вычислительных операций, которые нужно выполнить CPU, а не тем, сколько времени тратится на ожидание данных из внешних источников.

Многозадачность в Python

Concurrency vs Parallelism

• Concurrency — это управление несколькими задачами в одно и то же время, но не обязательно их одновременное выполнение. Задачи могут выполняться по очереди, создавая иллюзию многозадачности.
• Parallelism — это одновременное выполнение нескольких задач, как правило за счёт использования нескольких ядер CPU.

Критерии выбора подхода — Multithreading, Multiprocessing или Asyncio

Multiprocessing (многопроцессность)

• Лучше всего подходит для CPU-bound задач, требующих интенсивных вычислений.
• Используется, когда необходимо обойти GIL — каждый процесс имеет собственный интерпретатор Python, что позволяет достичь настоящего параллелизма.

Multithreading (многопоточность)

• Лучше всего подходит для быстрых I/O-bound задач, так как уменьшается частота переключений контекста, и интерпретатор Python дольше остаётся в одном потоке.
• Не подходит для CPU-bound задач из-за ограничений GIL.

Asyncio (асинхронность)

• Идеально подходит для медленных I/O-bound задач, таких как длительные сетевые запросы или обращения к базе данных, поскольку эффективно обрабатывает ожидание и хорошо масштабируется.
• Не подходит для CPU-bound задач, если вычисления не выносятся в другие процессы.

threading

threading в CPython — это инструмент для I/O-параллелизма.

Начальный пример Threading

Модуль threading предоставляет способ запуска нескольких потоков (меньших единиц процесса) конкурентно внутри одного процесса. Он позволяет создавать и управлять потоками, делая возможным параллельное выполнение задач с разделяемым адресным пространством памяти. Потоки особенно полезны, когда задачи являются I/O-bound, например при работе с файлами или выполнении сетевых запросов, где значительная часть времени тратится на ожидание внешних ресурсов.

Типичный сценарий использования threading — управление пулом рабочих потоков, которые могут конкурентно обрабатывать несколько задач. Ниже приведён базовый пример создания и запуска потоков с использованием Thread:

import threading
import time
import random
from datetime import datetime

def crawl(link):
    print(f"crawl запустился для ссылки {link}. Время вызова: {datetime.now()}")
    time.sleep(random.randint(1, 11))  # Блокирующий I/O (имитация сетевого запроса)
    print(f"crawl завершен для {link}. Время вызова: {datetime.now()}")

links = [
    "https://python.org",
    "https://docs.python.org",
    "https://peps.python.org",
]

# Создаём потоки для каждой ссылки
threads = []
for i, link in enumerate(links):
    # Используем `args` для позиционных аргументов и `kwargs` для именованных
    t = threading.Thread(target=crawl, args=(link,), name=f"Thread-{i+1}")
    threads.append(t)

# Запускаем каждый поток
for t in threads:
    t.start()
    print(f'Поток {t} запущен в {datetime.now()}')

# Ожидаем завершения всех потоков
for t in threads:
    t.join()
    print(f'{t} завершен в {datetime.now()}')

Результат:

crawl запустился для ссылки https://python.org. Время вызова: 2025-12-27 13:38:45.574122
Поток <Thread(Thread-1, started 138519994431168)> запущен в 2025-12-27 13:38:45.574331
crawl запустился для ссылки https://docs.python.org. Время вызова: 2025-12-27 13:38:45.574500
Поток <Thread(Thread-2, started 138519986038464)> запущен в 2025-12-27 13:38:45.574558
crawl запустился для ссылки https://peps.python.org. Время вызова: 2025-12-27 13:38:45.574701
Поток <Thread(Thread-3, started 138519977645760)> запущен в 2025-12-27 13:38:45.574758
crawl завершен для https://python.org. Время вызова: 2025-12-27 13:38:46.574254
<Thread(Thread-1, stopped 138519994431168)> завершен в 2025-12-27 13:38:46.574417
crawl завершен для https://docs.python.org. Время вызова: 2025-12-27 13:38:47.574610
<Thread(Thread-2, stopped 138519986038464)> завершен в 2025-12-27 13:38:47.574773
crawl завершен для https://peps.python.org. Время вызова: 2025-12-27 13:38:47.574813
<Thread(Thread-3, stopped 138519977645760)> завершен в 2025-12-27 13:38:47.574895

Результат второго запуска:

crawl запустился для ссылки https://python.org. Время вызова: 2025-12-27 13:44:50.159111
Поток <Thread(Thread-1, started 126693911033536)> запущен в 2025-12-27 13:44:50.159203
crawl запустился для ссылки https://docs.python.org. Время вызова: 2025-12-27 13:44:50.159412
Поток <Thread(Thread-2, started 126693902640832)> запущен в 2025-12-27 13:44:50.159460
crawl запустился для ссылки https://peps.python.org. Время вызова: 2025-12-27 13:44:50.159612
Поток <Thread(Thread-3, started 126693894248128)> запущен в 2025-12-27 13:44:50.159679
crawl завершен для https://docs.python.org. Время вызова: 2025-12-27 13:44:57.159525
crawl завершен для https://peps.python.org. Время вызова: 2025-12-27 13:44:58.159735
crawl завершен для https://python.org. Время вызова: 2025-12-27 13:44:59.159292
<Thread(Thread-1, stopped 126693911033536)> завершен в 2025-12-27 13:44:59.159502
<Thread(Thread-2, stopped 126693902640832)> завершен в 2025-12-27 13:44:59.159545
<Thread(Thread-3, stopped 126693894248128)> завершен в 2025-12-27 13:44:59.159565

Общая схема start и join в threading:

Деталь реализации CPython

В CPython из-за глобальной блокировки интерпретатора (GIL) только один поток может выполнять Python-код в каждый момент времени (хотя некоторые ориентированные на производительность библиотеки могут обходить это ограничение). Если требуется более эффективно использовать вычислительные ресурсы многоядерных машин, рекомендуется использовать multiprocessing или concurrent.futures.ProcessPoolExecutor. Тем не менее, threading остаётся подходящей моделью, если нужно одновременно выполнять несколько I/O-bound задач.

GIL и вопросы производительности

В отличие от модуля multiprocessing, который использует отдельные процессы для обхода GIL, модуль threading работает внутри одного процесса, а значит все потоки разделяют одно и то же адресное пространство памяти. Однако GIL ограничивает прирост производительности при работе с CPU-bound задачами, поскольку только один поток может выполнять байткод Python одновременно. Несмотря на это, потоки остаются полезным инструментом для достижения конкурентности во многих сценариях.

Начиная с Python 3.13, существуют free-threaded сборки, в которых GIL может быть отключён, что позволяет добиться настоящего параллельного выполнения потоков. Однако по умолчанию эта возможность недоступна (см. PEP 703).

Жизненный цикл потока

Жизненным циклом потоков можно управлять с помощью следующих методов:

• start() — Дает потоку жизнь.
• run() — Этот метод представляет действия, которые должны быть выполнены в
  потоке.
• join([timeout]) — Поток, который вызывает этот метод, приостанавливается, ожидая завершения потока, чей метод вызван. Параметр timeout (число с плавающей точкой) позволяет указать время ожидания (в секундах), по истечении которого приостановленный поток продолжает свою работу независимо от завершения потока, чей метод join был вызван. Вызывать join() некоторого потока можно много раз. Поток не может вызвать метод join() самого себя. Также нельзя ожидать завершения еще не запущенного потока. Слово «join» в переводе с английского означает «присоединить», то есть, метод, вызвавший join(), желает, чтобы поток по завершении присоединился к вызывающему метод потоку.
• getName() — Возвращает имя потока. Для главного потока это «MainThread«.
• setName(name) — Присваивает потоку имя name.
• isAlive() — Возвращает истину, если поток работает (метод run() уже вызван, но еще не завершился).
• isDaemon() — Возвращает истину, если поток имеет признак демона. Программа на Python завершается по завершении всех потоков, не являющихся демонами. Главный поток демоном не является.
• setDaemon(daemonic) — Устанавливает признак daemonic того, что поток является демоном. Начальное значение этого признака заимствуется у потока, запустившего данный. Признак можно изменять только для потоков, которые еще не запущены.

Атрибуты потока:

• t.name — имя потока
• t.ident — Уникальный идентификатор потока (ID) — None, если поток ещё не запущен
• threading.current_thread() — Возвращает объект текущего потока
• t.daemon = True — Демон-потоки убиваются при завершении главного потока. Используются для фоновых задач, логирования, heartbeat-потоков. daemon нужно задавать до start()
• threading.active_count() — Количество активных потоков
• threading.enumerate() — Список всех живых потоков

Реализация потокобезопасной записи результатов с Lock, чтобы избежать race condition

import threading
import time
import random
from datetime import datetime

def crawl(link, results, lock):
    print(f"Поток {threading.current_thread().name} запущен. Время вызова: {datetime.now()}")

    # Имитация сетевого запроса
    delay = random.randint(1, 10)
    time.sleep(delay)

    # Имитация полученного JSON
    response = {
        "url": link,
        "status": 200,
        "data": {
            "title": f"Данные с {link}",
            "value": random.randint(1, 100),
        },
        "fetched_at": datetime.now().isoformat(),
        "thread": threading.current_thread().name,
    }

    # Потокобезопасная запись результата
    with lock:
        results[link] = response

    print(f"Поток {threading.current_thread().name} завершен. Запрос длился {delay} секунд. Время завершения: {datetime.now()}")


links = [
    "https://python.org",
    "https://docs.python.org",
    "https://peps.python.org",
]

# Общее хранилище результатов
results = {}

# Lock для синхронизации доступа к results
lock = threading.Lock()

# Создаём потоки
threads = []
for i, link in enumerate(links):
    t = threading.Thread(
        target=crawl,
        args=(link, results, lock),
        name=f"Thread-{i + 1}",
    )
    threads.append(t)

# Запускаем потоки
for t in threads:
    t.start()

# Ждём завершения
for t in threads:
    t.join()

# Итоговый объединённый результат
print("\nИТОГОВЫЙ РЕЗУЛЬТАТ:")
for url, data in results.items():
    print(f"{url} → {data}")

Что выполняется в коде:

• t.start() — Создаёт реальный системный поток. Вызывает crawl(…) в новом потоке. Нельзя вызывать start() дважды для одного и того же объекта.
• t.join() — Блокирует главный поток и ждёт, пока поток t завершится. Гарантирует, что все данные собраны.
• threading.current_thread().name — Позволяет узнать, какой поток сейчас выполняется. Используется для логирования и отладки

Результат выполнения скрипта:

Поток Thread-1 запущен. Время вызова: 2025-12-27 20:45:11.807784
Поток Thread-2 запущен. Время вызова: 2025-12-27 20:45:11.807957
Поток Thread-3 запущен. Время вызова: 2025-12-27 20:45:11.808193
Поток Thread-3 завершен. Запрос длился 1 секунд. Время завершения: 2025-12-27 20:45:12.808385
Поток Thread-1 завершен. Запрос длился 4 секунд. Время завершения: 2025-12-27 20:45:15.808069
Поток Thread-2 завершен. Запрос длился 10 секунд. Время завершения: 2025-12-27 20:45:21.808165

ИТОГОВЫЙ РЕЗУЛЬТАТ:
https://peps.python.org → {'url': 'https://peps.python.org', 'status': 200, 'data': {'title': 'Данные с https://peps.python.org', 'value': 15}, 'fetched_at': '2025-12-27T20:45:12.808319', 'thread': 'Thread-3'}
https://python.org → {'url': 'https://python.org', 'status': 200, 'data': {'title': 'Данные с https://python.org', 'value': 84}, 'fetched_at': '2025-12-27T20:45:15.808019', 'thread': 'Thread-1'}
https://docs.python.org → {'url': 'https://docs.python.org', 'status': 200, 'data': {'title': 'Данные с https://docs.python.org', 'value': 17}, 'fetched_at': '2025-12-27T20:45:21.808113', 'thread': 'Thread-2'}

Основы threading

Создание потока через конструктор threading.Thread

threading.Thread(
    target=None,
    args=(),
    kwargs={},
    name=None,
    daemon=None
)

Основные параметры:

Запуск и управление потоками t.start()

t.start()

• Запускает поток
• Внутри вызывает run()
• Нельзя вызвать повторно

t.run()

• Содержит код потока
• Не запускает новый поток, если вызвать напрямую
• Обычно не вызывается вручную

join(timeout=None)

• Ждёт завершения потока
• timeout — максимальное время ожидания (в секундах)

t.is_alive()

• Возвращает True, если поток ещё работает

Примитивы синхронизации: Lock, RLock, Semaphore, Event, Condition

Подробнее: Python. Урок 23. Потоки и процессы в Python. Часть 2. Синхронизация потоков

В Python примитивы синхронизации из модуля threading решают одну ключевую задачу: они позволяют нескольким потокам безопасно и предсказуемо взаимодействовать с общим состоянием. Несмотря на наличие GIL, эти примитивы остаются необходимыми, потому что GIL защищает интерпретатор, но не бизнес-логику и не целостность данных.

Диспетчеры контекста предусмотрены для всех объектов модуля threading, таких как Lock, RLock, Condition, Semaphore и BoundedSemaphore, то есть для работы с этими объектами может применяться инструкция with.

Начнём с Lock и RLock, так как они лежат в основе почти всех сценариев синхронизации.

Lock

Lock — это обычный мьютекс, который может быть захвачен только одним потоком в конкретный момент времени. Когда поток вызывает acquire(), он либо сразу получает доступ к критической секции, либо блокируется до тех пор, пока другой поток не освободит lock. После выполнения защищённого участка кода поток обязан вызвать release(). В реальном коде Lock почти всегда используется через контекстный менеджер with, потому что это гарантирует освобождение блокировки даже при исключении. Lock подходит для защиты простых структур данных, таких как словари, списки или счётчики, и для коротких критических секций. Важно понимать, что один и тот же поток не может захватить Lock повторно: попытка сделать это приведёт к deadlock, когда поток будет ждать самого себя.

Проблема (без Lock)

import threading

counter = 0

def increment():
    global counter
    for _ in range(100_000):
        counter += 1

threads = [threading.Thread(target=increment) for _ in range(2)]

for t in threads:
    t.start()
for t in threads:
    t.join()

print(counter)  #  НЕ гарантировано 200000

Решение с Lock

import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100_000):
        with lock:          #  только один поток внутри
            counter += 1

threads = [threading.Thread(target=increment) for _ in range(2)]

for t in threads:
    t.start()
for t in threads:
    t.join()

print(counter)  #  всегда 200000

Что гарантирует Lock

• Только один поток изменяет общее состояние
• Нет гонок данных

RLock

Эта проблема решается с помощью RLock, или reentrant lock. По сути это мьютекс с учётом владельца. Поток, который уже владеет RLock, может захватить его ещё раз, и Python просто увеличит внутренний счётчик захватов. Освобождать такой lock нужно столько же раз, сколько он был захвачен. RLock необходим в более сложных архитектурах, когда функции с защитой lock вызывают друг друга, либо когда публичный метод и внутренний метод используют одну и ту же блокировку. Без RLock такой код почти неизбежно приводит к взаимной блокировке.

Проблема с Lock

lock = threading.Lock()

def outer():
    with lock:
        inner()

def inner():
    with lock:   #  deadlock: поток уже держит lock
        print("inner")

Решение с RLock

import threading

lock = threading.RLock()

def outer():
    with lock:
        print("outer")
        inner()

def inner():
    with lock:
        print("inner")

threading.Thread(target=outer).start()

Что даёт RLock

• Один поток может захватывать блокировку несколько раз
• Важно для рекурсии и вложенных вызовов

Semaphore

Следующий важный примитив — Semaphore. В отличие от Lock, который допускает ровно одного владельца, semaphore разрешает одновременно находиться в критической секции ограниченному числу потоков. При создании семафора задаётся счётчик, который уменьшается при acquire() и увеличивается при release(). Пока счётчик положительный, потоки могут входить без ожидания, а когда он становится равным нулю, все последующие вызовы acquire() блокируются. Семантически семафор описывает не владение ресурсом, а количество доступных слотов. Это делает его удобным для ограничения параллельного доступа к внешним системам, таким как база данных, пул соединений или сторонний API. В отличие от Lock, семафор не привязан к конкретному потоку, поэтому важно строго соблюдать баланс acquire() и release(), иначе система либо «утечёт» в блокировку, либо начнёт пускать больше потоков, чем предполагалось.

Пример: максимум 2 потока одновременно

import threading
import time

semaphore = threading.Semaphore(2)

def worker(name):
    print(f"{name} ждёт доступ")
    with semaphore:
        print(f"{name} вошёл")
        time.sleep(2)
        print(f"{name} вышел")

threads = [
    threading.Thread(target=worker, args=(f"Thread-{i}",))
    for i in range(5)
]

for t in threads:
    t.start()

Что гарантирует Semaphore

• Не более N потоков внутри секции
• Остальные ждут освобождения ресурса

BoundedSemaphore

BoundedSemaphore — это вариант семафора из модуля threading, который предназначен для строгого контроля количества одновременных доступов к ресурсу и дополнительно защищает от логических ошибок в коде.

По своей сути BoundedSemaphore работает так же, как обычный Semaphore: он хранит внутренний счётчик, и поток может войти в критическую секцию, только если счётчик больше нуля. При входе счётчик уменьшается, при выходе увеличивается. Это позволяет ограничить количество потоков, которые одновременно используют общий ресурс.

Ключевое отличие BoundedSemaphore от Semaphore заключается в том, что он не позволяет превысить начальное значение счётчика. Если вызвать release() больше раз, чем было успешных acquire(), BoundedSemaphore выбросит исключение ValueError. Обычный Semaphore такого не делает и молча увеличивает счётчик, что может привести к незаметным ошибкам и нарушению инвариантов программы.

Таким образом, BoundedSemaphore полезен в ситуациях, где важно гарантировать, что количество «освобождений» ресурса строго соответствует количеству его захватов, например при реализации пулов соединений или управлении ограниченными системными ресурсами. Он помогает выявлять ошибки проектирования на раннем этапе, вместо того чтобы позволять программе продолжать работу в некорректном состоянии.

Пример использования BoundedSemaphore для ограничения числа одновременных работников:

import threading
import time

pool = threading.BoundedSemaphore(2)

def worker(name):
    print(f"{name} пытается войти")
    pool.acquire()
    try:
        print(f"{name} работает")
        time.sleep(1)
    finally:
        pool.release()
        print(f"{name} вышел")

threads = [
    threading.Thread(target=worker, args=(f"Thread-{i}",))
    for i in range(4)
]

for t in threads:
    t.start()
for t in threads:
    t.join()

Если в этом примере по ошибке вызвать pool.release() дважды в одном потоке, программа сразу упадёт с ValueError, что явно укажет на ошибку управления ресурсом. Именно это поведение и является главным практическим отличием BoundedSemaphore от обычного Semaphore.

Event

Event решает другую задачу и не предназначен для защиты критических секций. Это потокобезопасный флаг, который может быть установлен или сброшен, и который другие потоки могут проверять или ожидать. Внутренне Event хранит состояние «установлен» или «не установлен». Когда поток вызывает wait(), он блокируется до тех пор, пока другой поток не вызовет set(). Если событие уже установлено, wait() возвращается сразу. В отличие от lock-ов, событие не «потребляется» при ожидании, и все потоки, ожидающие одного и того же события, будут разбужены одновременно. На практике Event чаще всего используется для управления жизненным циклом потоков, например для корректной остановки воркеров или для сигнализации о готовности системы к работе. Это более выразительная и безопасная альтернатива общим флагам и бесконечным циклам с sleep.

Пример: ожидание старта

import threading
import time

event = threading.Event()

def worker():
    print("Рабочий поток ждёт сигнал...")
    event.wait()          #  блокируется
    print("Рабочий поток получил сигнал!")

def starter():
    time.sleep(3)
    print("Сигнал отправлен!")
    event.set()           #  разблокирует всех

threading.Thread(target=worker).start()
threading.Thread(target=starter).start()

Event идеально подходит для

• старт / стоп сигналов
• graceful shutdown — (плавное или корректное завершение работы) — это процесс остановки компьютерной системы (приложения, сервера, контейнера), при котором она успевает выполнить необходимые задачи по очистке и сохранению данных перед полным выключением.
• ожидания готовности ресурса

Condition

Condition является самым сложным и одновременно самым гибким примитивом синхронизации. Он объединяет в себе мьютекс и механизм ожидания уведомлений. Идея Condition заключается в том, что поток может ждать не просто сигнала, а выполнения определённого логического условия, связанного с состоянием программы. Поток захватывает условие, проверяет состояние, и если оно не удовлетворяет требованиям, вызывает wait(). При этом lock временно освобождается, чтобы другие потоки могли изменить состояние. Когда другой поток вызывает notify() или notify_all(), ожидающие потоки пробуждаются и снова проверяют условие. Именно повторная проверка условия является ключевым моментом, так как пробуждение не гарантирует, что состояние действительно изменилось нужным образом. Condition активно используется в классических паттернах producer–consumer, очередях задач и системах, где потоки должны реагировать на изменение общего состояния, а не просто на факт события.

Если смотреть на эти примитивы как на систему, то Lock и RLock отвечают за эксклюзивный доступ, Semaphore ограничивает параллелизм, Event передаёт сигналы между потоками, а Condition позволяет потокам координироваться на основе сложных условий. В продакшене выбор примитива почти всегда диктуется смыслом задачи, а не техническими деталями. Хорошая синхронизация делает код не только корректным, но и читаемым, потому что по выбранному примитиву сразу понятно, как именно потоки должны взаимодействовать друг с другом.

Producer / Consumer с Condition

import threading
import time
import random

condition = threading.Condition()
queue = []
MAX_ITEMS = 5

def producer():
    for i in range(10):
        time.sleep(random.uniform(0.1, 0.5))
        with condition:
            while len(queue) >= MAX_ITEMS:
                condition.wait()   #  ждём, пока потребитель заберёт
            queue.append(i)
            print(f"Producer добавил {i}")
            condition.notify()     #  сигнал потребителю

def consumer():
    for _ in range(10):
        with condition:
            while not queue:
                condition.wait()   #  ждём данные
            item = queue.pop(0)
            print(f"Consumer забрал {item}")
            condition.notify()     #  сигнал производителю
        time.sleep(random.uniform(0.2, 0.6))

threading.Thread(target=producer).start()
threading.Thread(target=consumer).start()

Condition = Lock + Event

• wait() → отпускает lock и ждёт
• notify() → будит ожидающий поток
• Позволяет ждать логических условий, а не просто блокировки

Barrier

threading.Barrier — это примитив синхронизации в Python, который позволяет группе потоков одновременно ожидать друг друга в определенной точке выполнения (контрольной точке) перед тем, как продолжить работу.

todo

Итоговая таблица

concurrent.futures

todo

multiprocessing

Теория
Разница между:
fork / spawn / forkserver

IPC (межпроцессное взаимодействие):
Queue
Pipe
Manager
Стоимость сериализации (pickle)
Copy-on-write (Linux)

Практика
Параллельная обработка данных
Использование multiprocessing.Pool

Бенчмарк:
threading vs multiprocessing
Поймать баг с pickling’ом

Продакшн insight: multiprocessing часто убивает latency, если использовать бездумно.

asyncio

Ключевая тема для highload backend.

Теория
Event loop
Coroutine
Awaitable
Task vs Future
Cooperative multitasking
Почему async ≠ threading

Практика
Переписать синхронный код в async
Одновременные HTTP-запросы (aiohttp)
Ограничение параллелизма (Semaphore)

Ошибки:
blocking call внутри async
забытый await

Критически важно: понимание, почему один blocking вызов убивает весь сервис.

Сообщение Python — Многозадачность, конкурентность и асинхронность появились сначала на DataTalks.RU. Data Engineering / DWH / Data Pipeline.

Нотация Big O

Нотация Big O — это математический способ описывать асимптотическую сложность алгоритмов, то есть то, как растут затраты ресурсов при увеличении размера входных данных n. Она абстрагируется от конкретного железа, языка и констант и показывает порядок роста, что делает её универсальным инструментом анализа.

Временная сложность (time complexity) описывает, как растёт количество элементарных операций алгоритма в зависимости от n. Формально говорят, что алгоритм имеет сложность O(f(n)), если существует такая константа C, что при достаточно больших n время работы не превышает C · f(n). Важный момент: учитывается худший случай, если не указано иное. Константы, коэффициенты и члены меньшего порядка отбрасываются, потому что при больших n они не влияют на характер роста. Например, 3n² + 10n + 5 в Big O записывается как O(n²).

Пространственная сложность (space complexity) описывает, как растёт объём дополнительной памяти, используемой алгоритмом, также как функция от n. Обычно считают дополнительную память, а не входные данные. Например, сортировка «на месте» может иметь O(1) по памяти, а алгоритм, создающий вспомогательный массив размера n, — O(n).

Интуитивно Big O отвечает не на вопрос «сколько именно секунд или мегабайт», а на вопрос «насколько хуже станет, если данных станет в 10 раз больше». Именно поэтому нотация широко используется в теории алгоритмов и на практике при выборе подходящего решения.

Часто встречающиеся порядки роста, от лучшего к худшему, выглядят так:

• константный O(1) — затраты не зависят от размера входа;
• логарифмический O(log n) — рост очень медленный (типично для бинарного поиска);
• линейный O(n) — один проход по данным;
• квазилинейный O(n log n) — характерен для эффективных сортировок;
• квадратичный O(n²) и выше — быстро становятся непрактичными при больших n.

Важно понимать, что Big O — это верхняя оценка, а не точный прогноз. Она не заменяет профилирование, но позволяет заранее отсеять заведомо плохие алгоритмы и сравнивать решения на концептуальном уровне.

Шпаргалка по Big O

Профилирование

Профилирование — это процесс измерения и анализа фактического поведения программы во время выполнения. Его цель — понять, куда реально тратится время и память, какие части кода являются узкими местами и какие оптимизации действительно имеют смысл.

В отличие от асимптотического анализа и Big O, профилирование работает не с абстрактными оценками, а с конкретными метриками: временем выполнения функций, числом вызовов, потреблением памяти, частотой аллокаций, загрузкой CPU. Часто оказывается, что код с хорошей теоретической сложностью работает медленно из-за констант, кэш-промахов, лишних аллокаций или неудачных структур данных — и именно профилирование это выявляет.

Обычно процесс выглядит так: программу запускают с реальными или приближенными к реальным входными данными, собирают статистику выполнения, затем анализируют отчёт профайлера. Почти всегда подтверждается правило 80/20: небольшая часть кода потребляет большую часть ресурсов. Оптимизация без профилирования часто приводит к бессмысленной усложнённости и микроправкам там, где выигрыш минимален.

Различают несколько основных видов профилирования:

• Временное профилирование показывает, сколько времени тратится на функции и строки кода.
• Профилирование памяти показывает рост и распределение потребления памяти, утечки и лишние аллокации.
• CPU-профилирование анализирует загрузку процессора и горячие участки кода.
• Есть также событийное и трассировочное профилирование, полезное для сложных систем.

В контексте Python профилирование особенно важно, потому что язык интерпретируемый, и реальные узкие места часто находятся не там, где их ожидают по Big O. Стандартный модуль cProfile позволяет получить детальный отчёт по времени выполнения функций, line_profiler показывает стоимость отдельных строк, а memory_profiler помогает анализировать использование памяти.

Ключевая идея проста: Big O говорит, как алгоритм будет масштабироваться, а профилирование показывает, как он работает на самом деле. В хорошей инженерной практике сначала пишут корректный и понятный код, затем профилируют, и только после этого оптимизируют то, что действительно мешает производительности.

Динамическое программирование

Динамическое программирование (dynamic programming, DP) — это метод проектирования алгоритмов, который применяется к задачам, где решение можно разложить на перекрывающиеся подзадачи, а итоговый ответ строится из решений этих подзадач. Ключевая идея: не решать одну и ту же подзадачу больше одного раза.

Если кратко: рекурсия даёт корректность, а динамическое программирование — эффективность.

Когда задача решается динамическим программированием

У задачи должны быть два свойства.

Первое — оптимальная подструктура. Это означает, что оптимальное решение всей задачи можно получить из оптимальных решений её подзадач. Например, кратчайший путь до точки i проходит через кратчайший путь до предыдущих точек.

Второе — перекрывающиеся подзадачи. Одни и те же подзадачи возникают многократно. Обычная рекурсия будет пересчитывать их снова и снова, а DP — сохраняет и переиспользует результат.

Если хотя бы одно из этих свойств отсутствует, динамическое программирование либо не нужно, либо не применимо.

Основные подходы DP

Top-down (memoization)

Решение пишется как рекурсивная функция, но результаты вызовов сохраняются в кэше. При повторном обращении к подзадаче результат берётся из памяти, а не пересчитывается.

Плюс: код близок к математическому определению.
Минус: накладные расходы рекурсии и риск переполнения стека.

Bottom-up (tabulation)

Решение строится итеративно, начиная с самых простых подзадач и постепенно переходя к более сложным.

Плюс: нет рекурсии, обычно быстрее и надёжнее.
Минус: иногда сложнее понять и вывести формулы.

Оба подхода эквивалентны по асимптотике.

Классический пример: числа Фибоначчи

Наивная рекурсия имеет экспоненциальную сложность, потому что одно и то же значение вычисляется много раз.

DP-решение хранит уже вычисленные значения и получает сложность O(n) по времени. При этом память можно сократить до O(1), храня только два последних значения. Это важный момент: DP часто можно оптимизировать по памяти.

Как выглядит DP-решение концептуально

Почти любая задача DP решается по одному шаблону:

Определяется состояние DP — что именно мы храним (например, dp[i] — ответ для первых i элементов).

Формулируется переход — как получить dp[i] из более простых состояний.

Задаются базовые случаи.

Определяется порядок вычислений.

При необходимости оптимизируется память.

Умение правильно выбрать состояние — самый сложный этап.

Основные типы задач динамического программирования

DP на одномерном массиве
Примеры: Фибоначчи, максимальная сумма подмассива, лестница с шагами.

DP на двумерной таблице
Примеры: наибольшая общая подпоследовательность (LCS), расстояние Левенштейна, рюкзак.

DP на строках
Сравнение строк, редактирование, палиндромы.

DP на деревьях (Tree DP)
Решения строятся в postorder-обходе. Примеры: диаметр дерева, максимальный путь.

DP по подмножествам (Bitmask DP)
Используется, когда количество элементов мало (обычно до 20). Пример: задача коммивояжёра.

DP с оптимизацией переходов
Монотонная очередь, divide and conquer DP, convex hull trick — продвинутые темы для сильных кандидатов.

Временная и пространственная сложность

Сложность DP обычно равна количеству состояний, умноженному на стоимость перехода.
Например, таблица n × m с O(1) переходом даёт O(nm) по времени и памяти.

Очень частая ошибка — недооценивать размер пространства состояний и получить решение, которое не помещается в память или не укладывается по времени.

Типичные ошибки на собеседованиях

Писать рекурсию без мемоизации.
Выбирать слишком большое состояние DP.
Не замечать, что задачу можно решить жадно или через бинарный поиск.
Забывать про оптимизацию памяти, когда она очевидна.

Как понять, что тут DP

Фразы-триггеры в условиях:
«найти максимальный/минимальный…»,
«сколькими способами…»,
«оптимальное решение»,
«учитывая предыдущие шаги».

Если решение зависит от предыдущих решений и эти зависимости повторяются — почти наверняка это динамическое программирование.

Резюме

Динамическое программирование — это не конкретный алгоритм, а образ мышления. Ты разбиваешь задачу на подзадачи, сохраняешь результаты и собираешь ответ снизу вверх или сверху вниз. Именно поэтому DP считается одной из самых сложных, но и самых мощных тем на собеседованиях.

Алгоритмы сортировки

Bubble Sort — одна из самых простых и наименее эффективных сортировок. Алгоритм многократно проходит по массиву и сравнивает соседние элементы, меняя их местами, если они стоят в неправильном порядке. После каждого прохода самый большой элемент «всплывает» в конец массива, отсюда и название. В худшем и среднем случае сложность по времени составляет O(n²), так как выполняются вложенные проходы. В лучшем случае (если массив уже отсортирован и есть оптимизация с флагом) — O(n). По памяти алгоритм работает за O(1), так как сортирует массив на месте. Bubble Sort стабилен, но практически не используется из-за низкой эффективности.

Selection Sort работает иначе: на каждом шаге он находит минимальный элемент в неотсортированной части массива и ставит его на правильную позицию. Число сравнений всегда одинаково, независимо от входных данных, поэтому и лучший, и худший, и средний случаи имеют сложность O(n²). Память — O(1), так как сортировка выполняется на месте. Алгоритм не является стабильным, но имеет предсказуемое поведение и минимальное число обменов, что иногда полезно при дорогих операциях записи.

Insertion Sort имитирует процесс сортировки карт вручную. Алгоритм берёт элементы по одному и вставляет каждый новый элемент в уже отсортированную часть массива, сдвигая большие элементы вправо. В худшем и среднем случае сложность O(n²), но в лучшем случае, когда массив почти отсортирован, — O(n). По памяти — O(1). Insertion Sort стабилен и очень эффективен на маленьких массивах или как вспомогательная сортировка внутри более сложных алгоритмов.

QuickSort — одна из самых популярных и быстрых сортировок на практике. Он использует стратегию «разделяй и властвуй»: выбирается опорный элемент (pivot), массив разбивается на элементы меньше и больше него, после чего рекурсивно сортируются подмассивы. Средняя сложность по времени — O(n log n), но в худшем случае (неудачный выбор pivot, например уже отсортированный массив) — O(n²). Память обычно O(log n) из-за глубины рекурсии. QuickSort не стабилен, но выигрывает за счёт хорошей локальности данных и отсутствия дополнительной памяти.

Merge Sort также основан на «разделяй и властвуй». Массив рекурсивно делится пополам, затем отсортированные половины сливаются в один отсортированный массив. В отличие от QuickSort, Merge Sort всегда работает за O(n log n), независимо от входных данных. Основной минус — необходимость дополнительной памяти O(n) для слияния. Алгоритм стабилен и хорошо подходит для сортировки связанных списков и внешней сортировки (когда данные не помещаются в память).

Heap Sort использует структуру данных «куча» (обычно бинарная max-heap). Сначала массив преобразуется в кучу, затем максимальный элемент извлекается и помещается в конец массива, после чего куча перестраивается. Сложность по времени — O(n log n) во всех случаях, память — O(1), так как сортировка выполняется на месте. Heap Sort не стабилен и на практике часто медленнее QuickSort из-за плохой кэш-локальности, но ценится за гарантированное время работы.

Counting Sort — не сравнительная сортировка. Она работает только для целочисленных ключей из ограниченного диапазона. Алгоритм подсчитывает, сколько раз встречается каждое значение, а затем по этим подсчётам восстанавливает отсортированный массив. Время работы — O(n + k), где k — размер диапазона значений. Память также O(n + k). Counting Sort стабилен и очень быстр, но применим только при небольшом диапазоне ключей.

Radix Sort — тоже не сравнительная сортировка. Она сортирует числа (или строки) поразрядно, начиная с младшего или старшего разряда, используя стабильную сортировку (часто Counting Sort) на каждом шаге. Если число разрядов равно d, а диапазон разряда k, то сложность — O(d · (n + k)). Память — O(n + k). Radix Sort эффективен для больших массивов чисел фиксированной длины, но менее универсален, чем сравнительные алгоритмы.

Алгоритмы обхода деревьев

Бинарное дерево — это иерархическая структура данных, состоящая из узлов, где у каждого узла не более двух потомков. Эти потомки обычно называют левым и правым ребёнком. Структура начинается с одного выделенного узла — корня, от которого рекурсивно строятся все остальные узлы.

Каждый узел бинарного дерева содержит значение (данные) и ссылки на своих детей. Если у узла нет детей, он называется листом. Если у узла есть хотя бы один ребёнок, он считается внутренним узлом. Важная особенность бинарного дерева в том, что порядок детей имеет значение: левый и правый потомок — это разные позиции, даже если они содержат одинаковые значения.

Бинарное дерево удобно описывать рекурсивно: дерево либо пусто, либо состоит из корня, левого поддерева и правого поддерева, каждое из которых само является бинарным деревом. Это рекурсивное определение напрямую связано с тем, как такие структуры обрабатываются в алгоритмах.

Важно отличать бинарное дерево от других похожих структур:

• Бинарное дерево — это общее понятие, не накладывающее ограничений на значения в узлах.
• Бинарное дерево поиска (BST) — это частный случай, где для каждого узла все значения в левом поддереве меньше (или равны), а в правом — больше (или равны) значения узла.
• Также существуют полные, совершенные, сбалансированные бинарные деревья — это уже свойства формы, а не данных.

С точки зрения формы бинарное дерево может быть очень разным. Оно может быть вырожденным, когда каждый узел имеет только одного потомка, и тогда структура по сути превращается в список. В таком случае высота дерева равна количеству узлов, и многие алгоритмы работают медленно. В противоположность этому, сбалансированное бинарное дерево имеет высоту порядка log n, что делает операции поиска и обхода эффективными.

Бинарные деревья широко используются потому, что они хорошо отражают иерархии и позволяют эффективно реализовывать алгоритмы. На их основе строятся деревья поиска, кучи, синтаксические деревья выражений, структуры для парсинга, индексы в базах данных и множество алгоритмических задач на собеседованиях.

Под деревом ниже подразумевается в первую очередь бинарное дерево, но большинство идей обобщаются и на n-арные деревья.

Depth-First Search (DFS) — обход в глубину

Это общий класс обходов, при котором алгоритм уходит как можно глубже по одной ветке, прежде чем возвращаться назад. Почти всегда реализуется рекурсивно или с помощью стека. Все классические «in/pre/post-order» — это частные случаи DFS. Временная сложность любого DFS — O(n), память — O(h), где h — высота дерева (в худшем случае O(n)).

DFS часто спрашивают концептуально: чем отличается от BFS, где используется стек, где рекурсия, какие риски (переполнение стека).

Preorder Traversal (прямой обход)

Порядок: сначала текущий узел → затем левое поддерево → затем правое поддерево.

Идея: «обработать узел до его детей».
Используется для сериализации дерева, копирования структуры, построения выражений в префиксной форме.

Сложность: время O(n), память O(h).
Реализуется рекурсивно или итеративно через стек.

На собеседованиях часто спрашивают: как восстановить дерево по preorder + inorder.

Inorder Traversal (симметричный обход)

Порядок: левое поддерево → текущий узел → правое поддерево.

Ключевое свойство: для бинарного дерева поиска (BST) inorder-обход выдаёт отсортированную последовательность.

Это один из самых любимых обходов интервьюеров, потому что он напрямую связан с BST, проверкой корректности дерева поиска, поиском k-го минимального элемента.

Сложность стандартная: O(n) по времени, O(h) по памяти.

Postorder Traversal (обратный обход)

Порядок: левое поддерево → правое поддерево → текущий узел.

Идея: «обработать узел после детей».
Используется для удаления дерева, освобождения памяти, вычисления выражений в постфиксной форме, задач динамического программирования на деревьях (когда результат узла зависит от детей).

Часто спрашивают как более «неочевидный» обход, особенно в итеративной реализации.

DFS с явным стеком (итеративный DFS)

Любой из трёх обходов выше можно реализовать без рекурсии, используя стек. Это важно для языков с ограниченным стеком вызовов.

На собеседованиях могут спросить:
почему рекурсия = стек,
как переписать рекурсивный обход в итеративный,
чем они отличаются по памяти.

Morris Traversal

Это продвинутый вариант inorder (иногда preorder), который выполняется за O(1) дополнительной памяти.

Идея: временно «перепрошивать» указатели дерева, чтобы избежать стека и рекурсии, а потом восстанавливать структуру.

Время — O(n), память — O(1).
Алгоритм сложный и редко используется на практике, но иногда встречается как «вопрос со звёздочкой» для сильных кандидатов.

Breadth-First Search (BFS) / Level Order Traversal — обход в ширину

Обход по уровням: сначала корень, затем все узлы уровня 1, затем уровня 2 и так далее.

Реализуется с помощью очереди, а не стека.
Время — O(n), память — O(w), где w — максимальная ширина дерева (в худшем случае O(n)).

BFS часто спрашивают в задачах на уровни дерева:
вывод по уровням,
максимальная/минимальная глубина,
зигзагообразный обход,
правый или левый вид дерева.

Level Order с вариантами

Это не отдельные алгоритмы, а частые модификации BFS, которые почти гарантированно встречаются на собеседованиях:

• обход по уровням с группировкой значений
• zigzag level order
• обход с указанием уровня
• поиск первого элемента, удовлетворяющего условию

Важно понимать, что все они — один и тот же BFS с небольшой логикой поверх.

Обход n-арного дерева

Концептуально тот же DFS или BFS, но вместо левого и правого поддерева — список детей. На собеседованиях проверяют, понимаешь ли ты, что логика не меняется, меняется только цикл по детям.

Обход с возвратом значения (Tree DP)

Часто интервьюеры не называют это «обходом», но по сути это postorder DFS, где функция возвращает значение наверх: высоту, сумму, флаг, максимум и т.д.

Примеры задач:

• высота дерева
• диаметр дерева
• проверка сбалансированности
• максимальный путь

Это один из самых важных практических паттернов.

Алгоритмы поиска чисел

Под «поиском чисел» здесь понимается поиск элемента в массиве, диапазоне или числовом пространстве.

Линейный поиск (Linear Search)

Это самый простой и универсальный алгоритм поиска. Он последовательно проверяет элементы массива один за другим, пока не найдёт нужное значение или не дойдёт до конца.

Алгоритм не делает никаких предположений о структуре данных: массив может быть неотсортированным, произвольным, даже потоковым. Именно поэтому линейный поиск часто используется как базовый вариант или когда данные малы.

Временная сложность в худшем и среднем случае — O(n), в лучшем — O(1), если искомый элемент находится в начале. Память — O(1).

Пример: поиск числа в неотсортированном списке, поиск первого элемента, удовлетворяющего условию.

Бинарный поиск (Binary Search)

Бинарный поиск работает только с отсортированными данными. Алгоритм многократно делит диапазон поиска пополам: сравнивает искомое число с элементом в середине массива и отбрасывает половину, где элемента быть не может.

Ключевая идея — уменьшать пространство поиска в два раза на каждом шаге.

Временная сложность — O(log n) во всех случаях, память — O(1) в итеративной реализации или O(log n) при рекурсии.

Бинарный поиск — один из самых частых алгоритмов на собеседованиях. Его спрашивают не только напрямую, но и в виде вариаций: поиск первого/последнего вхождения, нижняя и верхняя границы, поиск по условию.

Пример: поиск числа в отсортированном массиве, поиск позиции вставки.

Поиск по ответу (Binary Search on Answer)

Это обобщение бинарного поиска, но применяется не к массиву, а к пространству возможных ответов. Используется, когда есть монотонное условие вида: «если ответ X подходит, то все ответы больше (или меньше) тоже подходят».

Алгоритм не ищет конкретное число в массиве, а подбирает минимальное или максимальное значение, удовлетворяющее условию.

Сложность — O(log R), где R — диапазон возможных значений, умноженная на стоимость проверки условия.

Очень популярный паттерн на собеседованиях.

Пример: найти минимальную скорость, за которую можно выполнить работу за заданное время; найти минимальный размер, при котором условие выполняется.

Интерполяционный поиск (Interpolation Search)

Интерполяционный поиск — улучшенная версия бинарного поиска для равномерно распределённых чисел. Вместо середины массива он вычисляет позицию элемента пропорционально значению искомого числа.

Если данные действительно равномерны, алгоритм работает очень быстро.

Средняя сложность — O(log log n), худшая — O(n). Память — O(1).

На практике используется редко, но иногда появляется в теоретических вопросах.

Jump Search

Алгоритм разбивает отсортированный массив на блоки фиксированного размера и «прыгает» по ним, пока не найдёт блок, в котором может находиться элемент. Затем выполняется линейный поиск внутри блока.

Оптимальный размер блока — √n, что даёт временную сложность O(√n).

Используется редко, но полезен как промежуточный вариант между линейным и бинарным поиском.

Exponential Search

Этот алгоритм применяется для поиска в очень больших или потенциально бесконечных отсортированных массивах. Сначала он экспоненциально увеличивает диапазон поиска (1, 2, 4, 8, …), пока не превысит искомое значение, а затем запускает бинарный поиск в найденном диапазоне.

Сложность — O(log n), память — O(1).

Пример: поиск в массиве неизвестного размера, потоках данных.

Поиск в хеш-таблице

Формально это не алгоритм поиска чисел в массиве, но на практике — один из самых частых способов поиска.

Идея: число преобразуется хеш-функцией в индекс, по которому элемент хранится в таблице.

Средняя сложность — O(1), худшая — O(n) при большом количестве коллизий. Память — O(n).

Пример: поиск числа в set или dict в Python.

Поиск в бинарном дереве поиска (BST)

Если числа хранятся в бинарном дереве поиска, то поиск идёт по тому же принципу, что и бинарный поиск: на каждом шаге выбирается левое или правое поддерево.

Средняя сложность — O(log n), но в худшем случае (несбалансированное дерево) — O(n). Память — O(h), где h — высота дерева.

Пример: поиск элемента в сбалансированном дереве (AVL, Red-Black Tree).

Линейный поиск с двумя указателями

Часто используется в задачах с отсортированными массивами. Вместо поиска одного числа ищется пара, сумма, разность или другое условие.

Алгоритм движется с двух концов массива навстречу друг другу.

Сложность — O(n), память — O(1).

Пример: найти два числа с заданной суммой.

Поиск с использованием битовых операций

Применяется в узких задачах: поиск уникального числа, поиск отсутствующего числа, поиск дубликата при ограничениях.

Алгоритмы используют свойства XOR, битовых масок и арифметики.

Сложность — O(n), память — O(1).

Пример: найти число, которое встречается один раз, когда остальные встречаются дважды.

Важное резюме для собеседований

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

Сообщение Введение в Структуры данных (Data Structures) и алгоритмы появились сначала на DataTalks.RU. Data Engineering / DWH / Data Pipeline.