Тернарный оператор

Зачем это нужно

Вы уже умеете писать условие через if и else — и знаете, что делать, когда веток становится больше, с elif. Это надёжный инструмент, он подходит для чего угодно. Но иногда весь смысл условия — это одна короткая мысль: «если человеку есть 18, статус — \"взрослый\", иначе — \"ребёнок\"». Ради такой мысли разворачивать условие на четыре строки не хочется: переменная, if, отступ, else, снова отступ.

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

Условие в одну строку

Представьте, что вы отвечаете на вопрос одним словом: «сдал или не сдал?». Вам не нужен целый абзац рассуждений — нужен один из двух готовых ответов, выбранный по условию. Именно так работает конструкция, о которой пойдёт речь: она не проверяет условие и не выполняет разные действия в разных ветках, как обычный if/else, — она сразу возвращает одно из двух значений.

Официально эта конструкция называется тернарный оператор, а в документации Python её называют ещё точнее — условное выражение (conditional expression). Слово «тернарный» означает «состоящий из трёх частей»: у конструкции три обязательных куска — то, что вернуть при истинном условии, само условие и то, что вернуть при ложном условии.

Вот как эти три части расставлены в Python:

значение_если_true  if  условие  else  значение_если_false

Порядок здесь непривычный: сначала идёт результат, а условие — только в середине. Читать такую строку лучше всего вслух, как обычное предложение: «верни вот это, если условие верно, иначе верни вот то».

Разберём на живом примере — определяем, сдал ли ученик экзамен:

score = 72

result = "сдал" if score >= 60 else "не сдал"

print(result)

Построчный разбор:

• score = 72 — обычная переменная с числом, ничего нового.
• result = "сдал" if score >= 60 else "не сдал" — сначала Python проверяет условие score >= 60. Раз 72 >= 60 — это True, значит всё выражение превращается в строку "сдал", и именно она сохраняется в result. Если бы условие оказалось False, в result попала бы строка после else.
• print(result) — печатает то, что лежит в переменной. Выведет сдал.

Это тот же if/else, просто короче

Важно понять: тернарный оператор не умеет ничего такого, чего не умеет обычный if/else. Это не новая логика — это другая запись уже знакомой. Сравните один и тот же результат в двух вариантах:

score = 72
if score >= 60:
    result = "сдал"
else:
    result = "не сдал"

score = 72
result = "сдал" if score >= 60 else "не сдал"

Оба варианта присваивают result одно и то же значение при одном и том же score. Разница только в том, сколько строк для этого понадобилось.

Где применяют тернарный оператор

Раз тернарный оператор — это выражение, а не отдельная команда, его можно использовать везде, где Python ожидает значение: не только в присваивании, но и прямо внутри print() или f-строки.

Присваивание переменной — самый частый случай. Значение сразу попадает в переменную и живёт своей жизнью дальше по коду:

age = 20
status = "совершеннолетний" if age >= 18 else "несовершеннолетний"
print(status)

Здесь age >= 18 истинно (20 >= 18), поэтому status получает "совершеннолетний", и именно эта строка попадает в print().

Прямо в print() — когда результат нужен только для вывода и хранить его в переменной незачем:

n = 7
print("чётное" if n % 2 == 0 else "нечётное")

Разбор: сначала считается n % 2 — остаток от деления 7 на 2, он равен 1. Условие 1 == 0 ложно, поэтому тернарный оператор возвращает вторую строку — "нечётное", и print() печатает её напрямую, без промежуточной переменной.

Внутри f-строки — когда одно из двух значений нужно вставить в середину фразы:

temperature = -5
print(f"На улице {{'холодно' if temperature < 0 else 'тепло'}}")

Внутри фигурных скобок f-строки может стоять любое выражение, в том числе тернарное. Python сначала вычисляет то, что внутри {}: раз temperature < 0 истинно (-5 < 0), получаем строку 'холодно', и она подставляется в текст — выводится строка На улице холодно.

Когда веток больше двух

Пока условие одно и исходов ровно два — тернарный оператор читается легко. Но что если исходов три, как в оценке за экзамен: «отлично», «хорошо», «неудовлетворительно»? Технически Python позволяет поставить один тернарный оператор внутрь другого — это называется вложенный тернарный оператор. Посмотрите на пример и засеките, сколько секунд нужно, чтобы понять, что здесь происходит:

score = 75
grade = "отлично" if score >= 90 else "хорошо" if score >= 70 else "неудовлетворительно"
print(grade)

Формально это работает: сначала проверяется score >= 90 (ложно, 75 меньше 90), значит вычисляется всё, что стоит после первого else — а это уже новый тернарный оператор, который проверяет score >= 70 (истинно), поэтому итог — "хорошо". Но чтобы это понять, пришлось прочитать строку минимум дважды.

Сравните с тем же самым через elif, который вы уже знаете:

score = 75
if score >= 90:
    grade = "отлично"
elif score >= 70:
    grade = "хорошо"
else:
    grade = "неудовлетворительно"
print(grade)

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

Частые ошибки

Перепутанный порядок частей. В других языках программирования похожая конструкция часто выглядит как условие ? значение1 : значение2 — сначала условие. В Python порядок другой, и по привычке легко написать неправильно:

score = 72
# неправильно: так работает не в Python, а в других языках
result = score >= 60 if "сдал" else "не сдал"

Здесь первым стоит score >= 60 — но Python ждёт на этом месте значение_если_true, а не условие. Такое выражение либо работает не так, как задумано, либо вызывает ошибку. Запомните порядок через фразу «что вернуть, если, иначе» — именно в этой последовательности.

Попытка выполнить действие вместо получения значения. Тернарный оператор возвращает значение, а не выполняет разные команды в разных ветках. Если нужно не выбрать значение, а сделать разные вещи (например, один раз вызвать print(), а в другом случае — ничего не печатать), тернарный оператор для этого не годится — здесь нужен обычный if:

n = 4
# тернарный оператор — про значение, а не про разные действия
print("чётное" if n % 2 == 0 else "нечётное")  # подходит: печатаем одно из двух значений

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

Слишком длинная цепочка вложенных тернарных. Как только вы ставите второй else подряд в одной строке — это сигнал остановиться и переписать через if/elif/else, как показано в разделе про вложенные тернарные операторы.