Где находятся инструкции которые выполняет цикл

Циклы

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

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

• while

• for

Цикл while

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

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

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

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

number = 1

while number < 5:
    print(f"number = {number}")
    number += 1
print("Работа программы завершена")

В данном случае цикл while будет выполняться, пока переменная number меньше 5.

Сам блок цикла состоит из двух инструкций:

print(f"number = {number}")
number += 1

Обратите внимание, что они имеют отступы от начала оператора while — в данном случае от начала строки. Благодаря этому Python может определить,
что они принадлежат циклу. В самом цикле сначала выводится значение переменной number, а потом ей присваивается новое значение. .

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

Весь процесс цикла можно представить следующим образом:

1. Сначала проверяется значение переменной number — меньше ли оно 5. И поскольку вначале переменная равна 1, то это условие возвращает True,
   и поэтому выполняются инструкции цикла

   Инструкции цикла выводят на консоль строку number = 1. И далее значение переменной number увеличивается на единицу — теперь она равна 2. Однократное выполнение блока инструкций цикла
   называется итерацией. То есть таким образом, в цикле выполняется первая итерация.

2. Снова проверяется условие number < 5. Оно по прежнему равно True, так как number = 2, поэтому выполняются инструкции цикла

   Инструкции цикла выводят на консоль строку number = 2. И далее значение переменной number опять увеличивается на единицу — теперь она равна 3.
   Таким образом, выполняется вторая итерация.

3. Опять проверяется условие number < 5. Оно по прежнему равно True, так как number = 3, поэтому выполняются инструкции цикла

   Инструкции цикла выводят на консоль строку number = 3. И далее значение переменной number опять увеличивается на единицу — теперь она равна 4.
   То есть выполняется третья итерация.

4. Снова проверяется условие number < 5. Оно по прежнему равно True, так как number = 4, поэтому выполняются инструкции цикла

   Инструкции цикла выводят на консоль строку number = 4. И далее значение переменной number опять увеличивается на единицу — теперь она равна 5.
   То есть выполняется четвертая итерация.

5. И вновь проверяется условие number < 5. Но теперь оно равно False, так как number = 5,
   поэтому выполняются выход из цикла. Все цикл — завершился. Дальше уже выполняются действия, которые определены после цикла. Таким образом, данный цикл
   произведет четыре прохода или четыре итерации

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

number = 1
number = 2
number = 3
number = 4
Работа программы завершена

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

number = 1

while number < 5:
    print(f"number = {number}")
    number += 1
else:
    print(f"number = {number}. Работа цикла завершена")
print("Работа программы завершена")

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

number = 1
number = 2
number = 3
number = 4
number =5. Работа цикла завершена
Работа программы завершена

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

number = 10

while number < 5:
    print(f"number = {number}")
    number += 1
else:
    print(f"number = {number}. Работа цикла завершена")
print("Работа программы завершена")

В данном случае условие number < 5 изначально равно False, поэтому цикл не выполняет ни одной итерации и сразу переходит в блоку else.

Цикл for

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

for переменная in набор_значений:
	инструкции

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

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

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

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

message = "Hello"

for c in message:
    print(c)

В цикле определяется переменную c, после оператора in в качестве перебираемого набора указана переменная message, которая хранит
строку «Hello». В итоге цикл for будет перебираеть последовательно все символы из строки message и помещать их в переменную c. Блок самого цикла
состоит из одной инструкции, которая выводит значение переменной с на консоль. Консольный вывод программы:

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

message = "Hello"
for c in message:
    print(c)
else:
    print(f"Последний символ: {c}. Цикл завершен");
print("Работа программы завершена")  # инструкция не имеет отступа, поэтому не относится к else

В данном случае мы получим следующий консольный вывод:

H
e
l
l
o
Последний символ: o. Цикл завершен
Работа программы завершена

Стоит отметить, что блок else имеет доступ ко всем переменным, которые определены в цикле for.

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

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

i = 1
j = 1
while i < 10:
    while j < 10:
        print(i * j, end="t")
        j += 1
    print("n")
    j = 1
    i += 1

Внешний цикл while i < 10: срабатывает 9 раз пока переменная i не станет равна 10. Внутри этого цикла срабатывает
внутренний цикл while j < 10:. Внутренний цикл также срабатывает 9 раз пока переменная j не станет равна 10.
Причем все 9 итераций внутреннего цикла срабатывают в рамках одной итерации внешнего цикла.

В каждой итерации внутреннего цикла на консоль будет выводится произведение чисел i и j. Затем значение переменной j увеличивается на единицу.
Когда внутренний цикл закончил работу, значений переменной j сбрасывается в 1, а значение переменной i увеличивается на единицу и происходит переход к
следующей итерации внешнего цикла. И все повторяется, пока переменная i не станет равна 10. Соответственно внутренний цикл сработает всего
81 раз для всех итераций внешнего цикла. В итоге мы получим следующий консольный вывод:

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	

Подобным образом можно определять вложенные циклы for:

for c1 in  "ab":
    for c2 in "ba":
        print(f"{c1}{c2}")

В данном случае внешний цикл проходит по строке «ab» и каждый символ помещает в переменную c1. Внутренний цикл проходит по строке «ba», помещает каждый
символ строки в переменную c2 и выводит сочетание обоих символов на консоль. То есть в итоге мы получим все возможные сочетания символов a и b:

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

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

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

number = 0
while number < 5:
    number += 1
    if number == 3 :    # если number = 3, выходим из цикла
        break
    print(f"number = {number}")

Здесь цикл while проверяет условие number < 5. И пока number не равно 5, предполагается, что значение number будет
выводиться на консоль. Однако внутри цикла также проверяется другое условие: if number == 3. То есть, если значение number равно 3, то с помощью
оператора break выходим из цикла. И в итоге мы получим следующий консольный вывод:

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

number = 0
while number < 5:
    number += 1
    if number == 3 :    # если number = 3, переходим к новой итерации цикла
        continue
    print(f"number = {number}")

И в этом случае если значение переменной number равно 3, последующие инструкции после оператора continue не будут выполняться:

number = 1
number = 2
number = 4
number = 5

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

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

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

Преимущества циклов

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

1. Это обеспечивает возможность повторного использования кода.
2. Используя циклы, нам не нужно писать один и тот же код снова и снова.
3. С помощью циклов мы можем перебирать элементы структур данных (массивов или связанных списков).

В Python существуют следующие операторы циклов.

Цикл for в Python

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

Синтаксис цикла for в python приведен ниже.

for iterating_var in sequence:    
    statement(s)    

Цикл For с использованием последовательности

Пример 1: Итерация строки с помощью цикла for

str = "Python"  
for i in str:  
    print(i)  

Вывод:

P
y
t
h
o
n

Пример 2: Программа для печати таблицы заданного числа.

list = [1,2,3,4,5,6,7,8,9,10]  
n = 5  
for i in list:  
    c = n*i  
    print(c)  

Вывод:

5
10
15
20
25
30
35
40
45
50s

Пример 3: Программа для печати суммы заданного списка.

list = [10,30,23,43,65,12]  
sum = 0  
for i in list:  
    sum = sum+i  
print("The sum is:",sum)  

Вывод:

The sum is: 183

Цикл For с использованием функции range()

Функция range()

Функция range() используется для генерации последовательности чисел. Если мы передадим range(10), она сгенерирует числа от 0 до 9. Синтаксис функции range() приведен ниже.

range(start,stop,step size)  

• Start означает начало итерации.
• Stop означает, что цикл будет повторяться до stop-1. range(1,5) будет генерировать числа от 1 до 4 итераций. Это необязательный параметр.
• Размер шага используется для пропуска определенных чисел в итерации. Его использование необязательно. По умолчанию размер шага равен 1. Это необязательно.

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

Пример 1: Программа для печати чисел по порядку.

for i in range(10):  
    print(i,end = ' ')  

Вывод:

0 1 2 3 4 5 6 7 8 9 

Пример 2: Программа для печати таблицы заданного числа.

n = int(input("Enter the number "))  
for i in range(1,11):  
    c = n*i  
    print(n,"*",i,"=",c)  

Вывод:

Enter the number 10
10 * 1 = 10
10 * 2 = 20
10 * 3 = 30
10 * 4 = 40
10 * 5 = 50
10 * 6 = 60
10 * 7 = 70
10 * 8 = 80
10 * 9 = 90
10 * 10 = 100

Пример 3: Программа для печати четного числа с использованием размера шага в range().

n = int(input("Enter the number "))  
for i in range(2,n,2):  
    print(i)  

Вывод:

Enter the number 20
2
4
6
8
10
12
14
16
18

Мы также можем использовать функцию range() с последовательностью чисел. Функция len() сочетается с функцией range(), которая выполняет итерацию по последовательности с использованием индексации. Рассмотрим следующий пример.

list = ['Peter','Joseph','Ricky','Devansh']  
for i in range(len(list)):  
    print("Hello",list[i])  

Вывод:

Hello Peter
Hello Joseph
Hello Ricky
Hello Devansh

Вложенный цикл for в python

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

for iterating_var1 in sequence:  #outer loop  
    for iterating_var2 in sequence:  #inner loop  
        #block of statements     
#Other statements    

Пример 1: Вложенный цикл for

# User input for number of rows  
rows = int(input("Enter the rows:"))  
# Outer loop will print number of rows  
for i in range(0,rows+1):  
# Inner loop will print number of Astrisk  
    for j in range(i):  
        print("*",end = '')  
    print()  

Вывод:

Enter the rows:5
*
**
***
****
*****

Пример 2: Программа для печати пирамиды чисел.

rows = int(input("Enter the rows"))  
for i in range(0,rows+1):  
    for j in range(i):  
        print(i,end = '')  
    print()  

Вывод:

1
22
333
4444
55555

Использование оператора else в цикле for

В отличие от других языков, таких как C, C++ или Java, Python позволяет нам использовать оператор else с циклом for, который может быть выполнен только тогда, когда все итерации исчерпаны. Здесь мы должны заметить, что если цикл содержит какой-либо оператор break, то оператор else не будет выполнен.

Пример 1

for i in range(0,5):    
    print(i)    
else:  
    print("for loop completely exhausted, since there is no break.")  

Вывод:

0
1
2
3
4
for loop completely exhausted, since there is no break.

Цикл for полностью исчерпал себя, так как нет прерывания.

Пример 2

for i in range(0,5):    
    print(i)    
    break;    
else:print("for loop is exhausted");    
print("The loop is broken due to break statement...came out of the loop")  

В приведенном выше примере цикл прерван из-за оператора break, поэтому оператор else не будет выполнен. Будет выполнен оператор, находящийся непосредственно рядом с блоком else.

Вывод:

0

Цикл был прерван, благодаря оператору break.

Цикл while в Python

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

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

Синтаксис приведен ниже.

while expression:    
    statements    

Здесь утверждения могут быть одним утверждением или группой утверждений. Выражение должно быть любым допустимым выражением Python, приводящим к true или false. Истиной является любое ненулевое значение, а ложью — 0.

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

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

1. Оператор continue — Когда встречается оператор continue, управление переходит в начало цикла. Давайте разберем следующий пример.

# prints all letters except 'a' and 't'   
i = 0  
str1 = 'javatpoint'  
  
while i < len(str1):   
    if str1[i] == 'a' or str1[i] == 't':   
        i += 1  
        continue  
    print('Current Letter :', a[i])   
    i += 1  

Вывод:

Current Letter : j
Current Letter : v
Current Letter : p
Current Letter : o
Current Letter : i
Current Letter : n

2. Оператор break — Когда встречается оператор break, он выводит управление из цикла.

Пример:

# The control transfer is transfered  
# when break statement soon it sees t  
i = 0  
str1 = 'javatpoint'  
  
while i < len(str1):   
    if str1[i] == 't':   
        i += 1  
        break  
    print('Current Letter :', str1[i])   
    i += 1  

Вывод:

Current Letter : j
Current Letter : a
Current Letter : v
Current Letter : a

3. Оператор pass — Оператор pass используется для объявления пустого цикла. Он также используется для определения пустого класса, функции и оператора управления. Давайте разберем следующий пример.

# An empty loop   
str1 = 'javatpoint'  
i = 0  
  
while i < len(str1):   
    i += 1  
    pass  
print('Value of i :', i)  

Вывод

Value of i : 10

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

i=1  
#The while loop will iterate until condition becomes false.  
While(i<=10):    
    print(i)   
    i=i+1   

Вывод

1
2
3
4
5
6
7
8
9
10

Пример 2: Программа для печати таблицы заданных чисел.

i=1    
number=0    
b=9    
number = int(input("Enter the number:"))    
while i<=10:    
    print("%d X %d = %d n"%(number,i,number*i))    
    i = i+1    

Вывод

Enter the number:10
10 X 1 = 10 

10 X 2 = 20 

10 X 3 = 30 

10 X 4 = 40 

10 X 5 = 50 

10 X 6 = 60 

10 X 7 = 70 

10 X 8 = 80 

10 X 9 = 90 

10 X 10 = 100 

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

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

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

Пример 1

while (1):    
    print("Hi! we are inside the infinite while loop"

Вывод

Hi! we are inside the infinite while loop
Hi! we are inside the infinite while loop

Пример 2

var = 1    
while(var != 2):    
    i = int(input("Enter the number:"))    
    print("Entered value is %d"%(i))    

Вывод

Enter the number:10
Entered value is 10
Enter the number:10
Entered value is 10
Enter the number:10
Entered value is 10
Infinite time

Использование else в цикле while

Python позволяет нам также использовать оператор else с циклом while. Блок else выполняется, когда условие, заданное в операторе while, становится ложным. Как и в случае с циклом for, если цикл while прервать с помощью оператора break, то блок else не будет выполнен, а будет выполнен оператор, присутствующий после блока else. Оператор else необязателен для использования с циклом while. Рассмотрим следующий пример.

i=1   
while(i<=5):    
    print(i)    
    i=i+1    
else:  
    print("The while loop exhausted")    

i=1    
while(i<=5):    
    print(i)    
    i=i+1    
    if(i==3):    
        break   
else:  
    print("The while loop exhausted")  

Вывод

1
2

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

Программа для печати чисел Фибоначчи до заданного предела

terms = int(input("Enter the terms "))  
# first two intial terms  
a = 0  
b = 1  
count = 0  
  
# check if the number of terms is Zero or negative  
if (terms <= 0):  
   print("Please enter a valid integer")  
elif (terms == 1):  
   print("Fibonacci sequence upto",limit,":")  
   print(a)  
else:  
   print("Fibonacci sequence:")  
   while (count < terms) :  
       print(a, end = ' ')  
       c = a + b  
       # updateing values  
       a = b  
       b = c  
     
    count += 1  

Enter the terms 10
Fibonacci sequence:
0 1 1 2 3 5 8 13 21 34 

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

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

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

Синтаксис прерывания приведен ниже.

#оператор цикла
break;   

Пример:

list =[1,2,3,4]  
count = 1;  
for i in list:  
    if i == 4:  
        print("item matched")  
        count = count + 1;  
        break  
print("found at",count,"location");  

Вывод:

item matched
found at 2 location

Пример:

str = "python"  
for i in str:  
    if i == 'o':  
        break  
    print(i);  

Вывод:

p
y
t
h

Пример: оператор break с циклом while

i = 0;  
while 1:  
    print(i," ",end=""),  
    i=i+1;  
    if i == 10:  
        break;  
print("came out of while loop");  

Вывод:

0  1  2  3  4  5  6  7  8  9  came out of while loop

Пример

n=2  
while 1:  
    i=1;  
    while i<=10:  
        print("%d X %d = %dn"%(n,i,n*i));  
        i = i+1;  
    choice = int(input("Do you want to continue printing the table, press 0 for no?"))  
    if choice == 0:  
        break;      
    n=n+1  

Вывод:

2 X 1 = 2

2 X 2 = 4

2 X 3 = 6

2 X 4 = 8

2 X 5 = 10

2 X 6 = 12

2 X 7 = 14

2 X 8 = 16

2 X 9 = 18

2 X 10 = 20

Do you want to continue printing the table, press 0 for no?1

3 X 1 = 3

3 X 2 = 6

3 X 3 = 9

3 X 4 = 12

3 X 5 = 15

3 X 6 = 18

3 X 7 = 21

3 X 8 = 24

3 X 9 = 27

3 X 10 = 30

Do you want to continue printing the table, press 0 for no?0

Оператор continue в Python

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

#loop statements    
continue  
#the code to be skipped     

Рассмотрим следующие примеры.

Пример

i = 0                     
while(i < 10):                
   i = i+1  
   if(i == 5):  
      continue  
   print(i)  

Вывод:

1
2
3
4
6
7
8
9
10

Обратите внимание на вывод приведенного выше кода, значение 5 пропущено, потому что мы предоставили условие if с помощью оператора continue в цикле while. Когда оно совпадает с заданным условием, управление передается в начало цикла while, и он пропускает значение 5 из кода.

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

Пример

str = "JavaTpoint"  
for i in str:  
    if(i == 'T'):  
        continue  
    print(i)  

Вывод:

J
a
v
a
p
o
i
n
t

Оператор pass в python

Оператор pass является нулевым оператором (null operation), поскольку при его выполнении ничего не происходит. Он используется в тех случаях, когда оператор синтаксически необходим, но мы не хотим использовать вместо него какой-либо исполняемый оператор.

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

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

list = [1,2,3,4,5]    
flag = 0    
for i in list:    
    print("Current element:",i,end=" ");    
    if i==3:    
        pass    
        print("nWe are inside pass blockn");    
        flag = 1    
    if flag==1:    
        print("nCame out of passn");    
        flag=0   

Вывод:

Current element: 1 Current element: 2 Current element: 3 
We are inside pass block


Came out of pass

Current element: 4 Current element: 5 

Python цикл Do While

В Python нет цикла do while. Но мы можем создать подобную программу.

Цикл do while используется для проверки условия после выполнения оператора. Он похож на цикл while, но выполняется хотя бы один раз.

Общий синтаксис цикла Do While (не отностится к python)

do {  
     //statement  
} while (condition);  

Пример: цикл do while в Python

i = 1  
  
while True:  
    print(i)  
    i = i + 1  
    if(i > 5):  
        break  

Вывод:

1  
2  
3  
4  
5  

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

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

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

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

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

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

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 очень значимы, именно они делают повторение простым, логичным и очень понятным.

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

Итерации

💡 Итерация — это повтор какого-либо действия. То есть один шаг цикла. Например, цикл из пяти повторений — пять итераций.

💡 Итератор — это интерфейс, который позволяет получить следующий объект последовательности.

💡 Итерируемые объекты — это объекты, которые можно повторять.

В Python проводят итерации только по тем объектам, которые реализуют интерфейс итератора. Это значит, что объект должен переопределять и реализовывать методы __iter__ и __next__.

Метод __iter__ возвращает self — ссылку на экземпляр. С помощью __next__ получают следующий элемент последовательности.

Виды циклов

В Python есть два вида циклов: for и while.

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

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

Пример:

int i = 0
while i < 10:
    print(“Hello, World!”)
    i++

Он выглядит так:

for (<объявление условия>)
    <условие 1>
        <тело цикла>
    <условие 2>
        <тело цикла>
    <условие n>
        <тело цикла>

    <код, который выполняет каждый шаг>
<код, который выполняется после итерации>

Как работать с циклом for в Python

Цикл for работает со встроенными типами данных. Например, строки, списки, множества, кортежи, словари и даже файлы.

🚀 По списку

Чтобы вывести на экран все элементы списка, напишите код:

# список
elems = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# итерация по списку
for item in elems:
    print(item)
...
0
1
2
3
4
5
6
7
8
9

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

# итерация по числам с нуля до 10 не включительно
for i in range(0, 10):
    print(i)
...
0
1
2
3
4
5
6
7
8
9

🚀 С шагом

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

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

Каждый шаг цикла делим индекс на 2 с остатком. Если остатка не будет, выводим число на печать. Вот так:

# кортеж
elems = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

# получаем размерность
length = len(elems)

# нам не нужно отнимать единицу, так как
# крайнее число в range не входит в последовательность
# первое число тоже не указываем
# по умолчанию — оно равно нулю

for i in range(length):
    # если остатка нет — выводим число
    if i % 2 == 0:
        print(elems[i])
...
0
2
4
6
8

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

# множество
elems = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

# применяется распаковка кортежа вида (индекс, элемент)
for index, elem in enumerate(elems):
    if index % 2 == 0:
        print(elem)
...
0
2
4
6
8

Так это делают с помощью шага в функции range:

</p>
# каждое второе число от 0 до 10
for i in range(0, 10, 2):
    print(i)
...
0
2
4
6
8

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

Пример:

for chr in "The t3st string"
    if chr.isdigit():
        break

    print(chr)
...
T
h
e

t

# дальше вывод не пойдет, так как слово t3st написано через тройку

Перейти на следующий шаг цикла можно с помощью инструкции continue.

Пример:

for i in range(10):
    if i % 3 == 0:
        continue

    print(i)
...
1
2
4
5
7
8

🚀 По строке

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

for chr in "THis is THe TEst sTRinG":
    if chr.islower():
        print(chr.upper())
    else:
        print(chr)
...
T
H
I
S

I
S

T
H
E

T
E
S
T

S
T
R
I
N
G

Если вы хотите прочитать каждую строку файла:

with open('file.txt', 'r') as f:
    for line in f:
        print(line)

🚀 По словарю

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

mydict = {1: "one", 2: "two", 3: "three", 4: "four", 5: "five"}

# итерация по ключам
for key in mydict:
    print(f"{key} :: {mydict[key]}")

# вывод вида <ключ :: значение>
...
1 :: one
2 :: two
3 :: three
4 :: four
5 :: five

# по ключам с явным указанием
for key in mydict.keys():
    print(f"{key} :: {mydict[key]}")

# вывод вида <ключ :: значение>
...
1 :: one
2 :: two
3 :: three
4 :: four
5 :: five

# итерация по значениям
for value in mydict.values():
    print(value)
...
one
two
three
four
five

# итерация по ключам и значениям
# применяется распаковка кортежа вида (ключ, значение)
for key, value in mydict.items():
    print(key, value)
...
1 one
2 two
3 three
4 four
5 five

🚀 Обратный цикл

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

elems = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

# пример
for item in reversed(elems):
    print(item)
...
9
8
7
6
5
4
3
2
1
0

# пример использования слайсингов
for item in elems[::-1]:
    print(item)
...
9
8
7
6
5
4
3
2
1
0

🚀 Генератор

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

# так мы сделаем список из 20 случайно сгенерированных чисел
mylist = [random.randint(0, 11) for _ in range(20)]

Главное о цикле for

• For перебирает элементы и выполняет код, который записан в теле цикла. В его основе лежат последовательности.
• Главное условие успешной работы цикла — объект должен быть итерируемым.
• Итерацию проводят по многим встроенным структурам данных: строки, словари, списки, множества, кортежи. Внутри инструкции создают ветвления в алгоритме с помощью проверок.
• Чтобы прервать цикл, используйте ключевое слово break. Чтобы пропустить элемент итерируемого множества — continue.
• Изучайте Python на онлайн-курсе от Skypro «Python-разработчик». Научитесь писать чистый код, разрабатывать сложную архитектуру сервисов. Даем только актуальные знания: исследовали 1230 вакансий, составили список самых частых требований к разработчикам без опыта и включили их в программу. В конце курса станете уверенным начинающим программистом и найдете работу в IT.