Как инструкция break влияет на работу цикла

Открыть доступ

Наши выпускники работают в компаниях:

При работе с циклами while и for бывает необходимо выполнить принудительный выход, пропустить часть или игнорировать заданные условия. Для первых двух случаев используются операторы break и continue Python, а для игнорирования условий — инструкция pass. Давайте посмотрим на примерах, как работают эти операторы.

Инструкция break в языке программирования Python прерывает выполнение блока кода. Простейший пример:

for j in 'bananafishbones':
    if j == 'f':
        break
    print(j)

Получаем такой вывод:

b
a
n
a
n
a

Как только программа после нескольких итераций доходит до элемента последовательности, обозначенного буквой f, цикл (loop) прерывается, поскольку действует оператор break. Теперь рассмотрим работу этой инструкции в цикле while:

x = 0
while x < 5:
    print(x)
    x += 0.5
print('Выход')

Вывод будет следующий (приводим с сокращениями):

0
0.5
…
4.0
4.5
Выход

Как только перестает выполняться условие и x становится равным 5, программа завершает цикл. А теперь перепишем код с использованием инструкции break:

x = 0
while True:
    print(x)
    if x >= 4.5:
        break
    x += 0.5
print('Выход')

Результат тот же:

0
0.5
…
4.0
4.5
Выход

Мы точно так же присвоили x значение 0 и задали условие: пока значение x истинно (True), продолжать выводить его. Код, правда, получился немного длиннее, но бывают ситуации, когда использование оператора прерывания оправданно: например, при сложных условиях или для того, чтобы подстраховаться от создания бесконечного цикла. Уберите из кода выше две строчки:

x = 0
while True:
    print(x)
    x += 0.5
print('Выход')

И перед нами бесконечный вывод:

0
0.5
…
100
100.5
…
1000000
1000000.5
…

И слово в конце (‘Выход’), таким образом, никогда не будет выведено, поскольку цикл не закончится. Поэтому при работе с последовательностями чисел использование оператора break убережет вас от сбоев в работе программ, вызываемых попаданием в бесконечный цикл.

клауд

Конструкция с else

Иногда необходимо проверить, был ли цикл исполнен до конца или выход произошел с использованием инструкции break. Для этого добавляется проверка по условию с else. Напишем программу, которая проверяет фразу на наличие запрещенных элементов:

word = input('Введите слово: ')
for i in word:
    if i == 'я':
        print('Цикл был прерван, обнаружена буква я')
        break
else:
    print('Успешное завершение, запрещенных букв не обнаружено')
print('Проверка завершена')

Теперь, если пользователь введет, например, «Привет!», программа выдаст следующее:

Успешное завершение, запрещенных букв не обнаружено
Проверка завершена

Но если во введенном слове будет буква «я», то вывод примет такой вид:

Цикл был прерван, обнаружена буква я
Проверка завершена

Небольшое пояснение: функция input принимает значение из пользовательского ввода (выражение 'Введите слово: ' необходимо только для пользователя, для корректной программы хватило бы и такой строки: word = input ()) и присваивает его переменной word. Последняя при помощи for поэлементно (в данном случае — побуквенно) анализируется с учетом условия, вводимого if.

Оператор continue в Python

Если break дает команду на прерывание, то continue действует более гибко. Его функция заключается в пропуске определенных элементов последовательности, но без завершения цикла. Давайте напишем программу, которая «не любит» букву «я»:

word = input('Введите слово: ')
for i in word:
    if i == 'я':
        continue
    print(i)

Попробуйте ввести, например, «яблоко», в этом случае вывод будет таким:

б
л
о
к
о

Это происходит потому, что мы задали условие, по которому элемент с определенным значением (в данном случае буква «я») не выводится на экран, но благодаря тому, что мы используем инструкцию continue, цикл доходит до последней итерации и все «разрешенные» элементы выводятся на экран. Но в коде выше есть одна проблема: если пользователь введет, например, «Яблоко», программа выведет слово полностью, поскольку не учтен регистр:

Я
б
л
о
к
о

Наиболее очевидное решение в данном случае состоит в добавлении и заглавной буквы в блок if таким образом:

word = input('Введите слово: ')
for i in word:
    if i == 'я' or i == 'Я':
        continue
    print(i)

Оператор pass в Python

Назначение pass — продолжение цикла независимо от наличия внешних условий. В готовом коде pass встречается нечасто, но полезен в процессе разработки и применяется в качестве «заглушки» там, где код еще не написан. Например, нам нужно не забыть добавить условие с буквой «я» из примера выше, но сам этот блок по какой-то причине мы пока не написали. Здесь для корректной работы программы и поможет заглушка pass:

word = input('Введите слово: ')
for i in word:
    if i == 'я':
        pass
else:
    print('Цикл завершен, запрещенных букв не обнаружено')
print('Проверка завершена')

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

Вот и всё, надеемся, скоро break, continue и pass станут вашими верными друзьями в разработке интересных приложений. Успехов! 

Last Updated :
07 Mar, 2025

The break in C is a loop control statement that breaks out of the loop when encountered. It can be used inside loops or switch statements to bring the control out of the block. The break statement can only break out of a single loop at a time.

Let’s take a look at an example:

C

#include <stdio.h>

int main() {
    for (int i = 1; i <= 10; i++) {
      
      	// Exit the loop when i equals 5
        if (i == 5) {
            break;  
        }
        printf("%d ", i);
    }
    return 0;
}

Explanation: In this program, the break statement exits the loop when i == 5. As a result, the loop stops prematurely, and only the numbers 1 to 4 are printed.

Syntax of break

// in a block {
break;
}

We just put the break wherever we want to terminate the execution of the loop.

How break Works?

Картинка с сайта: www.geeksforgeeks.org

The working of the break statement in C is described below:

1. STEP 1: The loop execution starts after the test condition is evaluated.
2. STEP 2: If the break condition is present the condition will be evaluated.
3. STEP 3A: If the condition is true, the program control reaches the break statement and skips the further execution of the loop by jumping to the statements directly below the loop.
4. STEP 3B: If the condition is false, the normal flow of the program control continues.

Flowchart of break

Картинка с сайта: www.geeksforgeeks.org

Examples of break

The following examples illustrate the use of break in C programming:

break with Nested Loops

C

#include <stdio.h>

int main() {
  
    // Nested for loops with break statement
    // at inner loop
    for (int i = 1; i <= 6; ++i) {
        for (int j = 1; j <= i; ++j) {
            if (i <= 4) {
                printf("%d ", j);
            }
            else {
              
                // If i > 4 then this innermost loop will
                // break
                break;
            }
        }
        printf("\n");
    }
    return 0;
}

1 
1 2 
1 2 3 
1 2 3 4 

Break statement only breaks out of one loop at a time. So, if in nested loop, we have used break in inner loop, the control will come to outer loop instead of breaking out of all the loops at once. We will have to use multiple break statements if we want to break out of all the loops.

break with Simple Loops

C

#include <stdio.h>
int main(){

    // Using break inside for loop to terminate
  	// after 2 iterations
    printf("break in for loop\n");
    for (int i = 1; i < 5; i++) {
        if (i == 3) {
            break;
        }
        else {
            printf("%d ", i);
        }
    }

    // using break inside while loop to terminate
  	// after 2 iterations
    printf("\nbreak in while loop\n");
    int i = 1;
    while (i < 20) {
        if (i == 3)
            break;
        else
            printf("%d ", i);
        i++;
    }
    return 0;
}

break in for loop
1 2 
break in while loop
1 2 

Explanation: In this code, the break statement is used in both a for and while loop to terminate after two iterations. In both loops, numbers 1 and 2 are printed, and when i reaches 3, the break statement exits the loop, stopping further iterations. This demonstrates how break can be used to stop execution based on a specific condition.

Break in C switch case

In general, the Switch case statement evaluates an expression, and depending on the value of the expression, it executes the statement associated with the value. Not only that, all the cases after the matching case after the matching case will also be executed. To prevent that, we can use the break statement in the switch case as shown:

C

#include <stdio.h>
#include <stdlib.h>

int main() {
    char c;
    float x, y;

    while (1) {
        printf("Enter an operator (+, -), if want to exit "
               "press x: ");
        scanf(" %c", &c);
        // to exit
        if (c == 'x')
            exit(0);

        printf("Enter Two Values:\n ");
        scanf("%f %f", &x, &y);

        switch (c) {
            
        // For Addition
        case '+':
            printf("%.1f + %.1f = %.1f\n", x, y, x + y);
            break;
            
        // For Subtraction
        case '-':
            printf("%.1f - %.1f = %.1f\n", x, y, x - y);
            break;
        default:
            printf(
                "Error! please write a valid operator\n");
        }
    }
}

Output:

Enter an operator (+, -), if want to exit press x: +
Enter Two Values:
10
20
10.0 + 20.0 = 30.0

Explanation: This C program uses a while loop to repeatedly prompt the user for an operator and two numbers, performing addition or subtraction based on the operator entered. The break statement is used in the switch case to exit after executing the relevant operation, and the program exits when the user enters ‘x’. If an invalid operator is provided, an error message is displayed.

break vs continue

The difference between the break and continue in C is listed in the below table:

Практический курс по C/C++: https://stepik.org/course/193691

На прошлых занятиях мы подробно разобрали работу трех операторов цикла: while, for и do-while. Также увидели
как можно формировать вложенные циклы и примеры задач, где это может
пригодиться. На этом заключительном занятии по циклам разберем следующие
управляющие операторы, которые можно использовать в любом операторе цикла:

• break – досрочное
  прерывание работы оператора цикла;

• continue – пропуск
  итерации тела цикла;

• goto – безусловный
  переход по метке.

Оператор break

Начнем с
оператора break. Предположим,
нам нужно написать программу подсчета суммы вещественных чисел, пока
пользователь вводит положительные числа. Как только он введет отрицательное
значение, подсчет суммы завершается с выводом результата на экран. Такую
программу можно реализовать следующим образом:

#include <stdio.h>
 
int main(void)
{
         double x, s = 0.0;
 
         while(scanf("%lf", &x) == 1) {
                   if(x < 0)
                            break;
 
                   s += x;
         }
 
         printf("s = %.2f\n", s);
 
         return 0;
}

Вначале
объявляются две вспомогательные переменные: x – для ввода
текущего вещественного значения; s – для подсчета
суммы вещественных положительных чисел. Далее запускается цикл while, который
работает, пока вводятся корректные числовые значения. В теле цикла идет
проверка, если введенное значение x отрицательное, то срабатывает
оператор break. Этот оператор
завершает работу цикла while и управление передается следующему
оператору printf(). Если же
введенное число неотрицательное, то выполняется подсчет суммы.

Как видите, все
предельно просто. Для примера, если в этой программе убрать условие и записать
оператор break в теле цикла,
то цикл while гарантированно
будет прерываться на первой же итерации.

Конечно, эту же
программу можно было бы записать и без оператора break, изменив
условие цикла:

         while(scanf("%lf", &x) == 1 && x >= 0) {
                   s += x;
         }

Возможно, даже
любую программу можно составить без оператора break. Но его использование
может заметно облегчить написание и понимание логики программы. Именно с этой
целью он и введен в язык Си, да и во многие другие языки высокого уровня.

Отмечу здесь еще
один распространенный способ прерывания работы цикла. Если вместо break записать
оператор return:

         while(scanf("%lf", &x) == 1) {
                   if(x < 0)
                            return 0;
 
                   s += x;
         }

то для цикла while эффект будет
такой же, как и от оператора break. Но, правда, есть и существенное
отличие. Как мы уже знаем, оператор return завершает
выполнение функции. В данном случае функции main(). Поэтому, как
только пользователь введет отрицательное число, то программа просто завершится,
результат на экран выведен не будет, так как все операторы после while уже не
сработают. В этом ключевое отличие между break и return. Оператор break позволяет
продолжить выполнение функции, и управление передается следующему оператору
после цикла. А при return текущая функция завершается сразу. На
самом деле, оператор return завершает работу
функции и лишь, как следствие, прерывает работу цикла. По той же логике
оператор return можно для
завершения работы оператора switch, о котором мы с вами ранее уже
говорили. И вообще, с помощью return можно прервать работу чего
угодно в пределах функции.

Оператор continue

Следующий
оператор continue прерывает лишь
текущую итерацию цикла. Давайте я покажу принцип его работы на конкретном
примере. Пусть мы также вводим с клавиатуры целые числа и хотим вычислить сумму
только нечетных чисел. Сделать это можно следующим образом:

#include <stdio.h>
 
int main(void)
{
         int x, s = 0;
 
         while(scanf("%d", &x) == 1 && x != 0) {
                   if(x % 2 == 0)
                            continue;
 
                   s += x;
         }
 
         printf("s = %d\n", s);
 
         return 0;
}

Начало вам уже
знакомо, а дальше записан цикл while, который работает пока пользователь
вводит корректные данные или не введет число 0. Затем, в теле цикла стоит
проверка на четность введенного числа x и если оно четно, то выполняется
оператор continue. Как только
встретился этот оператор, все остальные после него операторы тела цикла
пропускаются и мы переходим к следующей итерации цикла while. В результате,
сумма будет вычисляться только для нечетных значений.

Конечно, опять
же, эту программу можно было бы реализовать и без оператора continue, например, так:

         while(scanf("%d", &x) == 1 && x != 0) {
                   if(x % 2 != 0)
                            s += x;
         }

И это вполне
рабочий вариант. Здесь все как и с оператором break. Оператор continue введен для
удобства программирования и его следует использовать тогда, когда он позволяет
упростить логику программы и сделать ее более читабельной.

Оператор continue, равно как и
оператор break можно
использовать не только в цикле while, но и в циклах for и do-while. Например, если
нам нужно из диапазона целых чисел [1; 100] отобразить только те, что кратны 3
и 5 одновременно, то это можно сделать следующим образом:

#include <stdio.h>
 
int main(void)
{
         for(int i = 1; i <= 100; ++i) {
                   if(i % 3 != 0 || i % 5 != 0)
                            continue;
 
                   printf("%d ", i);
         }
 
         return 0;
}

Это учебный
пример. В этой задаче использование оператора continue избыточно и
проще было бы вызывать функцию printf() по обратному условию. Я лишь
показываю, что операторы continue и break допустимо
применять с любыми операторами циклов.

Оператор goto

Последний
оператор, который мы рассмотрим на этом занятии, это goto. Он позволяет
передать управление любому другому оператору по указанной метке в пределах
текущей функции (в пределах той функции, в которой вызывается данный оператор).

На многих
обучающих курсах и учебной литературе по языку Си сразу оговаривается, что
оператор goto не следует
использовать в своих программах, особенно, начинающим программистам. И я с этим
полностью согласен! Но, существует, по крайне мере, одна ситуация, когда
применение этого оператора оправданно. Это прерывание работы вложенных циклов.
Давайте я детально поясню о чем здесь речь, а позже отмечу, почему все же
оператор goto лучше не
использовать в своих программах.

Итак,
предположим, что мы вычисляем двойную сумму вида:

и хотим прервать
вычисления как только слагаемое i-j будет больше
нуля. Такую программу можно реализовать следующим образом:

#include <stdio.h>
 
int main(void)
{
         int s = 0;
         for(int i = 1; i <= 10; ++i)
                   for(int j = 7; j >= 5; --j) {
                            if(i-j > 0)
                                      goto exit_sum;
                            s += i - j;
                   }
 
         exit_sum: printf("s = %d\n", s);
 
         return 0;
}

Смотрите, здесь
два цикла, один вложен в другой. В теле второго цикла выполняется проверка на
положительность значения i-j. Если это так,
то по условию задания нам нужно прервать работу обоих циклов и завершить
подсчет суммы. Как раз для этого удобно воспользоваться оператором goto и по метке exit_sum (имя мы
придумываем сами) переходим к оператору printf(), стоящему
после этих циклов. В результате такого перехода работа циклов будет завершена.

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

         for(int i = 1; i <= 10; ++i)
                   for(int j = 7; j >= 5; --j) {
                            if(i-j > 0)
                                      break;
                            s += i - j;
                   }

то по условию
завершится работа внутреннего цикла, но внешний продолжит работать и на новой
итерации опять запустит внутренний цикл. Очевидно, это не то, что нам нужно. Запомните,
оператор break прерывает
только один текущий цикл и не более того. Начинающие программисты здесь часто
делают ошибку. Поэтому в нашей задаче вместо break используется
оператор goto и, как мы
видели, он позволяет прервать и два и три и более вложенных циклов при переходе
по метке за их пределы, но в пределах текущей функции.

Это тот редкий
случай, когда применение этого оператора оправданно. Но почему тогда к этому
оператору такое негативное отношение со стороны программистского сообщества
языка Си? Все очень просто. Если злоупотреблять использованием этого оператора,
то логика работы программы очень быстро становится очень запутанной, настолько,
что даже сам автор перестанет в ней ориентироваться. Соответственно читать и
редактировать такие программы чрезвычайно сложно. Второй момент связан с
компиляцией. Если программа написана без операторов goto, то, скорее
всего, при более-менее грамотном подходе к программированию, на выходе получим
качественный машинный код, который будет выполняться предельно быстро. Если же
в программе присутствуют постоянные переходы goto, то никто не
даст гарантии качественной трансляции такого текста в машинный код.
Соответственно, главный плюс языка Си сходит на нет: исполняемый файл не
оптимизирован для быстрого выполнения на текущей архитектуре компьютера.

Чтобы
гарантированно избежать этих недостатков при построении программ, стоит совсем
отказаться от применения оператора goto. Исключение может
составлять необходимость прерывания сразу нескольких вложенных циклов. Хотя и
здесь мы могли бы обойтись без этого оператора. Часто логику вложенных циклов
реализуют в отдельных функциях. И как только появляется необходимость прервать
их работу, завершают функцию оператором return. Это более
частый вариант по сравнению с оператором goto. Именно так я
рекомендую поступать при проектировании своих программ.

Практический курс по C/C++: https://stepik.org/course/193691

Введение в операторы управления потоком в Python

Операторы управления потоком в Python позволяют изменять стандартный порядок выполнения инструкций в программе. Они помогают создавать более гибкие и эффективные алгоритмы. В этой статье рассмотрим три ключевых оператора: break, continue и await. Понимание их использования поможет вам лучше контролировать выполнение вашего кода. Эти операторы часто используются в различных сценариях, от простых циклов до сложных асинхронных операций, и знание их применения является важным аспектом программирования на Python.

Картинка с сайта: sky.pro

Использование оператора break

Оператор break используется для выхода из цикла досрочно. Он прерывает выполнение текущего цикла и передает управление следующей инструкции после цикла. Это позволяет избежать выполнения оставшихся итераций цикла, что может быть полезно в различных ситуациях, таких как поиск элемента в списке или проверка условия.

Пример использования break

В этом примере цикл for прерывается, когда i достигает значения 5. Вывод будет следующим:

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

Оператор break полезен, когда нужно прекратить выполнение цикла при наступлении определенного условия. Например, при поиске элемента в списке:

В этом примере, как только найдено значение target, цикл прерывается, и программа продолжает выполнение после цикла. Это позволяет избежать ненужных итераций и улучшить производительность программы.

Дополнительные примеры использования break

Рассмотрим еще один пример, где break используется для завершения поиска в двумерном массиве:

В этом примере break используется дважды: первый раз для выхода из внутреннего цикла, и второй раз для выхода из внешнего цикла. Это позволяет эффективно завершить поиск, как только найдено нужное значение.

Использование оператора continue

Оператор continue пропускает текущую итерацию цикла и переходит к следующей. Это полезно, когда нужно пропустить определенные значения или условия в цикле. Например, если необходимо пропустить обработку определенных данных или условий, continue позволяет сделать это без завершения всего цикла.

Пример использования continue

В этом примере выводятся только нечетные числа, так как четные числа пропускаются оператором continue:

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

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

В этом примере отрицательные значения пропускаются, и выводятся только положительные числа. Это позволяет избежать выполнения ненужного кода и улучшить читаемость программы.

Дополнительные примеры использования continue

Рассмотрим еще один пример, где continue используется для пропуска определенных элементов в списке строк:

В этом примере выводятся только те слова, длина которых больше или равна 6 символам:

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

Использование оператора await

Оператор await используется в асинхронном программировании для ожидания завершения асинхронной операции. Он позволяет выполнять другие задачи, пока ожидается результат асинхронной операции. Это особенно полезно при работе с операциями ввода-вывода, сетевыми запросами и другими задачами, которые могут занять значительное время.

Пример использования await

В этом примере программа приостанавливается на 2 секунды, а затем продолжает выполнение. Это позволяет избежать блокировки выполнения программы и повысить ее производительность.

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

Оператор await полезен при работе с асинхронными функциями и операциями ввода-вывода, которые могут занять значительное время. Например, при выполнении сетевых запросов:

В этом примере await используется для ожидания завершения сетевого запроса. Это позволяет программе продолжать выполнение других задач, пока ожидается ответ от сервера.

Дополнительные примеры использования await

Рассмотрим еще один пример, где await используется для выполнения нескольких асинхронных задач параллельно:

В этом примере три задачи выполняются параллельно, и каждая из них завершается после указанной задержки. Это позволяет эффективно использовать время выполнения программы и улучшить ее производительность.

Практические примеры и советы

Пример с использованием всех операторов

Рассмотрим пример, где используются все три оператора: break, continue и await.

В этом примере программа обрабатывает элементы списка, пропуская элемент «skip» и останавливаясь на элементе «stop». Это демонстрирует, как можно комбинировать использование операторов для достижения желаемого поведения программы.

Советы по использованию операторов

1. Используйте break для досрочного завершения циклов, когда дальнейшее выполнение не имеет смысла. Это поможет избежать ненужных итераций и улучшить производительность программы.
2. Применяйте continue для пропуска ненужных итераций, чтобы избежать выполнения лишнего кода. Это улучшит читаемость и эффективность вашего кода.
3. Используйте await для асинхронных операций, чтобы не блокировать выполнение программы и повысить ее производительность. Это особенно важно при работе с операциями ввода-вывода и сетевыми запросами.

Эти операторы помогут вам создавать более эффективные и читаемые программы на Python. Знание их применения позволит вам лучше контролировать выполнение вашего кода и создавать более сложные и гибкие алгоритмы.

Читайте также