🧰 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

💬 Вопрос на собесе:
Как обеспечить бесперебойную работу сервиса CI/CD?

👶 Junior:
— Ну… надо, чтобы сервер не падал? И чтобы пайплайны сами запускались… 🤔

🧑‍💻 Middle:
— Нужно настроить резервирование, мониторинг и автоматический перезапуск пайплайнов.
Важно следить за нагрузкой, логами и быстро реагировать на сбои.

🧙‍♂️ Senior:
— Бесперебойная работа CI/CD — это не один инструмент, а набор практик и архитектурных решений:

🔹 Отказоустойчивость
— развёртывание CI/CD в нескольких инстансах или нодах
— использование load balancer’ов
— хранение состояния и артефактов во внешнем хранилище (S3, NFS, Artifactory)

🔹 Изоляция и масштабирование
— запуск билдов в контейнерах (Docker, Kubernetes)
— горизонтальное масштабирование executors/agents
— лимиты ресурсов для пайплайнов

🔹 Монинг и алерты
— метрики (CPU, память, очередь билдов, время выполнения)
— алерты на падения, зависшие джобы и рост очереди
— централизованные логи

🔹 Автовосстановление
— автоматический перезапуск агентов
— healthchecks
— инфраструктура как код (Terraform, Helm)

🔹 Минимизация single point of failure
— бэкапы конфигураций и secrets
— репликация БД
— независимость runners от master-узла

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

✅ Да, классы можно декорировать.

🔹 Декоратор класса — это функция или объект, который принимает класс
🔹 Может изменять класс: добавлять методы и атрибуты
🔹 Возвращает тот же или новый класс

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

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

🧰 Code Cleanup — выпуск 10
Тема: убираем “магические числа” из кода

Если в коде встречается такое — стоит насторожиться 👇

if attempts > 3:
    block_user()

Через месяц ты смотришь и думаешь:
почему 3? кто решил? это бизнес-логика или случайно? 😵‍💫

❌ До (магическое число прямо в коде):

def can_login(attempts):
    return attempts <= 3

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

MAX_LOGIN_ATTEMPTS = 3

def can_login(attempts):
    return attempts <= MAX_LOGIN_ATTEMPTS

🧹 Что улучшили:

🔹 код стал самодокументируемым

🔹 правка логики = изменение одной строки

🔹 меньше риска случайных ошибок

🔹 проще обсуждать бизнес-правила с командой

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

Чтобы собрать Docker-образ, используют команду:

docker build -t имя_образа .

🔹 -t задаёт имя (и при желании тег) образа
🔹 . указывает на каталог с Dockerfile
🔹 Docker читает Dockerfile, выполняет инструкции и создаёт образ

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

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

⏱️ 1 минута о Python
Тема: почему is и == не одно и то же

Выглядят похоже, но смысл совсем разный.

❌ Типичная ошибка:

a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)  # True
print(a is b)  # False

🧠 В чём разница?

🔹 == — сравнивает значения
🔹 is — проверяет, что это один и тот же объект в памяти

is = «указывают ли две переменные на один объект»

✅ Правило на каждый день:

для чисел, строк, списков используй ==

is — только для None, True, False

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

Python считается объектно-ориентированным, потому что всё в нём является объектом и язык предоставляет все ключевые механизмы ООП:

🔹 Классы — позволяют создавать собственные типы данных.
🔹 Объекты — экземпляры классов с состоянием и поведением.
🔹 Инкапсуляция — можно скрывать данные и управлять доступом.
🔹 Наследование — классы могут расширять и переиспользовать другие классы.
🔹 Полиморфизм — разные объекты могут иметь методы с одинаковыми именами, но разным поведением.

👉 Поэтому Python поддерживает все принципы ООП и использует их на уровне языка.

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

🧰 Code Cleanup — выпуск 11
Тема: убираем ручную работу там, где Python всё уже умеет

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

❌ До (лишний цикл и временная переменная):

def get_even_numbers(nums):
    result = []
    for n in nums:
        if n % 2 == 0:
            result.append(n)
    return result

Классика. Работает. Но выглядит тяжеловато.

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

def get_even_numbers(nums):
    return [n for n in nums if n % 2 == 0]

🧹 Что мы почистили:

🔸 убрали ручное создание списка

🔸 избавились от append

🔸 логика теперь читается как фраза:
«верни n для каждого n, если n чётный»

🔸 меньше строк -> меньше шума -> проще поддержка

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

🧰 Code Cleanup — выпуск 12
Тема: не превращай for в калькулятор

Иногда код выглядит так, будто Pythonу не доверяют вообще 😅
Посмотрим на типичный пример.

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

def sum_positive(nums):
    total = 0
    for n in nums:
        if n > 0:
            total = total + n
    return total

Работает.
Но выглядит как Python 2005 года.

✅ После (короче и выразительнее):

def sum_positive(nums):
    return sum(n for n in nums if n > 0)

🧹 Что мы почистили:

🔹 убрали ручное накопление total

🔹 избавились от лишнего цикла

🔹 использовали генератор + sum()

🔹 логика теперь читается как фраза:
«сумма всех положительных чисел»

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

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

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

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

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

🐍Вопросы с собесов -> 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