Инструкции управления циклом в языке python

программа до цикла
условие:
	первая строка тела
	вторая строка тела
программа после цикла

x = 1
while x < 5:
    print(x)
    x += 1  # Означает то же самое, что x = x + 1
>>> 1
>>> 2
>>> 3
>>> 4

# Этот код будет выполняться бесконечно
x = 1
while x < 5:
    print(x)

num_list = [14, 101, -7, 0]
for number in num_list:
    print(number)
>>> 14
>>> 101
>>> -7
>>> 0

for i in range(3):
    print(i)
>>> 0
>>> 1
>>> 2

for i in range(23, 26):
    print(i)
>>> 23
>>> 24
>>> 25

for i in range(10, 20, 3):
    print(i)
>>> 10
>>> 13
>>> 16
>>> 19

i for i in iterable_object

num_list = [i for i in range(1, 11)]
print(num_list)
>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print([i for i in range(1, 11) if i % 2 == 0])
>>> [2, 4, 6, 8, 10]

print([i ** 2 for i in range(1, 11) if i % 2 == 0])
>>> [4, 16, 36, 64, 100]

string = 'Hi, loop!'
for i in string:
    if i == ',':
        break
    print(i)
>>> H
>>> i

string = 'Hi loop!'
for i in string:
    if i == ',':
        break
    print(i)
>>> H
>>> i
>>>  
>>> l
>>> o
>>> o
>>> p
>>> !

for i in range(1, 10):
    if i%2 == 0 or i%3 == 0:
        continue
    print(i)
>>> 1
>>> 5
>>> 7

string = 'Hi, loop!'
for i in string:
    if i == ',':
        break
    print(i)
else:
    print('Цикл завершился без break')
>>> H
>>> i

string = 'Hi loop!'
for i in string:
    if i == ',':
        break
    print(i)
else:
    print('Цикл завершился без break')
>>> H
>>> i
>>>  
>>> l
>>> o
>>> o
>>> p
>>> !
>>> Цикл завершился без break

while 1 == 0:
    print('Эта строка никогда не выполнится')
else:
    print('Цикл завершился без break')
>>> Цикл завершился без break

# Способ №1 — «пока истинно»
while True:
	pass  # pass — оператор-заглушка, который ничего не делает

# Способ №2 — «пока проверяемое значение — любое ненулевое число»
while 1:
	pass
while -4:
	pass
while 2023:
	pass

# Способ №3 — «пока проверяемое значение — непустой элемент»
while 'string':
	pass
while [False, 'list', 0]:
	pass

# Способ №4 — корректное уравнение
while 1 == 1:
	pass
while 0 != 1:
	pass

# Способ №1
condition = True
while condition:
	pass
# Способ №2
condition = 1
while condition:
	pass
# Способ №3
condition = 'string'
while condition:
	pass

condition = True
x = 0
while condition:
    print(x)
    x += 1
    if x == 3:
        condition = False
else:
    print('Цикл завершился без break')
>>> 0
>>> 1
>>> 2
>>> Цикл завершился без break

x = 12
while True:
    x += 1
    print(x)
    if x > 5:
        break
>>> 13

while condition:
    pass
    while inner_condition:
        pass
    pass

for i in range(3):
    print(f'Итерация внешнего цикла: {i}')
    for j in range(2):
        print(f'Итерация внутреннего цикла: {j}')
>>> Итерация внешнего цикла: 0
>>> Итерация внутреннего цикла: 0
>>> Итерация внутреннего цикла: 1
>>> Итерация внешнего цикла: 1
>>> Итерация внутреннего цикла: 0
>>> Итерация внутреннего цикла: 1
>>> Итерация внешнего цикла: 2
>>> Итерация внутреннего цикла: 0
>>> Итерация внутреннего цикла: 1

Жизнь можно сделать лучше!
Освойте востребованную профессию, зарабатывайте больше и получайте от работы удовольствие. А мы поможем с трудоустройством и важными для работодателей навыками.
Посмотреть курсы

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

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

Циклы упрощают сложные задачи до простых. Он позволяет нам изменить поток программы таким образом, что вместо того, чтобы писать один и тот же код снова и снова, мы можем повторять его конечное число раз. Например, если нам нужно вывести первые 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 = %d\n"%(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 block\n");    
        flag = 1    
    if flag==1:    
        print("\nCame out of pass\n");    
        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  

As one of the most basic functions in programming, loops are an important piece to nearly every programming language. Loops enable developers to set certain portions of their code to repeat through a number of loops which are referred to as iterations. This topic covers using multiple types of loops and applications of loops in Python.

# Break and Continue in Loops

# break statement

When a break statement executes inside a loop, control flow «breaks» out of the loop immediately:

The loop conditional will not be evaluated after the break statement is executed. Note that break statements are only allowed inside loops, syntactically. A break statement inside a function cannot be used to terminate loops that called that function.

Executing the following prints every digit until number 4 when the break statement is met and the loop stops:

break statements can also be used inside for loops, the other looping construct provided by Python:

Executing this loop now prints:

Note that 3 and 4 are not printed since the loop has ended.

If a loop has an else clause (opens new window), it does not execute when the loop is terminated through a break statement.

# continue statement

A continue statement will skip to the next iteration of the loop bypassing the rest of the current block but continuing the loop. As with break, continue can only appear inside loops:

Note that 2 and 4 aren’t printed, this is because continue goes to the next iteration instead of continuing on to print(i) when i == 2 or i == 4.

# Nested Loops

break and continue only operate on a single level of loop. The following example will only break out of the inner for loop, not the outer while loop:

Python doesn’t have the ability to break out of multiple levels of loop at once — if this behavior is desired, refactoring one or more loops into a function and replacing break with return may be the way to go.

# Use return from within a function as a break

The return statement (opens new window) exits from a function, without executing the code that comes after it.

If you have a loop inside a function, using return from inside that loop is equivalent to having a break as the rest of the code of the loop is not executed (note that any code after the loop is not executed either):

If you have nested loops, the return statement will break all loops:

will output:

# For loops

for loops iterate over a collection of items, such as list or dict, and run a block of code with each element from the collection.

The above for loop iterates over a list of numbers.

Each iteration sets the value of i to the next element of the list. So first it will be 0, then 1, then 2, etc. The output will be as follow:

range is a function that returns a series of numbers under an iterable form, thus it can be used in for loops:

gives the exact same result as the first for loop. Note that 5 is not printed as the range here is the first five numbers counting from 0.

# Iterable objects and iterators (opens new window)

for loop can iterate on any iterable object which is an object which defines a __getitem__ or a __iter__ function.
The __iter__ function returns an iterator, which is an object with a next function that is used to access the next element of the iterable.

# Iterating over lists

To iterate through a list you can use for:

This will print out the elements of the list:

The range function generates numbers which are also often used in a for loop.

The result will be a special range sequence type (opens new window) in python >=3 and a list in python <=2. Both can be looped through using the for loop.

If you want to loop though both the elements of a list and have an index for the elements as well, you can use Python’s enumerate function:

enumerate will generate tuples, which are unpacked into index (an integer) and item (the actual value from the list). The above loop will print

Iterate over a list with value manipulation using map and lambda, i.e. apply lambda function on each element in the list:

Output:

NB: in Python 3.x map returns an iterator instead of a list so you in case you need a list you have to cast the result print(list(x)) (see http://stackoverflow.com/documentation/python/809/incompatibilities-between-python-2-and-python-3/8186/map) (opens new window)) in http://stackoverflow.com/documentation/python/809/incompatibilities-between-python-2-and-python-3 (opens new window) ).

# Loops with an «else» clause

The for and while compound statements (loops) can optionally have an else clause (in practice, this usage is fairly rare).

The else clause only executes after a for loop terminates by iterating to completion, or after a while loop terminates by its conditional expression becoming false.

output:

The else clause does not execute if the loop terminates some other way (through a break statement or by raising an exception):

output:

Most other programming languages lack this optional else clause of loops. The use of the keyword else in particular is often considered confusing.

The original concept for such a clause dates back to Donald Knuth and the meaning of the else keyword becomes clear if we rewrite a loop in terms of if statements and goto statements from earlier days before structured programming or from a lower-level assembly language.

For example:

is equivalent to:

These remain equivalent if we attach an else clause to each of them.

For example:

is equivalent to:

A for loop with an else clause can be understood the same way. Conceptually, there is a loop condition that remains True as long as the iterable object or sequence still has some remaining elements.

# Why would one use this strange construct?

The main use case for the for...else construct is a concise implementation of search as for instance:

To make the else in this construct less confusing one can think of it as «if not break» or «if not found«.

Some discussions on this can be found in [Python-ideas] Summary of for…else threads (opens new window), Why does python use ‘else’ after for and while loops?
, and Else Clauses on Loop Statements (opens new window)

# Iterating over dictionaries

Considering the following dictionary:

To iterate through its keys, you can use:

Output:

This is equivalent to:

or in Python 2:

To iterate through its values, use:

Output:

To iterate through its keys and values, use:

Output:

Note that in Python 2, .keys(), .values() and .items() return a list object. If you simply need to iterate trough the result, you can use the equivalent .iterkeys(), .itervalues() and .iteritems().

The difference between .keys() and .iterkeys(), .values() and .itervalues(), .items() and .iteritems() is that the iter* methods are generators. Thus, the elements within the dictionary are yielded one by one as they are evaluated. When a list object is returned, all of the elements are packed into a list and then returned for further evaluation.

Note also that in Python 3, Order of items printed in the above manner does not follow any order.

# The Pass Statement

pass is a null statement for when a statement is required by Python syntax (such as within the body of a for or while loop), but no action is required or desired by the programmer. This can be useful as a placeholder for code that is yet to be written.

In this example, nothing will happen. The for loop will complete without error, but no commands or code will be actioned. pass allows us to run our code successfully without having all commands and action fully implemented.

Similarly, pass can be used in while loops, as well as in selections and function definitions etc.

# While Loop

A while loop will cause the loop statements to be executed until the loop condition is falsey (opens new window). The following code will execute the loop statements a total of 4 times.

While the above loop can easily be translated into a more elegant for loop, while loops are useful for checking if some condition has been met. The following loop will continue to execute until myObject is ready.

while loops can also run without a condition by using numbers (complex or real) or True:

If the condition is always true the while loop will run forever (infinite loop) if it is not terminated by a break or return statement or an exception.

# Iterating different portion of a list with different step size

Suppose you have a long list of elements and you are only interested in every other element of the list. Perhaps you only want to examine the first or last elements, or a specific range of entries in your list. Python has strong indexing built-in capabilities. Here are some examples of how to achieve these scenarios.

Here’s a simple list that will be used throughout the examples:

# Iteration over the whole list

To iterate over each element in the list, a for loop like below can be used:

The for loop assigns s for each element of lst. This will print:

Often you need both the element and the index of that element. The enumerate keyword performs that task.

The index idx will start with zero and increment for each iteration, while the s will contain the element being processed. The previous snippet will output:

# Iterate over sub-list

If we want to iterate over a range (remembering that Python uses zero-based indexing), use the range keyword.

This would output:

The list may also be sliced. The following slice notation goes from element at index 1 to the end with a step of 2. The two for loops give the same result.

The above snippet outputs:

Indexing and slicing (opens new window) is a topic of its own.

# The «half loop» do-while

Unlike other languages, Python doesn’t have a do-until or a do-while construct (this will allow code to be executed once before the condition is tested). However, you can combine a while True with a break (opens new window) to achieve the same purpose.

This will print:

# Looping and Unpacking

If you want to loop over a list of tuples for example:

instead of doing something like this:

or something like this:

You can simply do this:

This will also work for most types of iterables, not just tuples.

# Syntax

• while :
• for in :
• for in range():
• for in range(<start_number>, <end_number>):
• for in range(<start_number>, <end_number>, <step_size>):
• for i, in enumerate(): # with index i
• for , in zip(, ):

# Parameters

while условие:
    блок инструкций

i = 1
while i <= 10:
    print(i ** 2)
    i += 1

n = int(input())
length = 0
while n > 0:
    n //= 10  # это эквивалентно n = n // 10
    length += 1
print(length)

i = 1
while i <= 10:
    print(i)
    i += 1
else:
    print('Цикл окончен, i =', i)

a = int(input())
while a != 0:
    if a < 0:
        print('Встретилось отрицательное число', a)
        break
    a = int(input())
else:
    print('Ни одного отрицательного числа не встретилось')

n = int(input())
for i in range(n):
    a = int(input())
    if a < 0:
        print('Встретилось отрицательное число', a)
        break    
else:
    print('Ни одного отрицательного числа не встретилось')

for i in range(3):
    for j in range(5):
        if j > i:
            break
        print(i, j)

n = int(input())
length = 0
while True:
    length += 1
    n //= 10
    if n == 0:
        break
print('Длина числа равна', length)

n = int(input())
length = 0
while n != 0:
    length += 1
    n //= 10
print('Длина числа равна', length)

n = int(input())
print('Длина числа равна', len(str(n)))

a = 1
b = 2
tmp = a
a = b
b = tmp
print(a, b)  
# 2 1

a = 1
b = 2
a, b = b, a
print(a, b)  
# 2 1

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

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

Например, если вы хотите вывести на экран числа от 1 до 10, вместо того чтобы написать десять отдельных строк с командой print(), можно использовать цикл for. Вот как это можно сделать:

for i in range(1, 11):
    print(i)

Этот код создает цикл for, который перебирает числа от 1 до 10 (включительно) и выводит каждое число на экран. Это намного эффективнее, чем написание десяти отдельных команд print(), и может сократить объем кода.

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

names = ['Андрей', 'Мария', 'Иван', 'Ольга']

for name in names:
    print('Привет, ' + name + '!')

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

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

Итерация, итерируемый объект

Итерация — это один шаг или повторение цикла.

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

Итерируемый объект — это что-то, по чему можно проходиться итерациями.

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

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

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

for variable in sequence:
    statement(s)

Где variable — это переменная, которая будет использоваться для хранения текущего элемента последовательности, sequence — это последовательность элементов, которые нужно перебрать, а statement(s) — это команды, которые будут выполняться для каждого элемента последовательности.

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

while condition:
    statement(s)

Где condition — это условие, которое должно быть выполнено для продолжения выполнения цикла, а statement(s) — это команды, которые будут выполняться до тех пор, пока условие не перестанет выполняться.

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

Цикл for в Python

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

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

for variable in sequence:
    statement(s)

Где:

• variable — это переменная, которая будет использоваться для хранения текущего элемента последовательности;
• sequence — это последовательность элементов, которые нужно перебрать;
• statement(s) — это команды, которые будут выполняться для каждого элемента последовательности.

Цикл for используется для перебора элементов в последовательности, например, в списке или строке. Для каждого элемента в последовательности переменная variable будет хранить значение этого элемента, и затем будут выполнены команды statement(s).

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

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

В этом примере мы создаем список fruits, содержащий три элемента. Затем мы используем цикл for для перебора всех элементов списка fruits. Переменная fruit будет хранить значение каждого элемента, начиная с первого элемента списка. Затем мы выводим каждый элемент списка на экран с помощью функции print(). В результате выполнения этого кода на экране будет выведено:

apple
banana
cherry

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

Функция range()

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

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

range(start, stop, step)

Где:

• start — необязательный аргумент, который указывает начальное значение последовательности. По умолчанию он равен 0.
• stop — обязательный аргумент, который указывает конечное значение последовательности. Оно не включается в последовательность.
• step — необязательный аргумент, который указывает шаг, с которым генерируются числа в последовательности. По умолчанию он равен 1.

Пример использования функции range() для генерации числовых последовательностей в цикле for:

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

В этом примере мы используем функцию range() для генерации последовательности чисел от 0 до 4. Цикл for используется для перебора каждого элемента в этой последовательности. На каждой итерации значение i будет увеличиваться на 1, и мы будем выводить это значение на экран с помощью функции print(). В результате выполнения этого кода на экране будет выведено:

0
1
2
3
4

Мы также можем использовать функцию range() для генерации последовательности чисел с другим начальным значением и шагом:

for i in range(1, 10, 2):
    print(i)

В этом примере мы используем функцию range() для генерации последовательности чисел от 1 до 9 с шагом 2. Цикл for используется для перебора каждого элемента в этой последовательности, и на каждой итерации мы будем выводить это значение на экран с помощью функции print(). В результате выполнения этого кода на экране будет выведено:

1
3
5
7
9

Функция range() также позволяет генерировать последовательности чисел в обратном порядке с помощью отрицательного шага. Например:

for i in range(10, 0, -1):
    print(i)

В этом примере мы используем функцию range() для генерации последовательности чисел от 10 до 1 с шагом -1. Цикл for используется для перебора каждого элемента в этой последовательности, и на каждой итерации мы будем выводить это значение на экран с помощью функции print(). В результате выполнения этого кода на экране будет следующее:

10
9
8
7
6
5
4
3
2
1

Функция range() с одним аргументом

Функция range() с одним аргументом используется для генерации последовательности чисел от 0 до заданного значения. Формат вызова функции выглядит следующим образом:

range(stop)

Где:

• stop — обязательный параметр, определяющий значение верхней границы последовательности (не включается в неё).

Пример использования функции range() с одним аргументом в цикле for:

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

В этом примере функция range() генерирует последовательность чисел от 0 до 4, которая используется в цикле for для перебора элементов. На каждой итерации значение i будет увеличиваться на 1, и мы будем выводить его на экран с помощью функции print(). В результате выполнения этого кода на экране будет выведено:

0
1
2
3
4

Можно заметить, что последовательность не содержит значение 5, так как оно не включается в неё. Если нам нужно включить значение 5, мы можем изменить вызов функции следующим образом:

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

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

range() с двумя аргументами

Функция range() с двумя аргументами используется для генерации последовательности чисел с определенным шагом. Формат вызова функции выглядит следующим образом:

range(start, stop)

Где:

• start — опциональный параметр, определяющий значение первого элемента последовательности. По умолчанию равен 0.
• stop — обязательный параметр, определяющий значение верхней границы последовательности (не включается в неё).

Пример использования функции range() с двумя аргументами в цикле for:

for i in range(2, 10):
    print(i)

В этом примере функция range() генерирует последовательность чисел от 2 до 9, которая используется в цикле for для перебора элементов. На каждой итерации значение i будет увеличиваться на 1, и мы будем выводить его на экран с помощью функции print(). В результате выполнения этого кода на экране будет выведено:

2
3
4
5
6
7
8
9

range() с тремя аргументами

Функция range() с тремя аргументами используется для создания последовательности чисел с определенным шагом (инкрементом). Три аргумента функции range() задают начальное значение, конечное значение и шаг.

Синтаксис:

range(start, stop, step)

• start — начальное значение (включительно). По умолчанию равно 0.
• stop — конечное значение (исключительно). Обязательный аргумент.
• step — шаг. По умолчанию равен 1.

Примеры использования:

# Печать чисел от 1 до 10 с шагом 2
for i in range(1, 11, 2):
    print(i, end=' ')

# Печать чисел от 10 до 1 с шагом -1
for i in range(10, 0, -1):
    print(i, end=' ')

В первом примере цикл for проходит по значениям от 1 до 10 (включительно) с шагом 2 и печатает каждое значение. Результат выполнения кода:

1 3 5 7 9

Во втором примере цикл for проходит по значениям от 10 до 1 (не включительно) с шагом -1 и печатает каждое значение. Результат выполнения кода:

10 9 8 7 6 5 4 3 2 1

range() с отрицательными аргументами

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

Например, если мы хотим напечатать числа от 10 до 1 в порядке убывания, мы можем использовать отрицательный шаг:

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

Результат выполнения кода:

10 9 8 7 6 5 4 3 2 1

Аналогично, мы можем напечатать числа от 5 до -5 в порядке убывания с шагом -1:

for i in range(5, -6, -1):
    print(i, end=' ')

Результат выполнения кода:

5 4 3 2 1 0 -1 -2 -3 -4 -5

Заметим, что в данном случае конечное значение равно -6, а не -5, поскольку последовательность не включает в себя значение -5.

Перебор последовательностей с помощью цикла for

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

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

Рассмотрим пример. Предположим, у нас есть список my_list с элементами [1, 2, 3, 4, 5]. Мы можем перебрать этот список следующим образом:

my_list = [1, 2, 3, 4, 5]

for element in my_list:
    print(element)

Результат выполнения кода:

1
2
3
4
5

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

Точно так же мы можем перебрать и символы в строке. Например, у нас есть строка "hello world". Мы можем перебрать ее символы следующим образом:

my_string = "hello world"

for char in my_string:
    print(char)

Результат выполнения кода:

h
e
l
l
o

w
o
r
l
d

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

Функция enumerate()

Мы также можем использовать функцию enumerate() для получения индексов элементов при переборе последовательности. Например:

my_list = [1, 2, 3, 4, 5]

for index, element in enumerate(my_list):
    print(f"Index: {index}, Element: {element}")

Index: 0, Element: 1
Index: 1, Element: 2
Index: 2, Element: 3
Index: 3, Element: 4
Index: 4, Element: 5

Здесь мы использовали функцию enumerate(), которая возвращает пару значений — индекс элемента и сам элемент на каждой итерации цикла for. Мы определяем две переменные — index и element, которые будут хранить соответствующие значения, и затем печатаем их.

Использование параметров sep и end функции print() в цикле for

Функция print() в Python имеет два параметра, которые могут быть использованы в цикле for: sep и end.

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

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

Пример использования параметров sep и end в цикле for:

numbers = [1, 2, 3, 4, 5]

for num in numbers:
    print(num, end=', ', sep='')

# Вывод: 1, 2, 3, 4, 5,

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

Таким образом, использование параметров sep и end в цикле for может значительно упростить форматирование вывода на экран.

Задания для закрепления

Задание 1. Вывести на экран все четные числа от 0 до 20

for i in range(0, 21, 2):
    print(i)

Задание 2. Посчитать сумму первых 10 натуральных чисел

sum = 0
for i in range(1, 11):
    sum += i
print(sum)

Задание 3. Вывести на экран таблицу умножения от 1 до 10

for i in range(1, 11):
    for j in range(1, 11):
        print(i * j, end='\t')
    print()

Задание 4. Вывести на экран последовательность чисел в обратном порядке

for i in range(10, 0, -1):
    print(i)

Задание 5. Напишите программу, которая перебирает строку, находит все цифры в ней и выводит их

text = "abc123xyz789"
for char in text:
    if char.isdigit():
        print(char)

Цикл while

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

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

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

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

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

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

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

while условие:
    блок кода

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

Один из примеров использования цикла while — это чтение ввода пользователя с клавиатуры. Например, мы можем написать цикл, который запрашивает у пользователя числа, пока он не введет число 0:

sum = 0
num = 1
while num != 0:
    num = int(input("Введите число (введите 0 для выхода): "))
    sum += num
print("Сумма введенных чисел равна", sum)

В этом примере мы создаем переменную sum и переменную num, которая будет использоваться для чтения ввода пользователя. Затем мы начинаем цикл while, который будет выполняться, пока значение переменной num не станет равным 0. Внутри цикла мы запрашиваем у пользователя ввод числа, преобразуем его в целое число с помощью функции int(), добавляем его к переменной sum, и затем проверяем условие, чтобы определить, продолжать ли цикл. Если пользователь введет число 0, то условие num != 0 станет ложным, и цикл завершится. Мы выводим сумму введенных чисел на экран с помощью функции print().

Условие выхода из цикла

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

Синтаксис условия выхода из цикла while выглядит так:

while условие:
    # блок инструкций

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

Например, давайте рассмотрим пример использования цикла while для подсчета суммы чисел от 1 до 10:

i = 1
summa = 0
while i <= 10:
    summa += i
    i += 1
print(summa)

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

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

Однако, если заранее известно количество итераций, то в этом случае лучше использовать цикл for.

Задание для закрепления

Задание 6. Написать программу, которая будет запрашивать у пользователя пароли до тех пор, пока он не введет правильный пароль. Правильный пароль задан заранее и равен «qwerty». После ввода правильного пароля программа должна вывести сообщение «Добро пожаловать!».

# Запрашиваем у пользователя пароли, пока он не введет правильный пароль
password = ""
while password != "qwerty":
    password = input("Введите пароль: ")

# Выводим на экран сообщение об успешной авторизации
print("Добро пожаловать!")

Инструкции управления циклом

break

Инструкция break в Python используется для принудительного выхода из цикла. Как только интерпретатор Python достигает инструкции break, выполнение цикла прекращается, и управление передается на следующую инструкцию после цикла.

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

while условие:
    if some_condition:
        break
    # остальной код

или

for элемент in последовательность:
    if some_condition:
        break
    # остальной код

Здесь some_condition — это условие, которое, если оно становится истинным, приводит к прерыванию цикла.

Вот пример использования break в цикле while, который выходит из цикла, если пользователь вводит слово "stop":

while True:
    user_input = input("Введите что-нибудь: ")
    if user_input == "stop":
        break
    print("Вы ввели:", user_input)
print("Цикл завершен.")

Как только пользователь вводит слово «stop», программа выходит из цикла и продолжает выполнение кода после цикла.

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

numbers = [1, 3, 5, 7, 10, 12]
for num in numbers:
    if num % 5 == 0:
        print("Первый элемент, который делится нацело на 5, это", num)
        break

Здесь, как только мы находим элемент, который делится нацело на 5, мы выводим его на экран и прерываем цикл.

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

continue

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

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

Пример использования continue:

for i in range(1, 6):
    if i == 3:
        continue
    print(i)

В этом примере цикл for перебирает числа от 1 до 5. Если число равно 3, то оператор continue переводит выполнение программы к следующей итерации, пропуская вывод числа 3. Таким образом, вывод программы будет:

1
2
4
5

В этом примере мы использовали continue, чтобы пропустить вывод числа 3 и перейти к выводу 4. Если бы мы не использовали continue, то число 3 также было бы выведено в консоль на экран.

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

Инструкция else в теле цикла — это опциональный (не обязательный) блок кода, который выполняется после того, как цикл завершается. Она выполняется только в том случае, если цикл завершился естественным путем, то есть без использования инструкций break. Синтаксис выглядит следующим образом:

while <условие>:
    <блок кода>
else:
    <блок кода>

или

for <переменная> in <итерируемый объект>:
    <блок кода>
else:
    <блок кода>

Здесь блок кода после else будет выполнен, когда завершится цикл. Если же цикл был прерван инструкцией break, блок кода после else не будет выполнен.

Пример:

numbers = [1, 2, 3, 4, 5]

for num in numbers:
    if num == 3:
        print("Число 3 найдено.")
        break
else:
    print("Число 3 не найдено.")

В этом примере мы создали список чисел и проходимся по нему с помощью цикла for. Если в списке встретится число 3, то будет выполнен блок кода внутри if, который выведет на экран «Число 3 найдено.» Затем выполнится инструкция break, которая прервет цикл.

Если же в списке не будет числа 3, то инструкция break не выполнится и цикл завершится нормально. Тогда выполнится блок кода внутри инструкции else, который выведет на экран «Число 3 не найдено.»

pass

Инструкция pass в Python — это оператор-заглушка, который не делает ничего. Он используется, когда синтаксически требуется оператор, но никакой действительной работы не нужно выполнять.

Например, если вы пишете функцию или цикл, но еще не определили тело, вы можете использовать pass в качестве временной заглушки, чтобы избежать ошибок синтаксиса:

def my_function():
    pass
    
for i in range(10):
    pass

return и циклы

Инструкция return используется для возврата значения из функции. В циклах return используется для выхода из цикла и возврата значения из функции. Когда оператор return выполняется внутри цикла, цикл останавливается и управление передается обратно в вызывающую функцию.

Например, если вы хотите выйти из цикла, когда определенное условие выполняется, вы можете использовать return:

def find_number(numbers, target):
    for num in numbers:
        if num == target:
            return True
    return False

В этой функции find_number мы проходимся по каждому элементу списка numbers и проверяем, равен ли он целевому числу target. Если мы находим его, мы возвращаем значение True. Если мы проходимся по всем элементам списка и не находим целевое число, мы возвращаем False.

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

Задания для закрепления

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

# Запрашиваем у пользователя числа, пока он не введет отрицательное число
sum = 0
while True:
    num = int(input("Введите целое число: "))
    if num < 0:
        break
    sum += num

# Выводим на экран сумму положительных чисел
print("Сумма положительных чисел: ", sum)

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

# Запрашиваем у пользователя строки, пока он не введет пустую строку
max_length = 0
while True:
    string = input("Введите строку: ")
    if string == "":
        break
    length = len(string)
    if length > max_length:
        max_length = length

# Выводим на экран длину самой длинной строки
print("Самая длинная строка имеет длину ", max_length, " символов.")

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

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

Синтаксис вложенных циклов аналогичен синтаксису обычных циклов. Внутренний цикл выполнится для каждой итерации внешнего цикла.

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

for i in range(1, 6):
    for j in range(1, 6):
        print(i, j)

В этом примере внешний цикл перебирает значения i от 1 до 5, а внутренний цикл перебирает значения j от 1 до 5 для каждого значения i. В результате мы получим все возможные комбинации чисел от 1 до 5.

Особенности использования break и continue в случае вложенных циклов

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

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

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

for i in range(2, 10):
    for j in range(2, i):
        if i % j == 0:
            break
    else:
        print(i, " - простое число")

В этом примере, если мы находим делитель, то инструкция break прерывает вложенный цикл for j. Если делителя нет, то выполняется инструкция else, которая выводит на экран простое число.

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

for i in range(10, 100):
    for j in range(10, 100):
        num = i * j
        str_num = str(num)
        if str_num == str_num[::-1]:
            print(num, " - палиндромное число")
            break
    else:
        continue
    break

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

Задания для закрепления

Задание 9. Напишите программу, которая выводит на экран следующую последовательность чисел:

1
12
123
1234
12345

for i in range(1, 6):
    for j in range(1, i+1):
        print(j, end='')
    print()

Задание 10. Напишите программу, которая выводит на экран следующую последовательность чисел:

1
22
333
4444
55555

for i in range(1, 6):
    for j in range(i):
        print(i, end='')
    print()

Задание 11. Напишите программу, которая выводит на экран следующую последовательность чисел:

1
23
456
78910

count = 1
for i in range(1, 5):
    for j in range(i):
        print(count, end='')
        count += 1
    print()

Задание 12. Напишите программу, которая выводит на экран следующую последовательность символов:

*
**
***
****
*****
****
***
**
*

for i in range(1, 6):
    for j in range(i):
        print('*', end='')
    print()

for i in range(4, 0, -1):
    for j in range(i):
        print('*', end='')
    print()

Множественное присваивание в Python

Множественное присваивание — это возможность присваивать нескольким переменным значения одновременно. В Python это можно сделать следующим образом:

a, b = 1, 2

В данном примере происходит множественное присваивание переменным a и b значений 1 и 2 соответственно. Это эквивалентно выполнению двух отдельных присваиваний:

a = 1
b = 2

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

a, b = b, a

В этом случае значения переменных a и b поменяются местами.

Также множественное присваивание может использоваться в циклах, например, для перебора последовательностей:

my_list = [1, 2, 3, 4, 5]
for i, value in enumerate(my_list):
    print(i, value)

В данном примере enumerate() возвращает пару (i, value) для каждого элемента списка my_list, которые затем распаковываются в переменные i и value с помощью множественного присваивания.

Видеоурок по циклам

Задания для закрепления работы с циклами

Задание 13. Дано два числа: a и b, a<b. Напечатать в столбик и строчку все числа от a до b включительно, а также квадраты этих чисел.

a = 1
b = 10

# Вывод чисел в столбик
for i in range(a, b+1):
    print(i, i**2)

# Вывод чисел в строку
for i in range(a, b+1):
    print(i, i**2, end=" ")

Задание 14. Дано два целых числа: a1 и a2. Если a1<a2, то напечатайте числа от a1 до a2 в порядке возрастания. В противном случае, напечатайте числа от a1 до a2 в порядке убывания.

a1 = int(input("Введите первое число: "))
a2 = int(input("Введите второе число: "))

if a1 < a2:
    for i in range(a1, a2+1):
        print(i)
else:
    while a1 >= a2:
        print(a1)
        a1 -= 1

Задание 15. Дано 20 чисел. Посчитайте их среднее арифметическое. Числа вводятся пользователем с клавиатуры

# инициализируем счетчики и сумму
count = 0
sum = 0

# вводим числа до тех пор, пока не наберем 20
while count < 20:
    num = int(input("Введите число: "))
    sum += num
    count += 1

# вычисляем среднее арифметическое
avg = sum / 20

# выводим результат
print("Среднее арифметическое:", avg)

Задание 16. Дано число k. Вычислите сумму квадратов нечетных чисел от 1 до k.

k = int(input("Введите число: "))
sum_of_squares = 0

for i in range(1, k+1, 2):
    sum_of_squares += i**2

print("Сумма квадратов нечетных чисел от 1 до", k, ":", sum_of_squares)

Задание 17. Дано число n. Мы вводим это число, а затем ровно n натуральных чисел. Посчитать, сколько среди этих чисел кратных трем

n = int(input("Введите количество чисел: "))
count = 0

for i in range(n):
    num = int(input("Введите число: "))
    if num % 3 == 0:
        count += 1

print("Количество чисел, кратных трем:", count)

Задание 18. Дано число n. Мы вводим это число, а затем ровно n слов, каждое с новой строки. Посчитать, сколько в этих словах сочетаний букв «ла».

n = int(input("Введите количество слов: "))
count = 0
i = 1

while i <= n:
    word = input(f"Введите слово №{i}: ")
    count += word.count("ла")
    i += 1

print(f"Количество сочетаний 'ла': {count}")

Задание 19. Дано число n>100. Напечатайте все числа, чьи кубы не превышают n

n = int(input("Введите число n: "))
num = 1
while num ** 3 <= n:
    print(num)
    num += 1

Задание 20. Простым числом называется натуральное число, большее единицы, которое имеет ровно два делителя: единицу и само себя. Дано число n. Определите, является ли число простым.

n = int(input("Введите число: "))

if n < 2:
    print(n, "не является простым числом")
else:
    is_prime = True
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            is_prime = False
            break
    if is_prime:
        print(n, "является простым числом")
    else:
        print(n, "не является простым числом")

Задание 21. Каждый день Хоббит съедает на 20 грамм больше еды, чем в предыдущий день. В первый день Хоббит съел x грамм еды. Определите, сколько дней Хоббит будет кушать, чтобы съесть не менее y грамм еды. Программа получает на вход действительные числа x и y и должна вывести одно натуральное число.

x = float(input("Введите количество съеденной еды в первый день, грамм: "))
y = float(input("Введите общее количество съеденной еды, грамм: "))

day = 1  # количество дней
total_food = x  # общее количество съеденной еды

while total_food < y:
    x += 20  # с каждым днем Хоббит съедает на 20 грамм больше еды
    total_food += x  # добавляем количество еды, съеденной в текущий день к общему количеству еды
    day += 1  # увеличиваем количество дней на 1

print("Хоббит будет кушать", day, "дней.")

Введите количество съеденной еды в первый день, грамм: <strong>50</strong>
Введите общее количество съеденной еды, грамм: <strong>500</strong>
Хоббит будет кушать <strong>5 дней</strong>.

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

count = 0  # переменная для хранения количества нулей
num = 0  # переменная для ввода чисел пользователем

while num >= 0:
    num = int(input("Введите неотрицательное число (для окончания введите отрицательное): "))
    if num == 0:
        count += 1  # увеличиваем счетчик нулей

print("Количество нулей в последовательности:", count)

Задание 23. Дана последовательность неотрицательных чисел. Последовательность вводится пользователем с клавиатуры, пока не будет введено отрицательное число. Посчитать среднее арифметическое всех чисел кратных 3.

count = 0
sum = 0
num = int(input("Введите число: "))
while num >= 0:
    if num % 3 == 0:
        count += 1
        sum += num
    num = int(input("Введите число: "))
if count == 0:
    print("В последовательности нет чисел, кратных 3")
else:
    average = sum / count
    print("Среднее арифметическое чисел, кратных 3, равно", average)

Задание 24. Дана последовательность неотрицательных чисел. Последовательность вводится пользователем с клавиатуры, пока не будет введено отрицательное число. Найдите максимальное число в последовательности и его позицию. Если максимальных чисел несколько, вывести позицию последнего из них. Номера позиции начинаются с нуля.:

max_num = -1
max_pos = -1
pos = 0
while True:
    num = int(input())
    if num < 0:
        break
    if num >= max_num:
        max_num = num
        max_pos = pos
    pos += 1
print(max_num)
print(max_pos)

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

max1 = max2 = max3 = -1

while True:
    num = int(input("Введите число: "))
    if num < 0:
        break
    if num > max1:
        max2 = max1
        max1 = num
    elif max2 < num <= max1:
        max2 = num
    elif max3 < num <= max2:
        max3 = num

print("Третье по величине число в последовательности:", max3)

Введите число: 5
Введите число: 8
Введите число: 2
Введите число: 10
Введите число: 3
Введите число: 6
Введите число: 7
Введите число: -1
Третье по величине число в последовательности: 7

Введите число: 5
Введите число: 2
Введите число: 5
Введите число: 1
Введите число: 3
Введите число: 5
Введите число: -1
Количество чисел в последовательности равных минимальному значению: 1

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

min_value = count_min_value = int(input("Введите число: "))
if min_value >= 0:
    while True:
        number = int(input("Введите число: "))
        if number < 0:
            break
        if number < min_value:
            min_value = number
            count_min_value = 1
        elif number == min_value:
            count_min_value += 1
    print("Количество чисел в последовательности равных минимальному значению:", count_min_value)
else:
    print("Последовательность пуста")

Введите число: 5
Введите число: 2
Введите число: 5
Введите число: 1
Введите число: 3
Введите число: 5
Введите число: -1
Количество чисел в последовательности равных минимальному значению: 1

Задание 27. Напишите программу, которая запрашивает у пользователя число n и выводит на экран первые n чисел Фибоначчи.

Числа Фибоначчи — это последовательность чисел, начинающаяся с 0 и 1, где каждое последующее число равно сумме двух предыдущих. То есть, первые числа Фибоначчи выглядят так: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 и т.д.

n = int(input("Введите количество чисел Фибоначчи: "))
a, b = 0, 1

if n <= 0:
    print("Введите число больше 0")
elif n == 1:
    print(a)
else:
    print(a, b, end=" ")
    for i in range(2, n):
        c = a + b
        print(c, end=" ")
        a = b
        b = c

Введите количество чисел Фибоначчи: 10
0 1 1 2 3 5 8 13 21 34

Задание 28. Напечатать минимальное число, большее 400, которое нацело делится на 19.

num = 400
while True:
    if num % 19 == 0:
        print(num)
        break
    num += 1

418

Вероятно, вы уже знакомы с оператором if и конструкциями if-else и if-elif-else. Теперь пришел черед для изучения циклов (loops). В статье рассмотрим простейшие конструкции с циклами for и while, инструкции для их прерывания и продолжения (break и continue соответственно), а также приведем примеры использования операторов if-elif-else для создания дополнительных условий.

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

Условия задаются при помощи специальных операторов (while или for, конструкции с которыми мы и рассмотрим), а однократное выполнение тела цикла называется итерацией. Итераций может быть сколько угодно, и они будут выполняться до тех пор, пока условие истинно. Если допустить логическую ошибку при написании кода, то итерации рискуют стать бесконечными. В таких случаях говорят о бесконечном цикле, который, впрочем, можно вызывать и намеренно.

Цикл for в языке программирования Python

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

word = "timeweb"
for letter in word:
    print (letter)

Получаем такой результат:

t
i
m
e
w
e
b

То есть программа перебирает все элементы, в данном случае символы, составляющие строку, и выдает их в виде последовательности. Но это могут быть и элементы списка (список создается при помощи символов [ ], а его элементы перечисляются через запятую. Давайте для примера возьмем тот самый список продуктов и выведем его на экран:

products = ['молоко', 'хлеб', 'яйца', 'колбаса', 'сахар', 'мука']
for element in products:
    print (element)
молоко
хлеб
яйца
колбаса
сахар
мука

Теперь несколько замечаний для новичков по приведенным выше примерам кода:

• Не забывайте про отступы, которые нужно делать для инструкций в теле цикла после главных строк с операторами for и while.
• Кавычки для корректного обозначения строк и элементов можно ставить как одинарные, так и двойные (для наглядности привели оба типа), но на практике лучше пользоваться каким-то одним вариантом, чтобы не ухудшать читаемость кода.
• Для обозначения счетчиков программисты обычно используют переменные i и j, но никто не запрещает маркировать их иначе. В данных примерах для наглядности мы намеренно обозначили счетчики как letter и element, чтобы было понятно, какие именно значения они перебирают.

Цикл while в Python 3

Функция оператора while иная, и проще всего ее понять, переведя слово while на русский: «до тех пор, пока». Это значит, что до тех пор, пока условие, вводимое while, истинное, тело цикла продолжит выполняться, при этом количество итераций заранее не известно (в отличие от циклов с оператором for). Пример:

number = 1
while number < 10:
    print (number)
    number += 2
print ('Следующее значение больше 10, поэтому счет прервался.')

Вот результат выполнения кода:

1
3
5
7
9
Следующее значение больше 10, поэтому счет прервался.

Одна из особенностей Python в том, что этот язык максимально наглядный, и какую работу выполняет код, часто понятно без подробных пояснений. В данном случае код можно расшифровать так: мы присвоили переменной number значение 1 и создали условие — до тех пор пока значение меньше 10, тело цикла будет выполняться. В теле создали две инструкции, одну видимую (выводить на экран очередное значение), а другая прибавляет к значению переменной указанное число и перезаписывает это значение. Для наглядности можно было бы переписать эту строку так:

number = number + 2

Записи x = x + 2 и x += 2 равнозначны (Python в некоторых случаях допускает использовать разный код для выполнения одних и тех же действий).

Как только условие, введенное оператором while, перестает быть истинным (number становится больше 10), тело цикла перестает выполняться, и программа переходит к заключительной строке (заметьте, что она расположена на другом уровне, поэтому не имеет отступа), а на экран выводится сообщение:

Следующее значение больше 10, поэтому счет прервался.

Использование конструкций if-elif-else с операторами цикла

Теперь рассмотрим более сложные и функциональные примеры конструкций с while, которые создаются с использованием операторов if, elif и else. Чтобы лучше понимать код с ними, удобно переводить их так:

• if — «если»;
• elif — «а если»;
• else — «в противном случае».

Приведем наглядный пример:

x = 0
while x < 10:
    if x == 0:
        print (x, "Выполняется условие оператора if")
        x += 1
    elif x <= 5:
        print (x, "Выполняется условие первого оператора elif")
        x += 1
    elif x > 5 and x < 9:
        print (x, "Выполняется условие второго оператора elif")
        x += 1
    else:
        print (x, "Выполняется условие оператора else")
        x += 1
print ("Вот и посчитали.")

Вот что получилось:

0 Выполняется условие оператора if
1 Выполняется условие первого оператора elif
…
6 Выполняется условие второго оператора elif
…
9 Выполняется условие оператора else
Вот и посчитали.

Разбираем. После присвоения переменной x значения 0 создаем условие для цикла while, а с помощью операторов if, elif и else добавляем набор условий, при которых на экран будет выводиться определенный текст. Условие if срабатывает тогда, когда значение x равно нулю, первый elif — при x меньше или равно пяти. В случае со вторым elif мы также использовали оператор and, добавляющий дополнительное условие, чтобы пользователь увидел и текст, который выводится при выполнении условия else. Python проверяет истинность условий последовательно, поэтому, если какое-то условие выше по списку будет оставаться истинным до последней итерации, инструкции тех условий, которые расположены ниже, выполняться не будут.

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

Инструкции break и continue дают дополнительные возможности для работы с циклами. Вот что они делают:

• break служит для прерывания цикла;
• continue — для пропуска определенной итерации и перехода к следующей, но без завершения цикла.

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

x = 0
while x < 10:
    if x == 0:
        print (x, "Выполняется условие оператора if")
        x += 1
    elif x <= 5:
        print (x, "Выполняется условие первого оператора elif")
        x += 1
    elif x > 5 and x < 9:
        print (x, "Выполняется условие второго оператора elif")
        x += 1
    else:
        print (x, "Выполняется условие оператора else")
print ("Вот и посчитали.")

Мы убрали строку с инструкцией x += 1 после оператора условия else и попали в бесконечный цикл! Конечно, можно просто вернуть ее, но можно сделать и так:

x = 0
while x < 10:
…
    else:
        print (x, "Выполняется условие оператора else")
        break
print ("Вот и посчитали.")

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

А вот пример, как работает инструкция continue:

products = ['молоко', 'хлеб', 'яйца', 'колбаса', 'сахар', 'мука']
print ('Нужно купить:')
print ()
for element in products:
    if element == 'колбаса':
        continue
    print (element)
print ()
print ('А колбасу мы уже купили.')

Результат работы программы:

Нужно купить:
молоко
хлеб
яйца
сахар
мука
А колбасу мы уже купили.

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

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

Также с помощью операторов циклов можно создавать вложенные циклы в Python 3. Пример:

for i in range (1, 4):
    for j in range (1, 4):
        print (i * j, end=" ")
    print ()

Результат работы программы:

1 2 3
2 4 6
3 6 9

Вы уже наверняка догадались, что таким образом достигается последовательное перемножение чисел (за это отвечает инструкция i * j в инструкции для вложенного цикла for, а код end=» « выводит полученные значения с пробелами). Нижняя инструкция с функцией print (), относящаяся к основному циклу for (это реализовано с помощью отступов), тоже нужна для наглядности: в этом случае программа выведет полученные значения в столбик.

Также у новичков может возникнуть вопрос, почему в выводе нет строки 4 8 12? Это особенность встроенной функции range, задающей диапазон значений: последнее число она не включает, поэтому, чтобы указанная выше строчка появилась, код должен быть написан так:

for i in range (1, 5):
    for j in range (1, 4):
        print (i * j, end=" ")
    print ()
1 2 3 
2 4 6 
3 6 9 
4 8 12 

Подведем итоги

Итак, в этом небольшом уроке мы познакомились с циклами for и while, узнали, как использовать вместе с ними условные конструкции if-elif-else, а также применять инструкции break и continue. Немного практики, и вы сможете писать более сложный код, чем был представлен в наших примерах. Удачи!

Кстати, в официальном канале Timeweb Cloud собрали комьюнити из специалистов, которые говорят про IT-тренды, делятся полезными инструкциями и даже приглашают к себе работать.