Какой шаг изменения переменной в цикле for
Введение в программирование
Видео может быть заблокировано из-за расширений браузера. В статье вы найдете решение этой проблемы.
Транскрипт урока
Этот урок будет быстрым и простым, так что пристегнитесь.
Вызовем функцию факториала с циклом while:
const factorial = (n) => {
let counter = 1;
let result = 1;
while (counter <= n) {
result = result * counter;
counter = counter + 1;
}
return result;
}
Когда мы работаем с переменными, мы часто поступаем так: меняем их значения, прибавляя к ним сколько-нибудь или умножая их на что-то. Или просто прибавляем или вычитаем единицу.
Как и во многих других языках программирования в JavaScript есть для этого упрощенные формы.
Вместо result = result * counter вы можете сказать result *= counter. Результат будет тот же самый, это просто способ сократить запись. Точно так же вы можете поступить со знаками плюс, минус и разделить:
result *= counter; // то же, что result = result * counter
result += counter; // то же, что result = result + counter
result -= counter; // то же, что result = result – counter
result %= counter; // то же, что result = result % counter
Добавление единицы к переменной — тоже очень типичная операция, поэтому вместо counter = counter + 1 можно записать counter++. Так же для минуса — counter = counter – 1 равносильно counter–. Это операторы инкрементирования и декрементирования.
Есть два вида, проще их понять на примере:
// Postfix
let a = 3;
let b;
b = a++; // b = 3, a = 4
// Prefix
let a = 3;
let b;
b = ++a; // b = 4, a = 4
Если вы поставите ++ после имени переменной — это постфиксная нотация — то фактическое сложение произойдёт после того, как значение вернётся. Вот почему b тут 3: оно получает значение перед тем как меняется a.
Если вы поставите ++ перед именем переменной — это префиксная нотация — то фактическое сложение произойдёт перед тем, как значение вернётся. Вот почему b тут 4: оно получает значение после того как меняется a.
Но в конце в обоих случаях a становится 4.
Это обновлённая функция факториала:
const factorial = (n) => {
let counter = 1;
let result = 1;
while (counter <= n) {
result *= counter;
counter++;
}
return result;
}
Здесь не имеет значения, используем мы префикс или постфикс когда инкрементируем counter, потому что значение не хранится больше нигде.
Этот код немного проще и короче. Иметь цикл — этот повторяющийся код — со счётчиком контролирующим повторения — распространённый в программировании приём. Поэтому кроме цикла while существует цикл for. В нем есть встроенные счетчики.
Это та же функция факториала, но с циклом for вместо цикла while:
const factorial = (n) => {
let result = 1;
for (let counter = 1; counter <= n; counter++) {
result *= counter;
}
return result;
}
Здесь три момента:
- Инициализация счётчика.
- Условие цикла. Так же как и в цикле while, этот цикл будет повторяться пока это условие истинно.
- Обновление счётчика. Как менять счётчик в каждом шаге.
А затем следует тело, код, который должен повторяться. Нам не нужно менять счётчик в теле, потому что он будет меняться, благодаря этому выражению сверху.
Пришло время использовать все эти навороченные знания и написать код! Переходите к тесту и упражнению прямо сейчас!
Дополнение к уроку
Скрытые сложности
Операции декремента и инкремента кажутся мощными механизмами, но их использование привносит ненужную сложность в программы. Код, написанный с их использованием, часто превращается в ребус. Попробуйте ответить, чему равно значение:
let x = 5;
let y = 10;
console.log(x++ + ++y);
Как видите, этот код заставляет думать, так как кроме арифметических выражений, мы имеем дело с побочными эффектами.
Во многих языках таких операций нет в принципе. Линтеры (программы, проверяющие код на соответствие стандартам) в JS настроены так, чтобы “ругаться” при виде этих операций в коде. Вместо них предлагается делать так:
x += 1; // x = x + 1;
Что гораздо проще и понятнее. Да, не получится записать выражение в одну строку, но сам код будет очевидным и без сюрпризов.
Соответствующее правило в eslint: https://eslint.org/docs/rules/no-plusplus
Switch
Конструкция switch может заменить собой несколько условий if. Вот пример обычного условия с if:
let answer;
if (num === 1) {
answer = “One”;
} else if (num === 2) {
answer = “Two”;
} else {
answer = “Nothing”;
}
А вот как его можно переписать с помощью switch:
switch(num) {
case 1: // if (num === 1)
answer = “One”;
break;
case 2: // if (num === 2)
answer = “Two”;
break;
default:
answer = “Nothing”;
break;
}
break необходим, чтобы выйти из блока switch. Если break отсутствует, то выполнение пойдёт ниже по следующим случаям, игнорируя проверки. break также можно использовать в циклах for для мгновенного выхода из цикла.
Если в примере выше убрать все break’и, а num равен 1, то выполнятся все строки:
answer = “One”;
answer = “Two”;
answer = “Nothing”;
}
Так что в итоге answer будет иметь значение “Nothing”.
Несколько значений case можно группировать.
switch(num) {
case 1: // if (num === 1)
answer = “One”;
break;
case 2: // if (num === 2)
case 3: // if (num === 3)
case 4: // if (num === 4)
answer = “Two to four”;
break;
default:
answer = “Nothing”;
break;
}
Выводы
Арифметические шорткаты:
b *= a; // same as b = b * a
b += a; // same as b = b + a
b -= a; // same as b = b – a
b %= a; // same as b = b % a
Операторы инкрементирования и декрементирования:
// Postfix
let a = 3;
let b;
b = a++; // b = 3, a = 4
// Prefix
let a = 3;
let b;
b = ++a; // b = 4, a = 4
Пример цикла:
const factorial = (n) => {
let result = 1;
// initialization↓ condition↓ update↓
for (let counter = 1; counter <= n; counter++) {
result *= counter;
}
return result;
}
Тут следует упомянуть о том, что все 3 выражения в цикле for не обязательны.
Например, в блоке инициализации не требуется определять переменные:
let counter = 1;
for (; counter <= n; counter++) {
// любой код
}
Как и блок инициализации, блок условия не обязателен. Если пропустите это выражение, вы должны быть уверены, что прервете цикл где-то в теле, а не создадите бесконечный цикл.
for (let counter = 1;; counter++) {
if (counter <= n) break;
// любой код
}
Вы можете пропустить все 3 блока. Снова убедитесь, что используете break, чтоб закончить цикл, а также изменить счётчик так, чтоб условие для break было истинно в нужный момент.
let counter = 1;
for (;;) {
if (counter <= n) break;
// любой код
counter++;
}
Обратите внимание на то, что если внутри тела цикла использовать оператор return, то его выполнение будет прервано и функция вернет значение.
// Функция должна посчитать сумму всех чисел от 1 до n
const sum = (n) => {
let result = 0;
for (let counter = 1; counter <= n; counter++) {
return 10; // return прерывает цикл
result += counter;
}
return result;
}
sum(5); // 10
sum(20); // 10
sum(50); // 10
Остались вопросы? Задайте их в разделе «Обсуждение»
Вам ответят команда поддержки Хекслета или другие студенты.
Зарегистрироваться
или
войти в аккаунт
Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно.
115 курсов, 2000+ часов теории
800 практических заданий в браузере
250 000 студентов
Наши выпускники работают в компаниях:
Источник
Обновл. 15 Сен 2020 |
Безусловно, наиболее используемым циклом в языке C++ является цикл for.
Цикл for
Цикл for в языке С++ идеален, когда известно необходимое количество итераций. Выглядит он следующим образом:
for (объявление переменных; условие; инкремент/декремент счетчика)
тело цикла;
Или, преобразуя for в эквивалентный цикл while:
{ // обратите внимание, цикл находится в блоке
объявление переменных;
while (условие)
{
тело цикла;
инкремент/декремент счетчика;
}
} // переменные, объявленные внутри цикла, выходят из области видимости здесь
Переменные, определенные внутри цикла for, имеют специальный тип области видимости: область видимости цикла. Такие переменные существуют только внутри цикла и недоступны за его пределами.
Выполнение цикла for
Цикл for в C++ выполняется в 3 шага:
Шаг №1: Объявление переменных. Как правило, здесь выполняется определение и инициализация счетчиков цикла, а точнее — одного счетчика цикла. Эта часть выполняется только один раз, когда цикл выполняется впервые.
Шаг №2: Условие. Если оно равно false, то цикл немедленно завершает свое выполнение. Если же условие равно true, то выполняется тело цикла.
Шаг №3: Инкремент/декремент счетчика цикла. Переменная увеличивается или уменьшается на единицу. После этого цикл возвращается к шагу №2.
Рассмотрим пример цикла for и разберемся детально, как он работает:
#include <iostream> int main() { for (int count = 0; count < 10; ++count) std::cout << count << ” “; return 0; } |
Сначала мы объявляем переменную count и присваиваем ей значение 0. Далее проверяется условие count < 10, а так как count равен 0, то условие 0 < 10 имеет значение true. Следовательно, выполняется тело цикла, в котором мы выводим в консоль переменную count (т.е. значение 0).
Затем выполняется выражение ++count, т.е. инкремент переменной. Затем цикл снова возвращается к проверке условия. Условие 1 < 10 имеет значение true, поэтому тело цикла выполняется опять. Выводится 1, а переменная count увеличивается уже до значения 2. Условие 2 < 10 является истинным, поэтому выводится 2, а count увеличивается до 3 и так далее.
В конце концов, count увеличивается до 10, а условие 10 < 10 является ложным, и цикл завершается. Следовательно, результат выполнения программы:
0 1 2 3 4 5 6 7 8 9
Циклы for могут быть несколько сложны для новичков, однако опытные кодеры любят их, так как эти циклы очень компактны и удобны. Для наглядности, давайте преобразуем цикл for, приведенный выше, в эквивалентный цикл while:
#include <iostream> int main() { { // внешние скобки нужны для обеспечения области видимости цикла int count = 0; while (count < 10) { std::cout << count << ” “; ++count; } } return 0; } |
Обратите внимание, внешние фигурные скобки здесь необходимы, так как переменная count выходит из области видимости при завершении цикла.
Еще примеры циклов for
Давайте, используя цикл for, напишем функцию вычисления значений в степени n:
int pow(int base, int exponent) { int total = 1; for (int count=0; count < exponent; ++count) total *= base; return total; } |
Функция возвращает значение base^exponent (число в степени n). base — это число, которое нужно возвести в степень, а exponent — это степень, в которую нужно возвести base.
Если экспонент равен 0, то цикл for выполняется 0 раз, и функция возвращает 1.
Если экспонент равен 1, то цикл for выполняется 1 раз, и функция возвращает 1 * base.
Если экспонент равен 2, то цикл for выполняется 2 раза, и функция возвращает 1 * base * base.
Хотя в большинстве циклов используется инкремент счетчика, мы также можем использовать и декремент счетчика:
#include <iostream> int main() { for (int count = 8; count >= 0; –count) std::cout << count << ” “; return 0; } |
Результат:
8 7 6 5 4 3 2 1 0
Также с каждой новой итерацией мы можем увеличить или уменьшить значение счетчика больше, чем на единицу:
#include <iostream> int main() { for (int count = 9; count >= 0; count -= 2) std::cout << count << ” “; return 0; } |
Результат:
9 7 5 3 1
Ошибка неучтенной единицы
Одна из самых больших проблем с которой приходится сталкиваться начинающим программистам в циклах for (а также и в других типах циклов) — это ошибка на единицу (или «ошибка неучтенной единицы»). Она возникает, когда цикл повторяется на 1 раз больше или на 1 раз меньше нужного количества итераций. Это обычно происходит из-за того, что в условии используется некорректный оператор сравнения (например, > вместо >= или наоборот). Как правило, эти ошибки трудно отследить, так как компилятор не будет жаловаться на них, программа будет работать, но её результаты будут неправильными.
При написании циклов for помните, что цикл будет выполняться до тех пор, пока условие является истинным. Рекомендуется тестировать циклы, используя разные значения для проверки работоспособности цикла. Хорошей практикой является проверять циклы с помощью данных ввода (чисел, символов и прочего), которые заставляют цикл выполниться 0, 1 и 2 раза. Если цикл работает исправно, значит всё ОК.
Правило: Тестируйте свои циклы, используя входные данные, которые заставляют цикл выполниться 0, 1 и 2 раза.
Пропущенные выражения в цикле
Также в циклах можно пропускать одно или сразу все выражения, например:
#include <iostream> int main() { int count = 0; for (; count < 10; ) { std::cout << count << ” “; ++count; } return 0; } |
Результат:
0 1 2 3 4 5 6 7 8 9
Инициализацию счетчика мы прописали вне тела цикла, а инкремент счетчика — внутри тела цикла. В самом операторе for мы указали только условие. Иногда бывают случаи, когда не требуется объявлять счетчик цикла (потому что у нас он уже есть) или увеличивать его (так как мы увеличиваем его каким-то другим способом).
Хоть это и не часто можно наблюдать, но в операторе for можно вообще ничего не указывать. Стоит отметить, что подобное приведет к бесконечному циклу:
for (;;)
тело цикла;
Вышеприведенный пример эквивалентен:
while (true)
тело цикла;
Объявления переменных в цикле for
Хотя в циклах for обычно используется только один счетчик, иногда могут возникать ситуации, когда нужно работать сразу с несколькими переменными. Для этого используется оператор Запятая. Например:
#include <iostream> int main() { int aaa, bbb; for (aaa = 0, bbb = 9; aaa < 10; ++aaa, –bbb) std::cout << aaa << ” ” << bbb << std::endl; return 0; } |
Этот цикл присваивает значения двум ранее объявленным переменным: aaa = 0 и bbb = 9. Только с каждой итерацией переменная aaa увеличивается на единицу, а bbb — уменьшается на единицу.
Результат выполнения программы:
0 9
1 8
2 7
3 6
4 5
5 4
6 3
7 2
8 1
9 0
Примечание: Вышеприведенный цикл можно переписать следующим образом:
#include <iostream> int main() { for (int aaa = 0, bbb = 9; aaa < 10; ++aaa, –bbb) std::cout << aaa << ” ” << bbb << std::endl; return 0; } |
В этом случае запятая в объявлении переменных является частью синтаксиса, а не использованием оператора Запятая. Но эффект идентичен.
Использование циклов for в старых версиях С++
В старых версиях C++ переменные, объявленные в цикле for, не уничтожались при завершении этого цикла. Т.е. у вас могло получиться что-то вроде следующего:
for (int count=0; count < 10; ++count) std::cout << count << ” “; // В старых версиях С++ переменная count здесь не уничтожается std::cout << “n”; std::cout << “I counted to: ” << count << “n”; // поэтому мы можем использовать count даже здесь |
Позднее это было запрещено, но вы все еще можете увидеть подобное в старом коде.
Вложенные циклы for
Подобно другим типам циклов, одни циклы for могут быть вложены в другие циклы for. В следующем примере мы разместили один for внутри другого for:
#include <iostream> int main() { for (char c = ‘a’; c <= ‘e’; ++c) // внешний цикл по буквам { std::cout << c; // сначала выводим букву for (int i = 0; i < 3; ++i) // внутренний цикл по числам std::cout << i; std::cout << ‘n’; } return 0; } |
С одной итерацией внешнего цикла выполняется три итерации внутреннего цикла. Следовательно, результат выполнения программы:
a012
b012
c012
d012
e012
Заключение
Циклы for являются наиболее часто используемыми циклами в языке C++. Несмотря на то, что их синтаксис, как правило, немного запутывает начинающих программистов, вы очень скоро к нему привыкните и ощутите всю мощь и удобство этих циклов.
Тест
Задание №1
Напишите цикл for, который выводит каждое четное число в диапазоне от 0 до 20.
Ответ №1
#include <iostream> int main() { for (int count = 0; count <= 20; count += 2) std::cout << count << std::endl; return 0; } |
Задание №2
Напишите функцию sumTo(), которая принимает целочисленный параметр с именем value и возвращает сумму всех чисел от 1 до значения value.
Например, если значением value является 5, то sumTo(5) должен возвратить 15, исходя из 1 + 2 + 3 + 4 + 5.
Подсказка: Используйте переменную вне тела цикла для хранения суммы чисел, как в примере с функцией pow() в подзаголовке «Еще примеры циклов for».
Ответ №2
int sumTo(int value) { int total(0); for (int count=1; count <= value; ++count) total += count; return total; } |
Задание №3
Что не так со следующим циклом?
// Выводим все числа от 8 до 0 for (unsigned int count=8; count >= 0; –count) cout << count << ” “; |
Ответ №3
Этот цикл for выполняется до тех пор, пока count >= 0. Другими словами, он работает до тех пор, пока переменная count не станет отрицательным числом. Однако, поскольку count является типа unsigned, то эта переменная никогда не сможет быть отрицательной. Следовательно, этот цикл бесконечный! Как правило, рекомендуется избегать использования типов unsigned в цикле, если на это нет веских причин.
Оценить статью:
Загрузка…
Источник
Циклы являются мощнейшим инструментом, предоставляемым высокоуровневыми языками программирования. Эти управляющие конструкции позволяют многократно выполнять требуемую последовательность инструкций. Циклы в языке Python представлены двумя основными конструкциями: while и for. Подробнее о циклах while вы можете прочитать здесь.
Применение циклов
Концепция циклов – это не просто очередная абстрактная выдумка программистов. Повторяющиеся раз за разом операции окружают нас и в реальной жизни:
???? добление щепотки приправ в варящийся бульон и помешивание его до тех пор, пока пакетик специй не закончится,
???? следование строгому расписанию каждый будний день, пока не наступят долгожданные выходные,
???? даже банальная смена времён год,
– всё это циклы, и представить нормальную жизнь без них попросту невозможно.
Впрочем, то же касается и программирования. Представьте, что вам нужно последовательно напечатать числа от 1 до 9999999999. В отсутствии циклов, эту задачу пришлось бы выполнять ручками, что потребовало бы колоссального количества кода и огромных временных затрат:
print(1)
print(2)
print(3)
# …
# 9999999995 строк
# …
print(9999999998)
print(9999999999)
Циклы же позволяют уместить такую многокилометровую запись в изящную и простую для понимания конструкцию, состоящую всего из двух строчек:
for i in range(1, 10000000000):
print(i)
Смысл её крайне прост. В основе цикла for лежат последовательности, и в примере выше это последовательность чисел от 1 до 9999999999. for поэлементно её перебирает и выполняет код, который записан в теле цикла. В частности, для решения данной задачи туда была помещена инструкция, позволяющая выводить значение элемента последовательности на экран.
Итерации
- Итерация (Iteration) – это одно из повторений цикла (один шаг или один “виток” циклического процесса). К примеру цикл из 3-х повторений можно представить как 3 итерации.
- Итерируемый объект (Iterable) – объект, который можно повторять. Проще говоря это объект, который умеет отдавать по одному результату за каждую итерацию.
- Итератор (iterator) – итерируемый объект, в рамках которого реализован метод __next__, позволяющий получать следующий элемент.
???? Чтобы выполнить итерацию, Python делает следующее:
- Вызывает у итерируемого объекта метод iter(), тем самым получая итератор.
- Вызывает метод next(), чтобы получить каждый элемент от итератора.
- Когда метод next возвращает исключение StopIteration, цикл останавливается.
Схема работы цикла “for” в Python
Пример создания итерируемого объекта
Для того чтобы создать собственный класс итерируемого объекта, нужно всего лишь внутри него реализовать два метода: __iter__() и __next__():
- внутри метода __next__ () описывается процедура возврата следующего доступного элемента;
- метод __iter__() возвращает сам объект, что даёт возможность использовать его, например, в циклах с поэлементным перебором.
Создадим простой строковый итератор, который на каждой итерации, при получении следующего элемента (т.е. символа), приводит его к верхнему регистру:
class ToUpperCase:
def __init__(self, string_obj, position=0):
“””сохраняем строку, полученную из конструктора,
в поле string_obj и задаём начальный индекс”””
self.string_obj = string_obj
self.position = position
def __iter__(self):
“”” возвращаем сам объект “””
return self
def __next__(self):
“”” метод возвращает следующий элемент,
но уже приведенный к верхнему регистру “””
if self.position >= len(self.string_obj):
# исключение StopIteration() сообщает циклу for о завершении
raise StopIteration()
position = self.position
# инкрементируем индекс
self.position += 1
# возвращаем символ в uppercase-e
return self.string_obj[position].upper()
low_python = “python”
high_python = ToUpperCase(low_python)
for ch in high_python:
print(ch, end=””)
> PYTHON
Синтаксис for
Как было замечено, цикл for python – есть средство для перебора последовательностей. С его помощью можно совершать обход строк, списков, кортежей и описанных выше итерируемых объектов.
В простейшем случае он выглядит так:
for item in collection:
# do something
Если последовательность collection состоит, скажем, из 10 элементов, for будет поочерёдно обходить их, храня значение текущего элемента в переменной item.
Принцип работы for максимально схож с таковым у циклов foreach, применяемых во многих других высокоуровневых языках.aliceQuote = “The best way to explain it is to do it.”
# с помощью цикла for посчитаем количество символов (с пробелами) в строке
# зададим счетчик
count = 0
# будем посимвольно обходить весь текст
for letter in aliceQuote:
# на каждой новой итерации:
# в переменной letter будет храниться следующий символ предложения;
# увеличиваем счетчик на 1;
count += 1
print(count)
> 39
range() и enumerate()
Вы уже наверняка запомнили, что for работает с последовательностями. В программировании очень часто приходится повторять какую-то операцию фиксированное количество раз. А где упоминается “количество чего-то”, существует и последовательность, числовая.
???? Для того чтобы выполнить какую-либо инструкцию строго определенное число раз, воспользуемся функцией range():
# скажем Миру привет целых пять раз!
for i in range(5):
print(“Hello World!”)
>
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
range() можно представлять, как функцию, что возвращает последовательность чисел, регулируемую количеством переданных в неё аргументов. Их может быть 1, 2 или 3:
- range(finish);
- range(start, finish);
- range(start, finish, step).
Здесь start – это первый элемент последовательности (включительно), finish – последний (не включительно), а step – разность между следующим и предыдущим членами последовательности.
# 0 – начальный элемент по умолчанию
for a in range(3):
print(a)
>
1
2
# два аргумента
for b in range(7, 10):
print(b)
>
7
8
9
# три аргумента
for c in range(0, 13, 3):
print(c)
>
3
6
9
12
???? Чрезвычайно полезная функция enumerate() определена на множестве итерируемых объектов и служит для создания кортежей на основании каждого из элементов объекта. Кортежи строятся по принципу (индекс элемента, элемент), что бывает крайне удобно, когда помимо самих элементов требуется ещё и их индекс.
# заменим каждый пятый символ предложения, начиная с 0-го, на *
text = “Это не те дроиды, которых вы ищете”
new_text = “”
for char in enumerate(text):
if char[0] % 5 == 0:
new_text += ‘*’
else:
new_text += char[1]
print(new_text)
> *то н* те *роид*, ко*орых*вы и*ете
break и continue
Два похожих оператора, которые можно встретить и в других языках программирования.
- break – прерывает цикл и выходит из него;
- continue – прерывает текущую итерацию и переходит к следующей.
# break
for num in range(40, 51):
if num == 45:
break
print(num)
>
40
41
42
43
44
Здесь видно, как цикл, дойдя до числа 45 и вернув истину в условном выражении, прерывается и заканчивает свою работу.
# continue
for num in range(40, 51):
if num == 45:
continue
print(num)
>
40
41
42
43
44
46
47
48
49
50
В случае continue происходит похожая ситуация, только прерывается лишь одна итерация, а сам же цикл продолжается.
else
Если два предыдущих оператора можно часто встречать за пределами Python, то else, как составная часть цикла, куда более редкий зверь. Эта часть напрямую связана с оператором break и выполняется лишь тогда, когда выход из цикла был произведен НЕ через break.
group_of_students = [21, 18, 19, 21, 18]
for age in group_of_students:
if age < 18:
break
else:
print(‘Всё в порядке, они совершеннолетние’)
> Всё в порядке, они совершеннолетние
Best practice
Цикл по списку
Перебрать list в цикле не составляет никакого труда, поскольку список – объект итерируемый:
# есть список
entities_of_warp = [“Tzeench”, “Slaanesh”, “Khorne”, “Nurgle”]
# просто берём список, «загружаем» его в цикл и без всякой задней мысли делаем обход
for entity in entities_of_warp:
print(entity)
>
Tzeench
Slaanesh
Khorne
Nurgle
Так как элементами списков могут быть другие итерируемые объекты, то стоит упомянуть и о вложенных циклах. Цикл внутри цикла вполне обыденное явление, и хоть количество уровней вложенности не имеет пределов, злоупотреблять этим не следует. Циклы свыше второго уровня вложенности крайне тяжело воспринимаются и читаются.
strange_phonebook = [
[“Alex”, “Andrew”, “Aya”, “Azazel”],
[“Barry”, “Bill”, “Brave”, “Byanka”],
[“Casey”, “Chad”, “Claire”, “Cuddy”],
[“Dana”, “Ditrich”, “Dmitry”, “Donovan”]
]
# это список списков, где каждый подсписок состоит из строк
# следовательно можно (зачем-то) применить тройной for
# для посимвольного чтения всех имён
# и вывода их в одну строку
for letter in strange_phonebook:
for name in letter:
for character in name:
print(character, end=”)
> A l e x A n d r e w A y a A z a z e l B a r …
Цикл по словарю
Чуть более сложный пример связан с итерированием словарей. Обычно, при переборе словаря, нужно получать и ключ и значение. Для этого существует метод .items(), который создает представление в виде кортежа для каждого словарного элемента.
Цикл, в таком случае, будет выглядеть следующим образом:
# создадим словарь
top_10_largest_lakes = {
“Caspian Sea”: “Saline”,
“Superior”: “Freshwater”,
“Victoria”: “Freshwater”,
“Huron”: “Freshwater”,
}
# обойдём его в цикле for и посчитаем количество озер с солёной водой и количество озёр с пресной
salt = 0
fresh = 0
# пара “lake, water”, в данном случае, есть распакованный кортеж, где lake – ключ словаря, а water – значение.
# цикл, соответственно, обходит не сам словарь, а его представление в виде пар кортежей
for lake, water in top_10_largest_lakes.items():
if water == ‘Freshwater’:
fresh += 1
else:
salt += 1
print(“Amount of saline lakes in top10: “, salt)
print(“Amount of freshwater lakes in top10: “, fresh)
> Amount of saline lakes in top10: 1
> Amount of freshwater lakes in top10: 3
Цикл по строке
Строки, по сути своей – весьма простые последовательности, состоящие из символов. Поэтому обходить их в цикле тоже совсем несложно.
word = ‘Alabama’
for w in word:
print(w, end=” “)
> A l a b a m a
Как сделать цикл for с шагом
Цикл for с шагом создается при помощи уже известной нам функции range, куда, в качестве третьего по счету аргумента, нужно передать размер шага:
# выведем числа от 100 до 1000 с шагом 150
for nums in range(100, 1000, 150):
print(nums)
>
100
250
400
550
700
850
Обратный цикл for
Если вы еще не убедились в том, что range() полезна, то вот ещё пример: благодаря этой функции можно взять и обойти последовательность в обратном направлении.
# выведем числа от 40 до 50 по убыванию
# для этого установим step -1
for nums in range(50, 39, -1):
print(nums)
>
50
49
48
47
46
45
44
43
42
41
40
for в одну строку
Крутая питоновская фишка, основанная на так называемых list comprehensions или, по-русски, генераторов. Их запись, быть может, несколько сложнее для понимания, зато очевидно короче и, по некоторым данным, она работает заметно быстрее на больших массивах данных.
В общем виде генератор выглядит так:
[результирующее выражение | цикл | опциональное условие]
Приведем пример, в котором продублируем каждый символ строки inputString:
# здесь letter * 2 — результирующее выражение; for letter in inputString — цикл, а необязательное условие опущено
double_letter = [letter * 2 for letter in “Banana”]
print(double_letter)
> [‘BB’, ‘aa’, ‘nn’, ‘aa’, ‘nn’, ‘aa’]
Другой пример, но теперь уже с условием:
# создадим список, что будет состоять из четных чисел от нуля до тридцати
# здесь if x % 2 == 0 — необязательное условие
even_nums = [x for x in range(30) if x % 2 == 0]
print(even_nums)
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]
–
Источник