Что делает инструкция elif в python

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

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

yesterday_temp = int(input())
today_temp = int(input())
if today_temp > yesterday_temp:
    print("Сегодня теплее, чем вчера.")
elif today_temp < yesterday_temp:
    print("Сегодня холоднее, чем вчера.")
else:
    print("Сегодня такая же температура, как вчера.")

Оператор if является началом условной конструкции. Далее идёт условие, которое возвращает логическое значение True (истина) или False (ложь). Завершается условие символом «двоеточие». Затем — обязательный отступ в четыре пробела, он показывает, что строки объединяются в один блок. Отступ аналогичен использованию фигурных скобок или ключевых слов begin и end в других языках программирования.

Тело условной конструкции может содержать одно или несколько выражений (строк). По завершении тела может идти следующее условие, которое начинается с оператора elif (сокращение от else if — «иначе если»). Оно проверяется только в случае, если предыдущее условие не было истинным.

Синтаксис в elif аналогичен if. Операторов elif для одного блока условного оператора может быть несколько, а может не быть совсем. Последним идёт оператор else, который не содержит условия, а выполняется, только если ни одно из предыдущих условий в if и elif не выполнилось. Оператор else не является обязательным.

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

• > (больше);
• >= (больше или равно);
• < (меньше);
• <= (меньше или равно);
• == (равно);
• != (не равно).

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

• and — логическое «И» для двух условий. Возвращает True, если оба условия истинны, иначе возвращает False;
• or — логическое «ИЛИ» для двух условий. Возвращает False, если оба условия ложны, иначе возвращает True;
• not — логическое «НЕ» для одного условия. Возвращает False для истинного условия, и наоборот.

Ниже приведена таблица истинности для логических операций.

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

print("Введите первую и последнюю буквы русского алфавита.")
first_letter = input()
last_letter = input()
if (first_letter == "а" or first_letter == "А") and (
        last_letter == "я" or last_letter == "Я"):
    print("Верно.")
else:
    print("Неверно.")

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

if x >= 0 and x < 100:
    ...

лучше записать так:

if 0 <= x < 100:
    ...

Строки также можно сравнивать между собой с помощью операций >, < и т. д. В отличие от чисел, строки сравниваются посимвольно в соответствии с кодами символов в таблице кодировки (в Python рекомендуется использовать кодировку UTF-8).

Компьютер изначально работает только с двоичными числами. Поэтому для работы с символами им назначаются коды — числа, а сами таблицы соответствия символов и кодов называются таблицами кодировки. Кодировок существует достаточно много, одной из самых популярных на данный момент является UTF-8. Например, сравним две односимвольные строки:

letter_1 = "t"
letter_2 = "w"
print(letter_1 > letter_2)

Программа выведет False, поскольку символ t стоит в таблице кодировки раньше, чем w (как и по алфавиту, то есть лексикографически). Чтобы убедиться в этом, можно использовать встроенную функцию ord(), которая возвращает код символа из таблицы кодировки:

print(ord("t"), ord("w"))

В консоли отобразится:

116 119

Поскольку 116 меньше 119, в предыдущем примере мы и получили False.

Чтобы получить символ по его коду, необходимо вызвать встроенную функцию chr() с соответствующим кодом:

print(chr(116), chr(119))

В результате увидим:

t w

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

Для проверки условия наличия подстроки в строке (и для некоторых других вещей, о которых будет рассказано позже) используется оператор in. Например, проверим, что во введённой строке встречается корень «добр» (для слов «добрый», «доброе» и подобных):

text = input()
if "добр" in text:
    print("Встретилось 'доброе' слово.")
else:
    print("Добрых слов не найдено.")

В Python версии 3.10 появился оператор match. В простейшем случае он последовательно сравнивает значение выражения с заранее заданными в операторах case. А затем выполняет код в операторе case, значение в котором соответствует проверяемому. Напишем программу, которая сравнивает значение текущего сигнала светофора с одним из трёх вариантов (красный, жёлтый или зелёный):

color = input()
match color:
    case 'красный' | 'жёлтый':
        print('Стоп.')
    case 'зелёный':
        print('Можно ехать.')
    case _:
        print('Некорректное значение.')

Обратите внимание, что для проверки выполнения условия «ИЛИ» в операторе case не используется логическая операция or. Её нельзя использовать, поскольку она применяется для переменных логического типа, а в примере перечисляются значения-строки. Вместо неё мы используем специальный оператор |.

Последний оператор case выполняется всегда и сработает в случае, если ни одно из предыдущих условий не сработало. Оператор match похож на оператор switch других языков программирования — C++, JavaScript и т. д.

Рассмотрим некоторые полезные встроенные функции.

• Для определения длины строки (а также других коллекций, о которых будет рассказано позже) используется функция len().
• Для определения максимального и минимального из нескольких значений (не только числовых) используются функции max() и min() соответственно.
• Функция abs() используется для определения модуля числа.

Рассмотрим применение встроенных функций в следующем примере. Обратите внимание на строки, начинающиеся со знака #. Так в Python обозначаются комментарии — линии, которые не выполняются интерпретатором, а служат для пояснения кода.

m = 12
n = 19
k = 25

# максимальное число
print(max(m, n, k))

line_1 = "m"
line_2 = "n"
line_3 = "k"

# минимальная лексикографически строка
print(min(line_1, line_2, line_3))

# количество цифр в числе 2 в степени 2022
print(len(str(2 ** 2022)))

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

Ещё по теме

• Оператор match также используется для так называемой проверки шаблона (pattern matching), почитать о которой можно в этом материале.
• Все доступные в Python встроенные функции можно посмотреть на этой странице.

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

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

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

• Проверка, входит ли пользовательское значение в определенный диапазон значений.
• Выбор правильной формы слова в зависимости от его рода (например, «яблоко» или «яблоки»).
• Проверка наличия правильных данных в форме входа.
• Определение, кто является победителем в игре на основе результатов игры.

Оператор if

Синтаксис if

Оператор if в Python позволяет проверить, выполняется ли заданное условие, и выполнить определенные действия, если условие истинно.

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

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

Где:

• условие — это выражение, которое должно быть оценено как истинное или ложное.
• блок кода — это блок инструкций, который будет выполнен, если условие истинно. Блок кода должен быть с отступом в 4 пробела (или 1 табуляция).

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

x = 5

if x > 0:
    print("Число положительное")

В этом примере, условие x > 0 оценивается как истинное, поэтому блок кода после оператора if будет выполнен, и выведется сообщение «Число положительное».

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

Вложенные инструкции и отступы

Обратите внимание, что в примере выше, инструкция print("Число положительное") смещена вправо относительно инструкции if. Это сделано специально, для того, чтобы показать Python, что вывод сообщения «Число положительное», будет сделан только, если выполнится условие x > 0

В этом случае говорят, что инструкция print("Число положительное") является вложенной для инструкции if.

То есть, она подчинена ей, и будет выполнена только в случае выполнения условия.

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

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

if условие1:
    if условие2:
        инструкция1
        инструкция2
    else:
        инструкция3
else:
    инструкция4

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

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

Отступы очень важны в Python, и неправильное их использование может привести к ошибкам в вашем коде!

Для корректного задания отступов в Python необходимо следовать определенным правилам:

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

Тип данных bool, значение True и False

Тип данных bool в Python представляет логические значения True (истина) и False (ложь). Он используется для представления результатов логических операций и условий.

Например, при выполнении операции сравнения 2 > 1 мы получим логическое значение True, а при выполнении операции сравнения 2 < 1 — логическое значение False.

Тип данных bool может быть преобразован из других типов данных. В Python любое значение может быть преобразовано в логическое значение bool. Логическое значение True соответствует числу 1, а логическое значение False — числу 0.

Приведем несколько примеров:

bool(0)    # False
bool(1)    # True
bool(2)    # True
bool(-1)   # True
bool("")   # False
bool("hello")  # True
bool([])   # False
bool([1, 2, 3])  # True
bool(None)  # False

Также тип данных bool может быть преобразован в другие типы данных, например, в целое число или строку. Логическое значение True при преобразовании в целое число будет равно 1, а False — 0. При преобразовании в строку логическое значение True будет преобразовано в строку «True», а логическое значение False — в строку «False».

int(True)   # 1
int(False)  # 0
str(True)   # 'True'
str(False)  # 'False'

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

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

Операторы сравнения — это операторы, которые сравнивают два значения и возвращают значение типа bool (True или False) в зависимости от результата сравнения.

Вот некоторые из наиболее распространенных операторов сравнения в Python:

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

a = 10
b = 5

print(a == b)  # False, потому что a не равно b
print(a != b)  # True, потому что a не равно b
print(a > b)   # True, потому что a больше b
print(a < b)   # False, потому что a меньше b
print(a >= b)  # True, потому что a больше или равно b
print(a <= b)  # False, потому что a меньше или равно b

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

Например:

print("hello" == "hello")  # True, потому что оба значения равны
print("hello" != "world")  # True, потому что значения не равны
print(True == False)       # False, потому что значения не равны

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

Несколько примеров использования if и операторов сравнения

1. Напишем программу, которая просит пользователя ввести свой возраст и выводит сообщение, является ли он совершеннолетним или нет.

age = int(input("Введите ваш возраст: "))
if age >= 18:
    print("Вы совершеннолетний!")
else:
    print("Вы несовершеннолетний.")

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

a = float(input("Введите первое число: "))
b = float(input("Введите второе число: "))

if a > b:
    print("Первое число больше второго.")
elif b > a:
    print("Второе число больше первого.")
else:
    print("Оба числа равны.")

1. Напишем программу, которая запрашивает у пользователя его имя и проверяет, совпадает ли оно с заданным именем (Анна).

name = input("Введите ваше имя: ")
if name == "Анна":
    print("Вы ввели верное имя.")
else:
    print("Вы ввели неверное имя.")

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

В примерах выше, мы увидели с вами незнакомые инструкции else и elif. Разберем, для чего нужна первая из них — else.

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

Вот синтаксис использования else вместе с if:

num = int(input("Введите число: "))
if num % 2 == 0:
    print("Число", num, "является четным.")
else:
    print("Число", num, "является нечетным.")

1. Пример программы, которая запрашивает у пользователя пароль и проверяет, верен ли он:

password = input("Введите пароль: ")
if password == "qwerty":
    print("Добро пожаловать!")
else:
    print("Неверный пароль. Попробуйте еще раз.")

В обоих примерах, если условие в if истинно, то выполняется соответствующий блок кода, а если условие ложно, то выполняется блок кода, указанный в else.

Задания на закрепление if-else и операторов сравнения

Задание 1. Напишите программу, которая запрашивает у пользователя его возраст и проверяет, является ли он совершеннолетним (18 лет и старше). Если пользователь совершеннолетний, то программа должна выводить сообщение «Добро пожаловать на сайт!», а если нет, то «Вы не совершеннолетний, доступ запрещен.».

age = int(input("Введите свой возраст: "))
if age >= 18:
    print("Добро пожаловать на сайт!")
else:
    print("Вы не совершеннолетний, доступ запрещен.")

Задание 2. Напишите программу, которая запрашивает у пользователя год его рождения и определяет, является ли он високосным. Если год високосный, программа должна выводить сообщение «Ваш год рождения — високосный!», а если нет, то «Ваш год рождения не является високосным.»

year = int(input("Введите год вашего рождения: "))
if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
    print("Ваш год рождения - високосный!")
else:
    print("Ваш год рождения не является високосным.")

Задание 3. Напишите программу, которая запрашивает у пользователя два числа и определяет, какое из них больше. Если первое число больше, программа должна выводить «Первое число больше», если второе — «Второе число больше», а если числа равны, то «Числа равны»

num1 = float(input("Введите первое число: "))
num2 = float(input("Введите второе число: "))
if num1 > num2:
    print("Первое число больше")
elif num1 < num2:
    print("Второе число больше")
else:
    print("Числа равны")

Конструкция elif

Конструкция elif используется вместе с if и позволяет проверять несколько условий одновременно. Если первое условие не истинно, то проверяется следующее, и так далее, до тех пор, пока не найдется условие, которое является истинным. Если ни одно из условий не является истинным, то выполняется блок else (если он присутствует).

Вот синтаксис использования elif:

if условие1:
    # код, который выполняется, если условие1 истинно
elif условие2:
    # код, который выполняется, если условие1 ложно, а условие2 истинно
elif условие3:
    # код, который выполняется, если условие1 и условие2 ложны, а условие3 истинно
...
else:
    # код, который выполняется, если все предыдущие условия ложны

Вот несколько примеров использования elif:

Пример 1: Проверка возраста и определение категории посетителей парка развлечений

age = int(input("Введите свой возраст: "))

if age < 5:
    print("Младенец - вход свободный")
elif age < 18:
    print("Дети - стоимость билета 10 долларов")
elif age < 65:
    print("Взрослые - стоимость билета 20 долларов")
else:
    print("Пожилые - стоимость билета 10 долларов")

В этом примере if используется для проверки возраста посетителя. Если возраст меньше 5 лет, программа напечатает сообщение «Младенец — вход свободный». Если возраст не меньше 5, то проверяется следующее условие в блоке elif. Если возраст меньше 18, то программа напечатает сообщение «Дети — стоимость билета 10 долларов». Если возраст не меньше 18, то проверяется следующее условие в блоке elif. Если возраст меньше 65, то программа напечатает сообщение «Взрослые — стоимость билета 20 долларов». Если ни одно из предыдущих условий не истинно, то выполняется блок else, и программа напечатает сообщение «Пожилые — стоимость билета 10 долларов».

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

age = int(input("Введите возраст: "))
if age < 18:
    print("Вы еще не совершеннолетний")
elif age < 25:
    print("Вы молодой человек")
else:
    print("Вы уже взрослый")

В этом примере мы сначала проверяем, является ли человек несовершеннолетним (меньше 18 лет). Если это не так, то проверяем, является ли он молодым человеком (от 18 до 24 лет). Если и это не так, то выводим, что он уже взрослый.

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

x = int(input("Введите число: "))
if x > 0:
    print("Число положительное")
elif x < 0:
    print("Число отрицательное")
else:
    print("Число равно нулю")

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

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

Задание 4. Напишите программу, которая принимает на вход возраст человека и выводит сообщение о его возрастной категории: «ребенок» (до 12 лет), «подросток» (от 12 до 18 лет), «взрослый» (от 18 до 60 лет) или «пенсионер» (старше 60 лет).

age = int(input("Введите возраст: "))

if age < 12:
    print("Ребенок")
elif age < 18:
    print("Подросток")
elif age < 60:
    print("Взрослый")
else:
    print("Пенсионер")

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

a = int(input("Введите первое число: "))
b = int(input("Введите второе число: "))
c = int(input("Введите третье число: "))

if a >= b and a >= c:
    print("Первое число наибольшее")
    if b >= c:
        print("Второе число второе по величине")
    else:
        print("Третье число второе по величине")
elif b >= a and b >= c:
    print("Второе число наибольшее")
    if a >= c:
        print("Первое число второе по величине")
    else:
        print("Третье число второе по величине")
else:
    print("Третье число наибольшее")
    if a >= b:
        print("Первое число второе по величине")
    else:
        print("Второе число второе по величине")

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

Логические операторы — это специальные операторы, которые позволяют соединять логические выражения между собой и строить более сложные условия. В Python есть три логических оператора: and, or и not.

Оператор and возвращает True, если оба операнда равны True, иначе он возвращает False. Например:

x = 5
y = 10
if x < 10 and y > 5:
    print("Оба условия выполнены")

Оператор or возвращает True, если хотя бы один операнд равен True, иначе он возвращает False. Например:

x = 5
y = 3
if x < 10 or y > 5:
    print("Хотя бы одно условие выполнено")

Оператор not инвертирует (делает противоположным) значение операнда. Если операнд равен True, то not возвращает False, и наоборот. Например:

x = True
if not x:
    print("x равно False")
else:
    print("x равно True")

При использовании логических операторов совместно с операторами сравнения, следует помнить о приоритете выполнения операторов. В Python порядок выполнения операций определяется следующим образом: сначала выполняются операции в скобках, затем унарные операции (например, not), затем умножение и деление, затем сложение и вычитание, затем операции сравнения (например, < и >), затем логические операторы and и or.

Примеры использования логических операторов:

x = 5
y = 10
z = 15

if x < y and y < z:
    print("y находится между x и z")

if x == 5 or y == 5:
    print("x или y равны 5")

if not (x > y):
    print("x меньше или равно y")

Задания на тренировку использования логических операторов

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

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

if num > 0 and num % 3 == 0:
    print("Число положительное и кратно 3.")
else:
    print("Число не положительное и/или не кратно 3.")

Задание 7. Напишите программу, которая проверяет, является ли введенный пользователем год високосным.

year = int(input("Введите год: "))

if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
    print("Год является високосным.")
else:
    print("Год не является високосным.")

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

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

if num <= 0 or num % 7 == 0:
    print("Число отрицательное или равно нулю или кратно 7.")
else:
    print("Число не отрицательное и не равно нулю и не кратно 7.")

Вложенные инструкции if

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

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

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

if num % 2 == 0:
    if num % 3 == 0:
        print("Число делится и на 2, и на 3")
    else:
        print("Число делится только на 2")
else:
    if num % 3 == 0:
        print("Число делится только на 3")
    else:
        print("Число не делится ни на 2, ни на 3")

В данном примере мы проверяем, делится ли введенное число на 2 и/или на 3, и выводим соответствующее сообщение. Если число делится на 2, то мы проверяем, делится ли оно еще и на 3. Если да, то выводим сообщение «Число делится и на 2, и на 3», иначе выводим «Число делится только на 2». Если число не делится на 2, то мы проверяем, делится ли оно на 3. Если да, то выводим «Число делится только на 3», иначе выводим «Число не делится ни на 2, ни на 3».

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

Также можно использовать каскадную конструкцию if-elif-else, которая позволяет проводить несколько проверок подряд, пока не будет найдено соответствующее условие. Пример:

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

if num > 0:
    print("Число положительное")
elif num < 0:
    print("Число отрицательное")
else:
    print("Число равно нулю")

В данном примере мы проверяем, является ли введенное число положительным, отрицательным или нулем, и выводим соответствующее сообщение. Если число больше нуля, то выводим «Число положительное», иначе проверяем, меньше ли число нуля. Если да, то выводим «Число отрицательное», иначе выводим «Число равно нулю».

Здесь мы использовали каскадную конструкцию if-elif-else.

Задание на тренировку

Задание 10. Напишите программу, которая запрашивает у пользователя 2 числа и определяет, какое из них больше, и насколько оно отличается от другого. Если числа равны, программа должна вывести сообщение «Числа равны».

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

if num1 > num2:
    print(f"Число {num1} больше на {num1 - num2}")
elif num2 > num1:
    print(f"Число {num2} больше на {num2 - num1}")
else:
    print("Числа равны")

Цепочки сравнений

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

Например, чтобы проверить, находится ли число x в диапазоне от 5 до 9 включительно, можно написать:

5 <= x <= 9

Такая запись эквивалентна следующей последовательности двух операторов сравнения:

5 <= x and x <= 9

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

'a' <= my_char <= 'z'

В этом случае мы проверяем, является ли символ my_char строчной буквой латинского алфавита.

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

Тернарный оператор

Тернарный оператор — это оператор условия в Python, который имеет следующий синтаксис: value_if_true if condition else value_if_false.

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

Вот пример использования тернарного оператора:

x = 5
y = 10
max_value = x if x > y else y
print(max_value)

В этом примере переменной max_value присваивается значение x, если x больше y, и значение y в противном случае. Результатом выполнения программы будет число 10.

Еще один пример использования тернарного оператора:

age = 18
is_adult = True if age >= 18 else False
print(is_adult)

В этом примере переменной is_adult присваивается значение True, если возраст (age) больше или равен 18, и значение False в противном случае. Результатом выполнения программы будет значение True.

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

Оператор is

Оператор is используется для проверки идентичности объектов в Python. Он возвращает значение True, если два объекта имеют одинаковый идентификатор (адрес в памяти) и False, если идентификаторы объектов разные.

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

x is y

где x и y — переменные или объекты.

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

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

print(a is b)  # True, т.к. a и b ссылаются на один и тот же объект
print(a is c)  # False, т.к. a и c имеют разные объекты, даже если они имеют одинаковое значение

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

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

if a is b:
    print("a и b ссылаются на один и тот же объект")
else:
    print("a и b ссылаются на разные объекты")

Кроме оператора is, в Python также есть оператор ==, который используется для проверки равенства значений переменных. Разница между is и == в том, что is проверяет идентичность объектов, а == — равенство их значений.

Оператор in

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

Синтаксис оператора in:

элемент in коллекция

где элемент – значение, которое необходимо проверить на наличие в коллекции.

Результатом выполнения оператора in является булевое значение True, если элемент содержится в коллекции, и False в противном случае.

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

# проверка наличия элемента в списке
fruits = ['apple', 'banana', 'cherry']
if 'banana' in fruits:
    print('Ура! Мы нашли банан!')

# проверка наличия символа в строке
word = 'hello'
if 'h' in word:
    print('Первая буква слова - "h"')

# проверка наличия ключа в словаре
person = {'name': 'John', 'age': 30, 'city': 'New York'}
if 'age' in person:
    print('Персона имеет возраст')

# проверка наличия элемента в множестве
set1 = {1, 2, 3, 4, 5}
if 3 in set1:
    print('Число 3 содержится в множестве set1')

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

Ура! Мы нашли банан!
Первая буква слова - "h"
Персона имеет возраст
Число 3 содержится в множестве set1

Также оператор in можно использовать вместе с условной конструкцией not для проверки отсутствия элемента в коллекции:

# проверка отсутствия элемента в списке
fruits = ['apple', 'banana', 'cherry']
if 'orange' not in fruits:
    print('Апельсина в списке нет :(')

# проверка отсутствия символа в строке
word = 'hello'
if 'z' not in word:
    print('Буквы "z" в слове нет')

Результатом выполнения программы будет:

Апельсина в списке нет :(
Буквы "z" в слове нет

Пример задания на закрепление оператора in

Допустим, мы хотим написать программу, которая проверяет, является ли заданное слово палиндромом, то есть словом, которое читается одинаково как слева направо, так и справа налево. Например, слова «ротор», «топот» и «довод» являются палиндромами, а слова «мама» и «папа» нет.

Мы можем использовать оператор in для проверки наличия символов в строке. Для этого сначала перевернем заданную строку и затем сравним ее с оригинальной строкой.

Вот код решения:

word = input("Введите слово: ")
if word == word[::-1]:
    print("Слово является палиндромом")
else:
    print("Слово не является палиндромом")

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

С использованием оператора in мы могли бы написать это условие так:

if all(word[i] == word[-i-1] for i in range(len(word)//2)):
    print("Слово является палиндромом")
else:
    print("Слово не является палиндромом")

Здесь мы использовали оператор all() для проверки того, что каждый символ в слове равен соответствующему символу в перевернутом слове. Для этого мы проходимся по половине длины слова с помощью range(len(word)//2) и проверяем равенство символов, используя индексы -i-1 для доступа к символам с конца слова.

Заглушки кода. Ключевое слово pass

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

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

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

if x > 0:
    pass
else:
    print("x is negative")

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

Видеоурок по условным и логическим операторам

Задания для тренировки

Задание 11. Известны два расстояния: одно в километрах, другое — в футах ( 1 фут 0,305 м ). Какое из расстояний меньше?

distance_km = 10
distance_ft = 32808.4

distance_m_km = distance_km * 1000
distance_m_ft = distance_ft * 0.305

if distance_m_km < distance_m_ft:
    print("Расстояние в километрах меньше")
else:
    print("Расстояние в футах меньше")

Задание 12. Даны радиус круга и сторона квадрата. У какой фигуры площадь больше?

import math

radius = float(input("Введите радиус круга: "))
side = float(input("Введите длину стороны квадрата: "))

area_circle = math.pi * radius ** 2
area_square = side ** 2

if area_circle > area_square:
    print("Площадь круга больше")
else:
    print("Площадь квадрата больше")

Задание 13. Поле шахматной доски определяется парой натуральных чисел, каждое из которых не превосходит 8: первое число — номер вертикали (при счете слева направо), второе — номер горизонтали (при счете снизу вверх). Даны натуральные числа a, b, c, d, каждое из которых не превосходит 8. На поле (a, b) расположена ладья. Может ли ладья пойти в клетку с координатами c,d?

a = int(input("Введите номер вертикали (от 1 до 8) для начальной клетки: "))
b = int(input("Введите номер горизонтали (от 1 до 8) для начальной клетки: "))
c = int(input("Введите номер вертикали (от 1 до 8) для конечной клетки: "))
d = int(input("Введите номер горизонтали (от 1 до 8) для конечной клетки: "))

if a == c or b == d:
    print("Ладья может пойти в клетку ({}, {})".format(c, d))
else:
    print("Ладья не может пойти в клетку ({}, {})".format(c, d))

Введите номер вертикали (от 1 до 8) для начальной клетки: 2
Введите номер горизонтали (от 1 до 8) для начальной клетки: 3
Введите номер вертикали (от 1 до 8) для конечной клетки: 4
Введите номер горизонтали (от 1 до 8) для конечной клетки: 3
Ладья может пойти в клетку (4, 3)

Задание 14. Поле шахматной доски определяется парой натуральных чисел, каждое из которых не превосходит 8: первое число — номер вертикали (при счете слева направо), второе — номер горизонтали (при счете снизу вверх). Даны натуральные числа a, b, c, d, каждое из которых не превосходит 8. На поле (a, b) расположена фигура — слон. Может ли слон пойти в клетку с координатами c,d?

a, b, c, d = 2, 3, 5, 6

dx = abs(c - a)
dy = abs(d - b)

if dx == dy:
    print("Слон может пойти в клетку ({}, {})".format(c, d))
else:
    print("Слон не может пойти в клетку ({}, {})".format(c, d))

Слон может пойти в клетку (5, 6)

Задание 15. Поле шахматной доски определяется парой натуральных чисел, каждое из которых не превосходит 8: первое число — номер вертикали (при счете слева направо), второе — номер горизонтали (при счете снизу вверх). Даны натуральные числа a, b, c, d, каждое из которых не превосходит 8. На поле (a, b) расположена фигура — король. Может ли король пойти в клетку с координатами c,d?

if abs(a-c) <= 1 and abs(b-d) <= 1:
    print("Король может пойти в клетку с координатами", c, d)
else:
    print("Король не может пойти в клетку с координатами", c, d)

Задание 16. Поле шахматной доски определяется парой натуральных чисел, каждое из которых не превосходит 8: первое число — номер вертикали (при счете слева направо), второе — номер горизонтали (при счете снизу вверх). Даны натуральные числа a, b, c, d, каждое из которых не превосходит 8. На поле (a, b) расположена фигура — ферзь. Может ли ферзь пойти в клетку с координатами c,d?

if a == c or b == d or abs(a-c) == abs(b-d):
    print("Ферзь может пойти в клетку (", c, ",", d, ")")
else:
    print("Ферзь не может пойти в клетку (", c, ",", d, ")")

Задание 17. Поле шахматной доски определяется парой натуральных чисел, каждое из которых не превосходит 8: первое число — номер вертикали (при счете слева направо), второе — номер горизонтали (при счете снизу вверх). Даны натуральные числа a, b, c, d, каждое из которых не превосходит 8. На поле (a, b) расположена фигура — конь. Может ли конь пойти в клетку с координатами c,d?

# координаты начальной позиции фигуры
a = 2
b = 3

# координаты конечной позиции
c = 4
d = 6
if abs(a-c) == 2 and abs(b-d) == 1 or abs(a-c) == 1 and abs(b-d) == 2:
    print("Фигура может пойти в клетку с координатами", c, d)
else:
    print("Фигура не может пойти в клетку с координатами", c, d)

Задание 18. Если целое число m делится нацело на целое число n, то вывести на экран частное от деления, в противном случае вывести сообщение «m на n нацело не делится».

m = 20
n = 5

if m % n == 0:
    quotient = m // n
    print("Частное от деления:", quotient)
else:
    print("m на n нацело не делится")

Частное от деления: 4

Задание 19. Дано двузначное число. Определить: а) какая из его цифр больше: первая или вторая; б) одинаковы ли его цифры.

num = 56

# определяем первую и вторую цифры
digit1 = num // 10
digit2 = num % 10

# выводим результаты
if digit1 > digit2:
    print("Первая цифра больше второй")
elif digit2 > digit1:
    print("Вторая цифра больше первой")
else:
    print("Цифры равны")

Задание 20. Дано число. Определить, является ли число палиндромом («перевертышем»), т. е. таким числом, десятичная запись которого читается одинаково слева направо и справа налево.

num = input("Введите число: ")
if num == num[::-1]:
    print("Число является палиндромом")
else:
    print("Число не является палиндромом")

Задание 21. Дано трехзначное число. Определить: а) является ли сумма его цифр двузначным числом; б) является ли произведение его цифр трехзначным числом; в) больше ли числа а произведение его цифр; г) кратна ли пяти сумма его цифр; д) кратна ли сумма его цифр числу а.

number = input("Введите трехзначное число: ")
a = int(number[0]) # первая цифра
b = int(number[1]) # вторая цифра
c = int(number[2]) # третья цифра

# а) проверка суммы цифр на двузначность
if (a + b + c) > 9 and (a + b + c) < 100:
    print("Сумма цифр является двузначным числом")
else:
    print("Сумма цифр не является двузначным числом")

# б) проверка произведения цифр на трехзначность
if a * b * c > 99 and a * b * c < 1000:
    print("Произведение цифр является трехзначным числом")
else:
    print("Произведение цифр не является трехзначным числом")

# в) сравнение числа а и произведения цифр
if a > (b * c):
    print("Число а больше произведения цифр")
else:
    print("Произведение цифр больше числа а")

# г) проверка кратности пяти суммы цифр
if (a + b + c) % 5 == 0:
    print("Сумма цифр кратна пяти")
else:
    print("Сумма цифр не кратна пяти")

# д) проверка кратности суммы цифр числу а
if (a + b + c) % int(number) == 0:
    print("Сумма цифр кратна числу а")
else:
    print("Сумма цифр не кратна числу а")

Введите трехзначное число: 456
Сумма цифр является двузначным числом
Произведение цифр не является трехзначным числом
Произведение цифр больше числа а
Сумма цифр не кратна пяти
Сумма цифр не кратна числу а

Идеи для задач взяты из Сборника задач по программированию Д.М. Златопольского

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

• условный оператор if,
• конструкция if-else,
• конструкция if-elif-else,
• примеры программ.

Проще всего это понять на примере. Введите в интерпретаторе Python следующее и нажмите Enter для вывода:

>>> if 5 > 4:
print('Верно, 5 больше, чем 4.')
Верно, 5 больше, чем 4.

Перед нами простейший пример работы программы по условию. Если переводить с Python (а это почти чистый английский — настолько порой понятен его код), мы написали буквально следующее: «Если 5 больше 4, напечатать: Верно, 5 больше, чем 4».

Таким образом, if служит для выполнения блока кода по условию: если условие истинно (то есть Python рассматривает его как True), код блока будет исполнен, а если ложно (False), то нет. Давайте приведем и пример False, введите и нажмите Enter:

if 5 < 4:
print('Верно, 4 больше 5')

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

Но в большинстве случаев одного условия нам будет не хватать и придется использовать более сложные конструкции: if-else и if-elif-else.

Условная конструкция if-else

if-else используется, когда нужно дать программе выбор: в первом случае сделать так, а во втором — иначе. Вот пример:

money = int(input('Какую сумму вы бы хотели потратить на покупки у нас? Введите цифру: '))
if money >= 100:
    print('Добро пожаловать! Отправили каталог на вашу электронную почту.')
else:
    print('К сожалению, у нас нет товаров дешевле 100 рублей. Заходите еще.')
input('Нажмите Enter для выхода.')

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

А далее в дело вступает условная конструкция: если введенная сумма равна или больше ста рублей, программа дает положительный ответ. Если же введенная сумма 99 рублей или меньше, выдается другой ответ.

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

Условная конструкция if-elif-else

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

money = int(input('Какую сумму вы бы хотели потратить на покупки у нас? Введите цифру: '))
if money >= 10000:
    print('Рады приветствовать оптового покупателя! Для вас у нас есть специальные скидки.')
elif money >= 100:
    print('Добро пожаловать! Отправили каталог на вашу электронную почту.')
else:
    print('К сожалению, у нас нет товаров дешевле 100 рублей. Заходите еще.')
input('Нажмите Enter для выхода.')

Теперь, если пользователь введет сумму равную или больше указанного значения (10000), программа выдаст текст из первого блока с if. А если сумма будет меньше этого значения, но равна или больше 100, будет выполнено условие оператора elif, и пользователь увидит второй текст.

Чтобы вам было удобнее читать код с условиями, операторы удобно переводить так: if — «если», elif — «а если», else — «в ином случае».

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

import random
star = random.randint(1, 5)
planets = random.randint(1, 10)
if star == 1:
    print('Ваша цивилизация живет в системе голубого гиганта, вокруг которого вращаются', planets, 'планет')
elif star == 2:
    print('Ваша цивилизация живет в системе белого карлика, вокруг которого вращаются', planets, 'планет')
elif star == 3:
    print('Ваша цивилизация живет в системе солнцеподобного желтого карлика, вокруг которого вращаются', planets, 'планет')
elif star == 4:
    print('Ваша цивилизация живет в системе оранжевого гиганта, вокруг которого вращаются', planets, 'планет')
else:
    print('Ваша цивилизация живет в системе красного сверхгиганта, вокруг которого вращаются', planets, 'планет')
input('Нажмите Enter для выхода')

Вот какую систему подарил рандом нам:

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

Почти солнечная, только планет поменьше. Обратите внимание, что мы создали две переменные (star и planets), генерацию значений для которых доверили модулю random, который сначала нужно вызвать:

import random

Далее при помощи инструкции random.randint мы задали диапазон генерируемых значений, из которого генератор случайных чисел (далее — ГСЧ) выбирает одно: для звезд из 5 и для планет из 10:

star = random.randint(1, 5)
planets = random.randint(1, 10)

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

И еще один момент: вы уже заметили, что в коде одни операции обозначаются знаком =, а другие знаком двойного равенства: ==. В Python один знак «равно» (=) используется только для присвоения значений переменным, а вот двойное равенство равно арифметическому. Поэтому в примере выше код:

star = random.randint(1, 5)

означает, что переменная star принимает случайное значение, сгенерированное модулем random, а выражение:

if star == 1:

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

Игровые примеры для закрепления

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

Подбрасываем монетку

Напишем такую программу с использованием условной конструкции if-elif-else и шаг за шагом рассмотрим, как эта программа устроена. Итак, наберите в редакторе, не забывая про отступы:

import random
coin = random.randint(1, 2)
attempts = 0
orel = 0
reshka = 0
while attempts < 100:
    if coin == 1:
        orel += 1
        attempts += 1
        coin = random.randint(1, 2)
    elif coin == 2:
        reshka += 1
        attempts += 1
        coin = random.randint(1, 2)
    else:
        print('Монетка упала ребром. Неужели такое бывает? Хорошо, перебрасываем.')
        attempts += 1
        coin = random.randint(1, 2)
print('Орёл выпал', orel, 'раз(-а), а решка', reshka, 'раз(-а).')
input('Нажмите Enter для выхода')

Броски монетки мы будем имитировать при помощи уже знакомого нам ГСЧ, за который отвечает модуль random. Его мы и вызываем в первой строчке кода:

import random

Далее вводим несколько переменных:

• coin — для бросков монетки,
• attempts — для подсчета количества бросков,
• orel — будет добавлять число выпавших «орлов»,
• reshka — будет добавлять число выпавших «решек».

При подбрасывании монетки мы будем сразу же использовать ГСЧ, поэтому пишем:

coin = random.randint(1, 2)

Это значит, что значение будет генерироваться случайным образом в пределах от 1 до 2, то есть может выпасть либо единица, либо двойка. Теперь осталось присвоить эти значения орлам и решкам соответственно, указать максимальное количество бросков и сделать так, чтобы при каждом броске их число увеличивалось на один. Для этого используем условную конструкцию if-elif-else внутри цикла while:

while attempts < 100:

Эта часть кода означает: до тех пор пока бросков меньше 100:

 if coin == 1:
        orel += 1
        attempts += 1
        coin = random.randint(1, 2)

если ГСЧ выдал 1:

• увеличиваем количество орлов на единицу,
• увеличиваем количество бросков на единицу,
• подбрасываем монетку снова.

elif coin == 2:
        reshka += 1
        attempts += 1
        coin = random.randint(1, 2)

То же самое, но с решкой.

 else:
        print('Монетка упала ребром. Неужели такое бывает? Хорошо, перебрасываем.')
        attempts += 1
        coin = random.randint(1, 2)

Код, добавленный на случай невозможного (ребром монетка никогда не упадет, поскольку наш ГСЧ может выдать только 1 или 2). В данном случае эта часть кода не обязательна, но заведите себе привычку добавлять последний блок с else — «невозможные» условия порой всё же могут выполняться, поскольку программисты не всегда могут учесть все сценарии работы программы. И поэтому блок с else в таких случаях сделает программу более стабильной в случае выполнения неучтенного условия.

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

print('Орёл выпал', orel, 'раз(-а), а решка', reshka, 'раз(-а).')
input('Нажмите Enter для выхода')

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

Орёл выпал 53 раз(-а), а решка 47 раз(-а).
Нажмите Enter для выхода

Конечно, понаблюдать за работой ГСЧ интересно, но всё же играми в полной мере что генератор звезд и планет, что броски монетки назвать сложно, поэтому напишем программу поинтереснее.

Играем с компьютером в кости

В этой игре будем по очереди бросать кубики с компьютером, а в конце объявим победителя. Это делает следующий код:

import random
score1 = 0
score2 = 0
games = 0
die1 = 0
die2 = 0
total1 = 0
die3 = 0
die4 = 0
total2 = 0
input('Бросай кости, жми Enter!\n')
while score1 < 6 and score2 < 6 and games <= 11:
    die1 = random.randint(1, 6)
    die2 = random.randint(1, 6)
    total1 = die1 + die2
    print(die1, die2)
    print(total1,'\n')
    input('Теперь я, жми Enter!\n')
    die3 = random.randint(1, 6)
    die4 = random.randint(1, 6)
    total2 = die3 + die4
    print(die3, die4)
    print(total2,'\n')
    if total1 > total2:
        score1 += 1
        games += 1
    elif total1 < total2:
        score2 += 1
        games += 1
    else:
        games += 1
        print('Ничья\n')
    print('Счёт', score1, ':', score2,'\n')
    input('Жми Enter!\n')
if score1 > score2:
    input('Ты победил! Жми Enter для выхода')
elif score1 < score2:
    input('Я победил! Жми Enter для выхода')
else:
    input('Победила дружба! Жми Enter для выхода')

Этот код уже может показаться немного длинным и непонятным, но зато, во-первых, мы уже написали настоящую игру (пусть пока и без графики), а во-вторых, ничего сложного здесь нет, сейчас всё объясним.

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

• score1 и score2 для подсчета побед, наших и компьютера;
• games для количества партий (их мы затем ограничим, чтобы предотвратить долгую игру в случае частых ничьих);
• die1, die2, die3, die4 для бросков отдельных костей;
• total1 и total2 для подсчета суммы очков в каждом броске двух игроков: для игрока-человека это будет сумма total1 костей die1, die2, а для компьютера — total2 и die3, die4 соответственно.

Далее идет призыв к началу игры (игрок первым увидит именно это), а затем программа входит в цикл:

while score1 < 6 and score2 < 6 and games < 11:

Как видим, условий несколько, и они соединены операторами and. Это значит, что программа выйдет из цикла, если одно из них перестанет быть истинным (то есть либо score1 или score2 станет равным 6, либо games будет равно 11). Играем почти теннисный сет: как только один из игроков выигрывает шесть партий, игра заканчивается его победой. При этом количество партий не может быть больше 11. Таким образом, если из-за ряда ничьих в партиях ни один из игроков не одержит 6 побед, игра всё равно закончится после 11-й партии.

Теперь бросает кости игрок, а программа считает их сумму (total1 = die1 + die2) и печатает результат. После по нажатию Enter то же самое делает компьютер (у него сумма будет total2 = die3 + die4). Конечно, на самом деле вся игра выполняется целиком и полностью силами ГСЧ, но так уж устроено большинство простых игр: даже за игрока здесь всё решает рандом. А мы переходим к самой важной части программы: двум блокам if-elif-else. Первый из них является частью цикла while:

if total1 > total2:
    score1 += 1
    games += 1
elif total1 < total2:
    score2 += 1
    games += 1
else:
    games += 1
    print('Ничья\n')
print('Счёт', score1, ':', score2,'\n')
input('Жми Enter!\n')

Тут тоже всё просто: если наша сумма больше, мы получаем очко, если в партии выиграл компьютер, очко начисляется ему, а при ничьей — никому, но партия засчитывается как сыгранная в любом случае. Далее на экран выводится текущий счет и предлагается играть дальше. Как только выполняется условие цикла while, то есть один из игроков одержал 6 побед или количество сыгранных партий достигло 11, программа выходит из цикла и переходит к последнему блоку:

if score1 > score2:
    input('Ты победил! Жми Enter для выхода')
elif score1 < score2:
    input('Я победил! Жми Enter для выхода')
else:
    input('Победила дружба! Жми Enter для выхода')

Первое условие с if выполняется, когда игрок выиграл больше партий, чем компьютер. Условие с elif — если удачливее был компьютерный оппонент. Но что если партий было сыграно 11 и при этом игроки выиграли равное число? Для этого мы и добавили блок с else, выполнение которого выдаст на экран примирительный текст.

Осталось добавить, что Python проверяет условия последовательно и исполняет первое, которое является истинным: то есть сначала всегда будет проверено условие с if, затем с elif (если их несколько, то одно за другим сверху вниз) и последним с else. Таким образом, если в сложной программе вдруг оказались выполнены сразу несколько условий, будет исполнен только тот блок, который стоит первым: учитывайте это при написании кода.

Toggle table of contents sidebar