Как выглядит общая форма условной инструкции if

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

Далее предстоит изучить конструкцию the if else then и условные операторы. Эта информация пригодится как новичкам, так и более опытным разработчикам. Она должна быть усвоена каждым, кто планирует заниматься созданием программного обеспечения и игр. Примеры будут приведены на the Pascal и the JavaScript.

Условные операторы

Условный оператор – основа любого языка разработки. С его помощью значение некоторого выражения принимается за определение дальнейшего поведения приложения. Через the operator происходит выбор действия из нескольких предложенных.

В основе работы оператора (не только состоящего из IF) заложена булева логика. Она подразумевает сведение любых утверждений к двум вариантам:

• истина (the true);
• ложь (the false).

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

Разновидности

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

• постфиксными;
• тернарными;
• с одной веткой;
• с двумя ветвями;
• с поддержкой нескольких ветвей (if elseif else или if else then);
• множественного выбора – switch.

Отдельно выделяются циклы:

• while;
• for;
• foreach;
• бесконечные.

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

Перед изучением if else then необходимо рассмотреть более простые варианты ветвлений. В противном случае разработчик рискует запутаться и получить «на выходе» совершенно непредсказуемый результат.

Конструкция «с одной веткой» – элементарный вариант ветвления. Заданная операция будет обрабатываться, если соблюдено то или иное условие. В случае с the JavaScript форма представления ветвления будет следующей:

Сначала здесь задается ключевое слово IF (без else и then). Далее прописывается условие (condition), а в фигурных скобках указывается реализуемый алгоритм. Блок выполняется, если результат condition становится истиной. В противном случае управление переходит к следующему написанному в программном обеспечении фрагменту.

В the Pascal соответствующий вариант рассматривается как неполный условный оператор. Его блок схема имеет следующую форму реализации:

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

Две ветви

Следующий вариант тоже является достаточно распространенным у большинства языков. Это двойное ветвление. В разных ЯП отмечается по-разному. В основном:

• If условие else;
• If условие then.

Соответствующая конструкция поддерживает несколько блоков кода:

• если условие является the true, выполняется алгоритм1;
• в противном случае обрабатывается алгоритм2.

В the Pascal if then – это тоже неполное ветвление. Примеры:

Здесь, если введенное значение переменной a = 7, на экране появится приветствие. В противном случае ничего не происходит.

В данном фрагменте на экране при соблюдении указанного условия в консоль будет выведено не только приветствие, но и прощание. Это связано с тем, что writeln(‘До встречи’) не имеет отношения к ветвлению.

Примеры реализации в the JavaScript конструкции if then будут выглядеть несколько иначе. Общая форма записи:

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

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

Операторные скобки

В the Pascal, работая с записями типа if else then необходимо использовать операторные скобки. Они включают в себя:

• begin;
• end if.

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

В приведенном выше фрагменте при if a = 10 then… ничего не произойдет. Если указать a = 7, на дисплее появится и приветствие, и прощание.

Составные условия

В the Pascal могут использоваться составные (сложные) условия. Такой подход встречается и в других языках разработки. Чтобы сформировать составное условие, необходимо применять:

• and – составное условие истинно, когда все его простые составляющие являются true;
• or – составное условие истинно, когда таким является хотя бы одно его составное условие.

Вот пример:

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

Множественное ветвление

The JavaScript и The Pascal, а также другие ЯП поддерживают множественное ветвление. Такой вариант иногда называется «полным оператором». Он подразумевает создание инструкций с несколькими «ветками». Встречается, когда требуется проверить разнообразные условия.

В the JS форма записи будет такой:

Соответствующий фрагмент if else then работает так:

1. Сначала проверяется condition1. Если оно истинно, реализовывается первый блок кода.
2. При the condition1 = false происходит проверка condition2. Присвоенный ему алгоритм работает, когда результат расчетов = true. В противном случае программа переходит к condition3 и так далее.
3. Если все условия – это ложь, система будет реализовывать последний написанный блок.

В the Pascal if else then выглядит схематично так:

Некоторые разработчики называют соответствующую концепцию двойным ветвлением. Пример:

В соответствующем операторе if then перед записью …else…точка с запятой не ставится. Зато программисту придется использовать операторные скобки.

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

Тернарный оператор – это выражение, возвращающее то или иное значение. Сокращенная форма записи then else. В the JavaScript используется следующий вариант реализации:

В случае с Pascal достаточно использовать сокращенную форму записи условного оператора. В приведенном выше примере поддерживаются три операнда:

• первое выражение;
• второе выражение;
• проверяемое системой условие.

Для разделения условия и выражений необходимо применять символы «?», «:». Если condition = true, выполняется expression1, в противном случае – expression2.

Работа со switch

Оператор if then в большинстве языков разработки очень легко использовать. Кроме обычного ветвления можно задействовать выбор варианта из нескольких предложенных. Для этого используется конструкция switch.

Выбор алгоритма действий базируется на основании полного совпадения результатов расчетов, записанный в case. В случае с JS форма записи будет такой:

Раздел default не является обязательным. Он встречается тогда, когда необходимо указать алгоритм, реализующийся, если ни одно case не обнаружено. Это своеобразная замена if then.

Можно заметить, что в записи поддерживается break. Данный компонент тоже не является обязательным. Он используется в switch для непосредственного прерывания. После его обработки управление переходит к инструкциям, написанным после условного оператора. В противном случае может образоваться цикл, который приведет к неправильной работе кода.

Здесь можно увидеть больше примеров реализации изученной темы на Pascal. Досконально условные операторы и их особенности помогут рассмотреть специальные компьютерные дистанционные курсы.

Хотите освоить современную IT-специальность? Огромный выбор курсов по востребованным IT-направлениям есть в Otus! 

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

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