Python 3. Циклы и условия

Разбираем условный оператор if, циклы while и for, команды break, continue, pass и блок else в Python 3. С простыми примерами, типичными ошибками и дополнениями — match/case, enumerate, zip.

Условия

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

В примере выше, при нелинейном выполнении кода, если условие выполняется, то мы выполняем шаг 3, а если не выполняется, то шаг 2. А затем, в любом случае выполняем шаг 4.

Использование условного оператора if

Для того, чтобы использовать условия в коде Python, существует условный оператор — if.

Ниже показана схема использования условного оператора if (при этом блоки elif и else — не обязательны):

if <условие>:
    <блок кода 1>
elif <условие 2>:
    <блок кода 2>
elif <условие 3>:
    <блок кода 3>
elif <условие N>:
    <блок кода N>
else:
    <блок кода N+1>

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

Обратите внимание на два момента:

  • после условия обязательно ставится двоеточие :;
  • блок кода внутри if, elif и else выделяется отступом. В Python это не просто красота, а часть синтаксиса: по отступам интерпретатор понимает, где заканчивается блок. Принято использовать 4 пробела, и не стоит смешивать пробелы с табуляцией.

Примеры условий

В качестве условия можно указать:

  • > — больше;
  • < — меньше;
  • >= — больше или равно;
  • <= — меньше или равно;
  • != — не равно;
  • == — равно;
  • in — входит;
  • not in — не входит;
  • is — тождественно (один и тот же объект);
  • is not — не тождественно (не один и тот же объект).

Кстати, элементы могут быть равными, но не тождественными (не являются одним и тем же объектом). Давайте посмотрим на примере:

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)
print(a is b)
print(a is c)
True
False
True

Здесь a и b — это два разных списка с одинаковым содержимым. Поэтому a == b верно (значения равны), а a is b нет (это разные объекты в памяти). А вот c — это просто второе имя для того же самого списка a, поэтому a is c верно.

Правило простое: для сравнения значений используйте ==, а is оставьте для проверки на None, например if x is None:.

Логические операторы and, or, not

Условия можно комбинировать с помощью логических операторов:

  • and — «и», верно, когда выполняются оба условия;
  • or — «или», верно, когда выполняется хотя бы одно из условий;
  • not — «не», меняет результат условия на противоположный.

Пример, который проверяет, что число лежит в диапазоне от 1 до 25:

a = 18

if a >= 1 and a <= 25:
    print('Число в диапазоне')
Число в диапазоне

В Python такое сравнение можно записать короче, цепочкой: if 1 <= a <= 25:. Результат будет тот же.

Примеры кода

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

a = int(input('Введите первое число... '))
b = int(input('Введите второе число... '))
if a > b:
    print(a, 'больше чем', b)
elif a < b:
    print(a, 'меньше чем', b)
else:
    print(a, 'и', b, 'равны')
Введите первое число... 1
Введите второе число... 5
1 меньше чем 5

Программа просит вас ввести первое число и присваивает это число переменной a. Просит вас ввести второе число и присваивает это число переменной b.

Обратите внимание на функцию int(). Функция input() всегда возвращает строку, а строки сравниваются посимвольно, как слова в словаре. Если не преобразовать их в числа, то '10' < '5' окажется верным, ведь символ 1 идёт раньше символа 5. Это очень частая ошибка у новичков.

Затем начинается блок с условием. После if пишется первое условие, после elif — второе. При этом количество elif может быть любым. И в конце пишется else, без условия, и в нём то, что должно выполниться во всех остальных случаях.

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

my_list = [2, 5, 9, 18, 20]
a = int(input("Введите число от 1 до 25... "))
if a in my_list:
    print('Введённое число входит в список')
else:
    print('Введённое число не входит в список')
Введите число от 1 до 25... 18
Введённое число входит в список

Программа просит вас ввести число и присваивает это число переменной a. Затем проверяет, есть ли это число в списке, и если есть, пишет одно, а если нет, то другое.

И ещё один пример. С помощью условия if not my_list, вы можете узнать, пустой ли список (либо строка, словарь и другой подобный объект):

my_list1 = [1, 2, 3]
my_list2 = []

if not my_list1:
    print("Список my_list1 - пустой")
else:
    print("Список my_list1 не пустой")
    
if not my_list2:
    print("Список my_list2 - пустой")
else:
    print("Список my_list2 не пустой")
Список my_list1 не пустой
Список my_list2 - пустой

Это работает потому, что в условии Python может проверять не только True и False, но и любые другие значения. К «ложным» относятся: False, None, число 0, пустая строка '', пустые список [], кортеж (), словарь {} и множество. Всё остальное считается «истинным».

Условное выражение в одну строку

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

age = 20
status = 'взрослый' if age >= 18 else 'несовершеннолетний'
print(status)
взрослый

Схема такая: <значение 1> if <условие> else <значение 2>. Если условие верно, то получим первое значение, иначе второе. Используйте её только для простых случаев, а для сложных лучше писать обычный if.

Оператор match/case

Начиная с Python 3.10 появился оператор match/case. Он удобен, когда нужно сравнить одну переменную с множеством вариантов, и заменяет длинные цепочки elif. Пример:

command = input('Введите команду (start, stop, restart)... ')
match command:
    case 'start':
        print('Запускаем сервис')
    case 'stop' | 'restart':
        print('Останавливаем сервис')
    case _:
        print('Неизвестная команда')
Введите команду (start, stop, restart)... restart
Останавливаем сервис

Здесь | означает «или», а case _ — это вариант «всё остальное», аналог else. На самом деле match/case умеет гораздо больше, но для начала достаточно и этого.

Цикл while

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

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

После выполнения первого шага, проверяется условие. Если условие выполняется, то выполняются шаги 2 и 3. Затем опять проверяется условие, если оно опять выполняется, то опять выполняются шаги 2 и 3. И так до тех пор, пока условие не перестанет выполняться, тогда выполнится шаг 4. Поэтому при использовании такого цикла важно сделать так, чтобы когда-нибудь условие перестало выполняться, а то цикл будет бесконечным.

Схема использования цикла while — следующая:

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

Блок кода в else выполнится 1 раз, когда условие перестанет выполняться. Этот блок не обязателен. Об этом подробнее будет написано ниже.

В качестве условий здесь можно использовать всё то же самое, что и в операторе if.

Примеры кода

Первый пример с циклом while:

i = 0
while i < 5:
    i += 1
    print(i)
1
2
3
4
5

Разберу работу цикла по итерациям (по шагам). Итерация — это один проход цикла.

  • На первой итерации i (которое равно 0) увеличивается на 1 (i += 1) и выводится в консоль.
  • На второй итерации i уже равно 1, оно увеличивается на 1 и выводится в консоль.
  • И так далее. Когда i станет равным 5, оно выведется, и при следующей проверке условие (i < 5) уже не выполнится, поэтому цикл завершится.

Если бы мы забыли написать i += 1, то i всегда был бы равен 0, условие всегда выполнялось бы и цикл никогда бы не закончился. Если вы случайно запустили бесконечный цикл, то остановить программу в терминале можно сочетанием клавиш Ctrl+C.

Бесконечные циклы бывают и полезными. Например, когда нужно повторять запрос, пока пользователь не введёт правильное значение. Для этого пишут while True: и выходят из цикла с помощью break (о нём ниже):

while True:
    answer = input('Введите число от 1 до 10... ')
    if not answer.isdigit():
        print('Это не число, попробуйте ещё раз')
        continue
    number = int(answer)
    if 1 <= number <= 10:
        break
    print('Число вне диапазона, попробуйте ещё раз')
print('Вы ввели', number)
Введите число от 1 до 10... abc
Это не число, попробуйте ещё раз
Введите число от 1 до 10... 15
Число вне диапазона, попробуйте ещё раз
Введите число от 1 до 10... 7
Вы ввели 7

Break и continue

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

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

Вот пример с break:

i = 1
while i < 20:
    if i > 4:
        break
    i += i
    print(i)
2
4
8

Здесь цикл работает, пока i меньше 20. При этом i вначале равняется 1, а в цикле постоянно растёт (удваивается). Но как только i станет больше 4, сработает оператор break, и цикл прервёт свою работу. Обратите внимание, что условие i > 4 проверяется до увеличения i, поэтому 8 успевает вывестись: на тот момент i ещё равно 4.

А вот пример с continue:

i = 0
while i < 10:
    i += 1
    if i % 2 != 0:
        continue
    print(i)
2
4
6
8
10

Этот цикл выводит только чётные числа от 1 до 10. Работает это таким образом. Вначале i = 0 и в цикле постоянно увеличивается на 1. Если i не делится на 2 без остатка (if i % 2 != 0), то есть остаток от деления на 2 не равен нулю, то команды ниже пропускаются и мы возвращаемся к началу цикла. А если делится на 2 без остатка, то выполняем действия ниже, то есть выводим i в консоль.

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

Блок else

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

В этом примере цикл не будет прерван оператором break (i никогда не станет равным 10) и блок кода в else выполнится:

i = 0
while i < 5:
    i += 1
    if i == 10:
        break
    print(i)
else:
    print("Конец цикла!")
1
2
3
4
5
Конец цикла!

А в этом примере цикл прервётся в тот момент, когда i станет равна 3, с помощью break. Поэтому блок else не выполнится:

i = 0
while i < 5:
    i += 1
    if i == 3:
        break
    print(i)
else:
    print("Конец цикла!")
1
2

Блок else в цикле удобно использовать для поиска. Например: «ищем нужный элемент, если нашли — делаем break, а если дошли до конца и не нашли — в else сообщаем об этом».

Цикл for

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

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

Схема работы цикла for следующая:

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

Схема использования цикла for — следующая:

for i in <список / строка / кортеж / словарь / последовательность>:
    <блок кода>
else:
    <блок кода 2>

Здесь i — это переменная цикла, на каждой итерации в неё попадает очередной элемент. Называть её можно как угодно, например for server in servers: читается намного лучше, чем for i in servers:. Буквы i, j обычно оставляют для чисел.

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

Примеры кода

В первом примере цикл будет по очереди выводить элементы списка my_list.

my_list = [1, 12, 18]
for i in my_list:
    print(i)
1
12
18

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

my_list = [2, 3, 4, 5]
my_list2 = []
for i in my_list:
    my_list2.append(i * 2)
print(my_list2)
[4, 6, 8, 10]

Строка — это тоже последовательность, поэтому по ней можно пробежаться по буквам:

for char in 'Linux':
    print(char)
L
i
n
u
x

Break и continue

Этот цикл, как и цикл while, поддерживает две служебные команды — break и continue.

Вот пример с break:

my_list = [1, 12, 45, 58, 96]
for i in my_list:
    i += i
    if i >= 100:
        break
    print(i)
2
24
90

Здесь я складываю числа из списка: вначале i = 1, получается 1 + 1 = 2, пишет 2. Затем i = 12, 12 + 12 = 24, пишет 24. Затем i = 45, 45 + 45 = 90, пишет 90. Затем i = 58, 58 + 58 = 116, 116 это больше 100, выполняем break и больше ничего не пишем. Число 96 даже не обрабатывается.

А вот пример с continue:

my_list = [1, 12, 45, 58, 96]
for i in my_list:
    if i % 2 != 0:
        continue
    print(i)
12
58
96

Здесь я вывожу только чётные числа. Если i не делится на 2 без остатка (i % 2 != 0), то возвращаемся к началу цикла и обрабатываем следующий элемент.

Команда pass

Кстати, есть ещё одна команда, которую можно использовать в цикле и не только в нём, это команда — pass. Она ничего не делает, но если в этом месте кода нужно что-то написать, а вы пока не знаете что, то можете написать pass.

Этот кусок кода вызовет ошибку, ведь после цикла должен быть блок кода:

my_list = [1, 12, 18, 45, 58, 96]
for i in my_list:
IndentationError: expected an indented block after 'for' statement on line 2

А этот не вызовет:

my_list = [1, 12, 18, 45, 58, 96]
for i in my_list:
    pass

Он ничего не выведет, но и ошибки не будет.

Блок else

Так же как и в цикле while, в цикле for есть дополнительный блок — else. Он выполняется, только если цикл не был прерван оператором break.

Например, здесь цикл дойдёт до конца и не выполнит оператор break:

my_list = [1, 12, 18]
for i in my_list:
    if i == 17:
        break
    print(i)
else:
    print("Конец цикла")
1
12
18
Конец цикла

А в этом примере оператор break выполнится:

my_list = [1, 12, 18, 45, 58, 96]
for i in my_list:
    if i == 45:
        break
    print(i)
else:
    print("Конец цикла")
1
12
18

Пробегаемся по другим последовательностям (дополнительные примеры)

Список кортежей:

my_list = [(3, 6), (0, 1), (4, 5)]
for (a, b) in my_list:
    print(a, b)
3 6
0 1
4 5

Здесь на каждой итерации кортеж сразу «распаковывается» в две переменные: a и b.

Ключи словаря:

my_dict = {'a': 1, 'b': 10, 'c': 38}
for key in my_dict:
    print(key)
a
b
c

Ключи и значения словаря. Для этого у словаря есть метод items(), который отдаёт пары «ключ — значение»:

my_dict = {'a': 1, 'b': 10, 'c': 38}
for key, value in my_dict.items():
    print(key, '=>', value)
a => 1
b => 10
c => 38

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

Функция range()

С помощью функции range() можно сделать последовательность чисел для цикла for, например:

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

Здесь мы создали последовательность от 0 до 5 (не включительно). И пробежались по этой последовательности. Если начало не указывать, то оно по умолчанию равно 0, поэтому range(5) даст такой же результат.

Функция range() позволяет указать шаг итерации, например укажем шаг = 2:

for i in range(0, 10, 2):
    print(i)
0
2
4
6
8

Шаг может быть и отрицательным, тогда числа будут идти в обратную сторону:

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

Кстати, range() не создаёт сразу весь список чисел в памяти, он выдаёт их по одному, поэтому range(1000000) почти не занимает память. Если вам всё же нужен список, то используйте list(range(5)).

Функции enumerate() и zip()

Часто в цикле нужен не только элемент, но и его номер. Новички для этого создают отдельный счётчик, но в Python есть функция enumerate():

servers = ['nginx', 'apache2', 'samba']
for number, name in enumerate(servers, start=1):
    print(number, name)
1 nginx
2 apache2
3 samba

Параметр start задаёт, с какого числа начинать нумерацию (по умолчанию с 0).

А если нужно пробежаться сразу по двум спискам одновременно, то поможет функция zip():

servers = ['web-1', 'web-2', 'db-1']
ips = ['10.0.0.11', '10.0.0.12', '10.0.0.21']
for server, ip in zip(servers, ips):
    print(server, '-', ip)
web-1 - 10.0.0.11
web-2 - 10.0.0.12
db-1 - 10.0.0.21

Если списки разной длины, то zip() остановится на самом коротком.

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

Цикл можно поместить внутрь другого цикла. На каждую итерацию внешнего цикла внутренний пройдёт полностью. Например, выведем таблицу умножения от 1 до 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 

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

Итог

Здесь мы рассмотрели циклы и условия работающие в Python, а именно условный оператор if и два цикла: while и for.

Узнали, что конструкция if может дополнительно содержать несколько блоков с elif (с дополнительными условиями) и один блок else (который выполняется в случае, если if и ни один elif не выполнился). Условия можно комбинировать с помощью and, or, not, а для выбора из множества вариантов в Python 3.10+ есть match/case.

Цикл while — это цикл с условием, цикл for — это цикл, пробегающий по последовательностям. Кстати, последовательность можно сделать с помощью функции range, а функции enumerate и zip делают перебор удобнее.

Узнали, что циклы while и for также содержат дополнительный блок else, который выполнится, если цикл завершился сам, без break. А также оба цикла управляются дополнительными инструментами continue и break. При этом, если цикл завершается с помощью break, то блок else не выполняется.

Каждый цикл может содержать в себе вложенный цикл, но не стоит допускать слишком большую вложенность. Также цикл может быть внутри блока if, или наоборот, блок if может быть внутри цикла. То есть все эти элементы (if, while, for) допускают вложенность.


Если понравилась статья, подпишись на мой канал в VK или Telegram .