1 цикл: 1. Циклы (Циклы и ветвления)

Пример цикла While.

Цикл — разновидность управляющей конструкции в высокоуровневых языках программирования, предназначенная для организации многократного исполнения набора инструкций. Также циклом может называться любая многократно исполняемая последовательность инструкций, организованная любым способом (например, с помощью условного перехода).

Определения

Последовательность инструкций, предназначенная для многократного исполнения, называется телом цикла. Единичное выполнение тела цикла называется итерацией. Выражение, определяющее, будет в очередной раз выполняться итерация или цикл завершится, называется условием выхода или условием окончания цикла (либо условием продолжения в зависимости от того, как интерпретируется его истинность — как признак необходимости завершения или продолжения цикла). Переменная, хранящая текущий номер итерации, называется счётчиком итераций цикла или просто счётчиком цикла. Цикл не обязательно содержит счётчик, счётчик не обязан быть один — условие выхода из цикла может зависеть от нескольких изменяемых в цикле переменных, а может определяться внешними условиями (например, наступлением определённого времени), в последнем случае счётчик может вообще не понадобиться.

Исполнение любого цикла включает первоначальную инициализацию переменных цикла, проверку условия выхода, исполнение тела цикла и обновление переменной цикла на каждой итерации. Кроме того, большинство языков программирования предоставляет средства для досрочного управления циклом, например, операторы завершения цикла, то есть выхода из цикла независимо от истинности условия выхода (в языке Си — break) и операторы пропуска итерации (в языке Си — continue).

Виды циклов

Безусловные циклы

Иногда в программах используются циклы, выход из которых не предусмотрен логикой программы. Такие циклы называются безусловными, или бесконечными. Специальных синтаксических средств для создания бесконечных циклов, ввиду их нетипичности, языки программирования не предусматривают, поэтому такие циклы создаются с помощью конструкций, предназначенных для создания обычных (или условных) циклов. Для обеспечения бесконечного повторения проверка условия в таком цикле либо отсутствует (если позволяет синтаксис, как, например, в цикле LOOP ... END LOOP языка Ада), либо заменяется константным значением (while true do ... в Паскале). В языке С используется цикл for(;;) с незаполненными секциями или цикл while (1).

Цикл с предусловием

Цикл с предусловием — цикл, который выполняется, пока истинно некоторое условие, указанное перед его началом. Это условие проверяется до выполнения тела цикла, поэтому тело может быть не выполнено ни разу (если условие с самого начала ложно). В большинстве процедурных языков программирования реализуется оператором while, отсюда его второе название — while-цикл. На языке Pascal цикл с предусловием имеет следующий вид:

while <условие> do
begin   
  <тело цикла> 
end;

На языке Си:

while (<условие>) {
   <тело цикла>
}

Цикл с постусловием

Цикл с постусловием — цикл, в котором условие проверяется после выполнения тела цикла. Отсюда следует, что тело всегда выполняется хотя бы один раз. В языке Паскаль этот цикл реализует оператор repeat..until; в Си — do…while.

На языке Pascal цикл с постусловием имеет следующий вид::

repeat
    <тело цикла>
until <условие выхода>

На языке Си:

do {
    <тело цикла>
} while (<условие продолжения цикла>)

В трактовке условия цикла с постусловием в разных языках есть различия. В Паскале и языках, произошедших от него, условие такого цикла трактуется как условие выхода (цикл завершается, когда условие истинно, в русской терминологии такие циклы называют ещё «цикл до»), а в Си и его потомках — как условие продолжения (цикл завершается, когда условие ложно, такие циклы иногда называют «цикл пока»).

Цикл с выходом из середины

Цикл с выходом из середины — наиболее общая форма условного цикла. Синтаксически такой цикл оформляется с помощью трёх конструкций: начала цикла, конца цикла и команды выхода из цикла. Конструкция начала маркирует точку программы, в которой начинается тело цикла, конструкция конца — точку, где тело заканчивается. Внутри тела должна присутствовать команда выхода из цикла, при выполнении которой цикл заканчивается и управление передаётся на оператор, следующий за конструкцией конца цикла. Естественно, чтобы цикл выполнился более одного раза, команда выхода должна вызываться не безусловно, а только при выполнении условия выхода из цикла.

Принципиальным отличием такого вида цикла от рассмотренных выше является то, что часть тела цикла, расположенная после начала цикла и до команды выхода, выполняется всегда (даже если условие выхода из цикла истинно при первой итерации), а часть тела цикла, находящаяся после команды выхода, не выполняется при последней итерации.

Легко видеть, что с помощью цикла с выходом из середины можно легко смоделировать и цикл с предусловием (разместив команду выхода в начале тела цикла), и цикл с постусловием (разместив команду выхода в конце тела цикла).

Часть языков программирования содержит специальные конструкции для организации цикла с выходом из середины. Так, в языке Ада для этого используется конструкция LOOP ... END LOOP и команда выхода EXIT или EXIT WHEN:

LOOP
  ... Часть тела цикла
  EXIT WHEN <условие выхода>;
  ... Часть тела цикла
  IF <условие выхода> THEN 
    EXIT; 
  END;
  ... Часть тела цикла
END LOOP:

Здесь внутри цикла может быть любое количество команд выхода обоих типов. Сами команды выхода принципиально не различаются, обычно EXIT WHEN применяют, когда проверяется только условие выхода, а просто EXIT — когда выход из цикла производится в одном из вариантов сложного условного оператора.

В тех языках, где подобных конструкций не предусмотрено, цикл с выходом из середины может быть смоделирован с помощью любого условного цикла и оператора досрочного выхода из цикла (такого, как break в Си, exit в Турбо Паскале и т. п.), либо оператора безусловного перехода goto.

Цикл со счётчиком (или цикл для)

Цикл со счётчиком — цикл, в котором некоторая переменная изменяет своё значение от заданного начального значения до конечного значения с некоторым шагом, и для каждого значения этой переменной тело цикла выполняется один раз. В большинстве процедурных языков программирования реализуется оператором for, в котором указывается счётчик (так называемая «переменная цикла»), требуемое количество проходов (или граничное значение счётчика) и, возможно, шаг, с которым изменяется счётчик. Например, в языке Оберон-2 такой цикл имеет вид:

 FOR v := b TO e BY s DO
   ... тело цикла
 END 

здесь v — счётчик, b — начальное значение счётчика, e — граничное значение счётчика, s — шаг).

Неоднозначен вопрос о значении переменной по завершении цикла, в котором эта переменная использовалась как счётчик. Например, если в программе на языке Паскаль встретится конструкция вида:

i := 100;
for i := 0 to 9 do
begin
  ... тело цикла
end;
k := i;

возникает вопрос: какое значение будет в итоге присвоено переменной k: 9, 10, 100, может быть, какое-то другое? А если цикл завершится досрочно? Ответы зависят от того, увеличивается ли значение счётчика после последней итерации и не изменяет ли транслятор это значение дополнительно. Ещё один вопрос: что будет, если внутри цикла счётчику будет явно присвоено новое значение? Различные языки программирования решают данные вопросы по-разному. В некоторых поведение счётчика чётко регламентировано. В других, например, в том же Паскале, стандарт языка не определяет ни конечного значения счётчика, ни последствий его явного изменения в цикле, но не рекомендует изменять счётчик явно и использовать его по завершении цикла без повторной инициализации. Программа на Паскале, игнорирующая эту рекомендацию, может давать разные результаты при выполнении на разных системах и использовании разных трансляторов.

Радикально решён вопрос в языках Ада и Kotlin: счётчик считается описанным в заголовке цикла, и вне его просто не существует. Даже если имя счётчика в программе уже используется, внутри цикла в качестве счётчика используется отдельная переменная. Счётчику запрещено явно присваивать какие бы то ни было значения, он может меняться только внутренним механизмом оператора цикла.

В результате конструкция на Аде:

i := 100;
for i in (0..9) loop
  ... тело цикла
end loop;
k := i;

И на Котлине:

val i = 100;
for (i in 0..9){
    ... тело цикла
}
val k = i;

внешне аналогичная вышеприведённому циклу на Паскале, трактуется однозначно: переменной k будет присвоено значение 100, поскольку переменная i, используемая вне данного цикла, не имеет никакого отношения к счётчику i, который создаётся и изменяется внутри цикла. Подобное обособление счётчика удобно и безопасно: не требуется отдельное описание для него и минимальна вероятность случайных ошибок, связанных со случайным разрушением внешних по отношению к циклу переменных. Если программисту требуется включить в готовый код цикл со счётчиком, то он может не проверять, существует ли переменная с именем, которое он выбрал в качестве счётчика, не добавлять описание нового счётчика в заголовок соответствующей процедуры, не пытаться использовать один из имеющихся, но в данный момент «свободных» счётчиков. Он просто пишет цикл с переменной-счётчиком, имя которой ему удобно, и может быть уверен, что никакой коллизии имён не произойдёт.

Цикл со счётчиком всегда можно записать как условный цикл, перед началом которого счётчику присваивается начальное значение, а условием выхода является достижение счётчиком конечного значения; к телу цикла при этом добавляется оператор изменения счётчика на заданный шаг. Однако специальные операторы цикла со счётчиком могут эффективнее транслироваться, так как формализованный вид такого цикла позволяет использовать специальные процессорные команды организации циклов.

Никлаус Вирт одно время называл цикл со счётчиком «маргинальным», утверждая, что такая конструкция является излишней и должна быть исключена из синтаксиса языков программирования как несистемная. В соответствии с этим представлением в языке программирования Оберон цикла со счётчиком не было. Однако в языке Оберон-2, созданном Виртом и Мёссенбёком в развитие Оберона, цикл со счётчиком FOR появился снова в интересах практического удобства использования^[1].

В некоторых языках, например, Си и других, произошедших от него, цикл for, несмотря на синтаксическую форму цикла со счётчиком, в действительности является циклом с предусловием. То есть в Си конструкция цикла:

for (i = 0; i < 10; ++i)
{
  ... тело цикла 
}

фактически представляет собой другую форму записи конструкции^[2]:

i = 0;
while (i < 10)
{
  ... тело цикла 
  ++i;
}

То есть в конструкции for сначала пишется произвольное предложение инициализации цикла, затем — условие продолжения и, наконец, выполняемая после каждого тела цикла некоторая операция (это не обязательно должно быть изменение счётчика; это может быть правка указателя или какая-нибудь совершенно посторонняя операция). Для языков такого вида вышеописанная проблема решается очень просто: переменная-счётчик ведёт себя совершенно предсказуемо и по завершении цикла сохраняет своё последнее значение.

Совместный цикл

Ещё одним вариантом цикла является цикл, задающий выполнение некоторой операции для объектов из заданного множества, без явного указания порядка перечисления этих объектов. Такие циклы называются совместными (а также циклами по коллекции, циклами просмотра) и представляют собой формальную запись инструкции вида: «Выполнить операцию X для всех элементов, входящих во множество M». Совместный цикл, теоретически, никак не определяет, в каком порядке операция будет применяться к элементам множества, хотя конкретные языки программирования, разумеется, могут задавать конкретный порядок перебора элементов. Произвольность даёт возможность оптимизации исполнения цикла за счёт организации доступа не в заданном программистом, а в наиболее выгодном порядке. При наличии возможности параллельного выполнения нескольких операций возможно даже распараллеливание выполнения совместного цикла, когда одна и та же операция одновременно выполняется на разных вычислительных модулях для разных объектов, при том, что логически программа остаётся последовательной.

Совместные циклы имеются в некоторых языках программирования (C#, Eiffel, Java, JavaScript, Perl, Python, PHP, LISP, Tcl и др.) — они позволяют выполнять цикл по всем элементам заданной коллекции объектов. В определении такого цикла требуется указать только коллекцию объектов и переменную, которой в теле цикла будет присвоено значение обрабатываемого в данный момент объекта (или ссылка на него). В различных языках программирования синтаксис оператора различен:

C++:

for (type &item : set) //поддерживается, начиная со стандарта C++11
{
    //использование item
}

C#:

foreach (type item in set) 
{
    //использование item
}

Delphi:

for item in [1..100] do
begin
  //Использование item (Работоспособность кода проверялась в Delphi 2010) 
end;

Perl (строгий порядок «от первого до последнего»):

foreach (@set) 
{
    #использование $_
}
# или
for (@set) 
{
    #использование $_
}
# или
foreach $item (@set) 
{
    #использование $item
}

Eiffel:

across set as cursor loop
    -- использование cursor.item
end

Java:

for (type item : set) 
{
    //использование item
}

JavaScript:

for (txtProperty in objObject)
  {
  /*
  использование:
  objObject [txtProperty]
  */
  }

PHP:

foreach ($arr as $item) {
    /* использование $item*/
}
//или
foreach ($arr as $key=>$value) {
    /* использование значений индекса $key и его значения $value*/
}

Visual Basic.NET:

For Each item As type In set
    'использование item
Next item

Windows PowerShell:

foreach ($item in $set) {
  # операции с $item
} 

или

$set | ForEach-Object {
  # операции с $_
}

Python

for item in iterator_instance:
    # использование item

Ruby

iterator_instance.each do |item|
    # использование item
end

Досрочный выход и пропуск итерации

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

Досрочный выход из цикла

Команда досрочного выхода применяется, когда необходимо прервать выполнение цикла, в котором условие выхода ещё не достигнуто. Такое бывает, например, когда при выполнении тела цикла обнаруживается ошибка, после которой дальнейшая работа цикла не имеет смысла.

Команда досрочного выхода обычно называется EXIT или break, а её действие аналогично действию команды безусловного перехода (goto) на команду, непосредственно следующую за циклом, внутри которого эта команда находится. Так, в языке Си два нижеприведённых цикла работают совершенно одинаково:

// Применение оператора break
while(<условие>) {
  ... операторы
  if (<ошибка>) break;
  ... операторы
}
... продолжение программы

// Аналогичный фрагмент без break
while(<условие>) {
  ... операторы
  if (<ошибка>) goto break_label;
  ... операторы 
}
break_label:
... продолжение программы

В обоих случаях, если в теле цикла выполнится условие <ошибка>, будет произведён переход на операторы, обозначенные как «продолжение программы». Таким образом, оператор досрочного выхода из цикла, по сути, просто маскирует безусловный переход, однако использование break предпочтительнее, чем goto, поскольку поведение break чётко задано языком, потенциально менее опасно (нет, например, вероятности ошибиться с положением или названием метки). Кроме того, явный досрочный выход из цикла не нарушает принципов структурного программирования.

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

Пропуск итерации

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

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

int arr[ARRSIZE];
...
// Суммирование отдельно всех и только положительных
// элементов массива arr с применением continue.
int sum_all = 0;
int sum_pos = 0;
for (int i = 0 ; i < ARRSIZE; ++i)
{
    sum_all += arr[i];
    if (arr[i] <= 0) continue;
    sum_pos += arr[i];
}

// Аналогичный код c goto
int sum_all = 0;
int sum_pos = 0;
for (int i = 0 ; i < ARRSIZE; ++i)
{
    sum_all += arr[i];
    if (arr[i] <= 0) goto cont_label;
    sum_pos += arr[i];
cont_label:
}

Из второго фрагмента ясно видно, как работает continue: он просто передаёт управление за последнюю команду тела цикла, пропуская выполнение команды суммирования, если очередной элемент массива не удовлетворяет условию. Таким образом, в sum_pos накапливается сумма лишь положительных элементов массива.

Необходимость

С точки зрения структурного программирования команды досрочного выхода из цикла и продолжения итерации являются избыточными, поскольку их действие может быть легко смоделировано чисто структурными средствами. Более того, по мнению ряда теоретиков программирования (в частности, Эдсгера Дейкстры), сам факт использования в программе неструктурных средств, будь то классический безусловный переход или любая из его специализированных форм, таких как break или continue, является свидетельством недостаточно проработанного алгоритма решения задачи.

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

// Досрочный выход из цикла без break
bool flag = false; // флаг досрочного завершения
while(<условие> && !flag) {
  ... операторы
  if (<ошибка>) {
    flag = true;
  } else {
    ... операторы
  }
}
... продолжение программы

Легко убедиться, что фрагмент будет работать аналогично предшествующим, разница лишь в том, что в месте проверки на ошибку вместо непосредственного выхода из цикла устанавливается флаг досрочного выхода, который проверяется позже в штатном условии продолжения цикла. Однако для отказа от команды досрочного выхода пришлось добавить в программу описание флага и вторую ветвь условного оператора, к тому же произошло «размытие» логики программы (решение о досрочном выходе принимается в одном месте, а выполняется в другом). В результате программа не стала ни проще, ни короче, ни понятнее.

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

int arr[ARRSIZE];
...
// Суммирование отдельно всех и только положительных
// элементов массива arr с заменой continue
int sum_all = 0;
int sum_pos = 0;
for (int i = 0 ; i < ARRSIZE; ++i)
{
    sum_all += arr[i];
    if (arr[i] > 0) // Условие заменено на противоположное!
    {
      sum_pos += arr[i];
    }
}

Как видим, достаточно было заменить проверяемое условие на противоположное и поместить заключительную часть тела цикла в условный оператор. Можно заметить, что программа стала короче (за счёт удаления команды пропуска итерации) и одновременно логичнее (из кода непосредственно видно, что суммируются положительные элементы).

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

int arr[ARRSIZE];
...
int sum_all = 0;
int sum_pos = 0;
int i = 0;
while (i < ARRSIZE) // Цикл внешне аналогичен предыдущему for ...
{
    sum_all += arr[i];
    if (arr[i] <= 0) continue;
    sum_pos += arr[i];
    ++i; // ... но эта команда будет пропущена при выполнении continue 
         // и программа зациклится
}

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

Вложенные циклы

Существует возможность организовать цикл внутри тела другого цикла. Такой цикл будет называться вложенным циклом. Вложенный цикл по отношению к циклу, в тело которого он вложен, будет именоваться внутренним циклом, и наоборот, цикл, в теле которого существует вложенный цикл, будет именоваться внешним по отношению к вложенному. Внутри вложенного цикла, в свою очередь, может быть вложен ещё один цикл, образуя следующий уровень вложенности и так далее. Количество уровней вложенности, как правило, не ограничивается.

Полное число исполнений тела внутреннего цикла не превышает произведения числа итераций внутреннего и всех внешних циклов. Например, взяв три вложенных друг в друга цикла, каждый по 10 итераций, получим 10 исполнений тела для внешнего цикла, 100 для цикла второго уровня и 1000 в самом внутреннем цикле.

Одна из проблем, связанных с вложенными циклами — организация досрочного выхода из них. Во многих языках программирования есть оператор досрочного завершения цикла (break в Си, exit в Турбо Паскале, last в Perl и т. п.), но он, как правило, обеспечивает выход только из цикла того уровня, откуда вызван. Вызов его из вложенного цикла приведёт к завершению только этого внутреннего цикла, внешний же цикл продолжит выполняться. Проблема может показаться надуманной, но она действительно иногда возникает при программировании сложной обработки данных, когда алгоритм требует немедленного прерывания в определённых условиях, наличие которых можно проверить только в глубоко вложенном цикле.

Решений проблемы выхода из вложенных циклов несколько.

• Простейший — использовать оператор безусловного перехода goto для выхода в точку программы, непосредственно следующую за вложенным циклом. Этот вариант критикуется сторонниками структурного программирования, как и все конструкции, требующие использования goto. Некоторые языки программирования, например, Модула-2, просто не имеют оператора безусловного перехода, и в них подобная конструкция невозможна.
• Альтернатива — использовать штатные средства завершения циклов, в случае необходимости устанавливая специальные флаги, требующие немедленного завершения обработки. Недостаток — усложнение кода, снижение производительности.
• Размещение вложенного цикла в процедуре. Идея состоит в том, чтобы всё действие, которое может потребоваться прервать досрочно, оформить в виде отдельной процедуры, и для досрочного завершения использовать оператор выхода из процедуры (если такой есть в языке программирования). В языке Си, например, можно построить функцию с вложенным циклом, а выход из неё организовать с помощью оператора return. Недостаток — выделение фрагмента кода в процедуру не всегда логически обосновано, и не все языки имеют штатные средства досрочного завершения процедур.
• Воспользоваться механизмом генерации и обработки исключений (исключительных ситуаций), который имеется сейчас в большинстве языков высокого уровня. В этом случае в нештатной ситуации код во вложенном цикле возбуждает исключение, а блок обработки исключений, в который помещён весь вложенный цикл, перехватывает и обрабатывает его. Недостаток — реализация механизма обработки исключений в большинстве случаев такова, что скорость работы программы уменьшается. Правда, в современных условиях это не особенно важно: практически потеря производительности столь мала, что имеет значение лишь для очень немногих приложений.
• Наконец, существуют специальные языковые средства для выхода из вложенных циклов. Так, в языке Ада программист может пометить цикл (верхний уровень вложенного цикла) меткой, и в команде досрочного завершения цикла указать эту метку. Выход произойдёт не из текущего цикла, а из всех вложенных циклов до помеченного, включительно^[3]. Язык PHP предоставляет возможность указать число прерываемых циклов после команды break — так break 2 прервёт сам цикл и вышестоящий над ним, а break 1 эквивалентно простой записи команды break^[4].

Циклы с несколькими охраняемыми ветвями

Цикл Дейкстры

В теории программирования известна ещё одна, принципиально отличающаяся от «классических», форма циклическо

Цикл (программирование) — Википедия

Цикл — разновидность управляющей конструкции в высокоуровневых языках программирования, предназначенная для организации многократного исполнения набора инструкций. Также циклом может называться любая многократно исполняемая последовательность инструкций, организованная любым способом (например, с помощью условного перехода).

Определения

Последовательность инструкций, предназначенная для многократного исполнения, называется телом цикла. Единичное выполнение тела цикла называется итерацией. Выражение, определяющее, будет в очередной раз выполняться итерация или цикл завершится, называется условием выхода или условием окончания цикла (либо условием продолжения в зависимости от того, как интерпретируется его истинность — как признак необходимости завершения или продолжения цикла). Переменная, хранящая текущий номер итерации, называется счётчиком итераций цикла или просто счётчиком цикла. Цикл не обязательно содержит счётчик, счётчик не обязан быть один — условие выхода из цикла может зависеть от нескольких изменяемых в цикле переменных, а может определяться внешними условиями (например, наступлением определённого времени), в последнем случае счётчик может вообще не понадобиться.

Исполнение любого цикла включает первоначальную инициализацию переменных цикла, проверку условия выхода, исполнение тела цикла и обновление переменной цикла на каждой итерации. Кроме того, большинство языков программирования предоставляет средства для досрочного управления циклом, например, операторы завершения цикла, то есть выхода из цикла независимо от истинности условия выхода (в языке Си — break) и операторы пропуска итерации (в языке Си — continue).

Виды циклов

Безусловные циклы

Иногда в программах используются циклы, выход из которых не предусмотрен логикой программы. Такие циклы называются безусловными, или бесконечными. Специальных синтаксических средств для создания бесконечных циклов, ввиду их нетипичности, языки программирования не предусматривают, поэтому такие циклы создаются с помощью конструкций, предназначенных для создания обычных (или условных) циклов. Для обеспечения бесконечного повторения проверка условия в таком цикле либо отсутствует (если позволяет синтаксис, как, например, в цикле LOOP ... END LOOP языка Ада), либо заменяется константным значением (while true do ... в Паскале). В языке С используется цикл for(;;) с незаполненными секциями или цикл while (1).

Цикл с предусловием

Цикл с предусловием — цикл, который выполняется, пока истинно некоторое условие, указанное перед его началом. Это условие проверяется до выполнения тела цикла, поэтому тело может быть не выполнено ни разу (если условие с самого начала ложно). В большинстве процедурных языков программирования реализуется оператором while, отсюда его второе название — while-цикл. На языке Pascal цикл с предусловием имеет следующий вид:

while <условие> do
begin   
  <тело цикла> 
end;

На языке Си:

while (<условие>) {
   <тело цикла>
}

Цикл с постусловием

Цикл с постусловием — цикл, в котором условие проверяется после выполнения тела цикла. Отсюда следует, что тело всегда выполняется хотя бы один раз. В языке Паскаль этот цикл реализует оператор repeat..until; в Си — do…while.

На языке Pascal цикл с постусловием имеет следующий вид::

repeat
    <тело цикла>
until <условие выхода>

На языке Си:

do {
    <тело цикла>
} while (<условие продолжения цикла>)

В трактовке условия цикла с постусловием в разных языках есть различия. В Паскале и языках, произошедших от него, условие такого цикла трактуется как условие выхода (цикл завершается, когда условие истинно, в русской терминологии такие циклы называют ещё «цикл до»), а в Си и его потомках — как условие продолжения (цикл завершается, когда условие ложно, такие циклы иногда называют «цикл пока»).

Цикл с выходом из середины

Цикл с выходом из середины — наиболее общая форма условного цикла. Синтаксически такой цикл оформляется с помощью трёх конструкций: начала цикла, конца цикла и команды выхода из цикла. Конструкция начала маркирует точку программы, в которой начинается тело цикла, конструкция конца — точку, где тело заканчивается. Внутри тела должна присутствовать команда выхода из цикла, при выполнении которой цикл заканчивается и управление передаётся на оператор, следующий за конструкцией конца цикла. Естественно, чтобы цикл выполнился более одного раза, команда выхода должна вызываться не безусловно, а только при выполнении условия выхода из цикла.

Принципиальным отличием такого вида цикла от рассмотренных выше является то, что часть тела цикла, расположенная после начала цикла и до команды выхода, выполняется всегда (даже если условие выхода из цикла истинно при первой итерации), а часть тела цикла, находящаяся после команды выхода, не выполняется при последней итерации.

Легко видеть, что с помощью цикла с выходом из середины можно легко смоделировать и цикл с предусловием (разместив команду выхода в начале тела цикла), и цикл с постусловием (разместив команду выхода в конце тела цикла).

Часть языков программирования содержат специальные конструкции для организации цикла с выходом из середины. Так, в языке Ада для этого используется конструкция LOOP ... END LOOP и команда выхода EXIT или EXIT WHEN:

LOOP
  ... Часть тела цикла
  EXIT WHEN <условие выхода>;
  ... Часть тела цикла
  IF <условие выхода> THEN 
    EXIT; 
  END;
  ... Часть тела цикла
END LOOP:

Здесь внутри цикла может быть любое количество команд выхода обоих типов. Сами команды выхода принципиально не различаются, обычно EXIT WHEN применяют, когда проверяется только условие выхода, а просто EXIT — когда выход из цикла производится в одном из вариантов сложного условного оператора.

В тех языках, где подобных конструкций не предусмотрено, цикл с выходом из середины может быть смоделирован с помощью любого условного цикла и оператора досрочного выхода из цикла (такого, как break в Си, exit в Турбо Паскале и т. п.), либо оператора безусловного перехода goto.

Цикл со счётчиком (или цикл для)

Цикл со счётчиком — цикл, в котором некоторая переменная изменяет своё значение от заданного начального значения до конечного значения с некоторым шагом, и для каждого значения этой переменной тело цикла выполняется один раз. В большинстве процедурных языков программирования реализуется оператором for, в котором указывается счётчик (так называемая «переменная цикла»), требуемое количество проходов (или граничное значение счётчика) и, возможно, шаг, с которым изменяется счётчик. Например, в языке Оберон-2 такой цикл имеет вид:

 FOR v := b TO e BY s DO
   ... тело цикла
 END 

здесь v — счётчик, b — начальное значение счётчика, e — граничное значение счётчика, s — шаг).

Неоднозначен вопрос о значении переменной по завершении цикла, в котором эта переменная использовалась как счётчик. Например, если в программе на языке Паскаль встретится конструкция вида:

i := 100;
for i := 0 to 9 do
begin
  ... тело цикла
end;
k := i;

возникает вопрос: какое значение будет в итоге присвоено переменной k: 9, 10, 100, может быть, какое-то другое? А если цикл завершится досрочно? Ответы зависят от того, увеличивается ли значение счётчика после последней итерации и не изменяет ли транслятор это значение дополнительно. Ещё один вопрос: что будет, если внутри цикла счётчику будет явно присвоено новое значение? Различные языки программирования решают данные вопросы по-разному. В некоторых поведение счётчика чётко регламентировано. В других, например, в том же Паскале, стандарт языка не определяет ни конечного значения счётчика, ни последствий его явного изменения в цикле, но не рекомендует изменять счётчик явно и использовать его по завершении цикла без повторной инициализации. Программа на Паскале, игнорирующая эту рекомендацию, может давать разные результаты при выполнении на разных системах и использовании разных трансляторов.

Радикально решён вопрос в языке Ада: счётчик считается описанным в заголовке цикла, и вне его просто не существует. Даже если имя счётчика в программе уже используется, внутри цикла в качестве счётчика используется отдельная переменная. Счётчику запрещено явно присваивать какие бы то ни было значения, он может меняться только внутренним механизмом оператора цикла. В результате конструкция

i := 100;
for i in (0..9) loop
  ... тело цикла
end loop;
k := i;

внешне аналогичная вышеприведённому циклу на Паскале, трактуется однозначно: переменной k будет присвоено значение 100, поскольку переменная i, используемая вне данного цикла, не имеет никакого отношения к счётчику i, который создаётся и изменяется внутри цикла. Подобное обособление счётчика удобно и безопасно: не требуется отдельное описание для него и минимальна вероятность случайных ошибок, связанных со случайным разрушением внешних по отношению к циклу переменных. Если программисту требуется включить в готовый код цикл со счётчиком, то он может не проверять, существует ли переменная с именем, которое он выбрал в качестве счётчика, не добавлять описание нового счётчика в заголовок соответствующей процедуры, не пытаться использовать один из имеющихся, но в данный момент «свободных» счётчиков. Он просто пишет цикл с переменной-счётчиком, имя которой ему удобно, и может быть уверен, что никакой коллизии имён не произойдёт.

Цикл со счётчиком всегда можно записать как условный цикл, перед началом которого счётчику присваивается начальное значение, а условием выхода является достижение счётчиком конечного значения; к телу цикла при этом добавляется оператор изменения счётчика на заданный шаг. Однако специальные операторы цикла со счётчиком могут эффективнее транслироваться, так как формализованный вид такого цикла позволяет использовать специальные процессорные команды организации циклов.

Никлаус Вирт одно время называл цикл со счётчиком «маргинальным», утверждая, что такая конструкция является излишней и должна быть исключена из синтаксиса языков программирования как несистемная. В соответствии с этим представлением в языке программирования Оберон цикла со счётчиком не было. Однако в языке Оберон-2, созданном Виртом и Мёссенбёком в развитие Оберона, цикл со счётчиком FOR появился снова в интересах практического удобства использования^[1].

В некоторых языках, например, Си и других, произошедших от него, цикл for, несмотря на синтаксическую форму цикла со счётчиком, в действительности является циклом с предусловием. То есть в Си конструкция цикла:

for (i = 0; i < 10; ++i)
{
  ... тело цикла 
}

фактически представляет собой другую форму записи конструкции^[2]:

i = 0;
while (i < 10)
{
  ... тело цикла 
  ++i;
}

То есть в конструкции for сначала пишется произвольное предложение инициализации цикла, затем — условие продолжения и, наконец, выполняемая после каждого тела цикла некоторая операция (это не обязательно должно быть изменение счётчика; это может быть правка указателя или какая-нибудь совершенно посторонняя операция). Для языков такого вида вышеописанная проблема решается очень просто: переменная-счётчик ведёт себя совершенно предсказуемо и по завершении цикла сохраняет своё последнее значение.

Совместный цикл

Ещё одним вариантом цикла является цикл, задающий выполнение некоторой операции для объектов из заданного множества, без явного указания порядка перечисления этих объектов. Такие циклы называются совместными (а также циклами по коллекции, циклами просмотра) и представляют собой формальную запись инструкции вида: «Выполнить операцию X для всех элементов, входящих во множество M». Совместный цикл, теоретически, никак не определяет, в каком порядке операция будет применяться к элементам множества, хотя конкретные языки программирования, разумеется, могут задавать конкретный порядок перебора элементов. Произвольность даёт возможность оптимизации исполнения цикла за счёт организации доступа не в заданном программистом, а в наиболее выгодном порядке. При наличии возможности параллельного выполнения нескольких операций возможно даже распараллеливание выполнения совместного цикла, когда одна и та же операция одновременно выполняется на разных вычислительных модулях для разных объектов, при том, что логически программа остаётся последовательной.

Совместные циклы имеются в некоторых языках программирования (C#, Eiffel, Java, JavaScript, Perl, Python, PHP, LISP, Tcl и др.) — они позволяют выполнять цикл по всем элементам заданной коллекции объектов. В определении такого цикла требуется указать только коллекцию объектов и переменную, которой в теле цикла будет присвоено значение обрабатываемого в данный момент объекта (или ссылка на него). В различных языках программирования синтаксис оператора различен:

C++:

for (type &item : set) //поддерживается, начиная со стандарта C++11
{
    //использование item
}

C#:

foreach (type item in set) 
{
    //использование item
}

Delphi:

for item in [1..100] do
begin
  //Использование item (Работоспособность кода проверялась в Delphi 2010) 
end;

Perl (строгий порядок «от первого до последнего»):

foreach (@set) 
{
    #использование $_
}
# или
for (@set) 
{
    #использование $_
}
# или
foreach $item (@set) 
{
    #использование $item
}

Eiffel:

across set as cursor loop
    -- использование cursor.item
end

Java:

for (type item : set) 
{
    //использование item
}

JavaScript:

for (txtProperty in objObject)
  {
  /*
  использование:
  objObject [txtProperty]
  */
  }

PHP:

foreach ($arr as $item) {
    /* использование $item*/
}
//или
foreach ($arr as $key=>$value) {
    /* использование значений индекса $key и его значения $value*/
}

Visual Basic.NET:

For Each item As type In set
    'использование item
Next item

Windows PowerShell:

foreach ($item in $set) {
  # операции с $item
} 

или

$set | ForEach-Object {
  # операции с $_
}

Python

for item in iterator_instance:
    # использование item

Досрочный выход и пропуск итерации

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

Досрочный выход из цикла

Команда досрочного выхода применяется, когда необходимо прервать выполнение цикла, в котором условие выхода ещё не достигнуто. Такое бывает, например, когда при выполнении тела цикла обнаруживается ошибка, после которой дальнейшая работа цикла не имеет смысла.

Команда досрочного выхода обычно называется EXIT или break, а её действие аналогично действию команды безусловного перехода (goto) на команду, непосредственно следующую за циклом, внутри которого эта команда находится. Так, в языке Си два нижеприведённых цикла работают совершенно одинаково:

// Применение оператора break
while(<условие>) {
  ... операторы
  if (<ошибка>) break;
  ... операторы
}
... продолжение программы

// Аналогичный фрагмент без break
while(<условие>) {
  ... операторы
  if (<ошибка>) goto break_label;
  ... операторы 
}
break_label:
... продолжение программы

В обоих случаях, если в теле цикла выполнится условие <ошибка>, будет произведён переход на операторы, обозначенные как «продолжение программы». Таким образом, оператор досрочного выхода из цикла, по сути, просто маскирует безусловный переход, однако использование break предпочтительнее, чем goto, поскольку поведение break чётко задано языком, потенциально менее опасно (нет, например, вероятности ошибиться с положением или названием метки). Кроме того, явный досрочный выход из цикла не нарушает принципов структурного программирования.

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

Пропуск итерации

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

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

int arr[ARRSIZE];
...
// Суммирование отдельно всех и только положительных
// элементов массива arr с применением continue.
int sum_all = 0;
int sum_pos = 0;
for (int i = 0 ; i < ARRSIZE; ++i)
{
    sum_all += arr[i];
    if (arr[i] <= 0) continue;
    sum_pos += arr[i];
}

// Аналогичный код c goto
int sum_all = 0;
int sum_pos = 0;
for (int i = 0 ; i < ARRSIZE; ++i)
{
    sum_all += arr[i];
    if (arr[i] <= 0) goto cont_label;
    sum_pos += arr[i];
cont_label:
}

Из второго фрагмента ясно видно, как работает continue: он просто передаёт управление за последнюю команду тела цикла, пропуская выполнение команды суммирования, если очередной элемент массива не удовлетворяет условию. Таким образом, в sum_pos накапливается сумма лишь положительных элементов массива.

Необходимость

С точки зрения структурного программирования команды досрочного выхода из цикла и продолжения итерации являются избыточными, поскольку их действие может быть легко смоделировано чисто структурными средствами. Более того, по мнению ряда теоретиков программирования (в частности, Эдсгера Дейкстры), сам факт использования в программе неструктурных средств, будь то классический безусловный переход или любая из его специализированных форм, таких как break или continue, является свидетельством недостаточно проработанного алгоритма решения задачи.

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

// Досрочный выход из цикла без break
bool flag = false; // флаг досрочного завершения
while(<условие> && !flag) {
  ... операторы
  if (<ошибка>) {
    flag = true;
  } else {
    ... операторы
  }
}
... продолжение программы

Легко убедиться, что фрагмент будет работать аналогично предшествующим, разница лишь в том, что в месте проверки на ошибку вместо непосредственного выхода из цикла устанавливается флаг досрочного выхода, который проверяется позже в штатном условии продолжения цикла. Однако для отказа от команды досрочного выхода пришлось добавить в программу описание флага и вторую ветвь условного оператора, к тому же произошло «размытие» логики программы (решение о досрочном выходе принимается в одном месте, а выполняется в другом). В результате программа не стала ни проще, ни короче, ни понятнее.

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

int arr[ARRSIZE];
...
// Суммирование отдельно всех и только положительных
// элементов массива arr с заменой continue
int sum_all = 0;
int sum_pos = 0;
for (int i = 0 ; i < ARRSIZE; ++i)
{
    sum_all += arr[i];
    if (arr[i] > 0) // Условие заменено на противоположное!
    {
      sum_pos += arr[i];
    }
}

Как видим, достаточно было заменить проверяемое условие на противоположное и поместить заключительную часть тела цикла в условный оператор. Можно заметить, что программа стала короче (за счёт удаления команды пропуска итерации) и одновременно логичнее (из кода непосредственно видно, что суммируются положительные элементы).

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

int arr[ARRSIZE];
...
int sum_all = 0;
int sum_pos = 0;
int i = 0;
while (i < ARRSIZE) // Цикл внешне аналогичен предыдущему for ...
{
    sum_all += arr[i];
    if (arr[i] <= 0) continue;
    sum_pos += arr[i];
    ++i; // ... но эта команда будет пропущена при выполнении continue 
         // и программа зациклится
}

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

Вложенные циклы

Существует возможность организовать цикл внутри тела другого цикла. Такой цикл будет называться вложенным циклом. Вложенный цикл по отношению к циклу, в тело которого он вложен, будет именоваться внутренним циклом, и наоборот, цикл, в теле которого существует вложенный цикл, будет именоваться внешним по отношению к вложенному. Внутри вложенного цикла, в свою очередь, может быть вложен ещё один цикл, образуя следующий уровень вложенности и так далее. Количество уровней вложенности, как правило, не ограничивается.

Полное число исполнений тела внутреннего цикла не превышает произведения числа итераций внутреннего и всех внешних циклов. Например, взяв три вложенных друг в друга цикла, каждый по 10 итераций, получим 10 исполнений тела для внешнего цикла, 100 для цикла второго уровня и 1000 в самом внутреннем цикле.

Одна из проблем, связанных с вложенными циклами — организация досрочного выхода из них. Во многих языках программирования есть оператор досрочного завершения цикла (break в Си, exit в Турбо Паскале, last в Perl и т. п.), но он, как правило, обеспечивает выход только из цикла того уровня, откуда вызван. Вызов его из вложенного цикла приведёт к завершению только этого внутреннего цикла, внешний же цикл продолжит выполняться. Проблема может показаться надуманной, но она действительно иногда возникает при программировании сложной обработки данных, когда алгоритм требует немедленного прерывания в определённых условиях, наличие которых можно проверить только в глубоко вложенном цикле.

Решений проблемы выхода из вложенных циклов несколько.

• Простейший — использовать оператор безусловного перехода goto для выхода в точку программы, непосредственно следующую за вложенным циклом. Этот вариант критикуется сторонниками структурного программирования, как и все конструкции, требующие использования goto. Некоторые языки программирования, например, Модула-2, просто не имеют оператора безусловного перехода, и в них подобная конструкция невозможна.
• Альтернатива — использовать штатные средства завершения циклов, в случае необходимости устанавливая специальные флаги, требующие немедленного завершения обработки. Недостаток — усложнение кода, снижение производительности.
• Размещение вложенного цикла в процедуре. Идея состоит в том, чтобы всё действие, которое может потребоваться прервать досрочно, оформить в виде отдельной процедуры, и для досрочного завершения использовать оператор выхода из процедуры (если такой есть в языке программирования). В языке Си, например, можно построить функцию с вложенным циклом, а выход из неё организовать с помощью оператора return. Недостаток — выделение фрагмента кода в процедуру не всегда логически обосновано, и не все языки имеют штатные средства досрочного завершения процедур.
• Воспользоваться механизмом генерации и обработки исключений (исключительных ситуаций), который имеется сейчас в большинстве языков высокого уровня. В этом случае в нештатной ситуации код во вложенном цикле возбуждает исключение, а блок обработки исключений, в который помещён весь вложенный цикл, перехватывает и обрабатывает его. Недостаток — реализация механизма обработки исключений в большинстве случаев такова, что скорость работы программы уменьшается. Правда, в современных условиях это не особенно важно: практически потеря производительности столь мала, что имеет значение лишь для очень немногих приложений.
• Наконец, существуют специальные языковые средства для выхода из вложенных циклов. Так, в языке Ада программист может пометить цикл (верхний уровень вложенного цикла) меткой, и в команде досрочного завершения цикла указать эту метку. Выход произойдёт не из текущего цикла, а из всех вложенных циклов до помеченного, включительно^[3]. Язык PHP предоставляет возможность указать число прерываемых циклов после команды break — так break 2 прервёт сам цикл и вышестоящий над ним, а break 1 эквивалентно простой записи команды break^[4].

Циклы с несколькими охраняемыми ветвями

Цикл Дейкстры

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

 do
   P1 → S1,
     …
   Pn → Sn
 od

Здесь do — маркер начала конструкции цикла, od — маркер завершения конструкции цикла, P_i — i-е охраняющее условие (логическое выражение, которое может иметь значение «истинно» или «ложно»), S_i — i-я охраняемая команда. Цикл состоит из одной или нескольких ветвей (охраняемых выражений), каждая из которых представляет собой пару из охраняющего условия (или, коротко, «охраны») и охраняемой команды (понятно, что в реальности команда может быть сложной).

При выполнении цикла Дейкстры в каждой итерации происходит вычисление охраняющих условий. Если хотя бы одно из них истинно, выполняется соответствующая охраняемая команда, после чего начинается новая итерация (если истинны несколько охраняющих условий, выполняется только одна охраняемая команда). Если все охраняющие условия ложны, цикл завершается. Нетрудно заметить, что цикл Дейкстры с одним охраняющим условием и одной охраняемой командой представляет собой, по сути, обычный цикл с предусловием (цикл «пока»).

Хотя цикл Дейкстры был изобретён ещё в 1970-х годах, специальных конструкций для его создания в языках программирования не содержится. Единственным исключением стал недавно созданный Оберон-07 — первый реальный язык программирования, явно поддерживающий цикл с несколькими охраняемыми ветвями. Впрочем, цикл Дейкстры может быть без больших затруднений смоделирован с помощью традиционных конструкций структурных языков программирования. Вот пример его реализации одним из возможных способов на языке Ада:

loop
  if P1 then 
    S1;
    ...
  elsif Pn then 
    Sn;
  else
    exit;
  end if;
end loop;

Здесь P1—Pn — охраняющие условия, а S1—Sn — соответствующие охраняемые команды.

Цикл Дейкстры удобен при реализации некоторых специфических повторяющихся вычислений, которые неудобно описывать с помощью более традиционных циклических конструкций. Например, этим циклом естественно представляется конечный автомат — каждая ветвь соответствует одному состоянию автомата, охраняемые условия строятся так, чтобы в текущей итерации выбиралась ветвь, соответствующая текущему состоянию автомата, а код охраняемой команды обеспечивает выполнение вычислений в текущем состоянии и переход в следующее (то есть такое изменение переменных, после которого на следующей итерации будет истинным охраняющее условие нужной ветви).

Цикл «паук»

Легко видеть, что цикл Дейкстры не содержит явного условия продолжения или выхода, что не всеми теоретиками программирования рассматривается как благо. Поэтому была предложена усложнённая конструкция цикла Дейкстры, получившая название «цикл-‘паук’». В той же нотации она выглядит следующим образом:

 do
   P1→S1,
     …
   Pn→Sn
 out
   Q1→T1,
     …
   Qn→Tn
 else
   E
 od

Здесь после маркера out добавлены ветви завершения, состоящие из условий выхода Q_i и команд завершения T_i. Кроме того, добавлена ветвь альтернативного завершения else с командой E.

Цикл-‘паук’ выполняется так:

• Вычисляются охраняющие условия. Если существует истинное охраняющее условие, выполняется соответствующая охраняемая команда.
• Вычисляются условия выхода. Если существует истинное условие выхода, выполняется соответствующая команда завершения, после чего выполнение цикла заканчивается. Если все условия выхода ложны, начинается следующая итерация, но только в том случае, если в текущей итерации было истинным хотя бы одно из охраняющих условий.
• Если в данной итерации оказались ложными и все охраняющие условия, и все условия выхода, выполняется команда альтернативного завершения E, после чего выполнение цикла прерывается.

Структура цикла-‘паука’ позволяет предельно строго описать условия выполнения цикла. Согласно теоретическим положениям, ветвь альтернативного завершения не должна использоваться в качестве одного из вариантов корректного прекращения работы цикла (все такие варианты должны быть оформлены в виде соответствующих ветвей завершения с явным условием), она служит только для того, чтобы отследить ситуацию, когда по каким-то причинам цикл начал выполняться нештатно. То есть команда альтернативного завершения может лишь анализировать причины ошибки и представлять результаты анализа.

Хотя явной поддержки на уровне синтаксиса для этого цикла не существует ни в одном языке программирования, цикл-‘паук’, как и цикл Дейкстры, может быть смоделирован с помощью традиционных структурных конструкций.

Методы оптимизации циклов

эквивалентными преобразованиями исходного кода

компилятором

См. также

Примечания

Ссылки

Понимание метода fit_one_cycle Фастая | IconOf.com

TL; DR: fit_one_cycle () использует большие циклические скорости обучения, чтобы обучать модели значительно быстрее и с большей точностью.

При обучении моделей глубокого обучения с помощью Fastai рекомендуется использовать метод fit_one_cycle () , благодаря его лучшей производительности в скорости и точности, по сравнению с методом fit () . Короче говоря, fit_one_cycle () — это реализация Fastai политики Лизли Смита на 1 цикл .Смит разработал, усовершенствовал и опубликовал свою методологию в трех научных статьях:

1. Курсов циклического обучения для обучения нейронных сетей (2017)
2. Супер-конвергенция: очень быстрое обучение нейронных сетей с использованием больших скоростей обучения (2018)
3. Дисциплинированный подход к гиперпараметрам нейронной сети: Часть 1 — скорость обучения, размер партии, импульс и снижение веса (2018)

В этой статье мы рассмотрим основные концепции политики 1cycle и попытаемся понять, почему этот метод работает лучше.

Проблема со скоростью обучения

Обучение глубокой нейронной сети (DNN) — сложная проблема глобальной оптимизации. Скорость обучения (LR) является критически важным гиперпараметром для настройки при обучении DNN. Очень малая скорость обучения может привести к очень медленному обучению, в то время как очень большая скорость обучения может препятствовать сближению, поскольку функция потерь колеблется около минимума или даже расходится.

Слишком маленький LR (0,01). Модель не сходится в течение 100 эпох. Требуется больше эпох и времени:

Хорошо LR (0.1). Модель успешно сходится в течение 100 эпох:

Оптимальный LR (0,7). Модель успешно, очень быстро сходится менее чем за 10 эпох:

Большой LR (0,99). Модель не сходится, так как функция потерь колеблется около минимума:

Слишком большой LR (1,01). Модель быстро расходится с :

(Графики портала Хосе Фернандеса)

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

На практике скорость обучения не является статичной, а изменяется по мере развития обучения. Желательно начать с оптимальной скорости обучения (для скорости) и постепенно снижать ее до конца (для точности).Есть два способа достичь этого: графики скорости обучения и методы адаптивной скорости обучения.

Графики скорости обучения — это математические формулы, которые снижают скорость обучения с использованием определенной стратегии (затухание по времени, затухание по ступеням, затухание по экспоненте и т. Д.). Эта стратегия / расписание устанавливается до начала обучения и остается неизменной на протяжении всего процесса обучения. Таким образом, графики скорости обучения не могут адаптироваться к конкретным характеристикам набора данных. Адаптивные методы обучения (Adagrad, Adadelta, RMSprop, Adam и т. Д.) Решают эту проблему, но требуют больших вычислительных ресурсов.См. «Обзор алгоритмов оптимизации градиентного спуска» (Ruder, 2016) для углубленного анализа.

курсов обучения

Смит обнаружил новый метод задания скорости обучения, названный Cyclical Learning Rates (CLR). Вместо использования фиксированной или уменьшающейся скорости обучения, метод CLR позволяет непрерывно колебаться в диапазоне между разумными минимальными и максимальными границами.

Один цикл CLR состоит из двух этапов; тот, в котором скорость обучения увеличивается, и тот, в котором она уменьшается.Каждый шаг имеет размер (называемый , размер шага ), который представляет собой количество итераций (например, 1k, 5k и т. Д.), В которых скорость обучения увеличивается или уменьшается. Два шага образуют цикл. Конкретно, цикл CLR с размером шага 5000 будет состоять из 5000 + 5000 = 10000 полных итераций. Политика CLR может состоять из нескольких циклов.

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

На приведенном выше рисунке показана точность обучения набора данных CIFAR-10 за 70000 итераций. Фиксированная скорость обучения (синяя линия) достигает 81,4% точности после 70 000 итераций, в то время как метод CLR (красная линия) достигает того же в течение 25 000 итераций.

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

Циклические скорости обучения эффективны, потому что они могут успешно согласовывать седловые точки, которые обычно имеют небольшие градиенты (плоские поверхности) и могут замедлять обучение, когда скорость обучения мала. Лучший способ преодолеть такие препятствия — это ускоряться и двигаться быстро, пока не будет найдена искривленная поверхность. Повышение скорости обучения CLR делает это эффективно.

Седловая точка (красная)

Тест на дальность обучения

Смит также разработал простой метод оценки разумных границ минимальной и максимальной скорости обучения; тест дальности LR .Тест включает в себя запуск модели для нескольких эпох, где скорость обучения начинается с низкого значения и линейно увеличивается до высокого значения. График точности в зависимости от скорости обучения показывает, когда точность начинает увеличиваться и когда она замедляется, становится неровной или снижается. На следующем тестовом графике диапазона LR показаны две точки, которые являются хорошими кандидатами на минимальные и максимальные границы:

График испытаний дальности LR

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

Суперконвергенция и политика 1 цикла

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

Суперконвергенция использует метод CLR, но только с одним циклом, который содержит два шага скорости обучения, один увеличивается, а другой уменьшается, и имеет большую максимальную границу скорости обучения. Размер цикла должен быть меньше, чем общее количество итераций / эпох.После завершения цикла скорость обучения должна уменьшиться еще больше для оставшихся итераций / эпох, на несколько порядков меньше, чем ее первоначальное значение. Смит назвал это 1cycle policy .

Конкретно, в супер-конвергенции, скорость обучения начинается с низкого значения, увеличивается до очень большого значения, а затем уменьшается до значения, намного меньшего, чем его первоначальное значение . Эффект этого движения скорости обучения является очень характерной кривой точности обучения .Традиционные кривые точности обучения увеличиваются, затем плато по мере изменения значения скорости обучения (см. Синюю кривую ниже). Кривые точности обучения супер-конвергенции (см. Красную кривую ниже) имеют драматический начальный скачок (движется быстро при увеличении скорости обучения), колеблются или даже немного снижаются (в то время как скорость обучения очень велика), а затем снова поднимаются до характерного пик точности (когда скорость обучения уменьшается до очень малого значения).

Пример кривой точности обучения супер-сходимости

Смит обнаружил, что большая скорость обучения действует как метод регуляризации .Следовательно, при использовании политики 1 цикла другие методы регуляризации (размер партии, импульс, снижение веса и т. Д.) Должны быть сокращены.

Как Fastai реализует политику 1 цикла

Fastai абстрагирует все детали реализации политики 1cycle и предоставляет интуитивно понятный интерфейс в виде fit_one_cycle () . Последний вызывает внутреннюю функцию fit () , добавляя обратный вызов OneCycleScheduler :

  def fit_one_cycle (учиться: учащийся, cyc_len: int,
    max_lr: Союз [поплавки, ломтик] = по умолчанию.lr, мам: Tuple [float, float] = (0,95,0,85),
    div_factor: float = 25., pct_start: float = 0.3, wd: float = None,
    обратные вызовы: Необязательно [CallbackList] = Нет, tot_epochs: int = Нет,
    start_epoch: INT = 1) -> None:
    «Установите модель, следуя политике 1 цикла».

    max_lr = learn.lr_range (max_lr)
    обратные вызовы = listify (обратные вызовы)
    callbacks.append (OneCycleScheduler (учиться, max_lr, мам = мам,
      div_factor = div_factor, pct_start = pct_start,
      tot_epochs = tot_epochs, start_epoch = start_epoch))

    learn.fit (cyc_len, max_lr, wd = wd, callbacks = callbacks)  

Вызов fit_one_cycle () с несколькими базовыми параметрами позволяет нам с минимальными усилиями воспользоваться преимуществами политики 1 цикла.

.

callbacks.one_cycle | Фастай

Переключить навигацию fastai

• Nav
• GitHub
• Новости

• Начиная
  • Установка
  • Дополнительная информация по установке
  • Устранение неисправностей
  • Производительность
  • Поддержка
• Повышение квалификации
  • Обзор
  • basic_train
  • поезд
  • метрик
  • обратный вызов
  • обратные вызовы
    • Обзор
    • HookCallback
    • MixedPrecision
    • OneCycleScheduler
    • LRFinder
    • MixUpCallback
    • RNNTrainer
    • GeneralScheduler
    • CSV Logger
    Отслеживание
    • Тензорная доска
    • Профилирование памяти
    • Разное
• Приложения
  • Обзор
  • видение
    • Обзор
    • видение.ученик
    • vision.interpret
    • vision.transform
    • vision.image
    • видение.данные
    • vision.gan
    • vision.model обзор
    • vision.models.unet
  • текст
    • Обзор
    • текст.ученик
    • text.interpret
    • text.transform
    • text.data
    • текст.модели
  • табличный
    • Обзор
    • tabular.transform
    • табличный.данные
    • tabular.models
    • tabular.learner
  • виджеты
    • виджетов.class_confusion
    • widgets.image_cleaner
  • коллаб
• ядро
  • Обзор
  • блок данных
  • basic_data
  • слоя
  • наборов данных
  • ядро ​​
  • torch_core
  • импорт
• Utils
  • Помощники
  • Управление памятью
  • помощников ipython
  • Дисплей утилит
• Учебники
  • Обзор
  • Посмотрите на данные
  • ученик логического вывода
  • Custom ItemList
  • DL на шнурке
  • Распределенное обучение
• Док авторинг
  • Инструкции
  • gen_doc
  • gen_doc.gen_notebooks

.

Поиск хорошей скорости обучения и политика одного цикла. | by nachiket tanksale

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

Градиентный спуск с малыми (вверху) и большими (внизу) скоростями обучения.Источник: курс по машинному обучению Эндрю Нга

Поиск и установка правильной скорости обучения — это все больше проб и ошибок. Наивный способ состоит в том, чтобы попробовать разные скорости обучения и выбрать тот, который дает наименьшее значение потерь, не жертвуя скоростью обучения (потеря валидации также имеет значение для недостаточного или избыточного соответствия).

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

При прохождении практического углубленного обучения для программистов, часть 1 mooc, упоминалось о работе «Циклические курсы обучения для обучения нейронных сетей » Лесли Н. Смита.

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

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

Идея состоит в том, чтобы начать с небольшой скорости обучения (например, 1e-4, 1e-3) и увеличивать скорость обучения после каждой мини-партии, пока потери не начнут взрываться.Как только потери начнут взрываться, остановите тестовый прогон. График зависимости скорости обучения от потерь. Выберите скорость обучения на порядок ниже, чем скорость обучения, где потери минимальны (если потеря низкая на уровне 0,1, хорошее значение для начала — 0,01). Это значение, при котором потери все еще уменьшаются. Бумага предлагает, чтобы это было хорошим значением скорости обучения для модели.

Пробный запуск на CIFAR-10 с размером партии 512, резнет 56, импульс = 0,9 и спад массы = 1e-4. Скорость обучения ~ 10⁰, то есть где-то около 1 можно использовать.

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

n = число итераций
max_lr = максимальная скорость обучения, которая будет использоваться.Обычно мы используем более высокие значения
, такие как 10, 100. Обратите внимание, что мы не можем достичь этого значения lr во время проверки диапазона.
init_lr = более низкая скорость обучения. Мы начнем тестирование диапазона с этого значения. Мы используем очень маленькое значение, как 1e-3, 1e-4.
Позвольте, q быть фактором, с помощью которого мы увеличиваем скорость обучения после каждой мини-партии.
На рисунке ниже показано уравнение для определения скорости обучения после i-й мини-партии.

Как только мы находим оптимальную скорость обучения, мы используем ее для обучения модели. Тест на дальность — очень полезный инструмент, поскольку он дает возможность найти хорошую скорость обучения с небольшим количеством запусков эпох.

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

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

Седловая точка на поверхности ошибки (Img Credit: safaribooksonline )

Цикл — это число итераций, когда мы переходим от скорости обучения к нижней границе и обратно к нижней границе. Цикл может не иметь границ в эпоху, но на практике это обычно бывает. Ступенька — это половина цикла. Итак, Stepsize — это количество итераций, где мы хотим, чтобы скорость обучения переходила от одной границы к другой.

Циклическая скорость обучения (Изображение: https: // arxiv.org / pdf / 1506.01186.pdf )

В статье «Дисциплинированный подход к гиперпараметрам нейронной сети: Часть 1 — скорость обучения, размер партии, импульс и снижение веса», Лесли Смит описывает подход к установке гипер- параметры (а именно скорость обучения, импульс и снижение веса) и размер партии. В частности, он предлагает политику «1 цикл» для применения ставок обучения.

Автор рекомендует сделать один цикл обучения из 2 шагов одинаковой длины. Мы выбираем максимальную скорость обучения, используя тест дальности.Мы используем более низкую скорость обучения как 1/5 или 1/10 от максимальной скорости обучения. Мы переходим от более низкой скорости обучения к более высокой скорости обучения на шаге 1 и обратно к более низкой скорости обучения на шаге 2. Мы выбираем эту продолжительность цикла немного меньше, чем общее количество эпох, которые необходимо обучить. И в последних оставшихся итерациях мы уничтожаем скорость обучения намного ниже значения скорости обучения (1/10 или 1/100).

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

CIFAR -10: один цикл для скорости обучения = 0,08–0,8, размер партии 512, снижение веса = 1e-4, resnet-56

Как и на рисунке, мы начинаем со скорости обучения 0,08 и делаем шаг в 41 эпоху, чтобы достичь скорости обучения 0,8, затем сделайте еще один шаг из 41 эпох, где мы вернемся к уровню обучения 0,08. Затем мы делаем еще 13 эпох, чтобы достичь 1/10 от нижней границы скорости обучения (0,08).

С CLR 0,08–0,8, размер партии 512, импульс 0.9 и Resnet-56, мы получили точность ~ 91,30% за 95 эпох на CIFAR-10.

Другой блог студента по науке о данных — политика 1 цикла

Здесь мы углубимся в первую часть работы Лесли Смита о настройке гиперпараметров (а именно скорости обучения, импульса и снижения веса). В частности, его политика 1cycle дает очень быстрые результаты для обучения сложных моделей. В качестве примера, мы увидим, как это позволяет нам обучать реснет-56 на cifar10 с той же или лучшей точностью, чем авторы в их оригинальная статья, но с гораздо меньшими итерациями.

Тренируясь с высокой скоростью обучения, мы можем достичь модели, которая достигает 93% точности в 70 эпохах , что меньше, чем 7 000 итераций (в отличие от 64 000 итераций, которые в оригинальной статье составили около 360 эпох).

Этот блокнот содержит все эксперименты. Они выполняются с тем же увеличением данных, что и в этой оригинальной статье, с одним небольшим изменением: мы случайным образом переворачиваем изображение по горизонтали и случайным кадрированием после добавления отступа 4 пикселя на каждой стороне. Небольшой твик заключается в том, что мы не окрашиваем дополняемые пиксели в черный, а используем отступ с отражением, поскольку он реализован в библиотеке Фастая. Вероятно, поэтому мы получаем немного лучшие результаты, чем Лесли, когда проводим эксперименты с теми же гиперпараметрами.{-2} \) кажется хорошей идеей.

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

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

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

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

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

На этом графике скорость обучения росла с 0,08 до 0,8 между эпохами 0 и 41, возвращаясь к 0,08 между эпохами 41 и 82, затем достигая одной сотой 0,08 в последние несколько эпох. Мы можем видеть, как потеря проверки становится немного более изменчивой в течение части цикла с высокой скоростью обучения (в основном эпох с 20 по 60), но важной частью является что в среднем расстояние между потерей обучения и потерей проверки не увеличивается. Мы действительно начинаем тренироваться только в конце цикла, когда скорость обучения уничтожается.

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

На этом графике скорость обучения поднималась с 0.15–3 между эпохами 0 и 22,5, возвращаясь к 0,15 между эпохами 22,5 и 45, затем достигая одной сотой от 0,15 в последнем несколько эпох. С очень высокой скоростью обучения, мы учимся быстрее, и предотвращают переоснащение. Разница между потерей при проверке и потерей обучения остается чрезвычайно низкой до тех пор, пока мы не уничтожим скорость обучения. Это явление, которое Лесли Смит описывает как супер-конвергенцию.

С помощью этой техники мы можем обучить resnet-56 для получения 92.Точность 3% на cifar10 всего за 50 эпох. Переход к циклу из 70 эпох дает нам точность 93%.

В противоположность этому, меньший цикл с более продолжительным уничтожением приведет к чему-то вроде этого:

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

Циклический импульс

Чтобы сопровождать движение к более высоким скоростям обучения, Лесли обнаружил в своих экспериментах, что уменьшение импульса приводит к лучшим результатам.Это поддерживает интуицию, что в В этой части обучения мы хотим, чтобы SGD быстро пошел в новых направлениях, чтобы найти более плоскую область, поэтому новым градиентам нужно придать больший вес. На практике он рекомендует выбрать два значения, таких как 0,85 и 0,95, и понизить значение с более высокого до более низкого при увеличении скорости обучения, а затем вернуться к более высокому импульсу в процессе обучения. Скорость снижается.

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

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

Все остальные параметры имеют значение

То, как мы настроим все остальные гиперпараметры модели, повлияет на лучшую скорость обучения. Вот почему, когда мы запускаем Finder Rate Learning, очень важно использовать его с теми же условиями, что и во время наших тренировок. Например, различные размеры партий или снижение веса будут влиять на результаты:

Это может быть полезно для установки некоторых гиперпараметров.{-4} \) использовано в наших экспериментах.

По его мнению, размер партии должен быть установлен на максимально возможное значение, чтобы поместиться в доступную память. Тогда другие гиперпараметры, которые у нас могут быть (например, отсев), могут настроиться так же, как снижение веса, или просто примерить цикл и посмотреть результаты, которые они дают. Единственное, что никогда не забывайте перезапускать программу обучения, особенно при принятии решения выбрать стратегию с агрессивной скоростью обучения, близкой к максимально возможному значению.

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

,