Условные конструкции в 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("Вы несовершеннолетний.")

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

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

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

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

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, "является нечетным.")

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

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 — это полезный инструмент, который помогает избежать ошибок синтаксиса при написании кода, когда необходимо создать заглушку для блока кода, который будет заполнен позже.

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

Конструкция match-case

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

Пример работы с конструкцией match-case:

def function(value):
    match value:
        case 1:
            print("Value is 1")
        case 2:
            print("Value is 2")
        case 3:
            print("Value is 3")
        case _:
            print("Value is something else")

function(1)  # Выведет: Value is 1
function(2)  # Выведет: Value is 2
function(3)  # Выведет: Value is 3
function(4)  # Выведет: Value is something else

В этом примере функция function принимает значение и с помощью конструкции match-case проверяет, равно ли это значение 1, 2 или 3. Если значение не равно ни одному из этих чисел, то выводится сообщение «Value is something else».

Конструкция match-case была добавлена в Python 3.10.

Примеры работы

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

def function(value):
    match value:
        case 1, 2, 3:
            print("Value is 1, 2 or 3")
        case _:
            print("Value is something else")

function(1)  # Выведет: Value is 1, 2 or 3
function(2)  # Выведет: Value is 1, 2 or 3
function(3)  # Выведет: Value is 1, 2 or 3
function(4)  # Выведет: Value is something else

В этом примере функция function принимает значение и с помощью конструкции match-case проверяет, равно ли это значение 1, 2 или 3. Если значение равно любому из этих чисел, то выводится сообщение «Value is 1, 2 or 3». Если значение не равно ни одному из этих чисел, то выводится сообщение «Value is something else».

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

def function(value):
    match value:
        case "Hello":
            print("Value is the string 'Hello'")
        case 1:
            print("Value is the integer 1")
        case 1.5:
            print("Value is the float 1.5")
        case (1, 2):
            print("Value is the tuple (1, 2)")
        case _:
            print("Value is something else")

function("Hello")  # Выведет: Value is the string 'Hello'
function(1)  # Выведет: Value is the integer 1
function(1.5)  # Выведет: Value is the float 1.5
function((1, 2))  # Выведет: Value is the tuple (1, 2)
function(4)  # Выведет: Value is something else

В этом примере функция `function` принимает значение и с помощью конструкции match-case проверяет, равно ли это значение строке «Hello», целому числу 1, числу с плавающей точкой 1.5, кортежу (1, 2) или чему-то другому. Если значение не равно ни одному из этих вариантов, то выводится сообщение «Value is something else».

Сложная логика в match-case

value = int (input ('enter number '))
match isinstance (value,int):
        case True if value % 2 == 1:
            print(f"Value is an integer and odd")
        case True if value % 2 == 0:
            print(f"Value is an integer and even")
        case _:
            print("Value is something else")

Введенное значение проверяется на соответствие типу int и четность/нечетность.

Моржовый оператор

Моржовый оператор (Walrus operator) был введен в Python 3.8 и предоставляет удобный способ присваивания значения переменной и использования этого значения внутри выражения.

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

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

# Без моржового оператора
value = calculate_value()
if value > 10:
    print(value)

# С моржовым оператором
if (value := calculate_value()) > 10:
    print(value)

В этом примере значение calculate_value() присваивается переменной value, и затем это значение используется в условии if. Это делает код более компактным и улучшает читаемость.

Пример использования моржового оператора для поиска минимального элемента в последовательности

# Обычный способ
numbers = [5, 2, 8, 1, 6]
min_value = min(numbers)
print(min_value)

# Используя моржовый оператор
if (min_value := min(numbers)) < 5:
    print(f"Минимальное значение ({min_value}) меньше 5.")
else:
    print(f"Минимальное значение ({min_value}) не меньше 5.")

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

Задание 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
Сумма цифр является двузначным числом
Произведение цифр не является трехзначным числом
Произведение цифр больше числа а
Сумма цифр не кратна пяти
Сумма цифр не кратна числу а

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