Ветвление в Python

Опубликовано: 08.04.2026
Категория: Python
Теги: #Python
Просмотров: 73

Любая программа — это последовательность инструкций, но настоящая мощь кода раскрывается, когда он может принимать решения. Ветвление — это конструкция, позволяющая программе выполнять разные блоки кода в зависимости от условий. Без ветвления все программы работали бы как простой калькулятор: ввели данные, получили результат. Благодаря if, else и современному match case, Python может «думать» и выбирать нужную ветку алгоритма.В этой статье мы подробно разберем все способы организации ветвления в Python — от базовых конструкций до сложного структурного сопоставления с образцом.

1. Булевы значения и операторы сравнения

Любая проверка в Python строится на условии — выражении, которое может быть либо истинным (True), либо ложным (False).

Операторы сравнения

Чтобы сравнить значения, используются следующие операторы:

  • == — равно
  • != — не равно
  • > — больше
  • < — меньше
  • >= — больше или равно
  • <= — меньше или равно

Логические операторы

Для создания сложных условий используйте логические связки:

  • and — И: истина, только если оба условия истинны.
  • or — ИЛИ: истина, если хотя бы одно условие истинно.
  • not — НЕ: инвертирует значение (меняет True на False и наоборот).

Важный нюанс про and и or: они вычисляются по короткой схеме. Python не проверяет всё выражение целиком, если ответ уже ясен. Например, в условии if x > 0 and (10 / x) > 1: если x окажется нулем, деление не произойдет, потому что левая часть (x > 0) будет False, и Python уже знает, что всё выражение ложно.


2. Классическое ветвление: if, elif, else

Это основа основ Python. Синтаксис максимально приближен к английскому языку, а блоки кода отделяются друг от друга отступами (обычно 4 пробела или табуляция). Ветвление (условные конструкции) позволяет программе выполнять разные блоки кода в зависимости от условий. В Python для этого используют:

  • if — основной блок условия;
  • elif (сокращение от else if) — дополнительные проверки;
  • else — блок по умолчанию, если все условия не выполнены.

Синтаксис и правила

  • после условия ставится двоеточие (:);
  • тело блока выделяется отступами (обычно 4 пробела);
  • условия проверяются последовательно сверху вниз;
  • выполняется только первый блок с истинным условием.

Конструкция if (Одиночный выбор)

Выполняет блок кода, если условие истинно (True).

Синтаксис: 
if условие:
    # код выполняется, если условие True
Пример: 
age = 18
if age >= 18:
    print("Вы совершеннолетний")
# Вывод: Вы совершеннолетний

temperature = 25
if temperature > 20:
    print("На улице тепло, можно идти без куртки!")
# Вывод: На улице тепло, можно идти без куртки!
Пример с использованием логических операторов: 
x = 5
y = 10

# and
if x > 0 and y > 0:
    print("Оба числа положительные")

# or
if x < 0 or y < 0:
    print("Хотя бы одно число отрицательное")

# not
if not x == y:
    print("Числа не равны")

Конструкция if-else (Двойной выбор)

Выполняет один блок кода, если условие истинно, и другой — если ложно (False).

Синтаксис: 
if условие:
    # выполняется, если True
else:
    # выполняется, если False
Пример: 
age = 16
if age >= 18:
    print("Доступ разрешен")
else:
    print("Доступ запрещен. Вам нет 18 лет.")
# Вывод: Доступ запрещен. Вам нет 18 лет.

temperature = 25
if temperature > 30:
    print("Жарко!")
else:
    print("Комфортная температура")
# Вывод: Комфортная температура

Конструкция if-elif-else (Множественный выбор)

elif — это сокращение от else if. Позволяет проверять несколько условий последовательно. Как только Python находит первое истинное условие, он выполняет соответствующий блок и выходит из всей конструкции .

Синтаксис: 
if условие1:
    # выполняется, если условие1 True
elif условие2:
    # выполняется, если условие2 True и условие1 False
elif условие3:
    # выполняется, если условие3 True и предыдущие False
else:
    # выполняется, если все условия False
Пример: 
score = 85

if score >= 90:
    grade = "Отлично (A)"
elif score >= 80:
    grade = "Хорошо (B)"
elif score >= 70:
    grade = "Удовлетворительно (C)"
else:
    grade = "Неудовлетворительно (F)"

print(f"Ваша оценка: {grade}")
# Вывод: Хорошо (B)

Совет: Порядок условий критичен. Если бы мы сначала проверили score >= 80, а потом score >= 90, то оценка 95 попала бы в блок B, потому что 95 >= 80 истинно, а последующие проверки уже не выполняются.

Вложенные условия

Можно размещать условные конструкции внутри других условных конструкций.

Пример: 
user_age = 20
has_license = True

if user_age >= 18:
    if has_license:
        print("Можно водить машину")
    else:
        print("Нужно получить права")
else:
    print("Слишком молод для вождения")
# Вывод: Можно водить машину

*Старайтесь избегать слишком глубокой вложенности (более 3-4 уровней). Это делает код «спагетти». Иногда лучше переписать логику, используя and или выделив часть кода в функцию.*

Условная ложь: что Python считает False?

В Python if можно использовать не только с явными True/False, но и с любыми объектами. Некоторые значения по умолчанию эквивалентны False:

  • None
  • Числовой ноль: 0, 0.0, 0j
  • Пустые коллекции: "" (пустая строка), [] (пустой список), {} (пустой словарь), set() (пустое множество).

Все остальные значения считаются True.

Пример: 
name = ""
if name:
    print(f"Привет, {name}")
else:
    print("Вы не ввели имя!")  # Сработает этот блок, так как строка пуста

Эта фишка позволяет писать очень лаконичный и читаемый код.


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

Для простых присваиваний, зависящих от условия, существует однострочная запись - компактная форма if-else. Синтаксис: 

значение_если_истина if условие else значение_если_ложь
Пример: 
age = 20
status = "Взрослый" if age >= 18 else "Ребенок"
print(status)  # Взрослый

Это гораздо удобнее, чем расписывать полную конструкцию if-else на три строки ради одного присваивания.


4. Оператор match case

Оператор match (pattern matching, сопоставление с образцом) появился в Python 3.10 (октябрь 2021). Это не просто аналог switch/case из других языков, а мощный механизм структурного сопоставления, который позволяет:

  • сравнивать значение с шаблонами;
  • извлекать данные из составных типов;
  • обрабатывать сложные структуры данных;
  • комбинировать проверку типа, распаковку и условия.
Синтаксис: 
match выражение:
    case шаблон_1:
        # действия для шаблона 1
    case шаблон_2:
        # действия для шаблона 2
    ...
    case _:
        # блок по умолчанию (аналог else)

Простая замена if-elif

def get_http_status(code):
    match code:
        case 200:
            return "OK"
        case 404:
            return "Not Found"
        case 500:
            return "Internal Server Error"
        case _:  # Аналог else — подстановочный знак
            return "Unknown code"

print(get_http_status(404))    # Not Found

Объединение вариантов (|)

def print_hello(language):
    match language:
        case "russian":
            print("Привет")
        case "american english" | "british english" | "english":
            print("Hello")
        case _:
            print("Undefined")

print_hello("american english")    # Hello

Работа с кортежами (распаковка и сопоставление)

def process_coordinates(point):
    match point:
        case (0, 0):
            print("Точка в начале координат")
        case (x, 0):
            print(f"Точка на оси X: {x}")
        case (0, y):
            print(f"Точка на оси Y: {y}")
        case (x, y):
            print(f"Точка в ({x}, {y})")
        case _:
            print("Не координаты")

process_coordinates((5, 0))   # Точка на оси X: 5
process_coordinates((3, 4))   # Точка в (3, 4)
process_coordinates([1, 2])   # Списки тоже работают: Точка в (1, 2)

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

def process_items(items):
    match items:
        case []:
            print("Пустой список")
        case [first]:
            print(f"Один элемент: {first}")
        case [first, second]:
            print(f"Два элемента: {first} и {second}")
        case [first, *rest]:
            print(f"Первый: {first}, остальные: {rest}")

process_items([1, 2, 3, 4])  # Первый: 1, остальные: [2, 3, 4]

Охранные выражения (if в case)

match value:
    case int(x) if x > 0:
        print(f"Положительное целое число: {x}")
    case int(x):
        print(f"Отрицательное или ноль: {x}")
def check_point(point):
    match point:
        case (x, y) if x == y:
            print(f"Точка на диагонали: ({x}, {y})")
        case (x, y) if x > 0 and y > 0:
            print(f"Точка в первом квадранте: ({x}, {y})")
        case _:
            print("Другая точка")

check_point((5, 5))  # Точка на диагонали: (5, 5)
check_point((3, 4))  # Точка в первом квадранте: (3, 4)

Сопоставление по типу

def process_value(value):
    match value:
        case int():
            print(f"Целое число: {value}")
        case float():
            print(f"Дробное число: {value}")
        case str() as text if len(text) > 10:
            print(f"Длинная строка: {text[:10]}...")
        case str() as text:
            print(f"Строка: {text}")
        case list() | tuple() as sequence:
            print(f"Последовательность длиной {len(sequence)}")
        case _:
            print("Что-то другое")

process_value("Hello world!")  # Длинная строка: Hello worl...
process_value([1, 2, 3])   # Последовательность длиной 3

Работа с классами и dataclass

from dataclasses import dataclass
from typing import Literal

@dataclass
class User:
    name: str
    role: Literal["admin", "editor", "viewer"]
    active: bool

def handle_user(user: User):
    match user:
        case User(name="admin", role="admin"):
            print("Супер-администратор")
        case User(name=name, role="admin"):
            print(f"Администратор {name}")
        case User(role="editor", active=True):
            print("Активный редактор")
        case User(role="viewer", active=False):
            print("Неактивный зритель")
        case User(name=name, active=True):
            print(f"Активный пользователь: {name}")
        case _:
            print("Неизвестный пользователь")

admin = User("alice", "admin", True)
editor = User("bob", "editor", True)
handle_user(admin)  # Администратор alice
handle_user(editor) # Активный пользователь: bob

Обработка JSON‑ответов API

def handle_api_response(response):
    match response:
        case {"status": "success", "data": list(data)}:
            print(f"Успех! Получено {len(data)} элементов")
            return process_data(data)
        case {"status": "error", "code": 404, "message": msg}:
            print(f"Не найдено: {msg}")
            return None
        case {"status": "error", "code": int(code), "message": msg}:
            print(f"Ошибка {code}: {msg}")
            return None

5. Сравнение match case с if-elif-elseр

Когда использовать match:

  • обработка сложных структур данных (кортежи, списки, словари);
  • распаковка и извлечение данных из структур;
  • обработка команд (например, в CLI‑приложениях);
  • работа с JSON/API‑ответами;
  • сопоставление по типам и структурам.

Когда лучше if-elif-else:

  • простые проверки одного значения;
  • проверки только по типу (isinstance);
  • в критичных по производительности участках кода (хотя разница обычно незначительна).