Чтобы собрать 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

С множествами (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