Практиическая часть ПМ 0.1_

 

1. Каковы основные принципы модульности в программировании?

Модульность в программировании основана на следующих принципах:

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

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

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

Четвертый принцип - инкапсуляция реализации. Модули должны скрывать свои внутренние детали и взаимодействовать через четко определенные интерфейсы.

В Python модульность реализуется через систему модулей и пакетов. Модуль - это файл с расширением .py, а пакет - это директория, содержащая файл init.py и другие модули или подпакеты.

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

В контексте FastAPI модульность реализуется через роутеры и зависимости. Роутеры позволяют группировать эндпоинты API по логическим категориям, а система зависимостей обеспечивает переиспользование компонентов приложения, таких как соединение с базой данных или авторизация.

2. Как организовать взаимодействие между модулями в Python-приложении?

Взаимодействие между модулями в Python организуется через систему импортов и применение паттернов проектирования.

Python поддерживает два типа импортов: абсолютные и относительные.

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

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

Среди паттернов проектирования для организации взаимодействия между модулями особо важны:

Внедрение зависимостей (Dependency Injection) - модуль не создаёт свои зависимости сам, а получает их извне, что повышает гибкость и тестируемость.

Фабричный метод (Factory Method) - создание объектов выносится в специализированные классы-фабрики, что централизует логику создания объектов.

Наблюдатель (Observer) - позволяет одним модулям реагировать на изменения состояния других модулей без создания сильных связей между ними.

Посредник (Mediator) - централизует взаимодействие между компонентами системы, что снижает связанность между ними.

Фасад (Facade) - предоставляет простой интерфейс к сложной подсистеме, скрывая её детали реализации.

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

3. Какие структуры данных в Python наиболее эффективны для разных задач?

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

Списки (list) - упорядоченные коллекции, эффективны для хранения последовательностей элементов, когда требуется частый доступ по индексу или модификация. Операции вставки и удаления в конце списка выполняются за константное время, а в середине - за линейное. Списки подходят для работы с данными в том порядке, в котором они поступают.

Множества (set) - неупорядоченные коллекции уникальных элементов, оптимизированные для проверки наличия элемента, объединения, пересечения и разности множеств. Операции поиска, добавления и удаления выполняются за константное время. Множества идеальны для исключения дубликатов и проверки принадлежности.

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

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

Для представления отдельных записей из реляционных баз данных часто используются словари, где ключи соответствуют названиям столбцов. Это соответствует формату строк, возвращаемых многими ORM и библиотеками доступа к БД.

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

Для NoSQL баз данных, например MongoDB, естественным представлением является вложенная структура из словарей и списков, что соответствует формату BSON/JSON.

При кэшировании запросов словари с составными ключами или вложенные словари обеспечивают эффективный доступ.

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

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

4. Как реализовать REST API на FastAPI?

REST API на FastAPI реализуется с использованием декораторов для определения эндпоинтов и Pydantic-моделей для валидации данных.

FastAPI - современный фреймворк для создания API на Python, который обеспечивает автоматическую валидацию, сериализацию, документирование и поддерживает как синхронный, так и асинхронный подходы к разработке.

Основные шаги создания REST API на FastAPI:

Первое - настройка приложения. Создаётся экземпляр FastAPI, который будет обрабатывать запросы.

Второе - определение моделей данных с помощью Pydantic. Это позволяет автоматически валидировать входящие данные и документировать API.

Третье - создание эндпоинтов с использованием декораторов для различных HTTP-методов: @app.get(), @app.post(), @app.put(), @app.delete().

Четвертое - организация API с помощью роутеров для группировки связанных эндпоинтов.

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

В отличие от Flask, который является более минималистичным фреймворком, FastAPI предоставляет встроенную поддержку Swagger UI, валидацию типов и более высокую производительность благодаря Starlette и Pydantic.

NodeJS с Express также позволяет создавать REST API, но использует JavaScript/TypeScript и другую модель обработки запросов, основанную на промежуточных обработчиках (middleware).

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

FastAPI поддерживает как синхронные, так и асинхронные обработчики. Асинхронный подход с async/await особенно полезен для операций ввода-вывода (например, запросы к базе данных или внешним API), так как позволяет обрабатывать множество запросов одновременно без блокировки, что значительно увеличивает производительность приложения в условиях высокой нагрузки.

Copy

продолжай

Продолжение ответа на вопрос 4 (Как реализовать REST API на FastAPI)

При создании асинхронных обработчиков в FastAPI важно использовать асинхронные версии драйверов для работы с базами данных, например, asyncpg для PostgreSQL или motor для MongoDB. Это позволяет полностью реализовать преимущества неблокирующего ввода-вывода.

Документация API в FastAPI генерируется автоматически на основе аннотаций типов и docstring функций. Доступны два интерфейса: Swagger UI по пути /docs и ReDoc по пути /redoc.

Для защиты API можно использовать встроенные механизмы аутентификации и авторизации FastAPI, включая OAuth2 с JWT-токенами. Это позволяет легко реализовать безопасный доступ к ресурсам API.

5. Как работать с файлами и сериализацией данных в Python?

Работа с файлами и сериализацией данных в Python осуществляется с помощью встроенных функций и специализированных библиотек.

Для работы с JSON используется встроенный модуль json, предоставляющий методы dumps() и loads() для сериализации и десериализации объектов Python в JSON-строки, а также dump() и load() для работы с файлами. Преимуществами JSON являются его читаемость, широкая поддержка и отсутствие необходимости в дополнительных библиотеках. Однако JSON имеет ограниченный набор типов данных и не поддерживает некоторые Python-объекты напрямую.

Для работы с CSV используется модуль csv, который предоставляет классы reader и writer для обработки CSV-файлов. CSV прост для понимания человеком, поддерживается практически всеми электронными таблицами и базами данных, но не подходит для вложенных структур и не имеет стандартизированного типа данных.

При работе с MongoDB используется формат BSON (Binary JSON), который расширяет JSON дополнительными типами, такими как ObjectId, Date, Binary. Библиотеки pymongo и motor обеспечивают автоматическое преобразование между Python-объектами и BSON.

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

• Чтение файлов построчно с использованием итератора
• Использование модуля itertools для эффективной работы с итераторами
• Применение библиотеки pandas с параметром chunksize для обработки CSV/JSON по частям
• Использование генераторов для преобразования данных "на лету"

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

6. Какие виды тестирования применяются в разработке ПО?

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

Модульное (unit) тестирование проверяет отдельные компоненты программы изолированно от остальной системы. Это позволяет быстро локализовать проблемы и обеспечивает документирование ожидаемого поведения. В Python для unit-тестирования используются библиотеки pytest, unittest и nose.

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

Нагрузочное тестирование определяет производительность и стабильность системы под различной нагрузкой. Оно помогает определить пределы масштабируемости и выявить узкие места в архитектуре. Для нагрузочного тестирования используются инструменты, такие как Locust, Apache JMeter или wrk.

В FastAPI тестирование реализуется с помощью встроенного TestClient, который позволяет отправлять запросы к приложению без запуска реального сервера. Для асинхронных тестов используется HTTPX.

Mock-объекты (заглушки) используются для имитации поведения реальных компонентов системы в тестах. Они позволяют изолировать тестируемый код от внешних зависимостей, таких как базы данных, API или файловая система. В Python для создания mock-объектов используются библиотеки unittest.mock и pytest-mock.

7. Как отлаживать Python-приложения?

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

Основным встроенным инструментом отладки является модуль pdb (Python Debugger), который позволяет устанавливать точки останова, выполнять код пошагово, исследовать стек вызовов и просматривать значения переменных. Более удобные альтернативы включают ipdb (улучшенный pdb с функциональностью IPython) и pudb (визуальный отладчик для консоли).

Современные IDE, такие как PyCharm, VSCode и Spyder, предоставляют встроенные отладчики с графическим интерфейсом, что значительно упрощает процесс отладки. Они позволяют устанавливать условные точки останова, следить за значениями переменных и визуализировать выполнение кода.

Логирование является важным аспектом отладки, особенно для продакшн-систем. Модуль logging позволяет настраивать уровни детализации логов, форматирование сообщений и направление вывода. Для распределенных систем полезны специализированные решения, такие как ELK стек (Elasticsearch, Logstash, Kibana) или Graylog.

Для тестирования API полезны инструменты, такие как Postman, curl или HTTPie, которые позволяют формировать запросы и анализировать ответы.

Профилирование используется для выявления узких мест производительности. В стандартной библиотеке Python доступны модули:

• cProfile/profile для профилирования времени выполнения функций
• tracemalloc для отслеживания выделения памяти
• timeit для точного измерения времени выполнения небольших фрагментов кода

Более продвинутые инструменты, такие как py-spy, позволяют профилировать работающие приложения без модификации кода, а memory_profiler помогает отслеживать потребление памяти построчно.

Для веб-приложений на FastAPI полезны middleware для логирования запросов и отладки, а также инструменты мониторинга, такие как Prometheus с Grafana для визуализации метрик производительности.

8. Как документировать код и API?

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

В Python основным способом документирования функций и классов являются docstrings - строки документации, расположенные в начале определения модуля, функции, класса или метода. Существует несколько форматов docstrings: Google style, reST и NumPy style, различающихся синтаксисом и структурой.

Sphinx - мощный генератор документации для Python, способный извлекать информацию из docstrings и создавать документацию в различных форматах (HTML, PDF). Он поддерживает системы расширений и интеграцию с инструментами контроля версий.

FastAPI обеспечивает автоматическую генерацию интерактивной документации API на основе Swagger/OpenAPI. Эта документация создается из аннотаций типов и docstrings функций-обработчиков и моделей Pydantic. Swagger UI предоставляет возможность не только просматривать документацию, но и тестировать API непосредственно через интерфейс браузера.

В NodeJS для документирования API используются инструменты, такие как JSDoc для документирования кода и библиотеки вроде Swagger-UI-Express или API-Doc для создания интерактивной документации API.

Хорошая документация должна включать:

• Общее описание проекта и его назначения
• Инструкции по установке и настройке
• Примеры использования
• Подробное описание API (для библиотек и веб-сервисов)
• Информацию о вкладе в проект для сторонних разработчиков
• Сведения о лицензии и авторских правах

Автоматическая генерация документации и её интеграция в процесс непрерывной интеграции (CI) обеспечивает актуальность документации и снижает барьер для её поддержания в актуальном состоянии.

Copy

продолжай

9. Какие методы рефакторинга кода вы знаете?

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

Улучшение читаемости кода согласно стандарту PEP 8 включает в себя:

• Использование стандартных соглашений об именовании (snake_case для функций и переменных, CamelCase для классов)
• Соблюдение отступов (4 пробела для каждого уровня вложенности)
• Ограничение длины строк (рекомендуемый максимум - 79 символов)
• Правильное использование пробелов вокруг операторов
• Разделение логических блоков пустыми строками
• Использование информативных имен переменных и функций

Для автоматизации проверки и исправления соответствия стилю применяются инструменты, такие как flake8, pylint, black и autopep8.

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

• Избегание SELECT * и выбор только необходимых столбцов
• Создание индексов для часто запрашиваемых полей
• Использование JOIN вместо вложенных подзапросов, где это возможно
• Оптимизация запросов с использованием EXPLAIN для анализа плана выполнения
• Использование пагинации для ограничения размера результата
• Применение кэширования запросов для повторяющихся операций

Оптимизация агрегаций в MongoDB:

• Использование индексов для полей, участвующих в агрегациях
• Применение операторов проекции для уменьшения объема обрабатываемых данных
• Использование операций предварительной фильтрации до агрегации
• Разделение сложных агрегаций на более простые этапы
• Применение методов map-reduce для сложных аналитических операций
• Использование опции allowDiskUse для работы с большими наборами данных

Другие методы рефакторинга кода включают:

• Выделение повторяющегося кода в функции
• Разделение больших функций на более мелкие и специализированные
• Замена условной логики полиморфизмом
• Упрощение сложных условных выражений
• Использование дескрипторов и свойств для контроля доступа к атрибутам
• Замена наследования композицией там, где это уместно
• Введение промежуточных переменных для улучшения читаемости выражений

10. Какие архитектурные паттерны используются в мобильной разработке?

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

MVC (Model-View-Controller) является классическим паттерном, разделяющим приложение на три компонента:

• Model (Модель): представляет данные и бизнес-логику
• View (Представление): отвечает за отображение данных пользователю
• Controller (Контроллер): обрабатывает ввод пользователя и обновляет модель и представление

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

MVVM (Model-View-ViewModel) решает проблему "массивных контроллеров" путем введения промежуточного слоя между представлением и моделью:

• Model (Модель): данные и бизнес-логика
• View (Представление): пользовательский интерфейс
• ViewModel (Модель представления): преобразует данные модели в формат, удобный для представления, и обрабатывает пользовательский ввод

MVVM особенно популярен в приложениях с привязкой данных, таких как Flutter, Kotlin с использованием Data Binding или Swift с Combine.

Clean Architecture (Чистая архитектура) представляет собой расширение принципов SOLID, разделяющее приложение на концентрические слои с зависимостями, направленными внутрь:

• Entities (Сущности): основные бизнес-объекты
• Use Cases (Варианты использования): правила приложения
• Interface Adapters (Адаптеры интерфейса): шлюзы, контроллеры, презентеры
• Frameworks & Drivers (Фреймворки и драйверы): интерфейс пользователя, базы данных, внешние API

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

Другие важные архитектурные паттерны в мобильной разработке включают:

• Redux/Flux: централизованное управление состоянием через одностороннее движение данных
• BLoC (Business Logic Component): разделение бизнес-логики и UI, популярно во Flutter
• Repository Pattern: абстрагирует источники данных от остальной части приложения
• Coordinator/Flow Controller: управляет навигацией и потоком экранов
• Dependency Injection: обеспечивает инверсию контроля и тестируемость

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

11. Как взаимодействовать с бэкендом (FastAPI) из мобильного приложения?

Взаимодействие мобильного приложения с бэкендом на FastAPI осуществляется преимущественно через HTTP-запросы к REST API и WebSockets для реактивного обмена данными.

REST API является основным способом коммуникации и использует стандартные HTTP-методы:

• GET для получения данных
• POST для создания новых ресурсов
• PUT/PATCH для обновления существующих ресурсов
• DELETE для удаления ресурсов

Мобильные приложения используют HTTP-клиенты для отправки запросов к API. В Android это может быть Retrofit, OkHttp или Volley, в iOS - URLSession или Alamofire, а в кроссплатформенных решениях - Dio (Flutter) или Axios (React Native).

WebSockets обеспечивают двунаправленную связь в реальном времени между клиентом и сервером через постоянное соединение. FastAPI поддерживает WebSockets через Starlette, что позволяет реализовать функциональность чатов, уведомлений и обновлений данных в реальном времени.

Аутентификация является критически важным аспектом взаимодействия с API. Наиболее распространенные подходы:

JWT-токены (JSON Web Tokens) представляют собой самодостаточные токены, содержащие зашифрованную информацию о пользователе. Процесс включает:

• Аутентификацию пользователя на сервере
• Получение JWT-токена
• Хранение токена на клиенте (SecureStorage, Keychain)
• Отправку токена с каждым запросом в заголовке Authorization

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

Безопасное взаимодействие с API включает:

• Использование HTTPS для шифрования передаваемых данных
• Валидацию входящих данных на клиенте и сервере
• Обработку ошибок и повторные попытки при нестабильном соединении
• Обновление токенов доступа при истечении срока действия
• Защиту от CSRF и XSS атак

Сериализация данных обычно осуществляется в формате JSON, который поддерживается как FastAPI (через Pydantic), так и мобильными платформами.

12. Как оптимизировать мобильное приложение?

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

Кэширование данных является одним из ключевых методов оптимизации:

• Локальное хранение часто используемых данных в базе данных (SQLite, Room, CoreData, Realm)
• Кэширование загруженных изображений и медиа-файлов
• Использование стратегий инвалидации кэша: TTL (time-to-live), LRU (least recently used)
• Применение слоя абстракции с приоритетом кэша над сетевыми запросами
• Фоновая синхронизация данных при наличии сетевого подключения

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

• Пакетная обработка запросов (batching) вместо множества отдельных вызовов
• Использование GraphQL для получения только необходимых данных
• Реализация стратегии "pull-to-refresh" вместо автоматического обновления
• Отложенная загрузка неприоритетного контента
• Использование дифференциальной синхронизации, передающей только измененные данные

Другие важные аспекты оптимизации включают:

• Эффективное управление памятью и предотвращение утечек
• Использование многопоточности для длительных операций
• Оптимизация отрисовки UI (повторное использование элементов, виртуализация списков)
• Адаптивная загрузка ресурсов в зависимости от характеристик устройства
• Сжатие передаваемых данных
• Предварительная загрузка контента, который может понадобиться пользователю
• Использование нативных компонентов для критичных к производительности функций
• Оптимизация размера приложения через удаление неиспользуемых ресурсов

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

Copy

продолжай

13. Какие фреймворки для кроссплатформенной разработки вы знаете?

Кроссплатформенная разработка позволяет создавать мобильные приложения для различных операционных систем, используя единую кодовую базу. Среди таких фреймворков выделяются Python Kivy и React Native на базе NodeJS.

Python Kivy — это открытый фреймворк для создания мультиплатформенных приложений с естественным пользовательским интерфейсом.

Преимущества Kivy:

• Использует Python — язык с простым синтаксисом и обширной экосистемой библиотек
• Работает на различных платформах: Android, iOS, Windows, Linux, macOS
• Имеет собственный язык разметки KV для отделения логики от представления
• Поддерживает мультитач и жесты
• Не требует JavaScript или веб-технологий
• Является полностью свободным ПО с открытым исходным кодом

Недостатки Kivy:

• Менее производительный по сравнению с нативными приложениями
• Ограниченный доступ к нативным API без дополнительных расширений
• Относительно небольшое сообщество разработчиков
• Визуальные компоненты могут выглядеть не так, как нативные элементы интерфейса
• Размер готового приложения больше из-за включения интерпретатора Python

React Native, основанный на NodeJS, использует JavaScript или TypeScript для создания приложений с нативным пользовательским интерфейсом.

Преимущества React Native:

• Использует реальные нативные компоненты UI, а не веб-представления
• "Горячая перезагрузка" позволяет мгновенно видеть результаты изменений
• Большое и активное сообщество, множество готовых библиотек
• Высокая производительность, близкая к нативным приложениям для большинства задач
• Единая парадигма разработки с веб-приложениями на React
• Хорошая поддержка со стороны Meta (Facebook) и крупных компаний

Недостатки React Native:

• Необходимость изучения JSX и экосистемы React
• Для сложной нативной функциональности требуется писать нативные мосты
• Зависимость от JavaScript-движка, что может влиять на производительность
• Потенциальные проблемы при обновлении до новых версий фреймворка
• Сложности с отладкой некоторых нативных проблем

Выбор между Kivy и React Native зависит от конкретных требований проекта, опыта команды и необходимой функциональности. React Native обычно предпочтительнее для сложных приложений с нативным внешним видом, в то время как Kivy может быть хорошим выбором для проектов, где команда уже работает с Python и требуется меньше нативных взаимодействий.

14. Как работать с процессами и потоками в Python?

Работа с процессами и потоками в Python имеет несколько особенностей, связанных с архитектурой языка и его реализацией.

GIL (Global Interpreter Lock) — глобальная блокировка интерпретатора — это механизм в CPython, который не позволяет нескольким потокам Python выполнять байт-код одновременно. GIL существенно влияет на многопоточное программирование в Python:

• Потоки эффективны для ввода-вывода (I/O-bound задач), так как GIL освобождается на время ожидания
• Для задач с интенсивными вычислениями (CPU-bound) потоки не дают прироста производительности из-за GIL
• Многопоточность все равно полезна для организации конкурентного исполнения задач, даже если они не выполняются параллельно

Модуль threading предоставляет высокоуровневый интерфейс для работы с потоками:

• Thread — базовый класс для создания потоков
• Lock, RLock — примитивы синхронизации для защиты разделяемых ресурсов
• Condition — для более сложной синхронизации
• Event — для простой коммуникации между потоками
• Semaphore — для ограничения доступа к ресурсам

Модуль multiprocessing обходит ограничения GIL путем создания отдельных процессов вместо потоков:

• Каждый процесс имеет свой интерпретатор Python и память
• Обеспечивает настоящее параллельное выполнение на многоядерных системах
• Имеет API, аналогичный threading, что облегчает миграцию кода
• Включает средства для обмена данными между процессами: Queue, Pipe, shared memory
• Предоставляет Pool для параллельного выполнения задач

Для сравнения, в C++ std::thread напрямую работает с потоками операционной системы без ограничений, подобных GIL, что позволяет достичь настоящего параллелизма даже для CPU-bound задач в рамках одного процесса.

В контексте FastAPI, разница между синхронным и асинхронным подходами существенна:

• Синхронные функции (def) блокируют выполнение до завершения операции
• Асинхронные функции (async def) позволяют приостановить выполнение на ключевом слове await, освобождая ресурсы для обработки других запросов
• Асинхронный код в FastAPI построен на asyncio и uvloop, что обеспечивает высокую производительность без использования многопоточности
• Асинхронный подход особенно эффективен для веб-приложений с большим количеством одновременных соединений и операций ввода-вывода

Выбор между потоками, процессами и асинхронным программированием зависит от характера задачи, требований к ресурсам и масштабируемости.

15. Как взаимодействовать с ОС на низком уровне?

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

Модуль os предоставляет функциональность для работы с операционной системой, не зависящую от платформы:

• Управление файлами и директориями (os.path, os.mkdir, os.remove)
• Доступ к переменным окружения (os.environ)
• Запуск процессов (os.system, os.execv)
• Получение информации о системе (os.uname, os.cpu_count)
• Работа с правами доступа к файлам (os.chmod)
• Низкоуровневые операции с дескрипторами файлов (os.open, os.read, os.write)

Модуль subprocess предоставляет более гибкие средства для запуска внешних процессов:

• Функция run() для простого выполнения команд и получения результата
• Класс Popen для более тонкого контроля над процессом
• Перенаправление стандартных потоков ввода/вывода/ошибок
• Асинхронное взаимодействие с процессами
• Безопасная обработка аргументов команды
• Управление окружением процесса

Системные вызовы и интеграция Python с C++ осуществляются несколькими способами:

• ctypes — библиотека для вызова функций из динамических библиотек/DLL
• CFFI (C Foreign Function Interface) — более современный и гибкий интерфейс для C
• Cython — язык, который компилирует Python-подобный код в C/C++
• swig — генератор интерфейсов для подключения кода на C/C++ к различным языкам
• pybind11 — современная библиотека для создания Python-привязок к C++11
• Расширения на C с использованием Python C API

Работа с файловой системой включает следующие аспекты:

• Высокоуровневые операции через модули os.path, pathlib, shutil
• Мониторинг изменений в файловой системе (watchdog)
• Работа с атрибутами и метаданными файлов
• Блокировки файлов для многопроцессного доступа (fcntl на Unix, msvcrt на Windows)
• Потоковая обработка больших файлов
• Работа с путями с учетом особенностей ОС

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

16. Как разрабатывать сетевые приложения?

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

Сокеты являются фундаментальным механизмом межпроцессного взаимодействия и сетевых коммуникаций. Модуль socket в Python предоставляет доступ к сетевому интерфейсу операционной системы:

TCP-сокеты обеспечивают надежную потоковую передачу данных с установлением соединения:

• Гарантируют доставку данных в порядке отправки
• Автоматически обрабатывают повторную передачу при потере пакетов
• Подходят для приложений, требующих надежности (веб-серверы, передача файлов)

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

• Не гарантируют доставку или порядок пакетов
• Обладают меньшей накладной нагрузкой, чем TCP
• Подходят для приложений, где скорость важнее надежности (онлайн-игры, потоковое видео)

Пример серверного TCP-сокета включает следующие шаги:

• Создание сокета с указанием семейства адресов и типа
• Привязка к адресу и порту
• Прослушивание входящих соединений
• Принятие соединений от клиентов
• Обмен данными
• Закрытие соединения

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

• Неблокирующий ввод-вывод позволяет обрабатывать тысячи соединений в одном потоке
• Сопрограммы (coroutines) обеспечивают понятную последовательную структуру кода
• Асинхронные серверы и клиенты легко масштабируются
• Транспортные протоколы и события абстрагированы через интерфейсы высокого уровня
• Встроенная поддержка таймаутов, планирования задач и управления ресурсами

Фреймворки, построенные на asyncio, такие как aiohttp, FastAPI и Tornado, предоставляют инструменты для создания высокопроизводительных веб-серверов и клиентов.

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

• Requests — для синхронных HTTP-запросов
• aiohttp, httpx — для асинхронных HTTP-запросов
• websockets, Socket.IO — для WebSocket-соединений
• Twisted — фреймворк для событийно-ориентированного сетевого программирования
• gRPC — для высокопроизводительных RPC (удаленных вызовов процедур)

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

Copy

продолжай

17. Как обеспечить безопасность системного ПО?

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

Хеширование паролей — это фундаментальный подход к защите учетных данных пользователей:

• Никогда не храните пароли в открытом виде
• Используйте современные алгоритмы хеширования, специально разработанные для паролей, такие как bcrypt, Argon2 или PBKDF2
• Добавляйте уникальную "соль" (salt) к каждому паролю перед хешированием для защиты от атак с использованием радужных таблиц
• Применяйте растяжение ключа (key stretching) через многократное хеширование для увеличения вычислительной сложности подбора
• В Python для этих целей используйте библиотеки passlib или встроенный модуль hashlib с необходимыми параметрами

SQL-инъекции представляют серьезную угрозу для приложений, взаимодействующих с реляционными базами данных:

• Никогда не формируйте SQL-запросы прямой конкатенацией строк с пользовательскими данными
• Используйте параметризованные запросы или prepared statements
• Применяйте ORM (Object-Relational Mapping), такие как SQLAlchemy, которые автоматически экранируют ввод
• Ограничивайте права доступа пользователя базы данных минимально необходимыми для работы приложения
• Валидируйте и санируйте пользовательский ввод на стороне приложения

Уязвимости MongoDB и других NoSQL-баз данных включают:

• NoSQL-инъекции через операторы запросов (например, с использованием операторов $gt, $where)
• Атака через переполнение объектов BSON
• Небезопасные конфигурации по умолчанию, позволяющие удаленный доступ без аутентификации
• Для защиты:
  • Используйте строго типизированные схемы и валидацию с помощью ODM (Object-Document Mapping) вроде mongoengine
  • Обеспечьте должную аутентификацию и авторизацию для всех соединений
  • Ограничьте сетевой доступ к базе данных только необходимыми источниками
  • Регулярно обновляйте MongoDB до последних версий

Другие важные меры безопасности системного ПО:

• Применяйте принцип минимальных привилегий для всех компонентов системы
• Используйте сильную аутентификацию, желательно многофакторную
• Шифруйте конфиденциальные данные как при передаче, так и при хранении
• Регулярно обновляйте все зависимости для устранения известных уязвимостей
• Внедряйте безопасную разработку на всех этапах жизненного цикла ПО
• Проводите регулярные аудиты безопасности и тестирование на проникновение
• Логируйте события безопасности и настройте мониторинг для обнаружения подозрительной активности

18. Как спроектировать многослойную архитектуру приложения с использованием FastAPI?

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

Классическое разделение FastAPI-приложения включает следующие слои:

1. Слой роутеров (Routers) - точка входа для HTTP-запросов:

   • Определяет эндпоинты API и методы HTTP
   • Валидирует входные данные с помощью Pydantic-моделей
   • Передает обработку запроса сервисному слою
   • Форматирует HTTP-ответ
   • Обрабатывает ошибки HTTP
   • Применяет декораторы для зависимостей, аутентификации и авторизации

2. Слой сервисов (Services) - содержит бизнес-логику приложения:

   • Реализует основные операции, независимые от протокола
   • Координирует репозитории для выполнения бизнес-операций
   • Обрабатывает ошибки предметной области
   • Реализует транзакции, охватывающие несколько репозиториев
   • Абстрагирует детали хранения данных от роутеров

3. Слой репозиториев (Repositories) - обеспечивает доступ к данным:

   • Инкапсулирует логику доступа к базе данных
   • Преобразует между моделями данных и сущностями предметной области
   • Абстрагирует конкретную СУБД от остального приложения
   • Реализует запросы к базе данных
   • Обрабатывает специфичные для хранилища ошибки

Для интеграции с PostgreSQL или MongoDB можно реализовать как синхронный, так и асинхронный доступ:

Синхронный доступ к PostgreSQL:

• Использует SQLAlchemy Core или ORM
• Подходит для простых приложений с небольшим числом одновременных запросов
• Проще в реализации и отладке
• Может блокировать асинхронный цикл событий при длительных операциях

Асинхронный доступ к PostgreSQL:

• Использует asyncpg или SQLAlchemy с асинхронными расширениями
• Значительно повышает параллелизм и пропускную способность под нагрузкой
• Не блокирует другие запросы во время операций с базой данных
• Требует последовательного использования async/await во всей цепочке вызовов

Синхронный доступ к MongoDB:

• Использует pymongo или mongoengine
• Подходит для приложений с простыми требованиями к базе данных
• Имеет более широкую экосистему инструментов

Асинхронный доступ к MongoDB:

• Использует motor или beanie (асинхронный ODM)
• Обеспечивает высокую производительность при большом количестве параллельных запросов
• Хорошо интегрируется с асинхронной моделью FastAPI

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

19. Какие паттерны проектирования наиболее полезны для модульной разработки?

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

Singleton (Одиночка) обеспечивает существование только одного экземпляра класса в приложении:

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

Dependency Injection (Внедрение зависимостей) позволяет компоненту получать свои зависимости извне, а не создавать их самостоятельно:

• Уменьшает связанность между модулями
• Повышает тестируемость через возможность подмены реальных реализаций мок-объектами
• Облегчает изменение реализаций без модификации использующего кода
• В FastAPI реализуется через механизм Depends:

Factory (Фабрика) в Python предоставляет интерфейс для создания объектов без явного указания их конкретных классов:

• Factory Method (Фабричный метод) определяет интерфейс для создания объектов, но позволяет подклассам решать, какой класс инстанцировать
• Abstract Factory (Абстрактная фабрика) предоставляет интерфейс для создания семейств взаимосвязанных объектов
• Помогает создавать сложные объекты с различными вариациями
• Упрощает добавление новых типов объектов без изменения существующего кода

В контексте FastAPI использование зависимостей (Depends) является мощным механизмом для организации модульной структуры:

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

Другие полезные паттерны для модульной разработки:

• Repository Pattern (Репозиторий) - абстрагирует источник данных от бизнес-логики
• Strategy (Стратегия) - определяет семейство алгоритмов, инкапсулирует каждый из них и делает их взаимозаменяемыми
• Observer (Наблюдатель) - определяет зависимость типа "один ко многим" между объектами
• Adapter (Адаптер) - позволяет использовать интерфейс существующего класса как другой интерфейс
• Facade (Фасад) - предоставляет упрощенный интерфейс к сложной подсистеме
• Command (Команда) - инкапсулирует запрос как объект

Применение этих паттернов должно быть обосновано реальными потребностями проекта, а не просто следованием "модным" практикам. Избыточное усложнение архитектуры может привести к обратному эффекту - ухудшению сопровождаемости кода.

20. Какие инструменты профилирования вы бы использовали для оптимизации Python-сервиса?

Для оптимизации Python-сервиса необходимо применять специализированные инструменты профилирования, позволяющие выявить узкие места в производительности.

Для анализа медленных SQL-запросов существуют следующие инструменты:

• Встроенные механизмы логирования запросов в СУБД (например, slow query log в PostgreSQL)
• EXPLAIN/EXPLAIN ANALYZE для анализа плана выполнения запроса
• django-debug-toolbar для визуализации SQL-запросов в Django-приложениях
• SQLAlchemy встроенное профилирование с использованием event listeners
• pgBadger для анализа логов PostgreSQL
• Инструменты мониторинга, такие как Datadog или New Relic, предоставляющие агрегированные данные о производительности запросов

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

• cProfile/profile - стандартные модули Python для статистического профилирования
• py-spy - профилировщик, не требующий модификации кода и минимально влияющий на производительность
• pyflame/Flamegraph - визуализация стека вызовов в виде "пламенных графиков"
• yappi - профилировщик с поддержкой многопоточности
• line_profiler - построчный профилировщик для детального анализа критических функций
• Профилировщики в IDE, такие как PyCharm Profiler или VS Code с расширениями

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

• tracemalloc - стандартный модуль для отслеживания выделения памяти
• memory_profiler - построчный анализ потребления памяти
• objgraph - визуализация графа объектов для поиска циклических ссылок
• pympler - комплексный инструмент для анализа размера и жизненного цикла объектов
• Heapy из пакета guppy для глубокого анализа кучи
• muppy для анализа объектов в многопользовательских приложениях

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

• Prometheus с Grafana для сбора и визуализации метрик в реальном времени
• Jaeger или Zipkin для трассировки распределенных систем
• New Relic или Datadog для глубокого мониторинга с минимальной настройкой
• statsd для агрегации произвольных метрик приложения
• OpenTelemetry как стандартизированный фреймворк для телеметрии приложений

Методология профилирования включает:

• Сбор базовых показателей перед оптимизацией
• Фокусирование на наиболее критичных узких местах (правило 80/20)
• Итеративную оптимизацию с измерением результатов после каждого изменения
• Балансирование между оптимизацией CPU, памяти, ввода-вывода и сети
• Создание автоматизированных тестов производительности для предотвращения регрессий

Copy

продолжай и пиши быстрее

21. Как отладить race condition в многопоточном Python-приложении?

Race condition (состояние гонки) в многопоточных приложениях возникает, когда результат операции зависит от порядка выполнения потоков. Отладка таких проблем требует специального подхода:

Диагностика через logging позволяет отследить последовательность событий в многопоточном приложении:

• Используйте потокобезопасное логирование через модуль logging
• Включайте в логи идентификатор потока (threading.get_ident())
• Логируйте начало и завершение критических секций
• Применяйте временные метки с высоким разрешением
• Настройте форматирование логов для удобного анализа

Синхронизация доступа через threading.Lock помогает предотвратить состояния гонки:

• Используйте Lock для защиты доступа к разделяемым ресурсам
• RLock для вложенных блокировок одним потоком
• Semaphore для ограничения доступа определенным числом потоков
• Event для сигнализации между потоками
• Condition для более сложных сценариев синхронизации

В сравнении с механизмами синхронизации в NodeJS:

• Python использует явные примитивы синхронизации (Lock, Event)
• NodeJS основан на однопоточной модели с циклом событий, где синхронизация обеспечивается через асинхронные обещания (Promises)
• В Python необходимо явно защищать разделяемые ресурсы
• В NodeJS состояния гонки возникают реже из-за выполнения JavaScript-кода в одном потоке

Дополнительные методы отладки race conditions:

• Использование модуля threading.current_thread() для идентификации потоков
• Применение декораторов для автоматической защиты критических секций
• Инструменты статического анализа кода для выявления потенциальных проблем
• Добавление искусственных задержек для проявления скрытых гонок
• Стресс-тестирование с увеличенным числом потоков
• Использование атомарных операций (threading.atomic в Python 3.11+)

22. Какие ограничения производительности есть у Python в мобильной разработке?

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

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

• Интерпретируемая природа Python приводит к медленному запуску приложения
• Значительное потребление памяти из-за необходимости включать интерпретатор
• Ограниченный доступ к нативным API без дополнительных расширений
• Неоптимальная производительность графических операций для сложных интерфейсов
• Больший размер приложения по сравнению с нативными решениями

React Native (NodeJS) имеет свои особенности:

• Лучшая оптимизация для мобильных платформ по сравнению с Kivy
• JavaScript-движок работает быстрее интерпретатора Python на мобильных устройствах
• Более эффективное использование нативных компонентов интерфейса
• "Мост" между JavaScript и нативным кодом может создавать узкие места при интенсивном взаимодействии
• Лучшая экосистема библиотек для мобильной разработки

Нативные решения (Kotlin/Swift) предлагают максимальную производительность:

• Прямой доступ ко всем возможностям платформы
• Оптимизированная отрисовка пользовательского интерфейса
• Меньший размер приложения
• Быстрый запуск и отклик интерфейса
• Эффективное использование ресурсов устройства (память, процессор, батарея)

Практические рекомендации для использования Python в мобильной разработке:

• Ограничение использования Python/Kivy для приложений с невысокими требованиями к производительности
• Перенос критических для производительности частей в нативный код (через расширения на C/C++)
• Использование компиляторов вроде Cython для оптимизации узких мест
• Предпочтение React Native для более требовательных приложений, если кроссплатформенность важна
• Выбор нативной разработки для приложений, где производительность критична

23. Как разработать высоконагруженный TCP-сервер?

Разработка высоконагруженного TCP-сервера требует тщательного планирования архитектуры и выбора оптимальных инструментов:

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

• Неблокирующий ввод-вывод освобождает ресурсы во время ожидания операций
• Сопрограммы (coroutines) обеспечивают понятную структуру кода
• Транспортные протоколы и серверы высокого уровня упрощают разработку
• Оптимальна для I/O-bound задач с множеством соединений
• Работает на базе цикла событий, выполняющего задачи последовательно

Модуль multiprocessing помогает распараллелить вычислительные задачи:

• Обходит ограничения GIL, запуская отдельные процессы Python
• Позволяет использовать все ядра процессора для параллельных вычислений
• Pool предоставляет удобный интерфейс для распределения задач
• Оптимален для CPU-bound задач
• Требует механизмов межпроцессного взаимодействия для обмена данными

Гибридный подход для высоконагруженных серверов:

• Использование asyncio для обработки сетевых соединений
• Делегирование тяжелых вычислений пулу процессов
• Применение нескольких процессов с asyncio для использования всех ядер
• Балансировка нагрузки между процессами через общий слушающий сокет

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

• Тестирование максимального числа одновременных подключений
• Измерение времени отклика под различной нагрузкой
• Анализ пропускной способности (throughput) в различных сценариях
• Мониторинг использования ресурсов (CPU, память, сеть)
• Сравнение различных реализаций и конфигураций

Инструменты для бенчмаркинга TCP-серверов:

• wrk и wrk2 для HTTP-тестирования
• tcpkali для тестирования произвольных TCP-протоколов
• Локуст (Locust) для создания распределенных тестов нагрузки
• Prometheus с Grafana для мониторинга показателей в реальном времени

Оптимизации для высоконагруженных TCP-серверов:

• Настройка параметров ОС (лимиты файловых дескрипторов, буферы TCP)
• Использование uvloop вместо стандартного цикла событий asyncio
• Пулинг соединений с базами данных и другими внешними службами
• Применение кэширования для снижения нагрузки
• Оптимизация сериализации и десериализации данных

24. Как работать с raw-сокетами в Python (пакеты Ethernet, ICMP)?

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

Библиотека socket предоставляет базовую функциональность для работы с raw-сокетами:

• Создание raw-сокета требует привилегий администратора/root
• Позволяет отправлять и принимать пакеты на уровне IP
• Требует ручного формирования заголовков пакетов
• Низкоуровневый контроль над сетевыми протоколами
• Поддержка ICMP, IP, Ethernet-фреймов

Библиотека scapy значительно упрощает работу с сетевыми пакетами:

• Предоставляет высокоуровневый интерфейс для создания и анализа пакетов
• Поддерживает множество протоколов (Ethernet, IP, TCP, UDP, ICMP и др.)
• Позволяет снифферить трафик с детальным разбором содержимого
• Имеет встроенные функции для сканирования сети, трассировки маршрута
• Поддерживает создание сложных многоуровневых пакетов

Применения raw-сокетов включают:

• Создание программ для сканирования сети и обнаружения устройств
• Реализация нестандартных сетевых протоколов
• Разработка инструментов сетевой безопасности и аудита
• Мониторинг и анализ сетевого трафика
• Имплементация ICMP-ping и traceroute с расширенной функциональностью

Ограничения и меры предосторожности при работе с raw-сокетами:

• Требуются привилегии суперпользователя (root/администратор)
• Возможность нарушения работы сети неправильно сформированными пакетами
• Ответственность за корректную реализацию протоколов
• Необходимость учитывать различия между операционными системами
• Возможность использования для вредоносной активности (требует этического подхода)

25. Какие механизмы ОС вы можете контролировать из Python?

Python предоставляет множество возможностей для взаимодействия с механизмами операционной системы через стандартные и сторонние библиотеки:

Управление процессами через библиотеку psutil:

• Получение информации о запущенных процессах (CPU, память, диск, сеть)
• Мониторинг системных ресурсов в реальном времени
• Завершение, приостановка и возобновление процессов
• Получение древовидной структуры процессов
• Кросс-платформенный интерфейс для различных операционных систем

Работа с сигналами в Python:

• Модуль signal для обработки и отправки сигналов ОС
• Перехват стандартных сигналов (SIGTERM, SIGINT, SIGKILL)
• Настройка обработчиков сигналов для корректного завершения программы
• Отправка сигналов другим процессам
• Ограничения обработки сигналов в многопоточных программах

Создание процесса-демона на Linux:

• Двойное ветвление (fork) для отсоединения от терминала
• Изменение рабочей директории на корневую
• Закрытие стандартных файловых дескрипторов
• Перенаправление вывода в лог-файлы или /dev/null
• Запись PID-файла для управления демоном
• Использование библиотек daemon или systemd для упрощения процесса

Дополнительные механизмы ОС, доступные из Python:

• Управление файловой системой (права доступа, атрибуты, ссылки)
• Межпроцессное взаимодействие (pipes, очереди, сокеты, общая память)
• Сетевые интерфейсы и маршрутизация
• Системные таймеры и планирование задач
• Взаимодействие с устройствами ввода-вывода
• Управление памятью и ресурсами системы
• Доступ к системному реестру (на Windows)
• Управление службами операционной системы

Инструменты для системного администрирования:

• Fabric/Invoke для автоматизации задач через SSH
• Ansible с Python API для управления конфигурациями
• Docker SDK для управления контейнерами
• Библиотеки для интеграции с системами инициализации (systemd, upstart)

Copy

продолжай

26. Какие уязвимости критичны для REST API на FastAPI и как их устранить?

REST API на FastAPI, как и любые веб-сервисы, подвержены различным уязвимостям безопасности, которые необходимо эффективно устранять:

SQL-инъекции представляют серьезную угрозу для API, взаимодействующих с базами данных:

• Угроза: злоумышленник может выполнить произвольный SQL-код через непроверенные входные данные
• Защита: использование ORM (SQLAlchemy) с параметризованными запросами вместо строковой конкатенации
• Дополнительная защита через pydantic-валидацию, которая ограничивает формат и диапазон входных данных
• Применение принципа минимальных привилегий для учетных записей БД
• Экранирование специальных символов и строгая типизация входных параметров

Небезопасная