Базовые управляющие структуры алгоритмов и их реализация на Python
Теорема о структурном программировании
В середине XX века было доказано (теорема Бёма — Якопини), что любой алгоритм, каким бы сложным он ни был, можно построить, комбинируя всего три базовые управляющие конструкции: следование (линейную последовательность действий), ветвление (выбор одного из нескольких путей выполнения в зависимости от условия) и цикл (повторение группы действий). Это утверждение легло в основу структурного программирования — подхода, при котором сложные алгоритмы строятся из этих трёх базовых блоков без использования неструктурных переходов (операторов безусловного перехода вроде GOTO), что делает программы понятнее, надёжнее и проще в отладке.
Следование (линейная конструкция)
Следование — самая простая конструкция: команды выполняются одна за другой строго в том порядке, в котором записаны в программе, без пропусков и повторов. Алгоритм, состоящий только из следования, называют линейным. На блок-схеме следование изображается как цепочка прямоугольников (блоков действия), соединённых стрелками сверху вниз.
Пример линейного алгоритма на Python — вычисление периметра и площади прямоугольника по введённым длинам сторон:
a = float(input("Введите длину стороны a: "))
b = float(input("Введите длину стороны b: "))
perimeter = 2 * (a + b)
area = a * b
print("Периметр:", perimeter)
print("Площадь:", area)
Здесь каждая строка выполняется ровно один раз, строго сверху вниз: сначала считываются данные, затем вычисляются результаты, затем они выводятся — типичная линейная структура без каких-либо условий или повторов.
Ветвление (условная конструкция)
Ветвление — конструкция, в которой дальнейший ход выполнения алгоритма зависит от истинности некоторого логического условия: в зависимости от того, истинно условие или ложно, выполняется одна из двух (или более) альтернативных последовательностей действий. Различают полную форму ветвления (если условие истинно — выполняется одна ветвь, иначе — другая) и неполную (если условие истинно — выполняется действие, иначе оно просто пропускается, и алгоритм продолжается дальше).
На языке Python полное ветвление записывается оператором if…else, а неполное — оператором if без else. Пример полного ветвления — определение чётности числа:
n = int(input("Введите целое число: "))
if n % 2 == 0:
print("Число чётное")
else:
print("Число нечётное")
Здесь условие n % 2 == 0 (остаток от деления n на 2 равен нулю) определяет, какая из двух веток будет выполнена — они взаимоисключающие, выполняется ровно одна из них.
Пример неполного ветвления — вывод предупреждения только при отрицательном значении температуры, без альтернативной ветки:
temperature = float(input("Введите температуру: "))
if temperature < 0:
print("Внимание: отрицательная температура!")
print("Обработка завершена")
Если температура неотрицательна, условие ложно, тело if пропускается, и выполнение сразу продолжается со строки print("Обработка завершена") — в отличие от полного ветвления, здесь нет обязательной альтернативной ветки действий.
Когда вариантов выбора больше двух, используется цепочка elif (сокращение от «else if»), которая последовательно проверяет условия одно за другим, пока одно из них не окажется истинным; если ни одно условие не истинно, выполняется финальная ветка else (если она задана).
score = int(input("Введите балл (0-100): "))
if score >= 85:
grade = 5
elif score >= 70:
grade = 4
elif score >= 50:
grade = 3
else:
grade = 2
print("Оценка:", grade)
Цикл (циклическая конструкция)
Цикл — конструкция, обеспечивающая многократное повторение одной и той же группы действий (тела цикла) до тех пор, пока выполняется (или не выполняется) некоторое условие. Различают циклы с заранее известным числом повторений (счётные, реализуемые оператором for) и циклы с условием, число повторений в которых заранее не определено и зависит от хода вычислений (реализуемые оператором while). Подробно циклы с разбором накопления суммы, произведения и вложенных циклов рассмотрены в отдельной теме курса — здесь приведём лишь минимальный иллюстративный пример.
total = 0
for i in range(1, 6):
total = total + i
print("Сумма чисел от 1 до 5:", total)
Тело цикла (строка total = total + i) выполняется 5 раз подряд — для значений i от 1 до 5 включительно, — после чего управление передаётся следующей за циклом строке print.
Комбинирование конструкций: вложенность
Ключевая идея структурного программирования — конструкции можно вкладывать друг в друга без ограничений: внутри ветвления может быть цикл, внутри цикла — ветвление, внутри одной ветки ветвления — другое ветвление и т.д. Именно благодаря такой вложенности из трёх простых базовых блоков собираются сколь угодно сложные алгоритмы. Пример: подсчёт количества чётных чисел среди введённых, где ветвление (проверка чётности) вложено внутрь цикла (перебор чисел):
count_even = 0
for i in range(1, 11):
if i % 2 == 0:
count_even = count_even + 1
print("Количество чётных чисел от 1 до 10:", count_even)
Блок-схемы трёх базовых конструкций
На блок-схемах следование изображается последовательными прямоугольниками сверху вниз; ветвление — ромбом с двумя выходящими стрелками, подписанными «да» и «нет», ведущими к разным блокам действий, которые затем сходятся в одной точке; цикл — блоком проверки условия (ромбом), из которого одна стрелка ведёт к телу цикла и возвращается обратно к проверке условия, а другая — выходит из цикла при завершении условия повторения.
| Конструкция | Оператор Python | Количество выполнений тела |
|---|---|---|
Следование | обычная последовательность строк | каждая строка ровно 1 раз |
Ветвление | if / if…else / if…elif…else | 0 или 1 раз (для каждой ветки) |
Цикл со счётчиком | for | заранее известное число раз |
Цикл с условием | while | неизвестное заранее число раз |
Пример: разбор задачи с комбинацией всех трёх конструкций
Задача. Написать программу, которая считывает 10 целых чисел и выводит, сколько среди них положительных, сколько отрицательных и сколько равно нулю.
Решение. Здесь нужен цикл (10 повторений, число заранее известно — используем for), внутри которого — ветвление на три случая (elif-цепочка) для классификации каждого числа, а до и после цикла — линейные следования (инициализация счётчиков, вывод результата):
positive = 0
negative = 0
zero = 0
for i in range(10):
x = int(input("Введите число: "))
if x > 0:
positive = positive + 1
elif x < 0:
negative = negative + 1
else:
zero = zero + 1
print("Положительных:", positive)
print("Отрицательных:", negative)
print("Нулей:", zero)
Эта программа наглядно показывает вложенность конструкций: следование (инициализация переменных) → цикл (10 повторений ввода) → ветвление внутри тела цикла (классификация каждого числа) → следование (финальный вывод трёх результатов).
Типичные ошибки
Частая ошибка начинающих — неверные отступы в Python: поскольку в этом языке границы тела ветвления и цикла определяются именно отступами (а не служебными словами begin/end или фигурными скобками, как в некоторых других языках), сбой в отступе меняет логику программы или вызывает ошибку синтаксиса. Вторая ошибка — путать полное и неполное ветвление там, где нужна именно альтернатива (например, писать два независимых if вместо if…else, из-за чего при определённых условиях могут «сработать» обе ветки одновременно, если условия не строго взаимоисключающие). Третья ошибка — при использовании elif забывать, что проверка условий идёт последовательно и останавливается на первом истинном, поэтому порядок условий в цепочке elif важен (например, при проверке диапазонов оценок нужно идти от большего порога к меньшему, а не наоборот).
Краткий словарь терминов
Следование — конструкция линейного выполнения команд одна за другой в порядке записи.
Ветвление — конструкция выбора одной из альтернативных последовательностей действий по условию.
Цикл — конструкция многократного повторения группы действий (тела цикла).
Полное ветвление — конструкция if…else с двумя взаимоисключающими ветками выполнения.
Неполное ветвление — конструкция if без else, где действие выполняется только при истинном условии.
Структурное программирование — подход к построению алгоритмов из трёх базовых конструкций без неструктурных переходов.
Тело цикла — последовательность действий, повторяемая при каждом проходе цикла.
Заключение
Следование, ветвление и цикл — три «кирпичика», из комбинации и вложенности которых строится абсолютно любой алгоритм, независимо от его сложности. Освоив их синтаксическую реализацию на Python (if, if…else, if…elif…else, for, while), можно переходить к практическому программированию — а начать стоит с понимания того, какие типы данных (числа, строки, логические значения, списки) эти конструкции обрабатывают, чему посвящена следующая тема.
