Циклы в python: Циклы for и while, операторы break и continue, волшебное слово else

Циклы for, while в Python

Автор Даниил Полянский На чтение 10 мин Просмотров 1.6к. Опубликовано 01.12.2021 Обновлено 29.08.2022

В статье разбираем циклы for, while в Python, использование функций range() и enumerate()

Содержание

1. Что такое циклы в Python: зачем они нужны
2. Цикл for: синтаксис
3. Использование функций range() и enumerate()
4. Вложенный цикл
5. Цикл while
6. Бесконечный цикл while
7. Операторы break, continue и pass в python
8. Оператор else
9. Заключение

Что такое циклы в Python: зачем они нужны

Итак, термин «цикл» часто встречается в обычной жизни.

Сутки, дни недели, времена года, даже года – это своеобразные представители циклов.

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

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

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

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

Допустим, вы решили перебрать старые вещи и достали все коробки с чулана. Теперь необходимо построить алгоритм проверки коробок.

Алгоритм без цикла (они называются линейными):

1. Открыть коробку №1.
2. Проверить ее содержимое.
3. Перейти к коробке №2.
4. Проверить ее содержимое.
5. Перейти к короб. №3.
6. Проверить ее содержимое.

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

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

1. Текущая коробка (n) = 1.
2. Открыть коробку № n.
3. Проверить ее содержимое.
4. Если ящики не закончились, то увеличить n на один, а после вернуться к пункту 2.
5. Иначе закончить поиск.

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

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

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

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

Цикл for: синтаксис

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

Синтаксис конструкции for в python выглядит следующим образом:

for i in variable:

#some code

Разберем каждую команду отдельно.

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

Вместо variable разработчик указывает структурную переменную, из которой необходимо брать переменные (то есть in указывает на variable). Знак двоеточия сообщает о начале нового блока. Все операторы внутри блока должны начинаться с одинарного отступа или 4 знаков пробелов.

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

Наглядное обозначение синтасиса

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

На языке python это будет выглядеть следующим образом:

boxes = ["текстиль", "старые игрушки", "посуда", "радиодетали", "зимние вещи", "фотографии"] # список с вещами
<p>print("среди боксов были найдены следующие вещи:") # операция вне цикла, которая выполнится один раз
for i in boxes:
print(i) # операция в цикле, которая выполнится столько раз, сколько значений в переменной boxes
print("Это весь список") # операция, которая выполнится один раз после завершения списка

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

Использование функций range() и enumerate()

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

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

counter = int(input("Ну сколько раз еще нужно сказать \"ну пожалуйста\", чтобы вы согласились:"))
for i in range(0, counter):
print ("ну пожалуйста!", sep=" ")
print("А теперь вы согласитесь?")

Теперь эта программа будет выводить сообщение столько раз, сколько введет пользователь. Это удобно, когда нужно получить только число. Теперь перейдем к функции enumerate.

Она, в отличие от range, принимает в качестве аргумента список, а после возвращает список кортежей, где каждый кортеж состоит из двух значений: индекс элемента и его значение.

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

Реализация:

example = ["-", "кило", "мега", "гига", "тера", "пета"]
print("приставки к единицам измерения в информатике:")
for k, i in enumerate(example): # в k будет храниться индекс, а в i значение
print(k, ":", i)

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

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

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

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

Пример вложенности:

strings = ["Утро","День","Вечер", "Ночь"]
for i in strings: # в i помещается отдельный элемент из списка
for z in i: # в z помещается отдельный символ из элемента, полученного в цикле выше
print(z, sep = " ")
print("\n")

Цикл while

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

В принципе, конструкции, которые упрощают какие-то процессы, но не добавляют ничего нового, называются «синтаксическим сахаром». А вот while – это уже не «сахар», а незаменимая конструкция, которая, в отличие от for, позволяет делать не только циклы с определенным количеством повторений, но и циклы с условиями и даже бесконечные (python от такого не защищен).

Синтаксис конструкции:

while (condition):

#code

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

Давайте рассмотрим три примера.

Пример с обычным условием:

numbers = [2,6,7,9,13,18,24,32,52,55,60,61,66,70,71,77,80,100] #список чисел
x = 0 # счетчик, по нему можно обратиться к элементу списка
while (numbers[x] <= 70): # выполнять, если (или пока) текущий элемент меньше 70
print(numbers[x]) # вывести текущий элемент
x+=1 # увеличить индекс, чтобы перейти к следующему элементу

Программа выведет все числа до 70, а вот 71, 77 и т. д. не выведутся, так как они не соответствуют условию внутри while.

Пример с заведомо ложным условием:

while (5 == 2):
print("YES")

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

Пример с всегда истинным условием:

while (5 == 5):
print("YES")

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

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

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

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

Реализация:

correct_password = "qwerty123"
user_password = ""
while (True): # условие заведомо постоянно истинно
user_password = input("введите пароль:")
if (user_password == correct_password):
break
print("Неверный пароль")

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

Операторы break, continue и pass в python

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

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

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

Пример программы, которая переписывает введенный текст, но без запятых:

word = "это предложение, чтобы показать работу continue,,,"
for i in word:
if(i == ","): # если запятая, то перейти к следующему элементу
continue
print(i, end = "")

На выходе пользователь получит только «это предложение чтобы показать работу continue». И, наконец, pass. Это слово не играет практической роли на итоговом этапе разработки, а нужно только при тестировании.

Если создать пустой цикл, то появится ошибка синтаксиса (а точнее отступов). Если создать его, а после добавить слово «pass», то все будет работать. Подытоживая, pass – это своего рода слово-пустышка для заполнения кода.

Оператор else

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

Else необходимо, если нужно выполнить какие-то действия только в том случае, если цикл был завершен «естественным» образом, а не через break.

Реализация:

rates = [5,5,3,5, 6, 5]
for i in rates:
if(i > 5 or i < 2):
print("В списке есть некорректная оценка")
break
else:
print("Проверен весь список, ошибок нет") 

Теперь else будет работать только в том случае, если цикл не будет прерываться break-ом. В этом примере, к слову, прерывание будет, а потому вывод из else не сработает. Попробуйте убрать 6 из списка, чтобы исправить ситуацию. 

Заключение

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

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

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

Содержание

1. Вложенные циклы Python
2. Пример 1: базовый пример вложенных циклов Python
3. Пример 2: Печать таблицы умножения с использованием вложенных циклов for в Python
4. Пример 3: Печать с использованием разных внутренних и внешних вложенных циклов
5. Использование оператора break во вложенных циклах
6. Использование оператора continue во вложенных циклах
7. Однострочные вложенные циклы с использованием list comprehension

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

Синтаксис вложенных циклов Python:

Outer_loop Expression:

Inner_loop Expression:

Statement inside inner_loop

Statement inside Outer_loop

Пример 1: базовый пример вложенных циклов Python

Python3

x =[1, 2]

y =[4, 5]

 

fori inx:

  forj iny:

    print(i, j)

Выход:

1 4
1 5
2 4
2 5

Time Complexity: O(n²)

Auxiliary Space: O(1)

Пример 2: Печать таблицы умножения с использованием вложенных циклов for в Python

Python3

 

fori inrange(2, 4):

 

    

    

    forj inrange(1, 11):

 

        

        print(i, "*", j, "=", i*j)

    

    print()

Выход:

2 * 1 = 2
2 * 2 = 4
2 * 3 = 6
2 * 4 = 8
2 * 5 = 10
2 * 6 = 12
2 * 7 = 14
2 * 8 = 16
2 * 9 = 18
2 * 10 = 20


3 * 1 = 3
3 * 2 = 6
3 * 3 = 9
3 * 4 = 12
3 * 5 = 15
3 * 6 = 18
3 * 7 = 21
3 * 8 = 24
3 * 9 = 27
3 * 10 = 30

Time Complexity: O(n²)

Auxiliary Space: O(1)

В приведенном выше примере мы берем внешний цикл for, работающий от 2 до 3, для таблицы умножения 2 и 3, а затем внутри этого цикла мы берем внутренний цикл for, который будет выполняться от 1 до 10, внутри которого мы печатаем умножение. table путем умножения каждого значения итерации внутреннего цикла на значение итерации внешнего цикла, как мы видим в приведенном ниже выводе.

Пример 3: Печать с использованием разных внутренних и внешних вложенных циклов

Python3

list1 =['I am ', 'You are ']

list2 =['healthy', 'fine', 'geek']

 

list2_size =len(list2)

 

foritem inlist1:

   

    

    print("start outer for loop ")

    

    i =

    

    

    while(i < list2_size):

       

        

        print(item, list2[i])

        

        i =i+1

    

    print("end for loop ")

Выход:

start outer for loop
I am  healthy
I am  fine
I am  geek

end for loop

start outer for loop

You are  healthy
You are  fine
You are  geek

end for loop

Time Complexity: O(n2)

Auxiliary Space: O(1)

В этом примере мы инициализируем два списка некоторыми строками. Сохраните размер list2 в ’list2_Size’, используя функцию len() и используя ее в цикле while в качестве счетчика. После этого запустите внешний цикл for для перебора list1, а внутри этого цикла запустите внутренний цикл while для перебора list2 с использованием индексации списка внутри, в котором мы печатаем каждое значение list2 для каждого значения list1.

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

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

Python3

fori inrange(2, 4):

 

    

    

    forj inrange(1, 11):

      ifi==j:

        break

      

      print(i, "*", j, "=", i*j)

    

    print()

Выход:

2 * 1 = 2

3 * 1 = 3
3 * 2 = 6

Time Complexity: O(n2)

Auxiliary Space: O(1)

Приведенный выше код такой же, как и в примере 2. В этом коде мы используем оператор break внутри внутреннего цикла с помощью оператора if. Внутри внутреннего цикла, если «i» становится равным «j», тогда внутренний цикл будет завершен и не выполнен, остальная часть итерации, как мы видим в выходной таблице 3, печатается до двух итераций, потому что в следующей итерации «i» становится равным «j», и цикл прерывается.

Использование оператора continue во вложенных циклах

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

Python3

fori inrange(2, 4):

 

    

    

    forj inrange(1, 11):

      ifi==j:

        continue

      

      print(i, "*", j, "=", i*j)

    

    print()

Выход:

2 * 1 = 2
2 * 3 = 6
2 * 4 = 8
2 * 5 = 10
2 * 6 = 12
2 * 7 = 14
2 * 8 = 16
2 * 9 = 18
2 * 10 = 20

3 * 1 = 3
3 * 2 = 6
3 * 4 = 12
3 * 5 = 15
3 * 6 = 18
3 * 7 = 21
3 * 8 = 24
3 * 9 = 27
3 * 10 = 30

Time Complexity: O(n2)

Auxiliary Space: O(1)

В приведенном выше коде вместо оператора break мы используем оператор continue. Здесь, когда «i» становится равным «j» во внутреннем цикле, он пропускает остальную часть кода во внутреннем цикле и переходит к следующей итерации, как мы видим в выводе «2 * 2 = 4» и «3 * 3 = 9» не печатается, потому что в этот момент ‘i’ становится равным ‘j’.

Однострочные вложенные циклы с использованием list comprehension

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

Синтаксис list comprehension:

newList = [ expression(element) for element in oldList if condition ] 

Код:

Python3

list1 =[[j forj inrange(3)]

         fori inrange(5)]

print(list1

Выход:

[[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]

В приведенном выше коде мы сохраняем список внутри списка, используя понимание списка во внутреннем цикле понимания списка [j для j в диапазоне (3)], чтобы создать список [0, 1, 2] для каждой итерации внешнего цикл «для i в диапазоне (5)».

Time Complexity: O(n2)

Auxiliary Space: O(n)

циклов в программировании на Python | Операторы управления в Python

Стать сертифицированным специалистом

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

1. Что такое циклы в Python?
2. Что такое за 9Цикл 0007 и цикл , а цикл ?
3. Операторы управления циклом

Если вы хотите освоить концепции циклов в Python к   Certified Python Expert , вы можете посмотреть видео ниже, где эти темы рассматриваются в более широком плане

Учебное пособие по циклам Python | Python для цикла | В то время как цикл Python | Обучение Python | Edureka

а = 10
б = 20
если а < б :
print("b больше")
 

а = 10
б = 20
если а < б :
print("b больше")
еще:
print("а больше")
 

а = 10
б = 20
если а < б :
print("b больше")
Элиф а == б :
print("а равно b")
еще:
print("а больше")
 

days = ["вс", "пн", "вт", "ср", "чт", "пт", "сб"]
за х в днях:
печать (х)
 

для x в диапазоне (3)
печать (х)
 

 0
1
2 

число = целое (ввод («число»))
факториал = 1
если число <0:
печатать("неверный ввод")
Элиф номер == 0:
print("факториал равен 1")
еще:
для i в диапазоне (1, число+1):
факториал = факториал * я
печать (факториал)
 

я = 1
пока я < 6:
     печать (я)
     я += 1
 

число = целое (ввод («введите число»))
пока число > 0:
    если число < 13:
        print("Число слишком большое")
        сломать
    Элиф номер < 13:
        print("Число слишком маленькое")
        сломать
    Элиф число == 13:
        print("Выход: поздравляю")
        сломать
 

для val в "string":
    если вал == "я":
       сломать
       печать (значение)
    распечатать("конец")
 

 с
т
р
Конец 

для val в "string":
    если вал == "я":
       Продолжить
       печать (значение)
   распечатать("конец")
 

 Выход:
с
т
р
н
грамм
конец
 

для val в "пожалуйста":
если вал == "а":
   проходят
   print("пропустить блок")
   печать (значение)
 

 р
л
е
проходной блок
а
с
e 

я = 1
пока я < 6:
     печать (я)
     если я == 3 :
        сломать
        я += 1
 

я = 1
пока я < 6:
   печать (я)
   если я == 3 :
      Продолжить
      я += 1
 

для i в диапазоне (1, 6):
  для j в диапазоне (i):
     распечатать (я, конец = "")
   Распечатать()
 

1
2 2
3 3 3
4 4 4 4
 

пока выражение:
пока выражение:
заявления)
заявления)
 

путешествие = ввод ("да или нет")
во время путешествия == "да" :
      num = int(input("количество людей"))
 для числа в диапазоне (1, число+1):
     имя = ввод ("имя")
     возраст = ввод ("возраст")
     пол = ввод ("пол")
     печать (имя)
     печать (возраст)
     печать (пол)
traveling = input("упс кого-то пропустил")
 

 для переменной в последовательности:
операторы 

 a = 5
для я в диапазоне (0, а):
печать (я)
 

 0
1
2
3
4
 

 Пока условие:
       оператор(ы) 

 count = 0
в то время как (количество 

 Flexiple
гибкий
гибкий
гибкий
гибкий