Основные виды тестов:

1️⃣ Юнит-тесты — проверяют отдельные функции и классы изолированно.

2️⃣ Интеграционные тесты — проверяют взаимодействие модулей между собой.

3️⃣ Функциональные (acceptance) тесты — проверяют работу функций и сценариев приложения.

4️⃣ Системные тесты — проверяют приложение целиком.

5️⃣ Регрессионные тесты — убеждаются, что новые изменения не сломали старый функционал.

6️⃣ Нагрузочные тесты — измеряют поведение системы под высокой нагрузкой.

7️⃣ UI/End-to-End тесты — проверяют работу приложения глазами пользователя.

🐍Вопросы с собесов -> ProstoPython

🧩 Новая рубрика — PyTools Finder!🔥🔥🔥

Будем разбирать одну интересную и полезную библиотеку Python,
которая реально может упростить жизнь разработчика: от ускорения кода до автоматизации, работы с данными, API, файлами 🤓

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

🐍Вопросы с собесов -> ProstoPython

🧩 PyTools Finder
Библиотека дня: pydantic

Если ты когда-нибудь страдал от бесконечных проверок типов, валидации данных и ловил баги из-за «не того формата»,
то pydantic — это то, что делает жизнь Python-разработчика спокойнее 😌.

🔥 Что делает Pydantic полезным:

Автоматически валидирует входные данные

Преобразует типы (str -> int, dict -> объект и т.д.)

Делает удобные модели данных, как в TypeScript

Покрывает половину рутины за тебя

Пример — валидация без лишнего шума ⬇️

from pydantic import BaseModel

class User(BaseModel):
    name: str
    age: int

u = User(name="Alice", age="23")
print(u.age)  # 23 — автоматически сконвертировал!

Почему это важно?
Потому что плохие данные ломают даже хороший код.
А pydantic превращает хаос входящей информации в аккуратные, понятные структуры данных.

🐍Вопросы с собесов -> ProstoPython

🧰 Code Cleanup — выпуск 3
Тема: избавляемся от лишних проверок

Иногда код работает… но выглядит как будто его писал человек, который очень сомневался в каждом шаге 😅
Вот типичный пример:

❌ До (слишком многословно):

def normalize_name(name):
    if name is not None:
        if isinstance(name, str):
            if name.strip() != "":
                return name.strip().title()
    return None

Работает? Да.
Понятно? Еле-еле.

✅ После (чисто и по-питоничному):

def normalize_name(name):
    if not isinstance(name, str) or not name.strip():
        return None
    return name.strip().title()

Что изменилось:

🔹 убрали вложенные if, теперь условие читается с первого взгляда

🔹 возврат данных стал предсказуемым

🔹 код короче, но логика прежняя

🔹 легче поддерживать и расширять

🐍Вопросы с собесов -> ProstoPython

CRUD — это набор базовых операций над данными:

C — Create (создание)
R — Read (чтение)
U — Update (обновление)
D — Delete (удаление)

Эти операции лежат в основе работы большинства приложений и баз данных.

🐍Вопросы с собесов -> ProstoPython

⏱️ 1 минута о Python — setdefault()

Когда нужно добавить элемент в словарь, но при этом не перезаписать существующее значение — многие пишут вот так:

if key not in data:
    data[key] = []
data[key].append(value)

Работает, но выглядит громоздко.
Python умеет проще 😎

⭐️ setdefault()

Метод, который возвращает значение по ключу,
а если ключа нет — создаёт его с дефолтом.

⚡️ Пример

data = {}
data.setdefault("users", []).append("Alice")
data.setdefault("users", []).append("Bob")

print(data)

Результат:

{"users": ["Alice", "Bob"]}

🧠 Почему это удобно?

🔷Избавляет от лишних проверок

🔷Позволяет «лениво» создавать списки, словари и даже сложные структуры

🔷Снижает количество кода и повышает читаемость

🐍Вопросы с собесов -> ProstoPython

GET не предназначен для передачи тела запроса, а значит отправить файл через GET невозможно.

Вот истинное положение дел:

❌ GET не может отправлять файл

У GET нет тела (body) — оно игнорируется большинством серверов и библиотек.

Поэтому файл нельзя вложить в GET так же, как в POST/PUT.

🐍Вопросы с собесов -> ProstoPython

🧰 Code Cleanup — выпуск 4
Тема: избавляемся от лишних условий в return

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

❌ До (типичное "если да — верни True")

def is_adult(age):
    if age >= 18:
        return True
    else:
        return False

Работает? Да.
Но логика избыточная: Python умеет проще.

✅ После (коротко и по делу)

def is_adult(age):
    return age >= 18

Почему так лучше:

🔹 меньше кода — меньше ошибок

🔹 читатель сразу видит условие, а не структуру из if/else

🔹 легче поддерживать и тестировать

🐍Вопросы с собесов -> ProstoPython

Apache Kafka — это платформа для потоковой передачи данных, которая используется для:

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

Итог: обеспечивает быстрый, масштабируемый и устойчивый обмен данными.

🐍Вопросы с собесов -> ProstoPython

🧰 Code Cleanup — выпуск 5
Тема: превращаем длинные проверки в понятные конструкции

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

❌ До (условие, которое путает мозг):

def can_access(user):
    if user is not None and user.is_active and not user.is_banned and user.role in ["admin", "moderator"]:
        return True
    return False

Нет, оно не плохое.
Но читать такое — страдание.

✅ После (логика та же, читаемость лучше):

def can_access(user):
    if not user:
        return False
    
    allowed_roles = {"admin", "moderator"}
    
    return (
        user.is_active
        and not user.is_banned
        and user.role in allowed_roles
    )

Что изменилось:

🔹 разбили логику на смысловые блоки

🔹 вынесли роли в отдельную структуру → проще поддерживать

🔹 избавились от «простыни» внутри одного if

🔹 вернули булево выражение напрямую (без громоздких if/else)

🐍Вопросы с собесов -> ProstoPython

🧰 Code Cleanup — выпуск 6
Тема: убираем дублирование и повторяющиеся конструкции

Один из частых анти-паттернов — одинаковые куски кода, разбросанные по функции.
Работает? Да.
Но поддерживать такое — мучение 😵‍💫

❌ До (копируем одну и ту же логику три раза):

def format_user(user):
    if user.name:
        name = user.name.strip().title()
    else:
        name = "Unknown"

    if user.email:
        email = user.email.strip().lower()
    else:
        email = "no-email"

    if user.city:
        city = user.city.strip().title()
    else:
        city = "N/A"

    return {"name": name, "email": email, "city": city}

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

✅ После (коротко, чисто, понятно):

def normalize(value, default, transform=str):
    if not value:
        return default
    return transform(value.strip())

def format_user(user):
    return {
        "name":  normalize(user.name,  "Unknown",   str.title),
        "email": normalize(user.email, "no-email",  str.lower),
        "city":  normalize(user.city,  "N/A",       str.title),
    }

Что изменилось:

🔹 повторяющаяся логика вынесена в отдельную функцию

🔹 меньше кода — больше смысла

🔹 легко переиспользовать и расширять

🔹 структура format_user стала читабельной

🐍Вопросы с собесов -> ProstoPython

В заголовках (headers) могут содержаться:

📌 Метаданные запроса и ответа
— тип контента (Content-Type)
— длина тела (Content-Length)
— кодировка (Content-Encoding)

📌 Информация о клиенте и сервере
— User-Agent
— Server
— Host

📌 Аутентификация и безопасность
— Authorization
— Cookie
— Set-Cookie

📌 Кэширование и контроль времени
— Cache-Control
— Expires
— ETag

📌 Параметры соединения
— Connection
— Keep-Alive

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

🐍Вопросы с собесов -> ProstoPython

🧰 Code Cleanup — выпуск 7
Тема: упрощаем вложенные условия

Часто можно встретить код с кучей вложенных if, который работает, но читается как лабиринт 😅

❌ До (слишком много уровней вложенности):

def process_order(order):
    if order is not None:
        if order.items:
            if order.user.is_active:
                print("Processing order")

Работает? Да.
Но читается плохо и сложно поддерживать.

✅ После (питонично и читабельно):

def process_order(order):
    if not order or not order.items or not order.user.is_active:
        return
    print("Processing order")

Что изменилось:

🔹 убрали лишние уровни вложенности

🔹 сразу проверяем условия, при которых функция не должна работать (guard clause)

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

🐍Вопросы с собесов -> ProstoPython

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

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

🐍Вопросы с собесов -> ProstoPython

💬 Вопрос на собесе:
В чём разница между асинхронностью, многопоточностью и мультипроцессингом?

👶 Junior:
— Эм… ну… это всё про параллельность? Или что-то в этом духе?.. 😅

🧑‍💻 Middle:
— Многопоточность — это когда несколько потоков выполняются внутри одного процесса.
Асинхронность — когда задачи переключаются без блокировок, но не обязательно выполняются одновременно.
Мультипроцессинг — это запуск нескольких процессов, которые могут работать параллельно на разных ядрах.

🧙‍♂️ Senior:
— Эти три подхода решают разные задачи и работают по-разному:

🔹 Асинхронность (asyncio)
— основана на неблокирующем вводе-выводе и цикле событий.
— идеально для I/O-bound задач: сетевые запросы, файлы, БД.
— код выполняется поочерёдно, но эффективно переключается между задачами, не простаивая.

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

🔹 Мультипроцессинг (multiprocessing)
— создаёт несколько процессов, каждый со своим интерпретатором Python.
— обходит GIL, поэтому обеспечивает настоящий параллелизм.
— идеально для CPU-bound задач: вычисления, обработка изображений, ML, тяжёлые операции.

💡 Кратко:
Асинхронность — переключение между задачами.
Многопоточность — параллельная работа потоков в одном процессе (но GIL мешает).
Мультипроцессинг — настоящий параллелизм на уровне процессов.

🐍Вопросы с собесов -> ProstoPython

Оптимистичная и пессимистичная блокировки — это два подхода к контролю конкурентного доступа к данным.

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

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

🐍Вопросы с собесов -> ProstoPython

🧰 Code Cleanup — выпуск 8
Тема: избавляемся от лишних временных переменных

Иногда разработчики создают кучу временных переменных, чтобы просто вернуть результат.
Работает? Да.
Читается? Не всегда 😅

❌ До (много лишнего):

def square_positive(x):
    result = x * x
    is_positive = result > 0
    return is_positive

Здесь мы создаём две переменные, хотя можем обойтись одной.

✅ После (коротко и понятно):

def square_positive(x):
    return x * x > 0

Что изменилось:

🔹 убрали временные переменные

🔹 выражение стало сразу читабельным

🔹 код компактнее и проще поддерживать

🐍Вопросы с собесов -> ProstoPython

⏱️ 1 минута о Python
Тема: Что делает оператор walrus (:=)?

Оператор «морж» появился в Python 3.8 и позволяет присваивать значение прямо внутри выражения. Это уменьшает количество дублирующих вызовов и делает код компактнее 🦭💛

❌ До (длиннее):

value = input("Введите число: ")
if value.isdigit():
    print("Это число:", value)

✅ После (короче и элегантнее):

if (value := input("Введите число: ")).isdigit():
    print("Это число:", value)

💡 Когда walrus полезен

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

🔷когда нужно получить и проверить значение в одной строке

🔷когда хочется сделать цикл лаконичным

🐍Вопросы с собесов -> ProstoPython

Ключом в словаре может быть любой неизменяемый (hashable) объект:

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

❗️ Нельзя использовать изменяемые типы: список, словарь, множество.

🐍Вопросы с собесов -> ProstoPython

🧰 Code Cleanup — выпуск 9
Тема: избавляемся от лишних условий

Иногда в коде встречаются условные конструкции, которые по факту ничего не делают — просто оборачивают очевидный результат.
Работает? Конечно.
Но читаемость страдает 😅

❌ До (лишняя вложенность):

def is_adult(age):
    if age >= 18:
        return True
    else:
        return False

Здесь if/else возвращает булевое выражение, которое можно вернуть напрямую.

✅ После (коротко и очевидно):

def is_adult(age):
    return age >= 18

Что изменилось:
🔹 убрали ненужный if/else
🔹 избавились от визуального шума
🔹 функция стала лаконичной и читабельной

🐍Вопросы с собесов -> ProstoPython