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

🔷 Преимущества:
🔹 простота разработки и понимания
🔹 лёгкий деплой и отладка
🔹 меньшие накладные расходы на инфраструктуру
🔹 удобна для небольших и средних проектов

🔷 Недостатки:
🔹 сложнее масштабировать отдельные части
🔹 любые изменения требуют пересборки и повторного деплоя всего приложения
🔹 со временем кодовая база становится тяжёлой для поддержки
🔹 ниже устойчивость при сбоях

👉 Монолит хорошо подходит на старте проекта, но может стать ограничением при росте системы.

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

🧼 Новая рубрика — Python Style

Код может работать.
Но вопрос — понятно ли его читать через месяц?

Python Style — это рубрика про грамотное оформление кода:

🔷как писать читаемо, а не «лишь бы работало»

🔷где упростить, а где наоборот сделать явнее

Накиньте 🔥если рубрика интересна вам

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

🐍 Python Style — выпуск №1

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

❌ Как часто бывает:

def f(x,y):return x+y

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

✅ Python Style:

def add(x: int, y: int) -> int:
    return x + y

Почему второй вариант лучше:
🔹 понятное имя функции
🔹 пробелы = читаемость
🔹 аннотации типов
🔹 код объясняет себя сам

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

🧰 Code Cleanup — выпуск 14
Тема: if x == True — зачем так делать?

Очень частая штука в коде, особенно у начинающих 👇
Работает? Да.
Нужно ли так писать? Нет 🙂

❌ До (избыточно и не по-питоничному):

def is_valid(user):
    if user.is_active == True:
        return True
    else:
        return False

Здесь сразу две проблемы:
🔹 сравнение с True
🔹лишний if/else

✅ После (чисто и читаемо):

def is_valid(user):
    return user.is_active

🧠 Почему так лучше?

🔹 булевы значения уже являются True или False

🔹 == True не добавляет смысла, только шум

🔹 код читается как обычная человеческая речь

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

SQL JOIN — это оператор, который объединяет строки из двух (или более) таблиц на основе связанного столбца.

🔹 Сравнивает значения в указанных полях (обычно по внешнему и первичному ключу)
🔹 Формирует результат, комбинируя данные из нескольких таблиц в один набор
🔹 Позволяет получать связанные данные без дублирования таблиц

👉 Принцип работы: для каждой строки одной таблицы ищутся подходящие строки в другой по условию соединения.

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

🧰 Code Cleanup — выпуск 15
Тема: перестаём ловить Exception и чинить всё подряд

❌ До (опасный анти-паттерн):

def get_discount(price, percent):
    try:
        return price - (price * percent / 100)
    except Exception:
        return 0

На первый взгляд — норм.
На деле — очень плохо.

Почему?

🔹Ловим любой Exception

🔹Скрываем реальные ошибки

🔹Дебаг превращается в ад

🔹Прод может тихо ломаться

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

def get_discount(price, percent):
    if not isinstance(price, (int, float)):
        raise TypeError("price must be a number")

    if not 0 <= percent <= 100:
        raise ValueError("percent must be between 0 and 100")

    return price - (price * percent / 100)

🧠 Что мы улучшили:

🔹 убрали «глушитель ошибок»

🔹 явно описали контракт функции

🔹 ошибки стали предсказуемыми

🔹 код стал безопаснее и более тестируемый

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

🐍 Python Style — выпуск №2
Тема: читаемый код через понятные имена переменных

Часто встречается код, который работает, но выглядит как загадка 🕵️‍♂️:

❌ Пример “нечитабельного” кода:

a = [1, 2, 3, 4, 5]
b = []
for i in a:
    if i % 2 == 0:
        b.append(i)
print(b)

Работает? Да.
Понятно? Сомнительно…

✅ Python Style: выбираем имена, которые сразу объясняют смысл

numbers = [1, 2, 3, 4, 5]
even_numbers = []
for number in numbers:
    if number % 2 == 0:
        even_numbers.append(number)
print(even_numbers)

Теперь читается как история:
“Берём все числа и выбираем только чётные”.

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

Хвостовая рекурсия — это вид рекурсии, при котором рекурсивный вызов является последней операцией функции, и после него не выполняется никаких действий.

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

⚠️ В Python оптимизация хвостовой рекурсии не применяется, поэтому глубина рекурсии всё равно ограничена.

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

🐍 Python Style — выпуск №3
Тема: ранний return вместо вложенных if

Один из самых простых приёмов, который сразу делает код профессиональнее — это early return.
Меньше вложенности -> меньше когнитивной боли 😌

❌ Не по-питоничному (лес из if):

def get_discount(user):
    if user:
        if user.is_active:
            if user.balance > 0:
                return 10
    return 0

Код работает, но читается снизу вверх и с напряжением.

✅ Python Style (чётко и линейно):

def get_discount(user):
    if not user:
        return 0
    if not user.is_active:
        return 0
    if user.balance <= 0:
        return 0

    return 10

А ещё лучше 👇

def get_discount(user):
    if not user or not user.is_active or user.balance <= 0:
        return 0
    return 10

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

🐍 Python Style — выпуск №2
Тема: не сравнивай с None как с обычным значением

Очень частая ошибка — писать код, который работает, но противоречит стилю Python и может привести к багам.

❌ Плохо:

if value == None:
    print("Нет значения")

Почему плохо:

None — это одиночный объект, а не обычное значение

оператор == может быть переопределён и вести себя неожиданно

✅ Python Style:

if value is None:
    print("Нет значения")

А если нужно проверить, что значение существует:

if value is not None:
    print("Есть значение")

🧠 Почему is, а не ==?

is проверяет один и тот же ли это объект в памяти

None всегда один → сравниваем по идентичности, а не по значению

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

🐍 Python Style — выпуск №3
Тема: ранний return вместо вложенных if

Один из самых простых, но мощных приёмов чистого Python-кода — early return.
Он делает функции короче, логику — прямолинейнее, а код — легче для мозга 🧠

❌ Не по-питоничному (глубокая вложенность):

def get_discount(user):
    if user:
        if user.is_active:
            if user.level == "gold":
                return 20
            else:
                return 5
        else:
            return 0
    else:
        return 0

Работает, но читать это — как спускаться по лестнице без перил 😅

✅ Python Style (ранний выход):

def get_discount(user):
    if not user or not user.is_active:
        return 0

    if user.level == "gold":
        return 20

    return 5

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

🔹 меньше уровней вложенности

🔹 логика читается сверху вниз

🔹 условия «ошибки» обрабатываются сразу

🔹 код проще тестировать и расширять

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

🧰 Code Cleanup — выпуск 16
Тема: убираем скрытые баги из mutable default arguments

Это одна из самых коварных ошибок в Python.

❌ До (выглядит безобидно):

def add_user(user, users=[]):
    users.append(user)
    return users

add_user("Alice")   # ['Alice']
add_user("Bob")     # ['Alice', 'Bob'] 

Почему так произошло?!
Мы же каждый раз вызываем функцию заново…

🧨 Проблема:

🔹users=[] создаётся один раз при объявлении функции

🔹список переиспользуется между вызовами

🔹итог — общий state, который сложно отловить

✅ После (правильно и безопасно):

def add_user(user, users=None):
    if users is None:
        users = []
    users.append(user)
    return users

Теперь:

🔹 каждый вызов получает новый список

🔹 нет скрытого состояния

🔹 код предсказуемый и безопасный

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

С множествами (set) можно выполнять следующие действия:

🔹 Добавление элементов — add(), update()
🔹 Удаление элементов — remove(), discard(), pop()
🔹 Проверка принадлежности — in
🔹 Объединение — union() или |
🔹 Пересечение — intersection() или &
🔹 Разность — difference() или -
🔹 Симметрическая разность — symmetric_difference() или ^
🔹 Сравнение множеств — подмножество, надмножество, равенство

Множества удобны для работы с уникальными элементами и быстрых операций над ними.

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

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

Это позволяет:
🔹 передавать логику как параметр
🔹 писать универсальные и гибкие функции
🔹 использовать callbacks, обработчики, декораторы

👉 Пример из практики: map(), filter(), sorted(key=...) принимают функции как аргументы.

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

🐍 Python Style — выпуск №4
Тема: if x is None vs if not x — тонкость, на которой часто падают

Это одна из тех мелочей, которые отличают аккуратный Python-код от потенциального бага.

❌ Плохой стиль (и возможная ошибка):

def process(value):
    if not value:
        return "Нет данных"
    return value * 2

На первый взгляд — нормально.
Но not value сработает для:

🔹0

🔹0.0

🔹""

🔹[]

🔹{}

И если 0 — валидное значение, логика ломается 💥

✅ Python Style (явно и безопасно):

def process(value):
    if value is None:
        return "Нет данных"
    return value * 2

Теперь:

🔹None -> отсутствие значения

🔹0 -> нормальное число

🔹логика читается однозначно

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

🐍 Python Style — выпуск №5
Тема: ранний return вместо вложенных условий

Одна из самых частых причин «тяжёлого» кода — глубокая вложенность.
Читаешь функцию и будто спускаешься в подземелье 🕳😅

❌ Плохо читается (много вложенных if):

def process_user(user):
    if user:
        if user.is_active:
            if user.age >= 18:
                return "Access granted"
            else:
                return "Too young"
        else:
            return "Inactive user"
    else:
        return "No user"

Работает, но чтобы понять логику — нужно напрячься.

✅ Python Style — используем ранний return:

def process_user(user):
    if not user:
        return "No user"
    if not user.is_active:
        return "Inactive user"
    if user.age < 18:
        return "Too young"
    return "Access granted"

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

🔹 нет глубокой вложенности

🔹 каждая проверка — отдельное понятное правило

🔹 код читается сверху вниз, как инструкция

🔹 легче добавлять новые условия

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

git commit нужен для сохранения текущего состояния проекта в истории Git.

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

Каждый commit — это логически завершённый шаг в развитии проекта.

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

🐍 Python Style — выпуск №6
Тема: enumerate вместо range(len())

Одна из частых мелочей, которая делает код «непитоничным» — перебор индексов вручную.
Работает, но выглядит как привет из C 😅

❌ Не лучший вариант (range(len())):

users = ["Alice", "Bob", "Charlie"]

for i in range(len(users)):
    print(i, users[i])

Читается тяжеловато: приходится держать в голове и индекс, и список.

✅ Python Style — используем enumerate:
```
users = ["Alice", "Bob", "Charlie"]

for i, user in enumerate(users):
print(i, user)
```
🧠 Почему так лучше:
🔹 сразу видно, что есть и индекс, и элемент
🔹 меньше «шумного» кода
🔹 не нужно обращаться к списку по индексу
🔹 сложнее допустить ошибку

📌 Бонус: если индекс нужен не с нуля

for i, user in enumerate(users, start=1):
    print(i, user)

Читаемо. Коротко. По-питоновски 🐍✨

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

С Новым годом 🎄

Пусть в новом году будет больше ясности —
в голове, в коде и в том, куда ты вообще идёшь.

Пусть Python приносит не только ошибки и Stack Overflow,
а ощущение, что ты реально что-то умеешь и растёшь.

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

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

🐍 Python Style — выпуск №7
Тема: list comprehension вместо for + append

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

❌ Не лучший вариант (for + append):

numbers = [1, 2, 3, 4, 5]
squares = []

for n in numbers:
    squares.append(n ** 2)

Много строк и лишних движений для простой операции.

✅ Python Style — используем list comprehension:

numbers = [1, 2, 3, 4, 5]
squares = [n ** 2 for n in numbers]

🧠 Почему так лучше:
🔹 логика в одной строке
🔹 сразу видно, что и откуда берётся
🔹 меньше кода — меньше ошибок
🔹 стандартный питоновский приём

📌 Бонус: с условием

squares = [n ** 2 for n in numbers if n % 2 == 0]

Чисто. Ясно. По-питоновски 🐍✨

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

WebSocket — это протокол, обеспечивающий постоянное двустороннее соединение между клиентом и сервером.

🔹 работает поверх одного TCP-соединения
🔹 позволяет серверу и клиенту обмениваться данными в реальном времени
🔹 не требует постоянных HTTP-запросов

Используется для чатов, уведомлений, онлайн-игр и других real-time приложений.

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