Расскажем о том какие есть операторы выбора в Python. Узнаем, как вводить и выводить информацию, и на простом примере покажем, как это все можно использовать на практике.
Условные операторы в Python
Условные операторы — это частный случай операторов выбора. При написании программ очень часто нужно производить проверку выполнения каких-либо условий. Когда, например, пользователь заполняет форму регистрации на сайте, полезно проверить на корректность заполненные им поля. Или когда нужно проверить значения переменных в формуле перед тем, как производить вычисления. В языке Python, как и во многих других языках программирования, для проверки условий существуют специальные операторы.
Конструкция if — else
Самый простейший случай использования этой конструкции в Python можно представить так:
a=0
if a==0:
print("a=0")
else:
print("a не равно нулю")
Здесь, сначала присваивается некоторое значение переменной a. Далее в условном операторе if — else проверяется это значение. Запись if a==0 означает «если a равно нулю». Если данное условие не выполняется, то выведется сообщение, содержащееся в блоке else. Понятно, что в приведенном примере будет выведено сообщение «a=0». Если не нужно производить какие-либо действия в случае, когда условие не выполняется, то блок else не используют:
a=0
if a==0:
print("a=0")
То есть если переменная a не будет равна нулю, то мы вообще не получим никакого сообщения. Когда нужно создать противоположное по значению условие, то можно применить ключевое слово not:
a=0
if not a==0:
print("a=0")
else:
print("a не равно нулю")
В этот раз мы увидим сообщение «a не равно нулю». Когда необходимо проверить несколько переменных, разумно использовать слова and (и) или or (или):
a=0
b=0
if a==0 and b==0:
print("a=0 и b=0")
else:
print("a и b не равны нулю")
Слово and говорит о том, что для того, чтобы условие было истинным, нужно, чтобы выполнялись обе его составляющие. То есть и переменная a должна равняться нулю, и b тоже должна быть равна нулю. Только тогда мы получим соответствующее сообщение. В противном случае отработает команда print в блоке else. Если вместо and вписать or, то тогда программа будет вести себя по-другому:
a=0
b=0
if a==0 or b==0:
print("a=0 или b=0")
else:
print("a и b не равны нулю")
В этом случае для истинности условия достаточно выполнения хотя бы одной его части. Другими словами, достаточно, чтобы или a равнялось нулю, или b.
Python позволяет использовать короткую запись конструкций с условным оператором if — else. Например, для самого простейшего случая, рассмотренного в самом начале этого подраздела, короткая запись будет выглядеть так:
a=0 result = "a=0" if a==0 else "a не равно нулю" print(result)
Как видим, весь условный оператор уместился в одну строку. Это бывает полезно, когда необходимо, чтобы исходник программы занимал поменьше места.
Конструкция if — elif — else
Данная конструкция позволяет работать с несколькими условиями. Приведем простой пример кода, содержащего эту конструкцию:
a = 2
b = 10
if b > a:
print("b больше, чем a")
elif a == b:
print("a и b равны")
else:
print("a больше, чем b")
В данном случае в консоли будет выведено сообщение, что b больше a. В блоке if как раз и проверяется условие, больше ли b, чем a. В блоке elif, название которого происходит от else if (иначе если), проверяется равенство переменных. Остается лишь случай, когда a больше, чем b. Он обрабатывается блоком else. Иными словами, блоку else достается все то, что не вошло в другие условия.
Для таких конструкций тоже существует короткая запись. Так, для примера выше она будет выглядеть следующим образом:
a=2 b=10 result = "b больше, чем a" if b > a else "a и b равны" if a == b else "a больше, чем b" print(result)
Для наглядности (чтобы лучше читалось) Python разрешает использовать скобки:
result = "b больше, чем a" if b > a else ("a и b равны" if a == b else "a больше, чем b")
Далее поговорим о вложенных условных операторах.
Вложенные условные операторы
Условные операторы можно размещать внутри других условных операторов. Рассмотрим такой пример:
x = 1
y = 2
if x > 0:
if y > 0:
print("Точка в первой четверти")
else:
print("Точка в четвертой четверти")
else:
if y > 0:
print("Точка во второй четверти")
else:
print("Точка в третьей четверти")
Эта программа определяет, какой четверти координатной плоскости принадлежит точка с координатами x (абсцисса) и y (ордината). Внешний оператор if — else проверяет знак абсциссы, а внутренние — знак ординаты. В случае приведенного выше примера в консоль будет выведено сообщение о том, что точка находится в первой координатной четверти.
Приведенный пример не учитывает случай, когда абсцисса и/или ордината могут равняться нулю. В этом случае точка может находиться на одной из координатных осей или в начале координат. Чтобы учесть нулевые значения координат, потребуется ввести еще один условный оператор и расположить его до основного:
x = 1
y = 2
if x == 0 or y == 0:
print("Точка находится на осях или в начале координат")
return
if x > 0:
if y > 0:
print("Точка в первой четверти")
else:
print("Точка в четвертой четверти")
else:
if y > 0:
print("Точка во второй четверти")
else:
print("Точка в третьей четверти")
Оператор return нужен для того, чтобы завершить выполнение программы сразу после вывода сообщения. Без него начнет выполняться основной if — else, а нам это не нужно, так как тогда в консоли будут выведены два сообщения, одно из которых будет ошибочным.
Далее рассмотрим оператор выбора match — case, который не так давно появился в Python.
Оператор выбора match — case
Этот оператор появился в Python начиная с версии 3.10. Он позволяет сделать выбор действия при совпадении некоторого субъекта с одним из шаблонов. В коде конструкции оператора прописывается определенный субъект (предмет совпадения), а ниже — некоторые варианты (шаблоны), которые будут сравниваться с субъектом. При совпадении шаблона с субъектом происходит какое-либо заранее прописанное действие. Рассмотрим простой пример с этой конструкцией:
day = 1
match day:
case 1: print("Понедельник")
case 2: print("Вторник")
case 3: print("Среда")
case 4: print("Четверг")
case 5: print("Пятница")
case 6: print("Суббота")
case 7: print("Воскресенье")
case _: print("Некорректное значение")
Здесь в качестве субъекта выступает переменная day. Ниже располагаются 8 блоков case, каждый со своим шаблоном. Если значение переменной совпадает с одним из первых семи шаблонов, то в консоли будет напечатано название соответствующего дня недели. В случае вышеприведенного примера будет выведено слово «Понедельник». Последний case нужен на случай, если совпадений не будет обнаружено. Этот case сработает, если присвоить переменной day, например, значение 8 или любое другое, отличное от тех, которые содержатся в остальных семи шаблонах.
Ввод и вывод в Python
В языке Python существуют специальные встроенные функции, позволяющие пользователю вводить какие-либо значения в программу. После обработки этих значений программа выводит результат при помощи функций вывода.
Функция input
Общий синтаксис данной функции такой:
input(prompt)
Параметр prompt — это подсказка для пользователя, говорящая, что именно нужно ввести. Функция всегда возвращает строковые значения. То есть если введено число, то на выходе функция input вернет это число в виде строки.
Работа этой функции хорошо иллюстрируется следующим примером:
name = input('Введите ваше имя:')
print('Ваше имя:'+name)
После запуска программа сразу же просит пользователя ввести свое имя. Когда имя будет введено, следует нажать на клавишу Enter. После этого в следующей строке будет отображено имя пользователя. Функцию input можно использовать и без параметра подсказки, но тогда эту подсказку обычно передают в функцию print:
print('Введите ваше имя:')
name = input()
print('Ваше имя: '+name)
Далее рассмотрим функцию вывода print.
Функция print
Мы уже ее неоднократно использовали, но в самом простом варианте. Рассмотрим и другие варианты. Например, вот эта команда выведет входящие в нее строки как одну:
print('Привет!', 'Как твои дела?')
Можно подавать на вход и большее количество строк:
print('1', '2', '3', '4', '5', '6')
На вход функции, в качестве еще одного аргумента, можно передать сепаратор. Он послужит разделителем строк. В следующем примере в качестве сепаратора передается запятая:
print('1', '2', '3', '4', '5', '6', sep=',')
В результате выполнения этой команды в консоли будут выведены числа от 1 до 6 через запятую. Для переноса строк можно использовать символ новой строки (\n):
print('Перенос строки\nс помощью символа новой строки')
Далее рассмотрим небольшую программу, в которой используются операторы выбора и функции ввода и вывода.
Решение квадратных уравнений на Python
Ниже представлен исходный код простой программы для решения квадратных уравнений через дискриминант:
a = input('Введите значение a: ')
b = input('Введите значение b: ')
c = input('Введите значение c: ')
a = float(a)
b = float(b)
c = float(c)
d = b**2 - 4*a*c
print('Дискриминант = ' + str(d))
if d < 0:
print('Корней нет')
elif d == 0:
x = -b / (2 * a)
print('x = ' + str(x))
else:
x1 = (-b + d ** 0.5) / (2 * a)
x2 = (-b - d ** 0.5) / (2 * a)
print('x₁ = ' + str(x1))
print('x₂ = ' + str(x2))
Сначала через функцию input получаем значения коэффициентов уравнения. Мы получили строковые значения коэффициентов, а нам нужны числовые. Поэтому следующие три команды при помощи функции float превращают строки в числа с плавающей точкой.
Далее вычисляется дискриминант и выводится в консоль посредством функции print. Здесь особое внимание следует обратить на функцию str, на вход которой подается значение дискриминанта. Она нужна, чтобы обратить число в строку, так как строка не может складываться с числом. Если бы выводилось просто значение дискриминанта без подписи, тогда функция str была бы не нужна.
Дальше идет условный оператор if — elif — else. В блоке if проверяется, меньше ли дискриминант нуля. Если это условие выполняется, то выводится сообщение о том, что корней нет. В блоке elif проверяется равенство дискриминанта нулю. Если это условие выполняется, то происходят вычисление и вывод единственного корня уравнения. Для блока else осталось только условие, когда дискриминант больше нуля. В этом блоке происходят вычисление и вывод в консоль двух корней уравнения.
А теперь давайте перепишем программу так, чтобы вместо оператора выбора if — elif — else был оператор match — case:
a = input('Введите значение a: ')
b = input('Введите значение b: ')
c = input('Введите значение c: ')
a = float(a)
b = float(b)
c = float(c)
d = b**2 - 4*a*c
print('Дискриминант = ' + str(d))
match d:
case d if d < 0: print('Корней нет')
case 0:
x = -b / (2 * a)
print('x = ' + str(x))
case _:
x1 = (-b + d ** 0.5) / (2 * a)
x2 = (-b - d ** 0.5) / (2 * a)
print('x₁ = ' + str(x1))
print('x₂ = ' + str(x2))
Как видим, особой разницы здесь нет. Единственное, на что можно обратить внимание, — это на синтаксис записи первого блока case. В него пришлось включить if, так как записи типа d<0 и им подобные не могут напрямую содержаться в case. Таким образом, в некоторых случаях можно заменить if — elif — else на match — case и наоборот.
Приведенная программа не учитывает того, что первый коэффициент может равняться нулю. Как это можно исправить?
Ответ
При a=0 мы получим линейное уравнение вместо квадратного. Следовательно нужно применить соответствующую формулу для вычисления корней линейного уравнения. Вычисление и вывод результата поместим в условный оператор, который размещаем до вычисления дискриминанта:
a = input('Введите значение a: ')
b = input('Введите значение b: ')
c = input('Введите значение c: ')
a = float(a)
b = float(b)
c = float(c)
if a == 0:
x = -c / b
print('x = ' + str(x))
return
d = b**2 - 4*a*c
print('Дискриминант = ' + str(d))
match d:
case d if d < 0: print('Корней нет')
case 0:
x = -b / (2 * a)
print('x = ' + str(x))
case _:
x1 = (-b + d ** 0.5) / (2 * a)
x2 = (-b - d ** 0.5) / (2 * a)
print('x₁ = ' + str(x1))
print('x₂ = ' + str(x2))
И не забываем про return, чтобы исключить выполнение уже ненужных дальнейших команд.
