Арифметические операции в bash скрипте

Синтаксис цикла while

В самом простом случае, цикл в python очень похож по своей структуре на условную конструкцию с

И в том и в другом случае, блок кода внутри (инструкция ) будет исполнен тогда и только тогда, когда условие будет иметь значение . Вот только в конструкции с , при успешной проверке, вывод на экран будет выполнен всего один раз, а в случае с фраза «I’m the loop» будет печататься бесконечно.

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

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

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

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

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

Автоматическое дополнение

При выполнении cd писать полное название директории необязательно.

Если из домашней директории вы хотите перейти в Documents, достаточно набрать
Doc и нажать Tab.

Если вы наберете просто D и нажмёте Tab, то Bash не поймёт куда вы хотите перейти —
в Desktop, Documents или в Downloads, поэтому ничего не произойдёт (в Zsh сразу появится подсказка).
Но если вы
нажмёте Tab ещё раз — появится подсказка, а именно список всех директорий, название
которых начинается на D

cd D

Desktop/ Documents/ Downloads/

Чтобы перейти в родительскую директорию выполните

cd ..

Чтобы узнать полный путь до текущей директории выполните

pwd

Приоритет и ассоциативность операторов

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

• Постфиксный инкремент и декремент
• Префиксный инкремент и декремент , унарные операторы и
• Мультипликативные операторы , , и
• Аддитивные операторы и

Бинарные арифметические операторы имеют левую ассоциативность. То есть операторы с одинаковым приоритетом вычисляются в направлении слева направо.

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

Полный список операторов C#, упорядоченный по уровню приоритета, можно найти в разделе статьи Операторы C#.

Как изменить порядок вычисления

Порядок вычисления логических операторов меняют круглые скобки — так же, как в арифметике:

Добавив круглые скобки, мы поменяли приоритеты для вычисления. Теперь сперва будет определено выражение (true ^ true), которое вернёт false. А после — вычислится выражение false & false, которое тоже вернёт false.

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

Пример посложнее — выражение !(true && (false || true)) ^ !false.

Порядок вычисления:

1. !(true && (false || true)) ^ !false
2. !(true && true) ^ !false
3. !true ^ !false
4. false ^ !false
5. false ^ true
6. true

Обновлённый оператор switch в Java 14

С версии 14 Java поддерживает новый синтаксис switch:

Теперь нам не нужно писать break, а двоеточие заменено на стрелочку и фигурные скобки. Блок default по-прежнему не обязателен.

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

В операторе switch прошлой версии мы задавали одно действие для нескольких значений case, располагая пустые case над case c кодом:

В новой версии для этого хватает одного case, а связанные с ним значения разделяются запятой. Например:

Теперь switch — уже не просто оператор ветвления, он может вернуть значение. Это делается с помощью вспомогательного оператора yield.

Пример:

В новой версии switch, когда нам нужно лишь вернуть значение из соответствующего case (он должен быть без кода), — можно обойтись и без слова yield:

Советы и упрощения

1. Фигурные скобки после if или else разрешено не ставить, если тело блока состоит всего из одной строки.

Однако всё же советую ставить скобки, так вы научитесь быть последовательными и облегчите рефакторинг кода.

2

Вот так писать не следует (внимание на условие в if):. Код будет работать, но сравнение boolean с boolean в условии — это лишняя операция

Код будет работать, но сравнение boolean с boolean в условии — это лишняя операция.

Поскольку метод isMoreFive сам возвращает булево значение — напишите вот так:

Здесь снова ненужное сравнение:

Чтобы не было лишней операции — пишите вот так:

Арифметические операторы

Арифметические операторы используются для выполнения арифметических операций между двумя операндами. Включает в себя операторы +(сложение), -(вычитание), *(умножение), /(деление),%(напоминание), //(деление по полу) и экспоненты(**).

Рассмотрим следующую таблицу для подробного объяснения арифметических операторов.

Оператор	Описание
+(Сложение)	Он используется для добавления двух операндов. Например, если a = 20, b = 10 => a + b = 30
-(Вычитание)	Он используется для вычитания второго операнда из первого операнда. Если первый операнд меньше второго, значение будет отрицательным. Например, если a = 20, b = 10 => a – b = 10
/(деление)	Он возвращает частное после деления первого операнда на второй операнд. Например, если a = 20, b = 10 => a / b = 2,0
*(Умножение)	Он используется для умножения одного операнда на другой. Например, если a = 20, b = 10 => a * b = 200
%(Остаток от деления)	Он возвращает напоминание после деления первого операнда на второй операнд. Например, если a = 20, b = 10 => a% b = 0
**(возведение в степень)	Это экспоненциальный оператор, представленный при вычислении степени первого операнда для второго операнда.
//(целочисленное деление)	Он дает минимальное значение частного, полученного при делении двух операндов.

Где нужны значения типа Boolean

Булевы значения и условные выражения часто используются в условиях операторов ветвления, тернарного оператора и циклов.

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

Оператор ветвления позволяет выбрать и исполнить определённый блок кода в зависимости от срабатывания некоторого условия.

Есть два оператора ветвления (условные конструкции): if-else и switch.

Оператор if

Его синтаксис выглядит так:

if (условие) {

//код

} else {

//код

}

В круглых скобках после if указывают условное выражение (высказывание). Если оно истинно (то есть результат его вычисления равен true), то выполняется код в фигурных скобках после условия, иначе выполняется код по ветке else (если она есть).

Примеры:

Проверяем условие в круглых скобках:

3 > 2?

Если да, то в консоль выводим: «Высказывание в скобках правдивое», иначе ничего не выводим.

Так как 3 и правда больше 2, то в консоли появилось наше сообщение.

Печатаем «Высказывание в скобках правдивое», если результат вычислений в круглых скобках = true. В ином случае выводим: «Высказывание в скобках ложное».

Так как выражение (3 < 2) возвращает false, то и в консоли видим: «Высказывание в скобках ложное».

Вложенные конструкции

Допустим, мы хотим проверить некое условие, и если оно не выполнилось — проверить другое условие и так далее. Сделать это можно двумя способами.

1. Вложенный if

Синтаксис тут такой:

if (условие1) {

//действия, если условие1 выполнено;

} else {

if (условие2) {

//действия, если условие2 выполнено;

}

<…>

else {

//действия, если все предыдущие условия не выполнились;

}

Пример:

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

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

Синтаксически это выглядит так:

if (условие1) {

//действия, если условие1 выполнено;

}

else if (условие2) {

//действия, если условие2 выполнено;

}

else if (условие3) {

//действия, если условие3 выполнено;

}

<…>

else {

//действия, если условие последнего if тоже не выполнилось;

}

Пример:

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

Иногда условий else if нужно довольно много:

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

Зачем нужен else при работе с циклами?

Оператор else в циклах выполняется только в том случае, если цикл выполнен успешно. Главная задача оператора else, это поиск объектов:

Python

my_list =

for i in my_list:
if i == 3:
print(«Item found!»)
break
print(i)
else:
print(«Item not found!»)

1 2 3 4 5 6 7 8 9

my_list=1,2,3,4,5 foriinmy_list ifi==3 print(«Item found!») break print(i) else print(«Item not found!»)

В этом коде мы разорвали цикл, когда i равно 3. Это приводит к пропуску оператора else. Если вы хотите провести эксперимент, вы можете изменить условное выражение, чтобы посмотреть на значение, которое находится вне списка, и которое приведет оператор else к выполнению. Честно, ни разу не видел, чтобы кто-либо использовал данную структуру за все годы работы. Большая часть примеров, которые я видел, приведена блогерами, которые пытаются объяснить, как это работает. Я видел несколько людей, которые использовали эту структуру для провоцирования ошибки, когда объект не удается найти в искомом цикле. Вы можете почитать статью, в которой вопрос рассматривается весьма детально. Статья написана одним из разработчиков ядра Python.

Сложение строк при помощи бинарного +

Давайте рассмотрим специальные возможности операторов JavaScript, которые выходят за рамки школьной арифметики.

Обычно при помощи плюса складывают числа.

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

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

Например:

Как видите, не важно, первый или второй операнд является строкой. Вот пример посложнее:

Вот пример посложнее:

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

Сложение и преобразование строк — это особенность бинарного плюса . Другие арифметические операторы работают только с числами и всегда преобразуют операнды в числа.

Например, вычитание и деление:

Параметрический цикл for

Общая форма записи

for (Инициализация; Условие; Модификация){  БлокОпераций;}

for

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

 
Эти три операции записываются в скобках и разделяются точкой с запятой ;;. Как правило, параметром цикла является целочисленная переменная.Инициализация параметра осуществляется только один раз — когда цикл for начинает выполняться.
Проверка Условия повторения цикла осуществляется перед каждым возможным выполнением тела цикла. Когда выражение, проверяющее Условие становится ложным (равным нулю), цикл завершается. Модификация параметра осуществляется в конце каждого выполнения тела цикла. Параметр может как увеличиваться, так и уменьшаться.Пример на Си: Посчитать сумму чисел от 1 до введенного k

123456789101112131415

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf#include <stdio.h>int main() {  int k;  // объявляем целую переменную key  int sum = 0; // начальное значение суммы равно 0  printf(«k = «);  scanf(«%d», &k);   // вводим значение переменной k  for(int i=1; i<=k; i++) // цикл для переменной i от 1 до k с шагом 1  {    sum = sum + i; // добавляем значение i к сумме  }  printf(«sum = %d\n», sum); // вывод значения суммы  getchar(); getchar();  return 0;}

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

12345678910111213141516

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf#include <stdio.h>int main() {  int k;  // объявляем целую переменную key  int sum = 0; // начальное значение суммы равно 0  printf(«k = «);  scanf(«%d», &k);   // вводим значение переменной k  int i=1;  for(; i<=k; i++) // цикл для переменной i от 1 до k с шагом 1  {    sum = sum + i; // добавляем значение i к сумме  }  printf(«sum = %d\n», sum); // вывод значения суммы  getchar(); getchar();  return 0;}

1234567891011121314151617

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf#include <stdio.h>int main() {  int k;  // объявляем целую переменную key  int sum = 0; // начальное значение суммы равно 0  printf(«k = «);  scanf(«%d», &k);   // вводим значение переменной k  for(int i=1; i<=k; ) // цикл для переменной i от 1 до k с шагом 1  {    sum = sum + i; // добавляем значение i к сумме    i++;           // добавляем 1 к значению i  }  printf(«sum = %d\n», sum); // вывод значения суммы  getchar(); getchar();  return 0;}

forзапятая,запятаяПример на Си

12345678910111213

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf#include <stdio.h>int main() {  int k;  // объявляем целую переменную key  printf(«k = «);  scanf(«%d», &k);   // вводим значение переменной k  for(int i=1, j=2; i<=k; i++, j+=2) // цикл для переменных  {                                  // (i от 1 до k с шагом 1) и (j от 2 с шагом 2)    printf(«i = %d   j = %d\n», i, j); // выводим значения i и j  }  getchar(); getchar();  return 0;}

Двойные скобки

Результат выполнения команды можно легко сохранить в переменную.

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

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

expansion_example.sh

Разберём этот скрипт:

Строка 4 — Базовый синтаксис. Можно ставить пробелы без использования кавычек.

Строка 7 — Работает и без пробелов.

Строка 10 — Можно использовать переменные без $ перед ними.

Строка 13 — А можно и с $

Строка 16 — Увеличение переменной на 1. Символ $ не нужен.

Строка 19 — Увеличение переменной на 3. Это краткая форма записи b = b &plus; 3.

Строка 19 — В отличие от других способов символ * не нужно экранировать.

./expansion_example.sh

981112131620

Двойные скобки дают довольно много свободы в форматировании кода.

Они доступны в Bash по умолчанию и их эффективность немного выше. Хотя заметить разницу на современных компьютерах будет непросто.

Сложные задачи

1. Дано целое число N (> 1). Найти наименьшее целое число K, при котором выполняется неравенство 3^K > N, где 3^K — это 3 в степени K или число 3, умноженное само на себя K раз. Например, 3^5 = 3*3*3*3*3. Ответом в задаче будет первая степень числа 3, которая больше, чем заданное число N. Например, если N=41, распишем степени числа три: 3^1 = 3; 3^2 = 3*3 = 9; 3^3 = 3*3*3 = 27; 3^4 = 3*3*3*3 = 27 * 3 = 81;. Таким образом, первая степень, в которую возвести число 3, превышающая число N — это 4. В этой задаче нужно выполнять цикл while, пока остаток от деления на число три равен

2. Дано целое число N (> 0). Используя операции деления нацело и взятия остатка от деления, вывести все его цифры, начиная с самой правой (разряда единиц). Перед решением этой задачи вспомните, как найти сумму цифр трехначного числа.

3. Даны целые положительные числа A и B. Найти их наибольший общий делитель (НОД), используя алгоритм Евклида: НОД(A, B) = НОД(B, A mod B), если B = 0; НОД(A, 0) = A.

4. Спортсмен-лыжник начал тренировки, пробежав в первый день 10 км. Каждый следующий день он увеличивал длину пробега на P процентов от пробега предыдущего дня (P — вещественное, 0

5. Дано целое число N (> 1). Последовательность чисел Фибоначчи FK определяется следующим образом: F(1) = 1, F(2) = 1, F(K) = F(K-2) + F(K-1), K = 3, 4, …. Проверить, является ли число N числом Фибоначчи. Если является, то вывести TRUE, если нет — вывести FALSE.

6. Даны положительные числа A, B, C. На прямоугольнике размера A x B размещено максимально возможное количество квадратов со стороной C (без наложений). Найти количество квадратов, размещенных на прямоугольнике. Операции умножения и деления не использовать.

7. Дано целое число N (> 1), являющееся числом Фибоначчи: N = F(K). Найти целое число K — порядковый номер числа Фибоначчи N.

Побитовые операторы

Побитовые операторы работают с 32-разрядными целыми числами (при необходимости приводят к ним), на уровне их внутреннего двоичного представления.

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

Поддерживаются следующие побитовые операторы:

• AND(и) ( )
• OR(или) ( )
• XOR(побитовое исключающее или) ( )
• NOT(не) ( )
• LEFT SHIFT(левый сдвиг) ( )
• RIGHT SHIFT(правый сдвиг) ( )
• ZERO-FILL RIGHT SHIFT(правый сдвиг с заполнением нулями) ( )

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

ОПЕРАТОРЫ ЯЗЫКА ПАСКАЛЬ

Оператором называется предложение языка программирования, задающее полное описание некоторого действия, которое необходимо выполнить. Основная часть программы на языке Турбо Паскаль представляет собой последовательность операторов. Разделителем операторов служит точка с запятой. Операторы, не содержащие других операторов, называются простыми. К ним относятся операторы присваивания, безусловного перехода, вызова процедуры, пустой. Структурные операторы представляют собой конструкции, построенные из других операторов по строго определенным правилам. Эти операторы можно разделить на три группы: составные, условные и повтора.

Циклы. Цикл for-in

Оператор for-in предназначен для поочередного обращения к значениям перечисленным в списке. Каждое значение поочередно в списке присваивается переменной. Синтаксис следующий:

for переменная in список_значений
do
  команды
done

Рассмотрим небольшой пример:

#!/bin/bash
for i in  1 2 3 4 #переменной $i будем поочередно присваивать значения от 0 до 4 включительно
do
echo "Console number is $i" >> devpts$i #Пишем в файл /dev/pts/$i(файл виртуального терминала) строку "Console number is $i"
done #цикл окончен
exit 

После выполнения примера в первых 5 виртуальных консолях (терминалах) появится строка с её номером. В переменную $i поочередно подставляются значения из списка и в цикле идет работа со значением этой переменной.

Как логические операторы работают с целыми числами

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

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

Можно. Внутри Java все целочисленные типы представлены двоичными числами разной длины. И к ним уже применимы бинарные логические операторы ^, | и &.

Только в этом случае они работают с двоичным представлением операндов — выполняют операции над их битами попарно (рассматривая их как логические единицы и нули). Поэтому и сами операторы ^, | и & зовутся побитовыми.

Как ^, | и & работают с целочисленными операндами

Рассмотрим пример:

Чтобы повторить вычисления Java, нужно:

1. Перевести значения обоих операндов в двоичную систему счисления.
2. Расположить результаты перевода друг под другом.
3. Сравнять в них число разрядов (дополнить лидирующими нулями).
4. Применить к битам из каждого столбца оператор (&, | или ^).
5. Записать результат каждой операции ниже в том же столбце.
6. Перевести итог в десятичную форму.

Потренируемся: вычислим сами 3 & 5

Число 3 в двоичной системе счисления имеет вид 11, а число 5 — 101.

Так как у числа 5 три разряда в двоичной системе, а у числа 3 — всего два, добавим лидирующий ноль к числу 3 в двоичной системе и получим 011.

Берём цифры из обоих чисел и применяем к ним попарно оператор & (AND):

3(10) = 011(2)	1	1
	&	&	&
5(10) = 101(2)	1	1
	=	=	=
001(2) = 1(10)	1

1.2. Как прервать цикл while на Python.

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

prompt = «Введите любое слово, и оно будет выведено наоборот»
prompt += «Если надоело введите команду ‘стоп’.»
message = »while message != «стоп»:
    message = input(prompt)    
     message != «стоп»:
        print(message)
    :
        print(«Программа завершена»)

В начале создаем сообщение prompt (посказку) которое объясняет пользователю что за программа и как ее можно завершить. Затем создается переменная message и ей присваивается пустое значение

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

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

Введите любое слово, и оно будет выведено наоборот
Если надоело введите команду ‘стоп’.python лучший язык программированияяинавориммаргорп кызя йишчул nohtyp

Введите любое слово, и оно будет выведено наоборот
Если надоело введите команду ‘стоп’.123456789987654321

Введите любое слово, и оно будет выведено наоборот
Если надоело введите команду ‘стоп’.стопПрограмма завершена

Пока пользователь не введет слово «стоп», цикл будет начинаться заново.

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

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

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

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

Вот примеры кода:

В этом фрагменте был создан двумерный массив chars, по которому мы прошли с помощью одного цикла for, вложенного в другой — тоже for. Для каждой итерации внешнего цикла выполняются все итерации вложенного в него внутреннего. Таким образом, для массива размерности 5 на 5 будет совершено 25 итераций — внешний цикл идёт по строкам, внутренний — по столбцам.

Ещё пример, но теперь уже трёх вложенных циклов:

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

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

Как видно из примера, ожидаемого результата (прекратить работу обоих циклов, если найдено число 5) мы не получили. В таких ситуациях можно использовать, например, проверку с помощью boolean-значения:

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

Присваивание

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

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

Тот факт, что является оператором, а не «магической» конструкцией языка, имеет интересные последствия.

Большинство операторов в JavaScript возвращают значение. Для некоторых это очевидно, например сложение или умножение . Но и оператор присваивания не является исключением.

Вызов записывает в и возвращает его.

Благодаря этому присваивание можно использовать как часть более сложного выражения:

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

Забавное применение присваивания, не так ли? Нам нужно понимать, как это работает, потому что иногда это можно увидеть в JavaScript-библиотеках.

Однако писать самим в таком стиле не рекомендуется. Такие трюки не сделают ваш код более понятным или читабельным.

Рассмотрим ещё одну интересную возможность: цепочку присваиваний.

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

Опять-таки, чтобы код читался легче, лучше разделять подобные конструкции на несколько строчек:

Польза от такого стиля особенно ощущается при быстром просмотре кода.