Курс по Python: https://stepik.org/course/100707

Смотреть материал на видео

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

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

Вот в таких ситуациях нам на помощь, как раз, и приходят циклы.

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

цикл (пока не прошел час):       прыгаем с горки

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

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

Обратите внимание на форматирование. Здесь также, как и в условных операторах, набор операторов внутри тела цикла должны иметь одинаковые отступы относительно ключевого слова while.

• Давайте вернемся к исходной задаче – вычисления суммы чисел от 1 до N и посмотрим, как здесь нам поможет цикл while. Вначале определим три вспомогательные переменные: N – значение последнего слагаемого; s – для хранения вычисленной суммы (начальное значение 0); i – значение текущего слагаемого (начинается с 1):
• Далее, так как сумму нужно вычислять, пока слагаемое i не достигнет значения N, то условие цикла можно определить, следующим образом:
• А внутри цикла будем выполнять следующие действия:

Вначале i равна 1 и эта единица прибавляется к сумме s. После чего i увеличивается на 1 и становится равной 2. Затем, выполняется проверка условия цикла.

Пока оно у нас истинно, поэтому снова попадаем внутрь тела цикла и к s прибавляется уже значение 2, а i опять увеличиваем на 1 и оно становится равным 3. И так до тех пор пока i не станет больше N.

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

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

Давайте реализуем теперь эту программу на Python и посмотрим как она сработает.

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

while i

Самоучитель Python — циклы for, while

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

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

Для чего нужны циклы в python?

Циклы упрощают сложные задачи до простых.

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

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

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

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

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

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

Оператор цикла
Описание

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

Цикл 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

4. More Control Flow Tools

As well as the while statement just introduced, Python uses a few more
that we will encounter in this chapter.

Perhaps the most well-known statement type is the if statement. For
example:

>>> x = int(input(«Please enter an integer: «))
Please enter an integer: 42
>>> if x >> # Measure some strings:
… words = ['cat', 'window', 'defenestrate']
>>> for w in words:
… print(w, len(w))
…
cat 3
window 6
defenestrate 12

Code that modifies a collection while iterating over that same collection can
be tricky to get right. Instead, it is usually more straight-forward to loop
over a copy of the collection or to create a new collection:

# Create a sample collection
users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'} # Strategy: Iterate over a copy
for user, status in users.copy().items(): if status == 'inactive': del users[user] # Strategy: Create a new collection
active_users = {}
for user, status in users.items(): if status == 'active': active_users[user] = status

If you do need to iterate over a sequence of numbers, the built-in function
range() comes in handy. It generates arithmetic progressions:

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

The given end point is never part of the generated sequence; range(10) generates
10 values, the legal indices for items of a sequence of length 10. It
is possible to let the range start at another number, or to specify a different
increment (even negative; sometimes this is called the ‘step’):

>>> list(range(5, 10))
[5, 6, 7, 8, 9] >>> list(range(0, 10, 3))
[0, 3, 6, 9] >>> list(range(-10, -100, -30))
[-10, -40, -70]

To iterate over the indices of a sequence, you can combine range() and
len() as follows:

>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
… print(i, a[i])
…
0 Mary
1 had
2 a
3 little
4 lamb

In most such cases, however, it is convenient to use the enumerate()
function, see Looping Techniques.

A strange thing happens if you just print a range:

>>> range(10)
range(0, 10)

In many ways the object returned by range() behaves as if it is a list,
but in fact it isn’t. It is an object which returns the successive items of
the desired sequence when you iterate over it, but it doesn’t really make
the list, thus saving space.

We say such an object is iterable, that is, suitable as a target for
functions and constructs that expect something from which they can
obtain successive items until the supply is exhausted. We have seen that
the for statement is such a construct, while an example of a function
that takes an iterable is sum():

>>> sum(range(4)) # 0 + 1 + 2 + 3
6

Later we will see more functions that return iterables and take iterables as
arguments. In chapter Data Structures, we will discuss in more detail about
list().

Цикл while в Python

Назад в начало

Цикл while («пока») позволяет выполнить одну и ту же последовательность действий, пока проверяемое условие истинно. Условие записывается после ключевого слова while и проверяется до выполнения тела цикла.

• Цикл while используется, когда невозможно определить точное количество повторений цикла.
• i = 0 # объявление переменной i для условия цикла while i < 5: # ключевое слово 'while' и условие выполнение цикла     # тело цикла     print(i) # вывод значения переменной i     i += 1 # увеличение значения переменной i на единицу
• # Вывод: >> 0 >> 1 >> 2 >> 3 >> 4
• Цикл while может быть бесконечным.
• i = 0 while True: # условие всегда истинно     print(i)     i += 1

# Вывод: >> 0 >> 1 >> 2 >> 3 >> 4 …

>> 999

…

# Это может продолжаться долго…

1. Выполнение цикла можно прерывать с помощью оператора break.
2. i = 0 while 1: # условие всегда истинно     if i == 3: # если i равно 3, то вызываем оператор break         break # оператор break прерывает выполнение цикла     print(i)     i += 1
3. # Вывод: >> 0 >> 1 >> 2
4. Оператор continue начинает повторение цикла заново.
5. i = 0 while i < 5:     i += 1 #     if i % 2 == 1: # если значение i нечетно, то вызываем оператор continue         continue # оператор continue начинает повторение цикла заново     # в случае вызова continue код ниже не выполнится     print(i)
6. # Вывод: >> 0 >> 2 >> 4
7. Как и для цикла for, для цикла while мы можем записать конструкцию else.
8. x = 1 while x < 5:     print(x)     x += 1 else:     print('Цикл завершен')
9. # Вывод: >> 1 >> 2 >> 3 >> 4 >> Цикл завершен

Примеры

1. Числа от A до B

# Пользователь вводит числа A и B (A > B). Выведите все числа от A до B включительно. A = int(input('Введите число: ')) B = int(input('Введите число: '))

while A >= B:

    print(A)     A -= 1

• # Ввод: >> 12 >> 7 # Вывод: >> 12 >> 11 >> 10 >> 9 >> 8 >> 7
• # Ввод:

>> 5 >> 2 # Вывод: >> 5 >> 4 >> 3 >> 2 2. Много чисел

# Пользователь вводит числа до тех пор, пока не введет 0. # Выведите количество введенных чисел (0 считать не нужно).

n = int(input('Введите число: ')) counter = 0 # счетчик введенных чисел while n: # n неявно преобразуется в тип bool     # если n равно 0, то выполнение цикла прервется     n = int(input('Введите число: ')) # вводим очередное число     counter += 1 # увеличиваем счетчик print(f'Количество чисел {counter}')

# Ввод: >> 1 >> 10 >> 100 >> 1000 >> 0 # Вывод: >> Количество чисел 4

3. Наименьший делитель

# Пользователь вводит число N (N > 1). Выведите его наименьший делитель. N = int(input('Введите число: ')) div = 2

while N % div != 0:

    div += 1 print(f'Наименьший делитель равен {div}')

1. # Ввод: >> 10 # Вывод: >> Наименьший делитель равен 2
2. # Ввод:

>> 15 # Вывод: >> Наименьший делитель равен 3

# Ввод:

>> 17 # Вывод: >> Наименьший делитель равен 17

Решение задач

1. Четные от A до B

Пользователь вводит числа A и B (A > B). Выведите четные числа от A до B включительно.

# Ввод: >> 10 >> 1 # Вывод: >> 10 >> 8 >> 6 >> 4 >> 2

2. От A до B на три

Пользователь вводит числа A и B (A < B, A меньше B). Выведите числа от A до B включительно, которые делятся на три.

# Ввод: >> 1 >> 15 # Вывод: >> 3 >> 6 >> 9 >> 12 >> 15

3. Сумма чисел

Пользователь вводит числа до тех пор, пока не введет 0. Выведите сумму введенных чисел (0 считать не нужно).

# Ввод: >> 1 >> 15 >> 10 >> 11 >> 2 >> 0 # Вывод: >> Сумма равна: 39

4. Максимум

Пользователь вводит числа до тех пор, пока не введет 0. Выведите максимальное введенное число (0 считать не нужно).

# Ввод: >> 1 >> 15 >> 10 >> 11 >> 2 >> 0 # Вывод: >> Максимум равен: 15

5. Минимум

Пользователь вводит числа до тех пор, пока не введет 0. Выведите минимальное введенное число (0 считать не нужно).

# Ввод: >> 1 >> 15 >> 10 >> 11 >> 2 >> 0 # 0 не входит в последовательность # Вывод: >> Минимум равен: 1

6. Факториал

Пользователь вводит число N. Выведите факториал число N. Факториал числа N — это произведение всех чисел от 1 до N включительно. Например, факториал числа 5 равен 120.

# Ввод: >> 5 # Вывод: >> 120

# Ввод:

>> 3 # Вывод: >> 6

# Ввод:

>> 4 # Вывод: >> 24 7. Фибоначчи (финальный босс)

Пользователь вводит число N. Выведите N-ное по счету число Фибоначчи. Последовательность чисел Фибоначчи рассчитывается по такой формуле: F(1) = 1, F(2) = 1, F(K) = F(K-2) + F(K-1). Идея такая: каждое следующее число равно сумму двух предыдущих.

Первые 10 чисел последовательности: 1 1 2 3 5 8 13 21 34 55 …

# Ввод: >> 5 # Вывод: >> 5

# Ввод:

>> 10 # Вывод: >> 55

# Ввод:

>> 8 # Вывод: >> 21

Как работает цикл "while" в Python

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

https://www.youtube.com/watch?v=qoGnMGd-wS8\u0026pp=ygVb0KbQuNC60Lsgd2hpbGUg0LIgUHl0aG9uOiDRh9GC0L4g0Y3RgtC-INGC0LDQutC-0LUsINC60LDQuiDRgNCw0LHQvtGC0LDQtdGCLCDQv9GA0LjQvNC10YDRiw%3D%3D

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

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

Как было отмечено выше,

Цикл — это управляющая конструкция, которая раз за разом выполняет серию команд (тело цикла) до тех пор, пока условие для выполнения является истинным.

Напишем на псевдокоде классическую схему:

повторять, пока условие
начало цикла
последовательность инструкций
конец цикла

Конструкция начинает свою работу с проверки условия, и, если оно истинно, запускается цикл.

На каждой новой итерации (единичный проход по циклу) условие продолжения проверяется вновь.

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

Циклы, как механизм программирования, нужны, главным образом, для упрощения написания кода. Вполне очевидно, что создавать программу, выполняющую определённую операцию для каждой точки 4К дисплея в отсутствии циклов — это вручную повторять описание нужной команды 4096*2160 раз. ???? Много? Безусловно.

Применение в этой задаче всего одного цикла позволит сократить длину кода, как минимум, на 6 порядков. А если представить, что ту же самую программу нужно переписать для 8К монитора, то, вместо изменения всего одной инструкции в счетчике цикла, вам придётся дописывать ещё пару десятков миллионов строк кода, что является попросту недопустимым по своей величине и трудозатратам объёмом.

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

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

В самом простом случае, цикл while в python очень похож по своей структуре на условную конструкцию с if:

import time
a = 1

if a == 1:
print(«I'm the condition»)

while a == 1:
print(«I'm the loop»)
time.sleep(1)

И в том и в другом случае, блок кода внутри (инструкция print(‘…’)) будет исполнен тогда и только тогда, когда условие (a == 1) будет иметь значение True. Вот только в конструкции с if, при успешной проверке, вывод на экран будет выполнен всего один раз, а в случае с while фраза «I’m the loop» будет печататься бесконечно.

Такое явление называется бесконечным циклом. У них есть свои определенные смысл и польза, но их мы разберём чуть позже, поскольку чаще всего цикл всё-таки должен как-то заканчиваться. И вполне логично, что для его завершения нужно произвести определенные манипуляции с условием.

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

count = 1 # фиксируем начальное значение
while count 20 23 26 29

Своеобразным счётчиком может быть даже строка:

word = «pythonchik»
while word:
print(word, end=» «)
# на каждой итерации убираем символ с конца
word = word[:-1]

> pythonchik pythonchi pythonch pythonc python pytho pyth pyt py p

break и continue

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

counter = 0
while True:
if counter == 10:
break
counter += 1

Цикл прервётся после того, как значение счетчика дойдёт до десяти.

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

# классический пример вывода одних лишь чётных значений
z = 10
while z:
z -= 1
if z % 2 != 0:
continue
print(z, end=» «)

> 8 6 4 2 0

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

else

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

В реальной практике, else в циклах применяется нечасто. Такая конструкция отлично сработает, когда будет необходимо проверить факт выполнения всех итераций цикла.

???? Пример из практики: проверка доступности всех выбранных узлов сети

Например, обойти все узлы локальной сети и

def print_prime_list(list_of_numbers: list) -> None:
«»» функция выведет список чисел,
если каждое из этих чисел является простым «»»
number_count = len(list_of_numbers) # количество чисел

i = 0
while i < number_count: x = list_of_numbers[i] // 2 if x != 0 and list_of_numbers[i] % x == 0: break i += 1 else: print(f'{list_of_numbers} - list is prime!') print_prime_list([11, 100, 199]) # 100 - не простое число >

print_prime_list([11, 113, 199])
> [11, 113, 199]

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

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

В большинстве случаев, бесконечные циклы появляются из-за логических ошибок программиста (например, когда условие цикла while при любых вариантах равно True). Поэтому следует внимательно следить за условием, при котором цикл будет завершаться.

https://www.youtube.com/watch?v=qoGnMGd-wS8\u0026pp=YAHIAQE%3D

Однако вы некоторых случая бесконечный цикл делают намерено:

1. Если нужно производить какие-то действия с интервалом, и выходить из цикла лишь в том случае, когда внутри тела «зашито» условие выхода.
   Пример: функция, которая возвращает connection базы данных. Если связь с базой данных отсутствует, соединение будет пытаться (в цикле) установиться до тех пор, пока не установится.
2. Если вы пишете полноценный демон, который продолжительное время висит как процесс в системе и периодически производит какие-то действия. В таком случае остановкой цикла будет прерывание работы программы. Пример: скрипт, который раз в 10 минут «пингует» IP адреса и пишет в лог отчет о доступности этих адресов.

????‍♂️ Совет: в бесконечных циклах рекомендуется ставить таймаут выполнения после каждой итерации, иначе вы очень сильно нагрузите CPU:

import time

while True:
print(«Бесконечный цикл»)
time.sleep(1)

>
Бесконечный цикл
Бесконечный цикл
Бесконечный цикл
Traceback (most recent call last):
File «main.py», line 5, in
time.sleep(1)
KeyboardInterrupt

Aborted!

Код был прерван комбинацией клавиш ^Ctrl + C. Иначе цикл продолжался бы бесконечно.

Best practice

Цикл while в одну строку

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

Например, записи:

while x < y: x +=1 # и while x < y: x += 1

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

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

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

q = 1
while q
J 200
J 201
J 202
# здесь видно, что внутренний цикл прерывается, но внешний продолжает работу
I 100
I 101
I 102
I 103
I 104

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

Способ №1 Используем конструкцию for … else …:

def same_values_exists(list_1: list, list_2: list) -> None:
«»» функция выводит на экран
первые совпавшие числа из списков «»»
for i in list_1:
for j in list_2:
print(«compare: «, i, j)
if i == j:
print(f»found {i}»)
break
else:
continue
break

same_values_exists([0, 10, -2, 23], [-2, 2])
>
compare: 0 -2
compare: 0 2
compare: 10 -2
compare: 10 2
compare: -2 -2
found -2

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

Способ №2
Через создание дополнительного флага:

def same_values_exists(list_1: list, list_2: list) -> None:
«»» функция выводит на экран
первые совпавшие числа из списков «»»
break_the_loop = False

for i in list_1:
for j in list_2:
print(«compare: «, i, j)
if i == j:
print(f»found {i}»)
break_the_loop = True
break
if break_the_loop:
break

same_values_exists([0, 10, -2, 23], [-2, 2])
>
compare: 0 -2
compare: 0 2
compare: 10 -2
compare: 10 2
compare: -2 -2
found -2

Внешний цикл был прерван вслед за внутренним. Дело сделано!

Способ №3
Если циклы находятся в функции (как в нашем примере), достаточно просто сделать return:

def same_values_exists(list_1: list, list_2: list) -> None:
«»» функция выводит на экран
первые совпавшие числа из списков «»»
for i in list_1:
for j in list_2:
print(«compare: «, i, j)
if i == j:
print(f»found {i}»)
return

same_values_exists([0, 10, -2, 23], [-2, 2])

>
compare: 0 -2
compare: 0 2
compare: 10 -2
compare: 10 2
compare: -2 -2
found -2

—

Циклы — Основы Python

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

Пользователь вводит пароль, а система разрешит вход, если пароль верный, а если нет — попросит ввести его снова. Для реализации программы недостаточно использовать только условный оператор, так как он позволит провести проверку только один раз. На помощь нам приходит цикл — он позволяет выполнять код многократно:

saved_pwd = «right_password»
pwd = input(«Введите пароль для входа: «)
while pwd != saved_pwd: pwd = input(«Введите пароль для входа: «)
print(«Пароль верный. Вход разрешён.»)

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

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

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

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

В предыдущем примере мы можем вообще обойтись без переменной pwd, так как она используется только в проверке условия продолжения цикла:

saved_pwd = «right_password»
while input(«Введите пароль для входа: «) != saved_pwd: pass
print(«Пароль верный. Вход разрешён.»)

Обратите внимание, что внутри тела цикла была использована пустая инструкция pass.

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

В Python версии 3.8 появился моржовый оператор (walrus operator). Он записывается как := и позволяет одновременно вычислить выражение, присвоить результат переменной и вернуть это значение, например в условие.

Давайте напишем программу, которая будет здороваться со всеми людьми, чьи имена введёт пользователь. Сигнал для остановки — ввод строки «СТОП»:

name = input(«Введите имя: «)
while name != «СТОП»: print(f»Привет, {name}!») name = input(«Введите имя: «)
print(«Программа завершена.»)

А теперь перепишем эту программу с использованием моржового оператора:

while (name := input(«Введите имя: «)) != «СТОП»: print(f»Привет, {name}!»)
print(«Программа завершена.»)

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

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

Если количество итераций заранее известно, то предпочтительнее использовать цикл for. Он применяется совместно с итерируемой переменной. Очень часто ей дают имя i и используют в теле цикла, а её значение изменяется на каждой итерации в соответствии с диапазоном, заданным функцией range().

Функция range() может принимать от одного до трёх целочисленных аргументов:

• range(n) — возвращает диапазон целых чисел от 0 до n — 1. Например, range(4) вернёт диапазон целых чисел: 0, 1, 2, 3;
• range(k, n) — возвращает диапазон целых чисел от k до n — 1. Например, range(1, 5) вернёт диапазон целых чисел: 1, 2, 3, 4;
• range(k, n, s) — возвращает диапазон целых чисел от k до n — 1 с шагом s. Например, range(1, 10, 2) вернёт диапазон целых чисел: 1, 3, 5, 7, 9.

Выведем на экран n целых чисел начиная с 0 (n вводится пользователем):

n = int(input(«Введите количество чисел: «))
for i in range(n): print(i)

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

Введите количество чисел: 5
0
1
2
3
4

Выведем на экран целые числа в диапазоне от k до n — 1 (k, n вводятся пользователем):

k = int(input(«Введите начало диапазона: «))
n = int(input(«Введите конец (без включения) диапазона: «))
for i in range(k, n): print(i)

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

Введите начало диапазона: 2
Введите конец (без включения) диапазона: 5
2
3
4

Выведем на экран целые чётные числа в диапазоне от 0 до n (n вводится пользователем):

n = int(input(«Введите конец диапазона: «))
for i in range(0, n + 1, 2): print(i)

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

Введите конец диапазона: 5
0
2
4

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

n = int(input(«Введите количество чисел: «))
for i in range(n, -1, -1): print(i)

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

Введите количество чисел: 5
5
4
3
2
1
0

Обратите внимание: изменение значения итерируемой переменной внутри тела цикла не имеет смысла, так как будет перезаписано на следующей итерации очередным значением из диапазона функции range(). Например, следующий код по-прежнему выведет числа от 0 до n — 1, несмотря на изменение значения итерируемой переменной в теле цикла:

n = int(input(«Введите n: «))
for i in range(n): print(i) i = 100

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

Введите n: 5
0
1
2
3
4

Изучаем основы работы с циклом while в Python: примеры применения и синтаксис

print(i)

i += 1

В данном примере цикл while выполняется, пока значение переменной i не станет больше 10. На каждой итерации переменная i увеличивается на единицу. Когда i достигнет значения 11, условие перестанет быть истинным и цикл закончится. Результатом работы данной программы будет вывод чисел от 1 до 10.

• Цикл while также может использоваться для обработки списков. Например, вы можете обойти список и выполнить над каждым его элементом действия:
• my_list = [1, 2, 3, 4, 5]
• i = 0
• while i < len(my_list):
• print(my_list[i])
• i += 1

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

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

Понимание цикла while

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

1. В простейшем случае цикл while выглядит следующим образом:
2. while условие:
3. инструкции

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

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

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

Описание синтаксиса

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

Вначале выполняется проверка условия.

Если оно истинно, то выполняется блок кода, который находится под ключевым словом while. После выполнения блока кода происходит повторная проверка условия и, если оно всё ещё истинно, цикл продолжает выполнение. Этот процесс повторяется до тех пор, пока условие не станет ложным.

Когда это происходит, управление передаётся на строку, следующую за циклом while.

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

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

Работа с логическими операторами

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

Основные логические операторы в Python:

• and – возвращает истину, если оба операнда истинны
• or – возвращает истину, если хотя бы один из операндов истинный
• not – возвращает противоположное значение операнда

1. Логические операторы могут быть использованы в условных выражениях, циклах и функциях. Например:
2. if x > 0 and y > 0:
3.       # выполнить действие, если x и y больше нуля

while x != 0 or y != 0:

•       # выполнять цикл, пока x или y не равны нулю
• Логические операторы также могут быть использованы в комбинации с другими операторами. Например:
• if x > 0 and (y < 0 or z > 0):
•       # выполнить действие, если x больше нуля и либо y меньше нуля, либо z больше нуля
• Знание логических операторов и умение их применять позволит вам создавать сложные и эффективные программы на Python.

Применение цикла while

1. Цикл while используется в Python для повторения одного и того же фрагмента кода до тех пор, пока заданное условие не станет ложным. Простой пример использования цикла while:
2. x = 1
3. while x < 5:
4. print(x)
5. x += 1

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

Что можно сделать с помощью цикла while?

• Итерироваться по элементам списка или кортежа:

• my_list = [1, 3, 7, 11]
• counter = 0
• while counter < len(my_list):
• print(my_list[counter])
• counter += 1

• Вычислять сумму элементов числового списка:

1. my_numbers = [1, 3, 5, 7, 9]
2. sum = 0
3. index = 0
4. while index < len(my_numbers):
5. sum += my_numbers[index]
6. index += 1
7. print(sum)

В данном случае сначала создаётся список my_numbers, потом введено значение переменной sum, равное 0, и переменной index, равное 0. Цикл while выполняется до тех пор, пока index меньше длины списка my_numbers. На каждой итерации значение sum увеличивается на значение элемента списка с индексом, указанным в переменной index, а переменная index увеличивается на 1.

• В Python возможно применение итератора для цикла while. Если необходимо выбрать одни или несколько элементов из объекта, можно использовать цикл вместе с вызовом метода списка:
• my_list = [11, 23, 7, 8, 3, 15]
• my_iterator = iter(my_list)
• while True:
• try:
• x = next(my_iterator)
• except StopIteration:
• break

В данном случае создаётся список my_list и итератор my_iterator. Затем задаётся бесконечный цикл while. Внутри цикла try, чтобы произвести вызов следующего элемента списка через метод next(), иначе вызывается исключение StopIteration, которое завершает цикл while. По мере прохождения цикла while переменная x будет присваиваться каждому следующему элементу списка.

Управление потоком выполнения программы

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

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

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

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

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

Использование для обхода и изменения списков

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

   Для начала мы можем воспользоваться методом len() для определения длины списка:

2. numbers = [1, 2, 3, 4, 5]
3. i = 0
4. while i < len(numbers):
5.     print(numbers[i])
6.     i += 1

В результате мы получим вывод всех элементов списка numbers – 1, 2, 3, 4, 5. А что, если мы захотим изменить каждый элемент списка? Для этого воспользуемся оператором присваивания:

• numbers = [1, 2, 3, 4, 5]
• i = 0
• while i < len(numbers):
•     numbers[i] *= 2
•     i += 1
• print(numbers)
• В результате мы получим измененный список, в котором каждый элемент умножен на 2 – 2, 4, 6, 8, 10.
• Также мы можем воспользоваться методом append() для добавления новых элементов в список:
• numbers = [1, 2, 3, 4, 5]
• i = 0
• while i < len(numbers):
•     numbers.append(numbers[i] * 2)
•     i += 1
• print(numbers)
• В результате мы получим список, в котором каждый элемент умножен на 2, а также добавлены новые элементы, равные удвоенным изначальным элементам – 1, 2, 3, 4, 5, 2, 4, 6, 8, 10.
• Цикл while позволяет использовать различные методы для обхода и изменения списков в Python, что делает его универсальным инструментом для работы с коллекциями данных.

Создание бесконечного цикла

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

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

1. Если вы все же захотите создать бесконечный цикл, используйте комбинацию из ключевых слов break и while, чтобы принудительно остановить выполнение цикла. Например:
2. “`python
3. while True:
4. # код, который будет выполняться вечно
5. if условие:
6. break
7. “`
8. Этот код будет выполняться бесконечно, пока не будет выполнено условие, после чего выполнение цикла будет прервано.
9. Однако, за исключением некоторых специфических случаев, создание бесконечных циклов не рекомендуется и может привести к нежелательным последствиям.

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

1. Подсчет суммы чисел.

• Цикл while может использоваться для подсчета суммы набора чисел. Например, в следующем примере мы используем цикл while для подсчета суммы чисел от 1 до 5:
• sum = 0
• i = 1
• while i