Что делает оператор while

Если в операторе while тело цикла составляет один оператор, то фигурные скобки можно опустить.

while ( Условие ) // Заголовок оператора цикла 
Один оператор, тело цикла // Тело цикла - один оператор

Правило исполнения оператора while

Пока Условие оператора while является истинным: передать управление первому оператору тела цикла, а после выполнения всех операторов тела цикла передать управление в заголовок для проверки истинности Условия. Если условие оператора while является ложным, передать управление оператору, следующему за оператором while.

Задача 12. Вычислить коэффициент Фибоначчи с точностью до 10-го знака.

Кратко охарактеризуем коэффициент Фибоначчи. Итальянский математик Леонардо Фибоначчи обнаружил уникальную последовательность чисел:

1 1 2 3 5 8 13 21 34 55 89 144 233 .

Каждое число в этой последовательности является суммой двух предыдущих чисел. Представленная последовательность чисел обладает уникальными свойствами: отношение любого числа к предыдущему равно 1.618, а к следующему — 0,618. Коэффициент 1.618 получил название коэффициента Фибоначчи, а указанная последовательность называется последовательностью Фибоначчи (отметим также, что 0,3819 — сопряжённая величина для коэффициента Фибоначчи, получена в результате его умножения на самого себя: 0.3819 = 0.618 х 0.618).

Задача состоит в том, чтобы вычислить коэффициент Фибоначчи более точно. Если проанализировать коэффициент Фибоначчи для нескольких десятков элементов последовательности, то становится очевидным, что полученные коэффициенты колеблются вокруг иррационального числа 1.61803398875. принимая поочерёдно то большие, то меньшие значения. Чем большие числа из последовательности участвуют в вычислениях, тем меньше отклонение от указанного значения.

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

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

//--------------------------------------------------------------------
// fibonacci.mq4
// Предназначен для использования в качестве примера в учебнике MQL4.
//--------------------------------------------------------------------
int start() // Спец. ф-ия start() 

//-------------------------------------------------------------------- 
int i; // Формальн параметр,счётчик 
double 
A,B,C, // Числа последовательности 
Delta, // Фактич. разница между Кф 
D; // Заданная точность
//-------------------------------------------------------------------- 
A=1; // Начальное значение 
B=1; // Начальное значение 
C=2; // Начальное значение 
D=0.0000000001; // Задаём точность 
Delta=1000.0; // Начальное значение
//-------------------------------------------------------------------- 
while(Delta > D) // Заголовок оператора цикла 
 // Скобка начала тела цикла 
i++; // Счётчик 
A=B; // Следующее значение 
B=C; // Следующее значение 
C=A + B; // Следующее значение 
Delta=MathAbs(C/B - B/A); // Искомая разница между Кф 
> // Скобка конца тела цикла
//-------------------------------------------------------------------- 
Alert("C=",C," Число Фибоначчи=",C/B," i=",i);//Сообщение на экран 
return; // Выход из start() 
>
//--------------------------------------------------------------------

В начале программы производится объявление переменных (и даётся их описание). В последующих строках переменным присваиваются численные значения. А, В и С получают значения первых чисел последовательности Фибоначчи. Здесь необходимо отметить, что, хотя в самой последовательности идёт речь о целых числах, частное от их деления должно быть учтено в программе как действительное число. Если бы в данном случае был использован тип int для этих чисел, то не было бы возможности вычислить коэффициент Фибоначчи, например, 8/5 = 1 (целое число 1, то есть без дробной части). Поэтому в данном случае использован тип переменных double. Собственно оператор цикла выглядит так:

while(Delta > D) // Заголовок оператора цикла 
 // Скобка начала тела цикла 
i++; // Счётчик 
A=B; // Следующее значение 
B=C; // Следующее значение 
C=A + B; // Следующее значение 
Delta=MathAbs(C/B - B/A); // Искомая разница между Кф 
> // Скобка конца тела цикла

Рассмотрим функциональную схему оператора цикла while:

Рис. 42. Функциональная схема исполнения оператора while в программе fibonacci.mq4.

Оператор цикла начинает свою работу с проверки условия. Многократное выполнение цикла будет повторяться до тех пор, пока условие (Delta>D) является истинным. Понимание кода программы существенно упрощается, если при чтении операторов произносить ключевую фразу — правило исполнения. Например, при чтении оператора while это фраза: «До тех пор пока . выполнять следующее: ..«. В данном случае заголовок оператора while звучит так: до тех пор, пока Delta больше D, выполнять следующее.. И далее можно перейти к анализу программных строк, составляющих тело цикла и исполняемых в случае истинности этого Условия.

Перед тем как управление в приведенном примере fibonacci.mq4 передано оператору цикла while, значения этих переменных соответственно равны 1000.0 и 0.0000000001, поэтому при первом обращении к оператору цикла условие является истинным. Это значит, что после проверки условия управление будет передано первому оператору, составляющему тело оператора цикла.

В данном примере — это оператор:

i++; // Счётчик

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

A = B; // Следующее значение 
B = C; // Следующее значение 
C = A + B; // Следующее значение

Легко увидеть, что переменные принимают значения следующих (ближайших больших) элементов. Если до исполнения оператора цикла значения А, В и С были равны соответственно 1.0, 1.0 и 2.0, то в процессе первой итерации эти переменные принимают значения 1.0, 2.0 и 3.0.

Итерация — повторное выполнение некоторых вычислений; используется для обозначения факта исполнения программных строк, составляющих тело оператора цикла.

В следующей строке вычисляется интересующая нас разница между коэффициентами Фибоначчи, полученным на основе последующих (C/B) и предыдущих (B/A) элементов последовательности:

Delta = MathAbs(C/B - B/A); // Искомая разница между Кф

В этом операторе используется стандартная функция MathAbs(), вычисляющая абсолютное значение выражения. Ранее указывалось, что по мере увеличения значений элементов последовательности, коэффициенты Фибоначчи принимают поочерёдно то большие, то меньшие значения, в сравнении с «эталоном». Поэтому разница между соседними коэффициентами будет принимать то отрицательное, то положительное значение. В то же время, нас интересует собственно величина этого отклонения, т.е. её абсолютное значение. Таким образом, независимо от того, в какую сторону отклонилось текущее значение коэффициента Фибоначчи, значением выражения MathAbs(C/B — B/A), а также значением переменной Delta, всегда будет положительное число.

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

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

Этот процесс будет продолжаться до тех пор, пока условие оператора цикла не станет ложным. В момент, когда значение переменной Delta окажется меньше или равным значению D, условие (Delta > D) перестанет соответствовать истине, а значит управление будет передано за пределы оператора цикла, в строку:

Alert("C=",C," Число Фибоначчи=",C/B," i=",i);//Сообщение на экран

В результате на экране появится окно оператора Alert(), в котором будет напечатано следующее:

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

Здесь нужно заметить, что действительные числа в MQL4 вычисляются с точностью до 15-го знака. В то же время, коэффициент Фибоначчи отражён с точностью до 3-го знака. Это произошло потому, что свойством функции Alert() является отображение чисел с точностью до 4-го знака, но все последние ноли при этом не отображаются. Если бы у нас возникла необходимость отобразить на экране число Фибоначчи с некоторой наперёд заданной точностью, то нам пришлось бы несколько изменить код, например, так:

Alert("C=",C," Число Фибоначчи=",C/B*10000000," i=",i);// Сообщение

Особо нужно отметить следующее:

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

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

При зацикливании программа бесконечно исполняет блок операторов, составляющих тело цикла. Вот простой пример оператора цикла while с зацикливанием:

int i=1; // Формальн параметр (счётчик) 
while (i > 0) // Заголовок оператора цикла 
i++; // Увеличение значения i

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

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

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

Циклы while и for

При написании скриптов зачастую встаёт задача сделать однотипное действие много раз.

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

Для многократного повторения одного участка кода предусмотрены циклы.

Циклы for…of и for…in

Небольшое объявление для продвинутых читателей.

В этой статье рассматриваются только базовые циклы: while , do..while и for(..;..;..) .

Если вы пришли к этой статье в поисках других типов циклов, вот указатели:

• См. for…in для перебора свойств объекта.
• См. for…of и Перебираемые объекты для перебора массивов и перебираемых объектов.

В противном случае, продолжайте читать.

Цикл «while»

Цикл while имеет следующий синтаксис:

while (condition) < // код // также называемый "телом цикла" >

Код из тела цикла выполняется, пока условие condition истинно.

Например, цикл ниже выводит i , пока i < 3 :

let i = 0; while (i < 3) < // выводит 0, затем 1, затем 2 alert( i ); i++; >

Одно выполнение тела цикла по-научному называется итерация. Цикл в примере выше совершает три итерации.

Если бы строка i++ отсутствовала в примере выше, то цикл бы повторялся (в теории) вечно. На практике, конечно, браузер не позволит такому случиться, он предоставит пользователю возможность остановить «подвисший» скрипт, а JavaScript на стороне сервера придётся «убить» процесс.

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

Например, while (i) – более краткий вариант while (i != 0) :

let i = 3; while (i) < // когда i будет равно 0, условие станет ложным, и цикл остановится alert( i ); i--; >

Фигурные скобки не требуются для тела цикла из одной строки

Если тело цикла состоит лишь из одной инструкции, мы можем опустить фигурные скобки :

let i = 3; while (i) alert(i--);

Цикл «do…while»

Проверку условия можно разместить под телом цикла, используя специальный синтаксис do..while :

do < // тело цикла >while (condition);

Цикл сначала выполнит тело, а затем проверит условие condition , и пока его значение равно true , он будет выполняться снова и снова.

let i = 0; do < alert( i ); i++; >while (i < 3);

Такая форма синтаксиса оправдана, если вы хотите, чтобы тело цикла выполнилось хотя бы один раз, даже если условие окажется ложным. На практике чаще используется форма с предусловием: while(…) .

Цикл «for»

Более сложный, но при этом самый распространённый цикл — цикл for .

Выглядит он так:

for (начало; условие; шаг) < // . тело цикла . >

Давайте разберёмся, что означает каждая часть, на примере. Цикл ниже выполняет alert(i) для i от 0 до (но не включая) 3 :

for (let i = 0; i < 3; i++) < // выведет 0, затем 1, затем 2 alert(i); >

Рассмотрим конструкцию for подробней:

В целом, алгоритм работы цикла выглядит следующим образом:

Выполнить начало → (Если условие == true → Выполнить тело, Выполнить шаг) → (Если условие == true → Выполнить тело, Выполнить шаг) → (Если условие == true → Выполнить тело, Выполнить шаг) → . 

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

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

Вот в точности то, что происходит в нашем случае:

// for (let i = 0; i < 3; i++) alert(i) // Выполнить начало let i = 0; // Если условие == true → Выполнить тело, Выполнить шаг if (i < 3) < alert(i); i++ >// Если условие == true → Выполнить тело, Выполнить шаг if (i < 3) < alert(i); i++ >// Если условие == true → Выполнить тело, Выполнить шаг if (i < 3) < alert(i); i++ >// . конец, потому что теперь i == 3

Встроенное объявление переменной

В примере переменная счётчика i была объявлена прямо в цикле. Это так называемое «встроенное» объявление переменной. Такие переменные существуют только внутри цикла.

for (let i = 0; i < 3; i++) < alert(i); // 0, 1, 2 >alert(i); // ошибка, нет такой переменной

Вместо объявления новой переменной мы можем использовать уже существующую:

let i = 0; for (i = 0; i < 3; i++) < // используем существующую переменную alert(i); // 0, 1, 2 >alert(i); // 3, переменная доступна, т.к. была объявлена снаружи цикла

Пропуск частей «for»

Любая часть for может быть пропущена.

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

let i = 0; // мы уже имеем объявленную i с присвоенным значением for (; i < 3; i++) < // нет необходимости в "начале" alert( i ); // 0, 1, 2 >

Можно убрать и шаг :

let i = 0; for (; i

Это сделает цикл аналогичным while (i < 3) .

А можно и вообще убрать всё, получив бесконечный цикл:

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

Прерывание цикла: «break»

Обычно цикл завершается при вычислении условия в false .

Но мы можем выйти из цикла в любой момент с помощью специальной директивы break .

Например, следующий код подсчитывает сумму вводимых чисел до тех пор, пока посетитель их вводит, а затем – выдаёт:

let sum = 0; while (true) < let value = +prompt("Введите число", ''); if (!value) break; // (*) sum += value; >alert( 'Сумма: ' + sum );

Директива break в строке (*) полностью прекращает выполнение цикла и передаёт управление на строку за его телом, то есть на alert .

Вообще, сочетание «бесконечный цикл + break » – отличная штука для тех ситуаций, когда условие, по которому нужно прерваться, находится не в начале или конце цикла, а посередине или даже в нескольких местах его тела.

Переход к следующей итерации: continue

Директива continue – «облегчённая версия» break . При её выполнении цикл не прерывается, а переходит к следующей итерации (если условие все ещё равно true ).

Её используют, если понятно, что на текущем повторе цикла делать больше нечего.

Например, цикл ниже использует continue , чтобы выводить только нечётные значения:

for (let i = 0; i < 10; i++) < // если true, пропустить оставшуюся часть тела цикла if (i % 2 == 0) continue; alert(i); // 1, затем 3, 5, 7, 9 >

Для чётных значений i , директива continue прекращает выполнение тела цикла и передаёт управление на следующую итерацию for (со следующим числом). Таким образом alert вызывается только для нечётных значений.

Директива continue позволяет избегать вложенности

Цикл, который обрабатывает только нечётные значения, мог бы выглядеть так:

for (let i = 0; i < 10; i++) < if (i % 2) < alert( i ); >>

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

Однако мы получили дополнительный уровень вложенности фигурных скобок. Если код внутри if более длинный, то это ухудшает читаемость, в отличие от варианта с continue .

Нельзя использовать break/continue справа от оператора „?“

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

Например, если мы возьмём этот код:

if (i > 5) < alert(i); >else

…и перепишем его, используя вопросительный знак:

(i > 5) ? alert(i) : continue; // continue здесь приведёт к ошибке

…то будет синтаксическая ошибка.

Это ещё один повод не использовать оператор вопросительного знака ? вместо if .

Метки для break/continue

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

Например, в коде ниже мы проходимся циклами по i и j , запрашивая с помощью prompt координаты (i, j) с (0,0) до (2,2) :

for (let i = 0; i < 3; i++) < for (let j = 0; j < 3; j++) < let input = prompt(`Значение на координатах ($,$)`, ''); // Что если мы захотим перейти к Готово (ниже) прямо отсюда? > > alert('Готово!');

Нам нужен способ остановить выполнение, если пользователь отменит ввод.

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

Метка имеет вид идентификатора с двоеточием перед циклом:

labelName: for (. )

Вызов break в цикле ниже ищет ближайший внешний цикл с такой меткой и переходит в его конец.

outer: for (let i = 0; i < 3; i++) < for (let j = 0; j < 3; j++) < let input = prompt(`Значение на координатах ($,$)`, ''); // если пустая строка или Отмена, то выйти из обоих циклов if (!input) break outer; // (*) // сделать что-нибудь со значениями. > > alert('Готово!');

В примере выше это означает, что вызовом break outer будет разорван внешний цикл до метки с именем outer .

Таким образом управление перейдёт со строки, помеченной (*) , к alert('Готово!') .

Можно размещать метку на отдельной строке:

outer: for (let i = 0; i

Директива continue также может быть использована с меткой. В этом случае управление перейдёт на следующую итерацию цикла с меткой.

Метки не позволяют «прыгнуть» куда угодно

Метки не дают возможности передавать управление в произвольное место кода.

Например, нет возможности сделать следующее:

break label; // не прыгает к метке ниже label: for (. )

Директива break должна находиться внутри блока кода. Технически, подойдет любой маркированный блок кода, например:

label: < // . break label; // работает // . >

…Хотя в 99.9% случаев break используется внутри циклов, как мы видели в примерах выше.

К слову, continue возможно только внутри цикла.

Итого

Мы рассмотрели 3 вида циклов:

• while – Проверяет условие перед каждой итерацией.
• do..while – Проверяет условие после каждой итерации.
• for (;;) – Проверяет условие перед каждой итерацией, есть возможность задать дополнительные настройки.

Чтобы организовать бесконечный цикл, используют конструкцию while (true) . При этом он, как и любой другой цикл, может быть прерван директивой break .

Если на данной итерации цикла делать больше ничего не надо, но полностью прекращать цикл не следует – используют директиву continue .

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

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

Что делает оператор while

Цикл while (“пока”) позволяет выполнить одну и ту же последовательность действий, пока проверяемое условие истинно. Условие записывается до тела цикла и проверяется до выполнения тела цикла. Как правило, цикл while используется, когда невозможно определить точное значение количества проходов исполнения цикла.

Синтаксис цикла while в простейшем случае выглядит так:

while условие: блок инструкций

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

Например, следующий фрагмент программы напечатает на экран квадраты всех целых чисел от 1 до 10. Видно, что цикл while может заменять цикл for . in range(. ) :

i = 1 while i 
В этом примере переменная i внутри цикла изменяется от 1 до 10. Такая переменная, значение которой меняется с каждым новым проходом цикла, называется счетчиком. Заметим, что после выполнения этого фрагмента значение переменной i будет равно 11 , поскольку именно при i == 11 условие i 
Вот еще один пример использования цикла while для определения количества цифр натурального числа n :
5678
n = int(input()) length = 0 while n > 0: n //= 10 # это эквивалентно n = n // 10 length += 1 print(length)
В этом цикле мы отбрасываем по одной цифре числа, начиная с конца, что эквивалентно целочисленному делению на 10 ( n //= 10 ), при этом считаем в переменной length , сколько раз это было сделано.
В языке Питон есть и другой способ решения этой задачи: .
2. Инструкции управления циклом

После тела цикла можно написать слово else: и после него блок операций, который будет выполнен один раз после окончания цикла, когда проверяемое условие станет неверно:
i = 1 while i 
Казалось бы, никакого смысла в этом нет, ведь эту же инструкцию можно просто написать после окончания цикла. Смысл появляется только вместе с инструкцией break . Если во время выполнения Питон встречает инструкцию break внутри цикла, то он сразу же прекращает выполнение этого цикла и выходит из него. При этом ветка else исполняться не будет. Разумеется, инструкцию break осмыленно вызывать только внутри инструкции if , то есть она должна выполняться только при выполнении какого-то особенного условия.
Приведем пример программы, которая считывает числа до тех пор, пока не встретит отрицательное число. При появлении отрицательного числа программа завершается. В первом варианте последовательность чисел завершается числом 0 (при считывании которого надо остановиться).
3 6 -1 4 0
a = int(input()) while a != 0: if a < 0: print('Встретилось отрицательное число', a) break a = int(input()) else: print('Ни одного отрицательного числа не встретилось')
Во втором варианте программы сначала на вход подается количество элементов последовательности, а затем и сами элементы. В таком случае удобно воспользоваться циклом for . Цикл for также может иметь ветку else и содержать инструкции break внутри себя.
3 6 2 4
n = int(input()) for i in range(n): a = int(input()) if a < 0: print('Встретилось отрицательное число', a) break else: print('Ни одного отрицательного числа не встретилось')
Другая инструкция управления циклом — continue (продолжение цикла). Если эта инструкция встречается где-то посередине цикла, то пропускаются все оставшиеся инструкции до конца цикла, и исполнение цикла продолжается со следующей итерации.
Если инструкции break и continue содержатся внутри нескольких вложенных циклов, то они влияют лишь на исполнение самого внутреннего цикла. Вот не самый интеллектуальный пример, который это демонстрирует:
for i in range(3): for j in range(5): if j > i: break print(i, j)
Увлечение инструкциями break и continue не поощряется, если можно обойтись без их использования. Вот типичный пример плохого использования инструкции break (данный код считает количество знаков в числе).
n = int(input()) length = 0 while True: length += 1 n //= 10 if n == 0: break print('Длина числа равна', length)
Гораздо лучше переписать этот цикл так:
n = int(input()) length = 0 while n != 0: length += 1 n //= 10 print('Длина числа равна', length)
Впрочем, на Питоне можно предложить и более изящное решение:
n = int(input()) print('Длина числа равна', len(str(n)))
3. Множественное присваивание

В Питоне можно за одну инструкцию присваивания изменять значение сразу нескольких переменных. Делается это так:
a, b = 0, 1
Этот код можно записать и так:
a = 0 b = 1
Отличие двух способов состоит в том, что множественное присваивание в первом способе меняет значение двух переменных одновременно.
Если слева от знака «=» в множественном присваивании должны стоять через запятую имена переменных, то справа могут стоять произвольные выражения, разделённые запятыми. Главное, чтобы слева и справа от знака присваивания было одинаковое число элементов.
Множественное присваивание удобно использовать, когда нужно обменять значения двух переменных. В обычных языках программирования без использования специальных функций это делается так:
a = 1 b = 2 tmp = a a = b b = tmp print(a, b) # 2 1
В Питоне то же действие записывается в одну строчку:
a = 1 b = 2 a, b = b, a print(a, b) # 2 1


Похожие публикации:

Debian как найти какому пакету принадлежит файл
Как перенести строку в js
Как сделать больше карту в роблокс студио
Как убрать мигающий курсор в браузере