Вложенные циклы python: вложенные и бесконечные, выход по break

Содержание

Python | Циклы

Циклы

Последнее обновление: 23.04.2017

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

Цикл while

Первый цикл, который мы рассмотрим, это цикл while. Он имеет следующее формальное определение:


while условное_выражение:
   инструкции

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

Все инструкции, которые относятся к циклу while, располагаются на последующих строках и должны иметь отступ от начала строки.


choice = "y"

while choice.lower() == "y":
    print("Привет")
    choice = input("Для продолжения нажмите Y, а для выхода любую другую клавишу: ")
print("Работа программы завешена")

В данном случае цикл while будет продолжаться, пока переменная choice содержит латинскую букву «Y» или «y».

Сам блок цикла состоит из двух инструкций. Сначала выводится сообщение «Привет», а потом вводится новое значение для переменной choice. И если пользователь нажмет какую-то другую клавишу, отличную от Y, произойдет выход из цикла, так как условие

choice.lower() == "y" вернет значение False. Каждый такой проход цикла называется итерацией.

Также обратите внимание, что последняя инструкция print("Работа программы завешена") не имеет отступов от начала строки, поэтому она не входит в цикл while.

Дугой пример — вычисление факториала:


#! Программа по вычислению факториала

number = int(input("Введите число: "))
i = 1
factorial = 1
while i <= number:
    factorial *= i
    i += 1
print("Факториал числа", number, "равен", factorial)

Здесь вводит с консоли некоторое число, и пока число-счетчик i не будет больше введенного числа, будет выполняться цикл, в котором происходит умножения числа factorial.

Консольный вывод:


Введите число: 6
Факториал числа 6 равен 720

Цикл for

Другой тип циклов представляет конструкция for. Цикл for вызывается для каждого числа в некоторой коллекции чисел. Коллекция чисел создается с помощью функции range(). Формальное определение цикла for:


for int_var in функция_range:
	инструкции

После ключевого слова for идет переменная int_var, которая хранит целые числа (название переменной может быть любое), затем ключевое слово in, вызов функции range() и двоеточие.

А со следующей строки располагается блок инструкций цикла, которые также должны иметь отступы от начала строки.

При выполнении цикла Python последовательно получает все числа из коллекции, которая создается функцией range, и сохраняет эти числа в переменной int_var. При первом проходе цикл получает первое число из коллекции, при втором — второе число и так далее, пока не переберет все числа. Когда все числа в коллекции будут перебраны, цикл завершает свою работу.

Рассмотрим на примере вычисления факториала:


#! Программа по вычислению факториала

number = int(input("Введите число: "))
factorial = 1
for i in range(1, number+1):
    factorial *= i
print("Факториал числа", number, "равен", factorial)

Вначале вводим с консоли число. В цикле определяем переменную i, в которую сохраняются числа из коллекции, создаваемой функцией range.

Функция range здесь принимает два аргумента — начальное число коллекции (здесь число 1) и число, до которого надо добавлять числа (то есть number +1).

Допустим, с консоли вводится число 6, то вызов функции range приобретает следующую форму:

range(1, 6+1):

Эта функция будет создавать коллекцию, которая будет начинаться с 1 и будет последовательно наполняться целыми числами вплоть до 7. То есть это будет коллекция [1, 2, 3, 4, 5, 6].

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

Консольный вывод программы:


Введите число: 6
Факториал числа 6 равен 720
Функция range

Функция range имеет следующие формы:

  • range(stop): возвращает все целые числа от 0 до stop

  • range(start, stop): возвращает все целые числа в промежутке от start (включая) до stop (не включая). Выше в программе факториала использована именно эта форма.

  • range(start, stop, step): возвращает целые числа в промежутке от start (включая) до stop (не включая), которые увеличиваются на значение step

Примеры вызовов функции range:


range(5)			# 0, 1, 2, 3, 4
range(1, 5)			# 1, 2, 3, 4
range(2, 10, 2)		# 2, 4, 6, 8
range(5, 0, -1)		# 5, 4, 3, 2, 1

Например, выведем последовательно все числа от 0 до 4:


for i in range(5):
    print(i, end=" ")

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

Одни циклы внутри себя могут содержать другие циклы. Рассмотрим на примере вывода таблицы умножения:


for i in range(1, 10):
    for j in range(1, 10):
        print(i * j, end="\t")
    print("\n")

Внешний цикл for i in range(1, 10) срабатывает 9 раз, так как в коллекции, возвращаемой функцией range, 9 чисел. Внутренний цикл for j in range(1, 10) срабатывает 9 раз для одной итерации внешнего цикла, и соответственно 81 раз для всех итераций внешнего цикла.

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


1	2	3	4	5	6	7	8	9	

2	4	6	8	10	12	14	16	18	

3	6	9	12	15	18	21	24	27	

4	8	12	16	20	24	28	32	36	

5	10	15	20	25	30	35	40	45	

6	12	18	24	30	36	42	48	54	

7	14	21	28	35	42	49	56	63	

8	16	24	32	40	48	56	64	72	

9	18	27	36	45	54	63	72	81	

Выход из цикла. break и continue

Для управления циклом мы можем использовать специальные операторы break и continue. Оператор break осуществляет выход из цикла. А оператор continue выполняет переход к следующей итерации цикла.

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


#! Программа Обменный пункт

print("Для выхода нажмите Y")

while True:
    data = input("Введите сумму для обмена: ")
    if data.lower() == "y":
        break  # выход из цикла
    money = int(data)
    cache = round(money / 56, 2)
    print("К выдаче", cache, "долларов")

print("Работа обменного пункта завершена")

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

В самом цикле получаем ввод с консоли. Мы предполагаем, что пользователь будет вводить число — условную сумму денег для обмена. Если пользователь вводит букву «Y» или «y», то с помощью оператора break выходим из цикла и прекращаем работу программы. Иначе делим введенную сумму на обменный курс, с помощью функции round округляем результат и выводим его на консоль. И так до бесконечности, пока пользователь не захочет выйти из программы, нажав на клавишу Y.

Консольный вывод программы:


Для выхода нажмите Y
Введите сумму для обмена: 20000
К выдаче 357.14 долларов
Введите сумму для обмена: Y
Работа обменного пункта завершена

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


#! Программа Обменный пункт

print("Для выхода нажмите Y")

while True:
    data = input("Введите сумму для обмена: ")
    if data.lower() == "y":
        break  # выход из цикла
    money = int(data)
    if money < 0:
        print("Сумма должна быть положительной!")
        continue
    cache = round(money / 56, 2)
    print("К выдаче", cache, "долларов")

print("Работа обменного пункта завершена")

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

И в этом случае мы уже не сможем получить результат для отрицательной суммы:


Для выхода нажмите Y
Введите сумму для обмена: -20000
Сумма должна быть положительной!
Введите сумму для обмена: 20000
К выдаче 357.14 долларов
Введите сумму для обмена: y
Работа обменного пункта завершена

вложенные и бесконечные, выход по break

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

Понятие циклов

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

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

Есть еще

несколько важных понятий, которые нужно знать:

  • Телом цикла называется та последовательность кода, которую нужно выполнить несколько раз.
  • Единоразовое выполнение – это итерация.

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

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

Цикл «for»

Цикл for в Python 3 выполняет написанный код повторно согласно введенной переменной или счетчику. Он используется только тогда, когда необходимо совершить перебор элементов заранее известное число раз

. Что это значит? У нас имеется список, сначала из него берется первый элемент, потом – второй и так далее, но с каждым из них совершается действие, которое указано в теле for. Примерно это выглядит так:

for [элемент] in [последовательность]:
    [сделать указанное]

For может содержать данные разных типов: цифры, слова и пр. Рассмотрим пример:

for i in 10, 14, 'первый', 'второй':
    print(i)

На экране после запуска появится такая запись:

10
14
первый
второй

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

:

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

Рассмотрим пример. Теоретически вы можете записать так:

for i in [14, 15, 16, 17, 18]:
    print(i)

Но это слишком затратно, особенно если чисел слишком много, поэтому лучше сделать так, используя указанный выше range():

for i in range(14,18):
    print(i)

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

14
15
16
17

Цикл «while»

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

Запись цикла while в Python выглядит так:

while [условие истинно]:
    [сделать указанное]

Приведем пример использования этого цикла:

count = 0
while count < 6:
    print(count)
    count += 2

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

0
2
4

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

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

count = 3
while count < 7:
    print count, " меньше 7"
    count = count + 1
else:
    print count, " не меньше 7"

Переменная – 3, задается условие, что пока она меньше 7, нужно выводить ее и выражение «меньше 7», затем прибавлять к ней 1. В тех случаях, когда она уже становится равной 7, то в ход пойдет условие, указанное в else, и на экране появится, что переменная не меньше 7. В результате выполнения этого кода мы увидим:

3 меньше 7
4 меньше 7
5 меньше 7
6 меньше 7
7 не меньше 7

Инструкции break и continue

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

while True:
    name = input(‘Введите имя:’)
    if name == ‘хватит’:
        break
print(‘Привет’, имя)

Его реализация будет выглядеть так:

Введите имя: Ирина
Привет Ирина
Введите имя: Алексей
Привет Алексей
Введите имя: хватит

После этого выполнение программы будет прервано.

Другая инструкция, которая может менять цикл, – это continue. Если она указана внутри кода, то все оставшиеся инструкции до конца цикла пропускаются и начинается следующая итерация.

В целом, не следует слишком увлекаться использованием этих инструкций.

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

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

  • repeat [тут исполняемый код] until [условия продолжения];
  • do [тут исполняемый код] while [условия продолжения];

К сожалению, в Python цикл с постусловием отсутствует!

Цикл while может стать циклом с постусловием, тогда его примерный вид будет таким:

while True:
    if not условие:
        break

Или таким:

while condition is True:
    stuff()
else:
    stuff()

Так получается, что сначала дается тело цикла, а потом задается условие.

Бесконечные циклы

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

Цикл while становится бесконечным, когда его условие не может быть ложным. Например, при помощи него можно реализовать программу «Часы», которая бесконечно отображает время.

Примером реализации в Python бесконечного цикла будет такой код:

Num = 3
while num < 5:
    print "Привет"

Очевидно, что заданная переменная всегда останется цифрой 3, поскольку никак не задано ее увеличение, поэтому на экране просто будет появляться слово «Привет».

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

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

Рассмотрим вложенные циклы в Python. Для реализации можно использовать как вложенные for, так и while.

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

Вот пример создания двумерного списка и вывода его на экран с помощью print.

d = [[1,2,3],[4,5,6]]
for i in range(2): 
    for j in range(3): 
        print(d[i][j])

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

toExit = False
while True:
    while True:
        toExit = doSomething()
        if toExit:
            break
    if toExit:
        break

Здесь приведен пример использования в Python цикла в цикле. Оба бесконечны. Все будет выполняться бесконечно, до тех пор, пока функция doSomething не вернет True. После этого поочередно сработают break во внешнем и во внутреннем циклах.

Заключение

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

Вложенный For, комбинация с If

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

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

Цикл for внутри цикла for — или просто вложенный цикл for

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

Предположим, что есть 9 сериалов в трех категориях: комедии, мультфильмы и драмы. Они представлены во вложенном списке Python («списки в списке»):

my_movies = [['How I Met Your Mother', 'Friends', 'Silicon Valley'],
	    ['Family Guy', 'South Park', 'Rick and Morty'],
	    ['Breaking Bad', 'Game of Thrones', 'The Wire']]

Необходимо посчитать символы в этих названиях и вывести результаты один за одним на экране в таком формате:

"The title [movie_title] is [X] characters long."

Как это можно сделать? Поскольку в основном списке есть три списка, чтобы получить их названия нужно перебрать элементы my_movies. Это нужно сделать и в основном списке, и в каждом вложенном:

for sublist in my_movies:
    for movie_name in sublist:
        char_num = len(movie_name)
        print("The title " + movie_name + " is " + str(char_num) + " characters long.")

Примечание: len() — это функция Python, которая выводит целое число. Чтобы сделать его «выводимым», нужно превратить число в строку. О том, как это сделать, говорилось в прошлом руководстве.

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

Подписывайтесь на телеграм каналы

И еще кое-что:
Синтаксис! Правила те же, что были при изучении простых циклов for. Единственное, на чем важно сделать акцент — отступы. Только используя корректные отступы в Python, вы сможете сообщить языку, в каком именно блоке цикла (внешнем или внутреннем) нужно применить тот или иной код. Попробуйте сделать следующее и обнаружить отличия в этих примерах:

Инструкции if в цикле for

Внутри цикла for также можно использовать инструкции if.

В качестве примера можно привести известное упражнение, которое предлагают junior-специалистам в сфере data science:

Переберите числа до 99. Выводите «fizz» для каждого числа, которое делится на 3, «buzz» — для тех, что делятся на 5 и «fizzbuzz» — для тех, что делятся на 3 и на 5! Если число не делится, выводите тире (’-’)

Вот решение:

for i in range(100):
    if i % 3 == 0 and i % 5 == 0:
        print('fizzbuzz')
    elif i % 3 == 0:
        print('fizz')
    elif i % 5 == 0:
        print('buzz')
    else:
        print('-')

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

Важно: при использовании инструкции if в цикле for будьте особенно внимательно с отступами, потому что если что-то упустить, то программа работать не будет.

Break

В Python есть удобный инструмент потока, который идеально подходит для управления инструкциями if в циклах for. Это инструкция break.

Найдете первое 7-значное число, которое делится на 137? (Только одно — первое).

Решение:

for i in range(0, 10000000, 137):
    if len(str(i)) == 7:
        print(i)
        break

Этот цикл берет каждое 137-е число (for i in range (0, 10000000, 137)) и проверяет, используется ли в нем 7 цифр или нет (if len(str(i) == 7). Как только он получит первое 7-значное число, инструкция if станет истинной (True), и произойдут две вещи:

  1. print(i) — число выведется на экран
  2. break прервет цикл, чтобы первое 7-значное число было также и последним на экране.

Узнать больше о break (и его брате близнеце, continue) можно в статье: Синтаксис, возможности и подводные камни цикла for Python 3.

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

Проверьте себя!

Пришло время узнать, насколько вы разобрались с инструкцией if, циклами for и их объединением. Попробуйте решить следующее задание.

Создайте скрипт на Python, который узнает ваш возраст максимум с 8 попыток. Он должен задавать только один вопрос: угадывать возраст (например, «Вам 67 лет?»). Отвечать же можно одним из трех вариантов:

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

Примечание: для решения задачи нужно изучить новую функцию input(). Больше о ней здесь.

Готовы? Вперед!

Решение

Вот код решения.

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

down = 0
up = 100
for i in range(1,10):
    guessed_age = int((up + down) / 2)
    answer = input('Are you ' + str(guessed_age) + " years old?")
    if answer == 'correct':
        print("Nice")
        break
    elif answer == 'less':
        up = guessed_age
    elif answer == 'more':
        down = guessed_age
    else:
        print('wrong answer')

Логика решения следующая:

Итого

Теперь вы знаете о:

  • Вложенных циклах for в Python
  • Объединении циклов for и инструкций if

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

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

Циклы в Python

Введение

Примеры

Перебор списков

Для того, чтобы перебирать список можно использовать for :

for x in ['one', 'two', 'three', 'four']:
    print(x)

 

Это распечатает элементы списка:

one
two
three
four

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

for x in range(1, 6):
    print(x)

 

Результат будет специальный диапазон типа последовательности в Python> = 3 и список в Python <= 2. И то, и другое можно пройти через цикл for.

1
2
3
4
5

 

Если вы хотите , чтобы петля , хотя обоих элементов списка и имеют индекс для элементов , а также, вы можете использовать Python, enumerate функции:

for index, item in enumerate(['one', 'two', 'three', 'four']):
    print(index, '::', item)

 

enumerate будет генерировать кортежи, которые распакованы в index (целое число) и item (фактическое значение из списка). Вышеуказанный цикл напечатает

(0, '::', 'one')
(1, '::', 'two')
(2, '::', 'three')
(3, '::', 'four')

 

Перебирать список с манипуляцией значений с использованием map и lambda , то есть применить функцию лямбда каждого элемента в списке:

x = map(lambda e :  e.upper(), ['one', 'two', 'three', 'four'])
print(x)

 

Выход:

['ONE', 'TWO', 'THREE', 'FOUR'] # Python 2.x

 

NB: в Python 3.x map возвращает итератор вместо списка , чтобы вы в случае , если вам нужен список , вы должны бросить результат print(list(x)) (см https://codecamp.ru/documentation/python/ 809 / несовместимости между ними-питоном-2-и-питоном-3/8186 / карта ) в https://codecamp.ru/documentation/python/809/incompatibilities-between-python-2-and-python-3 ).

Цикл for

for цикл итерирует по коллекции элементов, таких как list или dict , и запускает блок кода с каждым элементом из коллекции.

 for i in [0, 1, 2, 3, 4]:
    print(i)

 

Выше for итерации цикла над списком номеров.

Каждая итерация устанавливает значение i к следующему элементу списка. Итак , сначала будет 0 , то 1 , то 2 , и т.д. Вывод будет следующим образом :

0  
1
2
3
4

 

range это функция , которая возвращает ряд чисел под Iterable формы, таким образом , он может быть использован в for циклов:

for i in range(5):
    print(i)

 

дает тот же результат, что первый for цикл. Обратите внимание , что 5 не печатается , как диапазон здесь первые пять чисел , считая от 0 .

for цикла может итерацию по любому Iterable объекта , который является объектом , который определяет __getitem__ или __iter__ функцию. __iter__ функция возвращает итератор, который является объектом с next функцией, которая используется для доступа к следующему элементу итерации.

Перерыв (break) и продолжение (continue) в циклах

Когда break оператор выполняет внутри цикла, управление потоком «разрывов» из цикла немедленно:

i = 0
while i < 7:
    print(i)
    if i == 4:
        print("Breaking from loop")
        break
    i += 1

 

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

Выполнение следующему печатает каждую цифру до числа 4 , когда break заявление не будет выполнено и цикл останавливается:

0
1
2
3
4
Breaking from loop

 

break заявления также могут быть использованы внутри for петель, других для создания циклов , представленного Python:

 for i in (0, 1, 2, 3, 4):
    print(i)
    if i == 2:
        break

 

Выполнение этого цикла теперь печатает:

0
1
2
 

Обратите внимание, что 3 и 4 не печатаются, так как цикл закончился.

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

Заявление continue

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

for i in (0, 1, 2, 3, 4, 5):
    if i == 2 or i == 4:
        continue
    print(i)

0
1
3
5

 

Обратите внимание , что 2 и 4 не печатаются, это происходит потому , что по- continue идет к следующей итерации вместо продолжения на print(i) , когда i == 2 или i == 4 .

break и continue работать только на одном уровне цикла. Следующий пример сломается только из внутренних for цикла, а не внешние , while петель:

while True:
    for i in range(1,5):
        if i == 2:
            break    # Will only break out of the inner loop!

 

Python не имеет возможности вырваться из нескольких уровней петли сразу — если такое поведение желательно, рефакторинга один или несколько петель в функцию и заменить break с return может быть путь.

Используйте return из функции в качестве break

return оператор выходит из функции без выполнения кода , который приходит после него.

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

Циклы «while» и «for» в Python

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

Оглавление

  • Цикл While
    • о цикле
    • Прерывание и продолжение
    • Else
    • Бесконечные циклы
    • Вложенные циклы
    • Однолинейные циклы
    • Вывод
  • Цикл For
    • Обзор определенной итерации в программировании
      • Цикл числового диапазона
      • Цикл с тремя выражениями
      • Цикл на основе коллекции или итератора
    • Python цикл For
      • Итерируемые объекты
      • Итераторы
    • Под капотом
    • Перебор словаря
    • Функция range()
    • Изменение поведения цикла
    • Вывод

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

В программировании существует два типа итераций: неопределенный и определенный:

  • При неопределенной итерации (while) число выполнений цикла заранее не указывается явно. Скорее, назначенный блок выполняется многократно, пока выполняется некоторое условие.
  • При определенной итерации (for) число раз, когда указанный блок будет выполнен, указывается явно во время запуска цикла.

Цикл while

В этом блоке про while:

  • Узнаете о while цикле, структуре управления Python используемой для неопределенной итерации
  • Посмотрите, как преждевременно выйти из цикла
  • Исследуете цикл

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

Формат элементарного while цикла показан ниже:

while <expr>:
    <statement(s)>

<statement(s)> представляет собой блок для многократного выполнения, часто называемый телом цикла. Обозначается с отступом, как в if заявлении.

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

Управляющее выражение – <expr> как правило, включает в себя одну или несколько переменных, которые инициализируются до начала цикла, а затем изменяются где-то в теле цикла.

Когда встречается while цикл, <expr> сначала оценивается в логическом контексте . Если это правда, тело цикла выполняется. Затем <expr> проверяется снова, и если все еще true, то выполняется снова. Это продолжается до тех пор, пока <expr> станет false, после чего выполнение программы переходит к первому оператору после тела цикла.

Рассмотрим этот цикл:

n = 5
while n > 0:
    n -= 1
    print(n)

Вот что происходит в этом примере:

  • n изначально равно 5. Выражение в while заголовке оператора n > 0 имеет значение true, поэтому тело цикла выполняется. Внутри тела цикла n уменьшается на 1 до 4 и затем печатается.
  • Когда тело цикла завершено, выполнение программы возвращается к началу цикла, и выражение проверяется снова. Оно все еще true, поэтому тело выполняется снова и 3 печатается.
  • Это продолжается до тех пор, пока не n станет 0. В этот момент, когда выражение проверяется, оно ложно, и цикл завершается.

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

n = 0
while n > 0:
    n -= 1
    print(n)

В приведенном выше примере, когда встречается цикл, n равно 0. Управляющее выражение n > 0 уже ложно, поэтому тело цикла никогда не выполнится.

Вот еще один while цикл, включающий список, а не числовое сравнение:

a = ['foo', 'bar', 'baz']
while a:
    print(a.pop(-1))

Когда список оценивается в логическом контексте , true если в нем есть элементы, и false если он пустой. В этом примере a это правда, в нем есть элементы. Как только все элементы были удалены с помощью .pop() метода и список пуст, цикл завершается.

 break и continue

В каждом примере, который вы видели до этого, все тело while цикла выполняется на каждой итерации. Python предоставляет два ключевых слова, которые преждевременно завершают итерацию цикла:

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

Различие между break и continueпоказано на следующей диаграмме:

перерыв и продолжить

Вот файл сценария с именем break.py который демонстрирует break утверждение:

n = 5
while n > 0:
    n -= 1
    if n == 2:
        break
    print(n)
print('Loop ended.')

Запуск break.py из интерпретатора командной строки приводит к следующему выводу:

C:\Users\pythonguru\Documents>python break.py
4
3
Loop ended.

Когда n становится 2break заявление выполняется, цикл полностью завершается, и выполнение программы переходит к print() оператору.

Следующий скрипт continue.py идентичен, за исключением continue оператора вместо break:

n = 5
while n > 0:
    n -= 1
    if n == 2:
        continue
    print(n)
print('Loop ended.')

Вывод continue.py:

C:\Users\pythonguru\Documents>python continue.py
4
3
1
0
Loop ended.

На этот раз, когда n равно 2continue оператор вызывает завершение этой итерации. Таким образом, 2 не печатается. Выполнение возвращается к началу цикла, условие переоценивается, и оно все еще выполняется. Цикл возобновляется, завершается, когда n становится 0, как ранее.

else

Python допускает необязательное else в конце while цикла. Это уникальная особенность Python, не встречающаяся в большинстве других языков программирования. Синтаксис показан ниже:

while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>

<additional_statement(s)> указанный в else пункте, будет выполняться , когда прервётся цикл while .

Сейчас вы можете подумать: «Как это полезно?». Вы можете сделать то же самое, поместив эти операторы сразу после while цикла, без else:

while <expr>:
    <statement(s)>
<additional_statement(s)>

Какая разница?

В последнем случае, без else<additional_statement(s)> будет выполняться после завершения while цикла, несмотря ни на что.

Когда <additional_statement(s)> помещены в else, они будут выполняться только в том случае, если цикл завершается «по истощению», то есть, если цикл повторяется до тех пор, пока условие управления не станет ложным. Если цикл завершается break оператором, else предложение не будет выполнено.

Рассмотрим следующий пример:

n = 5
while n > 0:
    n -= 1
    print(n)
else:
    print('Loop done.')

В этом случае цикл повторялся до тех пор, пока условие не было false: n стало 0, а условие n > 0 стало ложным. Поскольку цикл прожил свою естественную жизнь, так сказать, else пункт был выполнен. Теперь обратите внимание на разницу здесь:

n = 5
while n > 0:
    n -= 1
    print(n)
    if n == 2:
        break
else:
    print('Loop done.')

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

Может показаться, что значение слова else не совсем соответствует while циклу, а также if выражению. Гвидо ван Россум (Guido van Rossum) , создатель Python, на самом деле сказал, что, если бы ему пришлось повторить, он бы исключил else цикла while   из языка.

Одна из следующих интерпретаций может помочь сделать ее более интуитивной:

  • Думайте о заголовке цикла (while n > 0) как об if операторе (if n > 0), который выполняется снова и снова, и else выполняется, когда условие становится false.

Если вы не найдете ни одну из этих интерпретаций полезной, не стесняйтесь игнорировать их.

Когда может быть полезным else в whileцикле? Одна распространенная ситуация, если вы ищете в списке определенный элемент. Вы можете использовать break для выхода из цикла, если элемент найден, и else может содержать код, который должен быть выполнен, если элемент не найден:

a = ['foo', 'bar', 'baz', 'qux']
s = 'corge'

i = 0
while i < len(a):
    if a[i] == s:
        # Processing for item found
        break
    i += 1
else:
    # Processing for item not found
    print(s, 'not found in list.')

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

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

Во-вторых, Python предоставляет встроенные способы поиска элемента в списке. Вы можете использовать in оператор:

if s in a:
    print(s, 'found in list.')
else:
    print(s, 'not found in list.')

list.index() метод также будет работать. Этот метод вызывает ValueError исключение, если элемент не найден в списке, поэтому для его использования необходимо понимать обработку исключений. В Python вы используете try оператор для обработки исключения. Пример приведен ниже:

try:
    print(a.index('corge'))
except ValueError:
    print(s, 'not found in list.')

Вы узнаете об обработке исключений позже.

Бесконечные циклы

Предположим, вы пишете while цикл, который теоретически никогда не заканчивается. Звучит странно, правда?

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

while True:
    print('foo')










KeyboardInterrupt

Этот код был завершен знаком Ctrl+C , который генерирует прерывание с клавиатуры. Иначе это продолжалось бы бесконечно. 

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

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

Говоря более прозаично, помните, что while можно закончить используя break. Может быть более простым завершить цикл на основе условий, распознанных в теле цикла, а не на условии, оцененном сверху.

Вот еще один вариант показанного выше цикла, который последовательно удаляет элементы из списка, .pop() пока он не станет пустым:>>>

a = ['foo', 'bar', 'baz']
while True:
    if not a:
        break
    print(a.pop(-1))

Когда a становится пустым, not a становится истинным, и break оператор выходит из цикла.

Вы также можете указать несколько break операторов в цикле:

while True:
    if <expr1>:  # One condition for loop termination
        break
    ...
    if <expr2>:  # Another termination condition
        break
    ...
    if <expr3>:  # Yet another
        break

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

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

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

В общем, управляющие структуры Python могут быть вложены друг в друга. Например, условные операторы if/elif/else могут быть вложенными:

if age < 18:
    if gender == 'M':
        print('son')
    else:
        print('daughter')
elif age >= 18 and age < 65:
    if gender == 'M':
        print('father')
    else:
        print('mother')
else:
    if gender == 'M':
        print('grandfather')
    else:
        print('grandmother')

Точно так же while цикл может содержаться в другом while цикле, как показано здесь:

a = ['foo', 'bar']
while len(a):
    print(a.pop(0))
    b = ['baz', 'qux']
    while len(b):
        print('>', b.pop(0))

Кроме того, while циклы могут быть вложены в if/elif/else операторы, и наоборот:

if <expr>:
    statement
    while <expr>:
        statement
        statement
else:
    while <expr>:
        statement
        statement
    statement
while <expr>:
    if <expr>:
        statement
    elif <expr>:
        statement
    else:
        statement

    if <expr>:
        statement

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

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

Однолинейные циклы while

Как и в if операторе, while цикл может быть указан в одной строке. Если в блоке, составляющем тело цикла, есть несколько операторов, они могут быть разделены точкой с запятой (;):

n = 5
while n > 0: n -= 1; print(n)

Это работает только с простыми утверждениями, хотя, вы не можете объединить два составных оператора в одну строку. Таким образом, вы можете указать while цикл в одной строке, как указано выше, как вы и пишете if оператор в одной строке:>>>

if True: print('foo')

Но вы не можете сделать это:

while n > 0: n -= 1; if True: print('foo')

Помните, что PEP 8 препятствует нескольким утверждениям в одной строке. Так что, вероятно, вам все равно не следует делать это очень часто.

Вывод

В этом блоке вы узнали о неопределенной итерации с помощью цикла Python while. Теперь вы можете:

  • Построить основные и сложные while циклы
  • Выполнение цикла с break иcontinue
  • Использование else с whileциклом
  • Разбираться с бесконечными циклами

Теперь вы должны хорошо понимать, как выполнять фрагмент кода повторно.

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


Цикл for

Этот блок покажет вам, как выполнить определенную итерацию с for циклом Python .

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

  • Повторное выполнение одного и того же блока кода снова и снова называется итерацией .
  • Существует два типа итерации:
    • Определенная итерация, в которой количество повторений указано заранее
    • Неопределенная итерация, в которой блок кода выполняется, пока не будет выполнено некоторое условие
  • В Python неопределенная итерация выполняется с помощью while цикла.

Вот что вы узнаете в этом блоке:

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

Обзор определенной итерации в программировании

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

Исторически языки программирования предлагали несколько разных вариантов for цикла. Они кратко описаны в следующих разделах.

Цикл числового диапазона

Самый простой for цикл – это простой числовой оператор диапазона с начальными и конечными значениями. Точный формат зависит от языка, но обычно выглядит примерно так:

for i = 1 to 10
    <loop body>

Здесь тело цикла выполняется десять раз. Переменная i принимает значение 1 на первой итерации, 2 на второй и т. д. Этот вид for цикла используется в языках BASIC, Algol и Pascal.

Цикл с тремя выражениями

Другая форма for цикла, популярная на языке программирования C, состоит из трех частей:

  • Инициализация
  • Выражение, указывающее конечное условие
  • Действие, которое нужно выполнить в конце каждой итерации.

Этот тип цикла имеет следующую форму:

for (i = 1; i <= 10; i++)
    <loop body>

Техническое примечание: на языке программирования C i++ увеличивает значение переменной i. Это примерно эквивалентно i += 1 в Python.

Этот цикл интерпретируется следующим образом:

  • Инициализировать i в 1.
  • Продолжать цикл до тех пор, пока i <= 10.
  • Увеличение i на 1 после каждой итерации цикла.

Циклы for с тремя выражениями популярны, потому что выражения, указанные для этих трех частей, могут быть почти любыми, поэтому это имеет немного большую гибкость, чем простая форма числового диапазона, показанная выше. Эти for циклы также представлены в языках C ++, Java, PHP и Perl.

Цикл на основе коллекции или итератора

Этот тип цикла перебирает коллекцию объектов, а не указывает числовые значения или условия:

for i in <collection>
    <loop body>

Каждый раз в цикле переменная i принимает значение следующего объекта в <collection>. Этот тип for цикла, пожалуй, наиболее обобщенный и абстрактный. Perl и PHP также поддерживают этот тип цикла, но он вводится ключевым словом foreach вместо for.

О цикле for

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

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

Цикл for в Python выглядит так:

for <var> in <iterable>:
    <statement(s)>

<iterable> – это коллекция объектов, например, список или кортеж. <statement(s)> в теле цикла обозначаются отступом, как и со всеми структурами управления Python и выполняются один раз для каждого элемента <iterable>. Переменная цикла <var> принимает значение следующего элемента в <iterable> каждый раз в цикле.

Вот типичный пример:

a = ['foo', 'bar', 'baz']
for i in a:
    print(i)

В этом примере <iterable> это список a, а <var> переменная i. Каждый раз через цикл, i берет последовательный элемент в a, так что print()отображает значения 'foo''bar' и 'baz', соответственно.

Но что именно повторяется? Перед for дальнейшим изучением циклов будет полезно более подробно изучить, что же такое итерации в Python.

Итерируемые объекты

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

  • Прилагательное: объект может быть описан как итеративный.
  • Существительное: объект может быть охарактеризован как итеративный.

Если объект является итеративным, его можно передать во встроенную функцию Python iter(), которая возвращает то, что называется итератором . Да, терминология становится немного повторяющейся. Все это работает в конце.

Каждый из объектов в следующем примере является итеративным и возвращает некоторый тип итератора при передаче в iter():

iter('foobar')                             # String


iter(['foo', 'bar', 'baz'])                # List


iter(('foo', 'bar', 'baz'))                # Tuple


iter({'foo', 'bar', 'baz'})                # Set


iter({'foo': 1, 'bar': 2, 'baz': 3})       # Dict

Эти типы объектов, с другой стороны, не повторяемы:>>>

iter(42)                                   # Integer

    


iter(3.1)                                  # Float

    


iter(len)                                  # Built-in function

Типы коллекций или контейнеров, являются итеративными. К ним относятся типы string , list , tuple , dict , set и frozenset .

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

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

Итераторы

Хорошо, теперь вы знаете, что значит для объекта быть итеративным, и вы знаете, как использовать его iter() для получения итератора. Если у вас есть итератор, что вы можете с ним сделать?

Итератор по сути является источником значений, который выдает последовательные значения из своего связанного итерируемого объекта. Встроенная функция next() используется для получения следующего значения в итераторе.

Вот пример, использующий тот же список, что и выше:>>>

a = ['foo', 'bar', 'baz']

itr = iter(a)
itr


next(itr)

next(itr)

next(itr)

В этом примере a это итеративный список, а itrсвязанный с ним итератор, полученный с помощью iter(). Каждый next(itr) вызов получает следующее значение от itr.

Обратите внимание, как итератор внутренне сохраняет свое состояние. Он знает, какие значения уже получены, поэтому при вызове next() он знает, какое значение будет возвращено следующим.

Что происходит, когда у итератора заканчиваются значения? Давайте сделаем еще один next()вызов итератора выше:

>>> next(itr)
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    next(itr)
StopIteration

Если все значения из итератора уже возвращены, последующий next() вызов вызывает StopIteration исключение. Любые дальнейшие попытки получить значения от итератора потерпят неудачу.

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

>>> a
['foo', 'bar', 'baz']

>>> itr1 = iter(a)
>>> itr2 = iter(a)

>>> next(itr1)
'foo'
>>> next(itr1)
'bar'
>>> next(itr1)
'baz'

>>> next(itr2)
'foo'

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

Если вы хотите получить все значения из итератора одновременно, вы можете использовать встроенную list() функцию. Среди других возможных применений, list() принимает итератор в качестве аргумента и возвращает список, состоящий из всех значений, полученных итератором:

>>> a = ['foo', 'bar', 'baz']
>>> itr = iter(a)
>>> list(itr)
['foo', 'bar', 'baz']

Аналогично, встроенные функции tuple() и set() функции возвращают кортеж и набор соответственно из всех значений, которые дает итератор:

>>> a = ['foo', 'bar', 'baz']

>>> itr = iter(a)
>>> tuple(itr)
('foo', 'bar', 'baz')

>>> itr = iter(a)
>>> set(itr)
{'baz', 'foo', 'bar'}

Не обязательно делать это постоянно. Часть элегантности итераторов в том, что они «ленивы». Это означает, что когда вы создаете итератор, он не генерирует все элементы, которые он может получить. Он ждет, пока вы не попросите их –  next(). Элементы не создаются, пока они не будут запрошены.

При использовании list()tuple() или тому подобное, вы заставляете итератор генерировать все свои значения сразу, поэтому все они могут быть возвращены. Если общее количество объектов, возвращаемых итератором, очень велико, то это может занять много времени.

Фактически в Python можно создать итератор, который возвращает бесконечный ряд объектов. Если вы попытаетесь получить все значения сразу из бесконечного итератора, программа зависнет .

Под капотом for

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

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

Теперь снова рассмотрим простой for цикл, представленный в начале этого урока:

a = ['foo', 'bar', 'baz']
for i in a:
    print(i)

Этот цикл может быть полностью описан в терминах концепций, о которых вы только что узнали. Чтобы выполнить итерацию, for описанную в этом цикле, Python делает следующее:

  • Призывает iter() чтобы получить итератор для a
  • Вызывает next() повторно, чтобы получить каждый элемент от итератора по очереди
  • Завершает цикл, когда next() поднимает StopIteration исключение

Тело цикла выполняется один раз для каждого элемента next() возврата,  с переменной цикла i , установленной для данного элемента для каждой итерации.

Эта последовательность событий представлена ​​на следующей диаграмме:

Принципиальная схема питона для цикла

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

  • Многие встроенные и библиотечные объекты являются итеративными.
  • Существует модуль стандартной библиотеки под названием itertools, он содержит много функций, которые возвращают итерации.
  • Пользовательские объекты, созданные с объектно-ориентированной возможностью, могут быть итеративными.
  • Python имеет конструкцию, называемую генератором, которая позволяет вам создать свой собственный итератор простым и понятным способом.

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

Перебор словаря

Ранее вы видели, что итератор может быть получен из словаря iter(), поэтому вы знаете, что словари должны быть итеративными. Что происходит, когда вы перебираете словарь? Посмотрим:

>>> d = {'foo': 1, 'bar': 2, 'baz': 3}
>>> for k in d:
...     print(k)
...
foo
bar
baz

Как вы можете видеть, когда for цикл перебирает словарь, переменная цикла присваивается ключам словаря.

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

>>> for k in d:
...     print(d[k])
...
1
2
3

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

>>> for v in d.values():
...     print(v)
...
1
2
3

Фактически, вы можете перебирать и ключи, и значения словаря одновременно. Это потому, что переменная цикла for цикла не ограничивается только одной переменной. Это также может быть кортеж, и в этом случае назначения производятся из элементов итерируемого с использованием packing и unpacking, так же как и с помощью оператора присваивания:

>>> i, j = (1, 2)
>>> print(i, j)
1 2

>>> for i, j in [(1, 2), (3, 4), (5, 6)]:
...     print(i, j)
...
1 2
3 4
5 6

Метод словаря .items() эффективно возвращает список пар ключ / значение в виде кортежей:

>>> d = {'foo': 1, 'bar': 2, 'baz': 3}

>>> d.items()
dict_items([('foo', 1), ('bar', 2), ('baz', 3)])

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

>>> d = {'foo': 1, 'bar': 2, 'baz': 3}
>>> for k, v in d.items():
...     print('k =', k, ', v =', v)
...
k = foo , v = 1
k = bar , v = 2
k = baz , v = 3

Функция range()

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

Например, если вы хотите перебрать значения из 0 в 4, вы можете просто сделать это:

>>> for n in (0, 1, 2, 3, 4):
...     print(n)
...
0
1
2
3
4

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

К счастью, Python предоставляет лучший вариант – встроенную range() функцию, которая возвращает итерацию, которая дает последовательность целых чисел.

range(<end>) возвращает итерацию, которая дает целые числа, начиная с 0, но не включая <end>:

>>> x = range(5)
>>> x
range(0, 5)
>>> type(x)
<class 'range'>

Обратите внимание, что range() возвращает объект класса range, а не список или кортеж значений. Поскольку range объект является итеративным, вы можете получить значения, повторяя их с помощью for цикла:

>>> for n in x:
...     print(n)
...
0
1
2
3
4

Вы также можете получить все значения сразу с помощью list() или tuple(). В сеансе REPL это может быть удобным способом быстрого отображения значений:

>>> list(x)
[0, 1, 2, 3, 4]

>>> tuple(x)
(0, 1, 2, 3, 4)

Однако, когда range() используется в коде, который является частью более крупного приложения, обычно считается плохой практикой использовать list() или tuple() таким образом. Как и итераторы, range объекты ленивы – значения в указанном диапазоне не генерируются, пока их не запросят. Использование list() или объекта tuple() приводит к тому, что range все значения возвращаются одновременно. Это редко необходимо, и если список длинный, он может тратить время и память.

range(<begin>, <end>, <stride>) возвращает итерацию, которая дает целые числа, начиная с <begin>, до, но не включая <end>. Если указано, <stride> указывает количество пропускаемых значений (аналогично значению шага, используемому для нарезки строк и списков):

>>> list(range(5, 20, 3))
[5, 8, 11, 14, 17]

Если <stride> опущено, то по умолчанию 1:

>>> list(range(5, 10, 1))
[5, 6, 7, 8, 9]
>>> list(range(5, 10))
[5, 6, 7, 8, 9]

Все указанные параметры range() должны быть целыми числами, но любой из них может быть отрицательным. Естественно, если <begin> больше чем <end>, то <stride> должно быть отрицательным (если вы хотите каких-либо результатов):

>>> list(range(-5, 5))
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]

>>> list(range(5, -5))
[]
>>> list(range(5, -5, -1))
[5, 4, 3, 2, 1, 0, -1, -2, -3, -4]

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

Изменение поведения цикла for

Вы видели в предыдущем блоке, как выполнение в while цикле может быть прервано с помощью break и continue, и также измененным с else . Эти возможности также доступны в for цикле.

break и continue

break и continue работает с for циклами так же, как с while циклами. break завершает цикл полностью и переходит к первому оператору, следующему за циклом:

>>> for i in ['foo', 'bar', 'baz', 'qux']:
...     if 'b' in i:
...         break
...     print(i)
...
foo

continue завершает текущую итерацию и переходит к следующей итерации:

>>> for i in ['foo', 'bar', 'baz', 'qux']:
...     if 'b' in i:
...         continue
...     print(i)
...
foo
qux

else

Цикл for может иметь else. Интерпретация аналогична интерпретации while цикла. else будет выполнено, если цикл завершится из-за исчерпания итерируемого:

>>> for i in ['foo', 'bar', 'baz', 'qux']:
...     print(i)
... else:
...     print('Done.')  # Will execute
...
foo
bar
baz
qux
Done.

else не будет выполнено, если список будет разбит breakоператором:

>>> for i in ['foo', 'bar', 'baz', 'qux']:
...     if i == 'bar':
...         break
...     print(i)
... else:
...     print('Done.')  # Will not execute
...
foo

Вывод

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


Совершенствуй знания каждый день у нас в Телеграм-каналах

Вопросы, реклама — VK | Telegram

Цикл for Python — примеры для новичков: синтаксис, вложенный, выход break, итерация, по списку, функции и по словарю

  • Цикл for в Python используется для перебора последовательности элементов.
  • Цикл for реализован с использованием зарезервированного ключевого слова — for.
  • Код цикла for выполняется для каждого элемента последовательности.
  • Мы можем выйти из цикла с помощью оператора break.
  • Мы можем использовать оператор continue, чтобы пропустить выполнение кода в цикле for для элемента.
  • отличается от других языков программирования, поскольку он больше похож на итератор.
  • Мы можем использовать его для перебора Tuple, List, Set или String. Все эти объекты представляют собой последовательность.
  • У нас могут быть вложенные циклы для перебора последовательности последовательностей.

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

Синтаксис цикла for Python очень прост. Он использует оператор in для перебора элементов в последовательности.

for element in sequence:
    # for statement code block

Блок-схема

Примеры

Давайте рассмотрим несколько примеров цикла for с различными типами последовательностей.

1. Строка

Строка Python — это последовательность символов. Давайте посмотрим на простую программу для печати индекса и символа в строке.

message = "Hello"

count = 0
for character in message:
    print(f'Index:{count}, Character:{character}')
    count += 1

Вывод:

2. Кортеж

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

def to_lower_case(my_tuple):
    temp_list = []
    for item in my_tuple:
        temp_list.append(str(item).lower())
    return tuple(temp_list)


fruits = ("Apple", "Orange", "BANANA")
fruits_new = to_lower_case(fruits)
print(fruits_new)

Вывод: ('apple', 'orange', 'banana')

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

3. Список

Давайте посмотрим на пример итерации по списку целых чисел и напечатаем, четное или нечетное число.

list_ints = [1, 2, 3, 4, 5]
for i in list_ints:
    if i % 2 == 0:
        print(f'{i} is even.')
    else:
        print(f'{i} is odd.')

Вывод:

4. Вывод набора

Вот простой пример печати элементов набора.

set_cities = set()
set_cities.add("New York")
set_cities.add("New Delhi")
set_cities.add("Bangalore")
set_cities.add("London")
set_cities.add("Bangalore")  # duplicate item, will be removed from set

for city in set_cities:
    print(city)

Вывод:

Примечание. Set — это неупорядоченная последовательность в Python. Таким образом, вывод может отличаться при каждом выполнении программы.

5. Словарь

Словарь Python — это не последовательность. Поэтому мы не можем напрямую перебирать его элементы. Однако у него есть метод items() который возвращает подобную множеству последовательность своих элементов. Мы можем использовать этот метод для перебора элементов словаря.

my_dict = {"1": "Apple", "2": "Kiwi", "3": "Orange"}

for k, v in my_dict.items():
    print(f'Key={k}, Value={v}')

Вывод:

Использование оператора break для выхода из цикла

Мы можем использовать оператор break для выхода из цикла без повторения всех элементов.

Допустим, у нас есть список сообщений для обработки. Если мы встретим сообщение «Выход», обработка должна прекратиться. Мы можем использовать оператор break для реализации этого сценария.

messages = ["Hi", "Hello", "Exit", "Adios", "Hola"]

for msg in messages:
    if msg == "Exit":
        break;
    print(f'Processing {msg}')

Вывод:

С оператором continue

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

ints = (1, 2, 3, 4, 5, 6)

# process only odd numbers
for i in ints:
    if i % 2 == 0:
        continue
    print(f'Processing {i}')

Вывод:

С функцией range()

Функция Python range() генерирует последовательность чисел. Мы можем использовать это с циклом for для выполнения блока кода определенное количество раз.

Давайте посмотрим, как использовать функцию range() для выполнения кода 5 раз.

for i in range(5):
    print("Processing for loop:", i)

Вывод:

С оператором else

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

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

databases = ("MySQL", "Oracle", "PostgreSQL", "SQL Server")

for db in databases:
    print(f'Processing scripts for {db}')
else:
    print("All the databases scripts executed successfully.")

Вывод:

Примечание. Если цикл вызывает какую-либо ошибку, код блока else не выполняется.

databases = ("MySQL", "Oracle", "PostgreSQL", "SQL Server")

for db in databases:
    print(f'Processing scripts for {db}')
    raise TypeError
else:
    print("All the databases scripts executed successfully.")

Вывод:

Processing scripts for MySQL
Traceback (most recent call last):
  File "/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/for-loop.py", line 65, in <module>
    raise TypeError
TypeError

Точно так же, если цикл завершается оператором break, блок else не выполняется.

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

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

list_tuples = [("Apple", "Banana"), ("Orange", "Kiwi", "Strawberry")]

for t_fruits in list_tuples:
    for fruit in t_fruits:
        print(fruit)

Вывод:

Обратная итерация с использованием функции Loop и reversed()

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

numbers = (1, 2, 3, 4, 5)

for n in reversed(numbers):
    print(n)

Вывод:

5
4
3
2
1

Переменные цикла в глобальную область видимости

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

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

global_var = "global"
for c in range(1,3):
    x = 10
    global_var = "for variable"

print(c)  # variable is defined in the for loop
print(x)  # variable is defined in the for loop
print(global_var)  # global variable

операторы циклов while и for, операторы break и continue

Ни одна сколь-нибудь серьезная программа на Python не обходится без циклов. Что такое циклы?

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

Смотрите как в Python записывается группа операторов (тело цикла): вся группа должна иметь один и тот же сдвиг относительно оператора while (обычно ставят четыре пробела или символ табуляции). Причем такой отступ строго обязателен – это элемент синтаксиса python. И благодаря этому текст программы становится наглядным и хорошо читаемым. Это, безусловно, один из плюсов данного языка.

Однократное выполнение тела цикла называется итерацией. То есть, может быть первая итерация, вторая итерация, N-я итерация и так далее.

Давайте в качестве примера с помощью оператора цикла while вычислим вот такую вот сумму:

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

S=0; i=1
while i <= 1000:
    S += 1/i
    i += 1
print(S)

В качестве выражения в цикле while можно писать все те же самые условия, что и в условном операторе if. Например, можно вычислять сумму S пока либо i<=1000, либо S < 5. Такое условие запишется так:

while i <= 1000 and S < 5:

здесь цикл будет работать пока i<=1000 и S<5 как только одно из подусловий станет ложным, все составное условие становится ложным и цикл завершит свою работу.

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

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

А что будет, если условие в цикле while будет истинным всегда? В этом случае мы получим «вечный» цикл, программа фактически зависнет и наш спортсмен будет обречен на бесконечный бег по кругу.

S=0; i=1
while 1 : S += 1
print(S)

Далее, цикл while может иметь необязательный блок else, который идет после цикла:

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

И здесь часто возникает вопрос: а чем блок else отличается от блока операторов, просто идущих после блока while? Ведь когда цикл while завершится, мы так и так перейдем к последующим операторам! Однако, тут есть один нюанс. Любой оператор цикла в Python может быть досрочно прерван с помощью оператора

break

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

S=0; i=-10
while i < 100:
    if i == 0: break
    S += 1/i
    i=i+1
else:
    print("Сумма вычислена корретно")
print(S)

Если здесь при вычислении суммы ожидается деление на 0, то срабатывает break и цикл досрочно прерывается. В этом случае блок else не срабатывает и мы не видим сообщения, что сумма вычислена корректно. Если же все проходит штатно (без вызова break), то в консоли появляется сообщение

Сумма вычислена корректно

означающее выполнение блока else.

Раз уж мы начали говорить об управляющем операторе break, сразу отметим второй подобный оператор

continue

Этот оператор позволяет пропускать тело цикла и перейти к следующей итерации, не прерывая работу самого цикла. Например, мы хотим перебрать все целые значения от -4 до 4, исключая значение 0. Такую программу можно реализовать так:

S=0; i=-5
while i < 4:
    i=i+1
    if i == 0: continue
    print(i)
    S += 1/i
print(S)

При выполнении этой программы увидим, что в консоль выведены все значения кроме нуля. Так как при i=0 срабатывает условие и выполняется оператор continue. Все что находится после этого оператора пропускается и цикл продолжается уже со значением i=1.

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

Оператор цикла for

Следующий и, наверное, самый часто используемый оператор цикла – это оператор for, который имеет такой синтаксис:

for <переменная> in <список> :
      операторы 1…N

Например,

for x in 1,5,2,4:
    print(x**2)

выведет в консоль квадраты соответствующих чисел. Но что, если мы хотим перебрать значения по порядку в соответствии с правилом:

начальное значение, шаг, конечное значение

Для этого используется генератор последовательностей

range(start, stop, step)

Например, если мы запишем его вот так:

for x in range(1,5,1):
    print(x)

то в консоли увидим числа от 1 до 4 с шагом 1. То есть, range генерирует последовательность в интервале

[1;5)

Последнее значение не входит в интервал. Если в нашем примере поставить шаг отрицательный -1, то конечное значение 5 не может быть достигнуто и в этом случае Python возвратит пустую последовательность:

for x in range(1,5,-1):
    print(x)

Если нам нужны числа от 5 до 1, то следует записывать range в таком виде:

for x in range(5,0,-1):
    print(x)

Причем, в range можно записывать только целые числа, с вещественными он не работает.

Давайте перепишем нашу программу подсчета суммы

с помощью цикла for, получим:

S=0
for i in range(1, 1001, 1):
    S += 1/i
print(S)

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

Вторым примером рассмотрим задачу вычисления значений линейной функции

Программа будет выглядеть так:

k = 0.5; b = 2
lst = [0, 0.1, 0.2, 0.3, 0.4, 0.5]
for x in lst:
    print(x*k+b)

Этот пример показывает, что для перебора значений счетчика x можно использовать списки, сформированные ранее в программе. (О списках мы подробнее будем говорить на последующих занятиях). Здесь же приведем еще один пример:

msg = "Hello World!"
for x in msg:
    print(x)

Он показывает, что строку можно воспринимать как список и перебирать с помощью цикла for.

Также в цикле for можно использовать блок else, о котором мы говорили ранее:

for <переменная> in <список> :
      операторы 1…N
else:
      операторы 1…N

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

Итак, мы с вами рассмотрели два оператора циклов: while и for. Все эти циклы можно комбинировать друг с другом. То есть, создавать вложенные циклы (цикл внутри цикла).

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

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

Тогда мы делаем первый цикл от 1 до N и вложенный от 1 до M

A = [ [1,2,3], [4,5,6] ]
N=2; M=3
for i in range(N):
    for j in range(M):
       print(A[i][j])
    print()

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

Программа будет выглядеть так:

S=0; M=10; N=5
for i in range(1,N+1):
    for j in range(1,M+1):
        S += i*j
print(S)

Мы здесь сначала пробегаем все значения j от 1 до M при фиксированном i=1, затем, значение i увеличивается на 1, становится 2 и при этом i снова пробегаются значения j от 1 до M. И так пока i не превысит значение N. То есть, второй цикл вложен вот в этот первый. И таких вложений можно делать сколько угодно.

Вот так работают операторы циклов в Python и теперь вы знаете как их можно применять на практике.

Python вложенный цикл for — qaru Переполнение стека
  1. Около
  2. Продукты
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. Вакансии Программирование и связанные с ним технические возможности карьерного роста
  4. Талант Нанимайте технических специалистов и создавайте свой бренд работодателя
  5. Реклама Обратитесь к разработчикам и технологам со всего мира
  6. О компании
.

python — Выход из вложенных циклов

Переполнение стека
  1. Около
  2. Продукты
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. Вакансии Программирование и связанные с ним технические возможности карьерного роста
  4. Талант Нанимайте технических специалистов и создавайте свой бренд работодателя
  5. Реклама Обратитесь к разработчикам и технологам со всего мира
  6. О компании

Загрузка…

.

Циклы в Python (For, While, Nested loops)

Роль циклов в Python вместе с их типами: For, While, Nested Loops

Мы узнали о четырех различных условных операторах в Python в нашем предыдущем руководстве .

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

Серия полного обучения на Python даст вам краткое представление о том, что такое Python.

Смотреть видеоурок

Циклические операторы в Python:

Циклические операторы в Python

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

Python предоставляет нам 2 типа циклов, как указано ниже:

# 1) Цикл while:

Цикл while в Python используется для многократного выполнения нескольких операторов или кодов до тех пор, пока данное условие не станет истинным.

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

Синтаксис:

  while (выражение): блок операторов Оператор увеличения или уменьшения  

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

Пример:

число = 5
сумма = 0
я = 0

в то время как (я <число):
        сумма = сумма + я
        я = я + 1

печать (сумма)

 

Выход:

10

Выход:

# 2) Цикл For:

Цикл For в Python используется для выполнения блока операторов или кода несколько раз, пока данное условие не станет ложный.

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

Синтаксис:

  для var в последовательности: Блок кода  

Здесь var берет значение из последовательности и выполняет его, пока не будут выполнены все значения в последовательности.

Пример:

language = [«Python», «Java», «Ruby»]

для lang в языке:
      print («Текущий язык:«, lang)

 

Вывод:

Текущий язык: Python

Текущий язык: Java

Текущий язык: Ruby

Вывод:

Для цикла с использованием функции range ():

Функция Range () используется для генерации последовательности чисел.

Например, диапазон (5) будет генерировать числа от 0 до 4 (5 чисел).

Пример:

language = [«Python», «Java», «Ruby»]

для lang in range (len (язык)):
      print («Текущий язык:«, язык [lang])

 

Вывод:

Текущий язык: Python

Текущий язык: Java

Текущий язык: Ruby

Вывод:

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

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

PREV Tutorial | СЛЕДУЮЩИЙ Учебник

.

python - заменить вложенные циклы ... или нет

Переполнение стека
  1. Около
  2. Продукты
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. Вакансии Программирование и связанные с ним технические возможности карьерного роста
  4. Талант Нанимайте технических специалистов и создавайте свой бренд работодателя
  5. Реклама Обратитесь к разработчикам и технологам со всего мира
  6. О компании
.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Theme: Overlay by Kaira Extra Text
Cape Town, South Africa