Python с переходом на C++: полный путь и связка языков

Python: основы, стиль, ООП, типизация и работа с данными

Зачем эта статья в курсе с переходом на C++

Python и C++ часто используют вместе: Python — для быстрых прототипов, скриптов, анализа данных и автоматизации, C++ — для производительности и низкоуровневого контроля. Чтобы грамотно увязать их в одном проекте, нужно хорошо понимать:

как Python-код устроен и как его писать читабельно

как работают функции, структуры данных и модули

что такое ООП в Python и чем оно отличается от C++

зачем нужна типизация в Python и как она помогает при переходе к C++

как Python работает с файлами, форматами данных и базами

В следующих статьях курса мы будем переходить к C++ и к связкам Python↔C++ (например, через расширения и биндинги). Сейчас задача — сделать фундамент на стороне Python.

!Карта соответствий тем Python и будущего перехода к C++

Среда разработки и стиль кода

Версия Python и виртуальные окружения

Рекомендуется Python 3.11+ (или 3.12). В проектах обычно используют виртуальное окружение — отдельную папку с зависимостями, чтобы не смешивать библиотеки разных проектов.

Официальная документация по виртуальным окружениям: venv — Creation of virtual environments

PEP 8 и читабельность

PEP 8 — это руководство по стилю: как называть переменные, как форматировать код, где ставить пробелы. Это важно не из-за «красоты», а потому что:

код проще читать и поддерживать

в командах уменьшается количество спорных решений

инструменты (линтеры/форматтеры) работают предсказуемо

Источник: PEP 8 — Style Guide for Python Code

Практический минимум:

имена функций и переменных: snake_case

имена классов: CamelCase

константы: UPPER_CASE

длина строки часто ограничивается (например, 88 символов у black), но главное — единый стиль в проекте

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

Переменные и присваивание

В Python переменная — это имя, которое ссылается на объект.

Это отличается от C++-переменной, которая обычно связана с конкретным типом и областью памяти (хотя в C++ тоже есть ссылки/указатели, но модель другая).

Управляющие конструкции

range(3) генерирует числа 0, 1, 2 без хранения всего списка в памяти.

Функции

Функции — основной способ структурировать код.

Полезные особенности Python:

значения по умолчанию для параметров

именованные аргументы (clamp(x=5, low=0, high=10))

возврат нескольких значений (на практике возвращается кортеж)

Основные структуры данных

Список, кортеж, словарь, множество

| Структура | Пример | Когда использовать | Аналогия с C++ | |---|---|---|---| | list | [1, 2, 3] | изменяемая последовательность | примерно как std::vector | | tuple | (1, 2) | неизменяемая последовательность | как std::tuple/std::pair | | dict | { "a": 1 } | ключ → значение | как std::unordered_map | | set | {1, 2, 3} | уникальные элементы | как std::unordered_set |

Пример со словарём:

Срезы и итерации

Итерация по dict:

Comprehensions (выражения-генераторы коллекций)

Они помогают писать коротко, но их важно не превращать в «головоломки».

Модули, пакеты и импорт

модуль — файл .py

пакет — папка с Python-кодом (обычно с __init__.py)

Пример структуры:

Импорт:

Почему это важно для перехода к C++: при связке языков границы модулей и чистые интерфейсы помогают отделять «быстрый Python» от «тяжёлого C++».

Ошибки и исключения

Исключение — это объект, который описывает ошибку и может быть перехвачен.

Рекомендации:

ловите конкретные исключения (ValueError), а не просто Exception, если это возможно

используйте finally, когда нужно гарантированно освободить ресурс

ООП в Python: классы, инкапсуляция, наследование

Класс и объект

self — ссылка на текущий объект

__init__ — конструктор (в терминах C++ похож по смыслу, но работает иначе)

Инкапсуляция в Python

В Python нет строгих модификаторов доступа как в C++ (private, protected). Вместо этого действует соглашение:

_name — «внутреннее» поле (не трогать снаружи без необходимости)

__name — name mangling (механизм переименования атрибута внутри класса)

Наследование и полиморфизм

Полиморфизм в Python часто строится на принципе duck typing: «если объект ведёт себя как утка, значит это утка». То есть важны методы/интерфейс, а не строгий тип на этапе выполнения.

Типизация в Python: зачем она нужна и как помогает для C++

Python — язык с динамической типизацией: типы проверяются во время выполнения. Но можно (и нужно в больших проектах) добавлять подсказки типов (type hints).

Источник: typing — Support for type hints

Пример:

Что дают подсказки типов:

лучшее автодополнение и навигация в IDE

более раннее обнаружение ошибок (ещё до запуска)

дисциплина, близкая к C++: вы начинаете проектировать интерфейсы «по типам»

Для проверки типов часто используют mypy:

mypy — Optional Static Typing for Python

Важно: подсказки типов не делают Python статически типизированным сами по себе — это метаданные для инструментов.

dataclass как удобный контейнер данных

dataclass сокращает шаблонный код для классов-структур.

Источник: dataclasses — Data Classes

Это похоже на простую struct в C++ по назначению: хранить данные, а не сложную бизнес-логику.

Работа с данными: файлы, пути, JSON, CSV, SQLite

Пути и файловая система через pathlib

pathlib даёт объектный интерфейс для путей.

Источник: pathlib — Object-oriented filesystem paths

Текстовые файлы и кодировки

Если вы работаете с русским текстом, почти всегда указывайте encoding="utf-8" при чтении/записи.

with гарантирует закрытие файла, даже если произошла ошибка.

JSON

JSON — самый популярный формат обмена данными между сервисами.

Источник: json — JSON encoder and decoder

ensure_ascii=False сохраняет читаемые Unicode-символы.

CSV

CSV часто используют для табличных данных.

Источник: csv — CSV File Reading and Writing

SQLite как встроенная база данных

SQLite встроена в стандартную библиотеку и удобна для учебных и небольших проектов.

Источник: sqlite3 — DB-API 2.0 interface for SQLite databases

? — параметр запроса, так безопаснее, чем собирать SQL-строку вручную.

Мост к C++: что запомнить уже сейчас

Главное отличие: модель типов и памяти

В C++ типы жёстче и компилятор проверяет их до запуска. В Python тип можно менять, и многие ошибки проявляются только при выполнении. Поэтому в Python-проектах, которые планируют ускорять C++-кодом, особенно полезны:

подсказки типов (typing)

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

классы-контейнеры (dataclass) для чётких структур данных

Как обычно связывают Python и C++ (мы подробно разберём это позже)

Python/C API — низкоуровневый способ писать расширения для CPython: Python/C API Reference Manual

pybind11 — удобные биндинги C++↔Python: pybind11 documentation

ctypes — вызов функций из динамических библиотек: ctypes — A foreign function library for Python

Смысл в том, что Python остаётся «дирижёром», а самые тяжёлые части (например, вычисления) переезжают в C++.

Итог

После этой статьи у вас должны сложиться опоры:

базовый синтаксис Python и работа с функциями

ключевые структуры данных и итерации

модульность (импорт и пакеты)

обработка ошибок через исключения

ООП по-питоновски и где оно отличается от C++

подсказки типов и dataclass как подготовка к более строгому стилю

чтение/запись данных: файлы, JSON, CSV, SQLite

Дальше по курсу мы будем углублять Python (тестирование, архитектура, производительность), а затем перейдём к C++ и практической интеграции Python↔C++.

Python: экосистема, тестирование, асинхронность и архитектура проектов

Как эта статья помогает перейти к C++ и связать языки

В прошлой статье вы закрепили базовый Python: синтаксис, структуры данных, ООП, подсказки типов, работу с файлами и форматами данных. Чтобы уверенно двигаться к C++ и особенно к связке Python↔C++, нужно научиться делать Python-проекты похожими на инженерные: воспроизводимая сборка, тестируемость, понятная архитектура, контроль качества и аккуратная работа с конкурентностью.

Идея курса такая:

Python часто становится оркестратором: CLI/сервер/пайплайн, который вызывает вычислительные модули.

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

Чтобы эта связка работала, границы модулей и контракты интерфейсов должны быть четкими уже в Python.

!Схема показывает, где обычно живет Python-код, а где выгодно подключать C++ и как держать зависимости под контролем

Экосистема Python: зависимости, упаковка, инструменты качества

Виртуальные окружения и менеджеры зависимостей

Даже если вы уже использовали venv, важно закрепить правило: один проект — одно окружение.

venv создает изолированное окружение (базовый стандарт): venv — Creation of virtual environments

pip устанавливает пакеты: pip documentation

Минимальный рабочий шаблон:

requirements.txt удобен, но современный стандарт экосистемы — pyproject.toml.

pyproject.toml и современная упаковка

pyproject.toml — единый конфигурационный файл проекта: сборка, зависимости, инструменты (линтеры/форматтеры/тесты). Он стандартизирован несколькими PEP.

Рекомендации по структуре и упаковке: Python Packaging User Guide

Метаданные проекта: PEP 621

Сборка через pyproject.toml: PEP 517 и PEP 518

На практике часто используют Poetry как инструмент управления зависимостями и публикации:

Poetry documentation

Важно для связки с C++: когда вы дойдете до биндингов (например, pybind11), сборка C++-части тоже часто будет описываться через pyproject.toml (через build-backend), а значит воспроизводимость окружения критична.

Форматирование, линтинг, статическая типизация

Цель инструментов качества — ловить ошибки раньше тестов и выполнения.

Форматирование кода: Black

Линтер и быстрые проверки: Ruff

Статическая проверка типов: mypy

Автоматический запуск проверок перед коммитом: pre-commit

Почему это важно именно для перехода на C++:

C++ вынуждает мыслить контрактами типов и интерфейсов.

Type hints + mypy дисциплинируют Python-код и делают границы модулей жестче.

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

Тестирование: как сделать код проверяемым и пригодным для рефакторинга

Зачем тесты, если “и так работает”

Тесты — это способ сохранить скорость разработки, когда проект растет.

Они защищают от регрессий (сломали старое, добавляя новое).

Они позволяют смело оптимизировать и переносить части кода в C++.

Они фиксируют контракт функций и модулей.

pytest: де-факто стандарт

pytest популярен из-за простого синтаксиса и мощной системы фикстур.

pytest documentation

Пример:

Запуск:

Фикстуры: подготовка окружения тестов

Фикстуры создают данные или ресурсы (временные директории, подключения, тестовые объекты) и убирают дублирование.

pytest fixtures

Пример с временной директорией:

Моки: тестируем без реального HTTP/БД

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

unittest.mock — mock object library

Пример: мы хотим протестировать функцию, которая использует объект с методом get_price, не трогая реальную базу.

Это напрямую связано с будущим C++: C++-модуль удобно прятать за интерфейсом и мокать в тестах, не компилируя его на каждом прогоне.

Покрытие тестами

Покрытие не гарантирует качество, но помогает увидеть непроверенные ветки.

Coverage.py documentation

Обычно используют связку pytest + coverage (часто через pytest-cov).

Асинхронность: когда она нужна и как работает asyncio

Конкурентность vs параллелизм простыми словами

Важно различать:

конкурентность: умеем “переключаться” между задачами, пока одна ждет (например, сеть).

параллелизм: реально выполняем несколько задач одновременно (например, несколько ядер CPU).

asyncio в Python в первую очередь про конкурентность и I/O-bound задачи (сеть, диски, ожидания).

Модель asyncio: event loop и await

В asyncio есть цикл событий (event loop), который запускает корутины и переключает их, когда они “ждут” I/O.

asyncio — Asynchronous I/O

Базовый пример:

await означает: “я дошел до операции ожидания, можно переключиться на другие задачи”.

!Иллюстрация помогает понять, почему async эффективен для сетевых задач без потоков

HTTP-клиенты для async

Для реальных запросов часто используют:

aiohttp documentation

httpx documentation

Ключевая практика: если вы выбрали async-стек, держите его “чистым” (не вставляйте блокирующие вызовы внутрь корутин, иначе вы теряете выгоду).

Где здесь место C++

Типичная граница такая:

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

Тяжелые вычисления (CPU-bound) лучше уносить в:

- отдельные процессы, - или C/C++ расширение, - или специализированные библиотеки.

Важно понимать: если ваш C++-код вызывается из Python и долго считает, он может “заморозить” поток интерпретатора. Позже в курсе мы разберем, как обходят это (архитектурой, многопроцессностью, а в продвинутых случаях — освобождением GIL в расширениях).

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

Принципы: разделение ответственности и управление зависимостями

Удобная архитектура начинается с простых правил:

Модуль делает одну понятную вещь.

Сложные зависимости (БД, сеть, файловая система) вынесены на края системы.

Основная логика может тестироваться без инфраструктуры.

Эти правила помогают и при переносе части логики в C++: вы заменяете реализацию, но сохраняете интерфейс.

Типичная структура проекта

Один из практичных вариантов:

Идея:

domain/ содержит модели и правила предметной области.

services/ содержит сценарии использования (use cases): “посчитать цену”, “сформировать отчет”.

infrastructure/ содержит конкретику: SQLite, HTTP, файлы.

api/ это внешний слой: CLI или веб-сервер.

Явные интерфейсы и внедрение зависимостей

В Python не обязательно вводить тяжелые контейнеры DI. Часто достаточно:

передавать зависимости параметрами,

хранить их в объекте сервиса,

выделять протокол (контракт) для зависимости.

Protocol из typing позволяет описать интерфейс без наследования.

typing — Support for type hints

Пример:

Теперь в тестах легко подставить мок, а позже легко подставить C++-реализацию репозитория (или обертку над C++ модулем), не трогая бизнес-логику.

Логирование вместо print

Для реальных проектов используйте logging.

logging — Logging facility for Python

Минимальный шаблон:

Это важно для связки Python↔C++: при проблемах на границе языков логи часто становятся главным способом быстро понять, что происходит.

Конфигурация: параметры через окружение и файлы

Два практичных правила:

Не хардкодьте пути, токены, адреса.

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

Обычно используют переменные окружения (os.environ) и конфиг-файлы (например, toml/yaml — по ситуации). Даже без дополнительных библиотек полезно держать конфигурацию в одном месте и явно передавать ее в сервисы.

Итог: что вы должны уметь после этой статьи

Поднимать проект в изолированном окружении и воспроизводимо ставить зависимости.

Понимать роль pyproject.toml и место инструментов качества (форматтер, линтер, mypy).

Писать тесты на pytest, использовать фикстуры и моки, измерять покрытие.

Понимать модель asyncio: event loop, корутины, await, gather.

Проектировать архитектуру со стабильными интерфейсами и зависимостями на “краях”.

Дальше по курсу эта база позволит:

безопасно оптимизировать Python-код,

выделять вычислительные ядра,

и переносить их в C++ так, чтобы внешний Python-интерфейс оставался чистым и тестируемым.

C++: базовый синтаксис, память, ООП, STL и RAII

Зачем эта статья в курсе с переходом из Python

В прошлых статьях вы сделали Python-фундамент: стиль, ООП, типизацию, тестирование, архитектуру. Теперь мы начинаем C++ — язык, который часто становится ускоряющим ядром в проектах, где Python остаётся оркестратором.

Главная цель этой статьи — дать вам инженерный базис C++:

как устроен код и сборка (компиляция и линковка)

как работать с типами, ссылками и указателями

как управлять ресурсами через RAII (ключевой принцип C++)

как писать классы и понимать конструкторы/деструкторы

как пользоваться STL: контейнеры, итераторы, алгоритмы

Это всё напрямую подготовит к теме связки Python↔C++ (биндинги, расширения, управление ресурсами на границе языков).

Минимальная модель: как C++ превращается в программу

C++ — компилируемый язык. Условная цепочка такая:

исходники .cpp и заголовки .h/.hpp

компиляция в объектные файлы

линковка в исполняемый файл или библиотеку

!Пайплайн: исходники → компиляция → линковка

Что важно помнить при переходе из Python:

#include не «импортирует модуль» как в Python, а вставляет текст заголовка на этапе препроцессинга

ошибки бывают двух основных классов: ошибки компиляции (тип, синтаксис) и ошибки линковки (не нашли реализацию функции)

Справочник по языку и STL: cppreference

Базовый синтаксис: переменные, типы, функции

Простая программа

Ключевые элементы:

int main() — точка входа

std::cout — вывод в консоль

std::endl — перевод строки и сброс буфера (часто можно заменить на "\n")

Типы и инициализация

В C++ тип — часть объявления переменной.

Практика C++: использовать uniform initialization (фигурные скобки) там, где удобно — она часто предотвращает неявные сужающие преобразования.

const и неизменяемость

const означает: «через это имя нельзя изменить значение».

Очень важная привычка (и для качества кода, и для оптимизаций компилятора): делать неизменяемым всё, что не должно меняться.

Функции

Перегрузка функций: одно имя, разные параметры.

Ссылки и указатели: основа понимания памяти

В Python «переменная — это имя объекта». В C++ чаще нужно думать про значение и место хранения.

Ссылка T&

Ссылка — это алиас (второе имя) уже существующего объекта.

Свойства ссылок в базовой модели:

должна быть инициализирована сразу

обычно не бывает null

после инициализации «переназначить на другой объект» нельзя

Указатель T*

Указатель хранит адрес и может быть nullptr.

Где это пригодится для Python↔C++:

при биндингах вы часто будете передавать объекты по ссылке или через «умные указатели», чтобы корректно управлять временем жизни

Память: стек, куча и время жизни

Упрощённая модель:

стек — автоматическое время жизни (объект уничтожается при выходе из блока)

куча — динамическое выделение (живёт, пока вы не освободили ресурс)

!Интуитивная картинка: стек vs куча и владение ресурсом

Опасный минимум: new и delete

Так делать можно, но в современном C++ стараются почти всегда избегать ручного new/delete.

Проблемы ручного управления:

утечки памяти (забыли delete)

двойное освобождение

исключения могут «перепрыгнуть» через delete

Решение в современном C++: RAII и умные указатели.

RAII: главный принцип управления ресурсами в C++

RAII расшифровывается как Resource Acquisition Is Initialization: ресурс захватывается в конструкторе, освобождается в деструкторе.

Идея:

объект отвечает за ресурс

ресурс освобождается автоматически, когда объект выходит из области видимости

Это фундаментально важно для связки с Python, потому что на границе языков ошибки управления ресурсами (память, файлы, мьютексы, дескрипторы) — частый источник падений и утечек.

Пример RAII на стандартных типах

Файл закрывается сам благодаря объекту потока.

Умные указатели: std::unique_ptr и std::shared_ptr

std::unique_ptr<T> — единоличное владение (обычно выбор по умолчанию)

std::shared_ptr<T> — совместное владение со счётчиком ссылок

Почему это лучше new/delete:

нельзя забыть освободить ресурс

корректно работает при исключениях

владение выражено в типе (это часть контракта)

Документация: std::unique_ptr, std::shared_ptr

Исключения: базовая модель обработки ошибок

C++ поддерживает исключения, похожие по идее на Python, но с важным отличием: благодаря RAII исключения не «ломают» освобождение ресурсов.

Практика:

бросайте исключения по смыслу (std::runtime_error, std::invalid_argument)

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

ООП в C++: классы, конструкторы, деструкторы

Класс и инкапсуляция

В C++ есть модификаторы доступа: public, private, protected.

Пояснения:

explicit запрещает нежелательные неявные преобразования при создании объекта

name() const означает: метод не меняет объект

std::move передаёт право «забрать ресурсы» у временного объекта (часть модели перемещения)

Конструктор, деструктор и правило «не делай лишнего»

В C++ важно понимать, кто владеет ресурсами и как объект копируется/перемещается.

Практическая опора:

Rule of Zero: если вы используете RAII-типы (std::string, std::vector, unique_ptr), часто не нужно писать ни деструктор, ни копирование, ни перемещение вручную

Rule of Five: если вы управляете ресурсом вручную, вам, вероятно, нужны: деструктор, копирующий конструктор, копирующее присваивание, перемещающий конструктор, перемещающее присваивание

Для перехода из Python важна мысль: в C++ «время жизни» — часть дизайна, а не деталь реализации.

STL: контейнеры, итераторы, алгоритмы

STL (часть стандартной библиотеки) — это мощный набор:

контейнеров (vector, string, unordered_map)

итераторов (единый способ прохода по данным)

алгоритмов (sort, find, accumulate)

Документация: C++ standard library

Частые контейнеры и аналогии с Python

| Задача | C++ | Python | Комментарий | |---|---|---|---| | Динамический массив | std::vector<T> | list | В Python list ближе всего к vector по смыслу | | Строка | std::string | str | std::string изменяемая, str в Python неизменяема | | Хэш-таблица | std::unordered_map<K,V> | dict | Оба дают среднее на доступ, но детали разные | | Множество | std::unordered_set<T> | set | Хэш-множество |

Итерация и range-based for

Алгоритмы: думать «данные + операция»

Пример: отсортировать и удалить дубликаты.

Почему это важно для будущего C++-ядра в Python-проекте:

STL-алгоритмы часто дают быструю реализацию без написания низкоуровневых циклов

контейнеры и RAII снимают значительную часть «боли» управления памятью

Мини-перевод мышления: Python-подход и C++-подход

Что чаще всего удивляет после Python:

в C++ важно различать передачу по значению, по ссылке и по указателю

стоимость копирования может быть существенной (поэтому часто используют const T& для входных параметров)

ресурсы (память, файл, мьютекс) должны иметь владельца, который гарантирует освобождение

Пример «типичной C++ сигнатуры» для функции без лишних копий:

Мост к будущей связке Python↔C++: что унести из этой статьи

К моменту, когда вы дойдёте до биндингов (например, через pybind11), эти идеи будут критичны:

RAII — основной способ сделать код безопасным при исключениях и на границе языков

умные указатели выражают владение и предотвращают утечки

чёткие типы и сигнатуры — аналог строгих контрактов (усиление того, что вы делали в Python через typing)

STL позволяет писать компактно и эффективно, не скатываясь в ручное управление памятью

Дальше по курсу логично углубляться в:

сборку (CMake), структуру проектов и библиотеки

шаблоны и обобщённое программирование

производительность и профилирование

практическую интеграцию Python↔C++ (биндинги, управление временем жизни объектов, исключения на границе)

Современный C++: шаблоны, move-семантика, исключения и многопоточность

Зачем эта статья в курсе Python→C++ и для связки языков

В предыдущей статье вы освоили базовый C++: типы, ссылки и указатели, STL, RAII и базовое ООП. Эта статья закрывает ключевые современные темы, без которых сложно писать производительное и безопасное C++-ядро для Python-проекта:

шаблоны как основной механизм обобщённого программирования и «контракты по типам»

move-семантика как способ убирать лишние копии и правильно выражать владение

исключения и гарантии безопасности кода при ошибках

многопоточность и защита от гонок данных

В связке Python↔C++ эти темы встречаются постоянно:

биндинги и библиотеки обычно активно используют шаблоны

без move-семантики вы случайно делаете копии больших буферов (строк, массивов)

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

вычислительное C++-ядро часто распараллеливают, а Python остаётся «дирижёром»

Шаблоны и обобщённое программирование

Шаблоны позволяют писать код один раз и получать специализированные версии для разных типов во время компиляции. Это отличается от типичного полиморфизма в Python:

в Python полиморфизм чаще динамический (duck typing)

в C++ шаблоны дают статический полиморфизм: компилятор подставляет конкретные типы и проверяет операции

Справочник: Шаблоны на cppreference

Шаблоны функций

Пример: обобщённый clamp, который работает с любым типом, у которого есть сравнение.

Что важно понимать:

template <class T> означает: T будет подставлен компилятором

ошибки часто появляются не в месте вызова, а глубже, при инстанцировании шаблона

Шаблоны классов

Самый знакомый пример из STL: std::vector<T>.

Здесь T задаёт тип элементов. Это одновременно:

часть контракта

основа производительности (нет «универсального элемента» как в Python, всё типизировано)

Вывод типов: auto и decltype

В современном C++ часто используют auto, чтобы не дублировать сложный тип.

decltype(expr) позволяет получить тип выражения, когда это нужно для интерфейса или метапрограммирования.

Справочник: auto, decltype

Ограничения шаблонов: concepts (C++20)

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

Concepts позволяют явно сформулировать требования к типу.

Здесь std::integral означает: допускаются только целочисленные типы.

Справочник: Concepts

Практическая связь с Python↔C++

В биндингах (например, через pybind11) вы часто будете видеть:

шаблонные функции регистрации типов

шаблонные обёртки над контейнерами

универсальные функции, которые принимают произвольные диапазоны

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

Move-семантика и эффективная передача объектов

Move-семантика решает задачу: как быстро передать владение ресурсом без дорогостоящего копирования. Ресурсом может быть:

память под строку std::string

буфер std::vector

владение объектом через std::unique_ptr

Справочник: rvalue-ссылки и move

!Иллюстрация показывает, почему move часто сильно дешевле копирования

std::move не перемещает сам по себе

std::move(x) делает приведение к rvalue, разрешая использовать перемещающий конструктор или перемещающее присваивание.

Справочник: std::move

Практическое правило:

после std::move(x) считайте x валидным, но логически пустым объектом

std::unique_ptr как учебный пример владения

std::unique_ptr нельзя копировать, но можно перемещать. Это напрямую выражает владение.

Справочник: std::unique_ptr

Возврат по значению и оптимизации

В современном C++ возвращать объект по значению обычно нормально: компилятор часто применяет оптимизацию устранения копирования.

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

Perfect forwarding как основа универсальных фабрик

Иногда нужно принять аргументы «как есть» и передать дальше, сохранив, являются ли они временными объектами.

Справочник: std::forward

Практическая связь с Python↔C++

На границе Python↔C++ вы постоянно упираетесь в стоимость копирования:

передача больших массивов чисел

строки и байтовые буферы

результаты вычислений

Move-семантика и аккуратные интерфейсы помогают:

возвращать большие результаты без лишних копий

выражать владение ресурсом (кто отвечает за освобождение)

безопасно проектировать API для биндингов

Исключения и безопасность при ошибках

Исключения в C++ похожи на Python по идее, но в C++ особую роль играет то, что RAII гарантирует освобождение ресурсов при раскрутке стека.

Справочник: Exceptions

Базовая модель throw и catch

Обычно выбрасывают исключения из стандартной иерархии:

std::invalid_argument

std::out_of_range

std::runtime_error

Справочник: std::exception

Гарантии безопасности при исключениях

В инженерной практике полезно различать уровни гарантий:

базовая гарантия: инварианты объекта сохраняются, утечек нет, но состояние могло частично измениться

сильная гарантия: операция либо успешно завершилась, либо состояние осталось прежним

гарантия отсутствия исключений: операция не бросает исключений

RAII обычно автоматически обеспечивает отсутствие утечек, но не всегда обеспечивает сильную гарантию.

noexcept

noexcept обозначает, что функция не должна выбрасывать исключения.

Важно:

если из noexcept функции всё же «вылетит» исключение, программа завершится через std::terminate

noexcept особенно важен для некоторых операций перемещения, чтобы контейнеры STL могли оптимально перемещать элементы

Справочник: noexcept

Исключения на границе Python↔C++

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

Практика выглядит так:

C++ код выбрасывает std::exception

слой биндинга ловит исключение и преобразует в Python-исключение

Если вы используете pybind11, то базовые стандартные исключения обычно переводятся автоматически.

Справочник: pybind11: Exceptions

Многопоточность: потоки, синхронизация и гонки данных

Многопоточность в C++ нужна, когда вычислительное ядро можно распараллелить по CPU. Важно отличать:

конкурентность: несколько задач продвигаются вперёд, переключаясь

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

Опасность номер один: гонки данных

Если два потока обращаются к одной памяти, и хотя бы один из них пишет без синхронизации, возникает data race. Это приводит к неопределённому поведению.

Справочник: Модель памяти и гонки данных

std::thread и управление временем жизни

Правила:

поток нужно либо join(), либо detach()

забытый join() для joinable-потока обычно приводит к аварийному завершению в деструкторе

Справочник: std::thread

std::jthread (C++20) как более безопасный вариант

std::jthread автоматически делает join() при выходе из области видимости.

Справочник: std::jthread

Мьютексы и блокировки

Чтобы защитить общий ресурс, используют std::mutex и RAII-обёртки блокировки.

Справочник: std::mutex, std::lock_guard

Если нужно захватить несколько мьютексов без дедлока, используйте std::scoped_lock.

Справочник: std::scoped_lock

std::condition_variable для ожидания события

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

Справочник: std::condition_variable

std::future и std::async как более высокий уровень

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

Справочник: std::async, std::future

std::atomic для простых случаев без мьютекса

Для некоторых операций (счётчики, флаги) можно использовать атомики.

Справочник: std::atomic

Важно:

атомики подходят не для всего

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

Практическая связь с Python↔C++

При вызове C++ кода из Python есть два типичных сценария:

C++ считает в нескольких потоках, но не трогает Python API: это обычно безопаснее

C++ потоки хотят вызывать Python API или работать с Python-объектами: тогда нужно корректно работать с GIL

Если вы используете pybind11, полезны механизмы управления GIL.

Справочник: pybind11: Global Interpreter Lock

Итог

После этой статьи у вас должны появиться практические опоры:

шаблоны как способ писать обобщённый и быстрый код, который проверяется компилятором

move-семантика как механизм эффективной передачи владения и устранения лишних копий

исключения и уровни гарантий безопасности, усиленные RAII

многопоточность в стандартной библиотеке C++ и базовые инструменты синхронизации

Следующий логичный шаг курса для связки языков: сборка C++-части как библиотеки и подключение к Python (обычно через pybind11 или C API), включая управление временем жизни объектов, перевод исключений и работу с потоками на границе Python↔C++.

Связка Python и C++: расширения, FFI, сборка и производительность

Зачем связывать Python и C++ именно так

В предыдущих статьях курса вы построили две опоры:

в Python: архитектура, тестирование, типизация и дисциплина интерфейсов

в C++: RAII, STL, исключения, move-семантика и многопоточность

Теперь цель связки Python↔C++ — оставить Python управляющим слоем (CLI, сервис, пайплайн, интеграция), а C++ сделать вычислительным ядром (алгоритмы, тяжёлые циклы, работа с памятью и потоками).

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

!Карта слоёв: где обычно живёт Python, где выгодно подключать C++, и что такое слой интеграции

Термины, которые нужны для понимания

FFI (Foreign Function Interface) — вызов функций из нативной библиотеки (C/C++) из Python без «родного» Python-модуля.

Расширение CPython — модуль, который импортируется как обычный Python-пакет, но внутри реализован на C/C++.

ABI (Application Binary Interface) — договорённость о бинарной совместимости: как функции вызываются, как устроены типы и символы на уровне бинарника.

Wheel — готовый бинарный пакет для pip, чтобы пользователь не компилировал C++ у себя.

Основные способы интеграции: что выбрать и почему

Обзор подходов

Запуск внешнего процесса: Python вызывает отдельную C++ программу (через subprocess).

FFI через динамическую библиотеку: Python загружает .so/.dll/.dylib и вызывает функции.

Расширение CPython: пишете модуль на C/C++ для прямого импорта.

Биндинги-обёртки: инструменты, которые упрощают написание расширений (например, pybind11).

Таблица выбора

| Подход | Инструменты | Сложность | Производительность вызова | Удобство API | Типичные случаи | |---|---|---:|---:|---:|---| | Внешний процесс | subprocess | низкая | средняя/низкая | среднее | изоляция, безопасность, тяжёлые задачи батчами | | FFI | ctypes, cffi | средняя | высокая | низкое/среднее | простой C-API, вызов функций без Python-объектов | | CPython C API | Python/C API | высокая | высокая | высокая | максимальный контроль, тонкая интеграция | | Биндинги | pybind11 | средняя | высокая | высокая | классы/исключения/контейнеры, удобный Python-интерфейс | | Генерация кода | Cython, SWIG | средняя | высокая | среднее | постепенная миграция, смешанный код |

Полезные источники:

Extending and Embedding the Python Interpreter

ctypes — A foreign function library

CFFI documentation

pybind11 documentation

FFI: быстрый старт через C-совместимый интерфейс

Главное правило FFI: Python проще всего вызывает C-совместимые функции.

Почему часто нужен именно C-API даже для C++

C++ поддерживает перегрузку функций и имеет сложное имя-манглинг-правило. Поэтому для FFI обычно делают «тонкий» слой:

C++ внутри

снаружи extern "C" функции без перегрузки

Минимальный пример: C++ библиотека + ctypes

C++ код (экспортируем C-совместимую функцию):

Сборка (пример для Linux):

Python-вызов:

Практические выводы:

FFI хорошо работает для функций, где данные простые: числа, указатели, буферы.

Для сложных объектов и классов FFI быстро становится неудобным, тогда чаще берут pybind11.

Расширения CPython и pybind11: «правильный» импортируемый модуль

Если вы хотите в Python писать import fastcore и получать функции/классы «как будто они питоновские», вы обычно делаете расширение.

Почему pybind11 часто лучший компромисс

pybind11 даёт удобную обвязку над Python/C API:

экспорт функций и классов

автоматический перевод исключений (в типичных случаях)

работа с std::string, std::vector и другими типами через конвертеры

управление временем жизни объектов (важно при RAII)

Источник: pybind11 documentation

Минимальный пример модуля на pybind11

C++ код модуля:

CMakeLists (упрощённый вариант):

Дальше есть два пути:

собирать локально для разработки (CMake + установленный pybind11)

упаковать проект так, чтобы pip install . собирал модуль автоматически

Сборка и упаковка: как сделать так, чтобы это ставилось через pip

Что обычно хотят в реальных проектах

разработчик ставит проект одной командой

CI собирает колёса (wheels) под нужные платформы

пользователю не нужен компилятор

Современная точка входа: pyproject.toml

pyproject.toml — стандартная конфигурация сборки Python-проектов.

Источник: Python Packaging User Guide

Для проектов, где сборка идёт через CMake, удобен backend scikit-build-core.

Источник: scikit-build-core documentation

Пример минимальной конфигурации (идея, а не единственно верный шаблон):

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

Если вы собираете бинарники, вы должны думать о совместимости:

версия Python и реализация (обычно CPython)

платформа (Linux, Windows, macOS)

архитектура (x86_64, arm64)

Чтобы пользователь не компилировал исходники, вы публикуете wheels. Для Linux есть политика manylinux.

Источник: manylinux specifications

Данные на границе: копирование, буферы и «узкие места»

Главная ловушка производительности

Ускорить вычисления в C++ можно сильно, но легко потерять всё на:

частых вызовах через границу Python↔C++

копировании больших массивов

Практическое правило:

делайте меньше вызовов, передавайте больше данных за один вызов

Как уменьшать копирование

Использовать типы, которые поддерживают буферы (например, bytes, bytearray, memoryview).

Для числовых массивов часто используют NumPy и zero-copy подходы через buffer protocol.

Справочник по буферам в CPython: Buffer Protocol

Если вы идёте через pybind11 и массивы, почти всегда стоит посмотреть на поддержку NumPy:

pybind11: NumPy

Ошибки и исключения: как не «взорвать» границу

Нельзя «пропускать» C++ исключения напрямую

На границе языков исключение должно быть преобразовано в Python-исключение. В pybind11 типичные исключения из std::exception обычно переводятся автоматически.

Источник: pybind11: Exceptions

Для FFI подхода (ctypes/cffi) вы чаще делаете так:

возвращаете код ошибки (int)

отдельной функцией отдаёте описание ошибки

Это менее удобно, но иногда проще и стабильнее.

Потоки и GIL: как ускорять CPU-bound задачи

Что такое GIL в контексте интеграции

В CPython есть глобальная блокировка интерпретатора (GIL), которая ограничивает параллельное выполнение Python-байткода в нескольких потоках.

Источник: Python Glossary: Global Interpreter Lock

Практическая модель:

если C++ код долго считает и не трогает Python API, его можно выполнять параллельно

если C++ код обращается к Python-объектам, нужно аккуратно управлять GIL

В pybind11 есть готовые RAII-обёртки для управления GIL.

Источник: pybind11: Global Interpreter Lock

Стратегия оптимизации: как правильно «переезжать» в C++

Правильный порядок действий

Профилируете Python-код и находите горячие точки.

Упрощаете алгоритм на Python-уровне, если это возможно.

Переносите в C++ только узкие места.

Минимизируете число переходов через границу.

Добавляете тесты на контракт (ещё до переноса) и сравниваете результаты.

Инструменты профилирования Python:

cProfile

Что обычно переносить в C++ выгоднее всего

плотные циклы по большим данным

парсинг/сериализация нестандартных бинарных форматов

алгоритмы на графах, геометрия, численные методы

многопоточные вычисления

Что часто невыгодно переносить

сетевой I/O и высокоуровневую интеграцию

мелкие функции, которые вызываются миллионы раз по одной операции

Практический чеклист для проектов Python↔C++

Определите границу модулей: что остаётся в Python, что уходит в C++.

Выберите технологию: FFI для простых функций, pybind11 для богатого API.

Зафиксируйте интерфейс типами и тестами на Python-уровне.

Думайте о владении ресурсами: кто освобождает память и когда.

Минимизируйте копирование данных и число вызовов через границу.

Сразу продумайте сборку: pyproject.toml, CI и wheels.

Итог

Вы теперь понимаете, какими способами Python и C++ связывают в реальных проектах и как выбрать подход под задачу:

FFI (ctypes/cffi) — быстро и хорошо для простого C-API

расширение CPython — максимальный контроль, но дороже в разработке

pybind11 — практичный стандарт для C++ API «как в Python»

сборка через pyproject.toml и публикация wheels — ключ к удобной установке

производительность зависит не только от скорости C++, но и от границы: вызовы, копирование, владение ресурсами, GIL