Elif python что это

Python: Конструкция else + if = elif

Функция get_type_of_sentence() различает только вопросительные и обычные предложения. Добавим в нее поддержку восклицательных предложений:

def get_type_of_sentence(sentence): last_char = sentence[-1] if last_char == '?': sentence_type = 'question' if last_char == '!': sentence_type = 'exclamation' else: sentence_type = 'normal' return 'Sentence is ' + sentence_type print(get_type_of_sentence('Who?')) # => 'Sentence is normal' print(get_type_of_sentence('No')) # => 'Sentence is normal' print(get_type_of_sentence('No!')) # => 'Sentence is exclamation' 

Мы добавили проверку восклицательных предложений — exclamation. Технически эта функция работает, но вопросительные предложения трактует неверно. Еще в ней есть проблемы с точки зрения семантики:

• Наличие восклицательного знака проверяется в любом случае, даже если уже обнаружился вопросительный знак
• Ветка else описана для второго условия, но не для первого. Поэтому вопросительное предложение становится «normal»

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

def get_type_of_sentence(sentence): last_char = sentence[-1] if last_char == '?': sentence_type = 'question' elif last_char == '!': sentence_type = 'exclamation' else: sentence_type = 'normal' return 'Sentence is ' + sentence_type print(get_type_of_sentence('Who?')) # => 'Sentence is question' print(get_type_of_sentence('No')) # => 'Sentence is normal' print(get_type_of_sentence('No!')) # => 'Sentence is exclamation' 

Теперь все условия выстроились в единую конструкцию. elif означает — «если не выполнено предыдущее условие, но выполнено текущее». Получается такая схема:

• если последняя буква ? , то ‘question’
• если последняя буква ! , то ‘exclamation’
• остальные варианты — ‘normal’

Выполнится только один из блоков кода, который относится ко всей конструкции if .

Задание

На электронной карте Вестероса, которую реализовал Сэм, союзники Старков отображены зелёным кружком, враги — красным, а нейтральные семьи — серым.

Напишите для Сэма функцию who_is_this_house_to_starks() , которая принимает на вход фамилию семьи и возвращает одно из трёх значений: ‘friend’ , ‘enemy’ , ‘neutral’ .

• Друзья ( ‘friend’ ): ‘Karstark’ , ‘Tully’
• Враги ( ‘enemy’ ): ‘Lannister’ , ‘Frey’
• Любые другие семьи считаются нейтральными ( ‘neutral’ )

print(who_is_this_house_to_starks('Karstark')) # => 'friend' print(who_is_this_house_to_starks('Frey')) # => 'enemy' print(who_is_this_house_to_starks('Joar')) # => 'neutral' print(who_is_this_house_to_starks('Ivanov')) # => 'neutral' 

Упражнение не проходит проверку — что делать? ��

Если вы зашли в тупик, то самое время задать вопрос в «Обсуждениях». Как правильно задать вопрос:

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

В моей среде код работает, а здесь нет ��

Тесты устроены таким образом, что они проверяют решение разными способами и на разных данных. Часто решение работает с одними входными данными, но не работает с другими. Чтобы разобраться с этим моментом, изучите вкладку «Тесты» и внимательно посмотрите на вывод ошибок, в котором есть подсказки.

Мой код отличается от решения учителя ��

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

В редких случаях бывает, что решение подогнано под тесты, но это видно сразу.

Прочитал урок — ничего не понятно ��

Создавать обучающие материалы, понятные для всех без исключения, довольно сложно. Мы очень стараемся, но всегда есть что улучшать. Если вы встретили материал, который вам непонятен, опишите проблему в «Обсуждениях». Идеально, если вы сформулируете непонятные моменты в виде вопросов. Обычно нам нужно несколько дней для внесения правок.

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

Определения

• else + if = elif — способ задать несколько альтернативных условий.

if elif else

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

 if a: 
print('a - истина')

Обратите внимание, что в Питоне принято использовать укороченную форму проверки ( if a: ), вместо часто избыточной полной ( if a == True: ).

elif

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

else

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

 if x < 0:
print('Отрицательное число') 
elif x == 0: 
print('Нуль') 
elif x == 1: 
print('Единица') 
else: 
print('Другое положительное число')

Однострочная форма

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

 my_var = 'one' if x == 1 else 'other' 
# my_var укажет на `one` если x равно 1, иначе на `other`

Проверка условий, конструкция if/elif/else в Python

Условный оператор if/elif/else, ветвление кода программы

Возможно, самый известный тип инструкций — это конструкция if/elif/else . Часто возникает необходимость, чтобы некоторый код выполнялся только при соблюдении определенного условия или код подлежащий выполнению, должен выбираться исходя из выполнения одного из нескольких взаимоисключающих условий.
Например:

>>> x = int(input("Please enter an integer: ")) # Please enter an integer: 42 >>> if x  0: . x = 0 . print('Negative changed to zero') . elif x == 0: . print('Zero') . elif x == 1: . print('Single') . else: . print('More') # More 

Ключевое слово elif является сокращением от else if . Инструкции elif и else могут отсутствовать и не являются обязательными. Инструкция elif может повторяться сколько угодно раз if/elif/else . Такая последовательность инструкций elif является заменой для конструкции switch или case , которые есть в других языках программирования.

Составная инструкция if , elif и else обеспечивает условное выполнение блоков инструкций.
Она имеет следующий синтаксис:

if выражение: блок кода elif выражение: блок кода elif выражение: блок кода . . else: блок кода

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

В предложениях if и elif в качестве условия можно использовать любое выражение Python. В подобных случаях говорят, что условие используется в логическом контексте. В логическом контексте любое выражение рассматривается как истинное или ложное. Любое ненулевое число или любой непустой контейнер (строка, кортеж, список, словарь, множество) расценивается как истинное значение. Нуль (любого числового типа), None и пустой контейнер расцениваются как ложные значения. Для тестирования значения x в логическом контекстеиспользуйте следующий стиль написания кода:

if x: 

Это наиболее ясная и соответствующая духу Python форма кода.

Примеры if/elif/else конструкций

Использование None в конструкции if :

a = None if a is not None: print('a НЕ равно None') else: print('a равно None') 

Использование False и True в конструкции if :

bul = False if bul: print('bul = True') else: print('bul = False') 

Использование integer числа 0 в конструкции if :

number = 0 if number: print('number не равно 0') else: print('number = 0') 

Использование числовых сравнений в конструкции if :

a = 10 b = 20 if a != b and a > b: print('a не равно b и a больше b') else: print('a не равно b и a меньше b') 

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

a = 15 b = 3 if a != b if a > b: print('a больше b') else: print('a меньше b') else: print('a равно b') 

Проверка наличия слова в строке str с помощью конструкции if :

string1 = 'Привет мир' string2 = 'мир' if string2 in string1: print('Слово "мир" присутствует в строке "Привет мир"') else: print('Слово "мир" отсутствует в строке "Привет мир"') 

Проверка вхождения элемента в список list с помощью конструкции if :

a = 'bc' lst = ['ac', 'bc', 0, 1, 3, 'abc'] if a in lst: print('Значение "bc" входит в список', lst) else: print('Значение "bc" не входит в список', lst) 

Проверка вхождения элемента в кортеж tuple с помощью конструкции if :

a = 'bc' tpl = ('ac', 'bc', 0, 1, 3, 'abc') if a in tpl: print('Значение "bc" входит в кортеж', tpl) else: print('Значение "bc" не входит в кортеж', tpl) 

Проверка вхождения элемента в множество set с помощью конструкции if :

a = 'bc' set_ = 'ac', 'bc', 0, 1, 3, 'abc'> if a in set_: print('Значение "bc" входит в множество', set_) else: print('Значение "bc" не входит в множество', set_) 

Проверка наличия ключа key в словаре dict с помощью конструкции if :

key = 'bc' dct = 'ac':None, 'bc':False, '0':0, '1':3, '3':1, 'abc':True> if key in dct: print('Ключ "bc" присутствует в словаре', dct) else: print('Ключ "bc" отсутствует в словаре', dct) 

• ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
• Проверка условий, конструкция if/elif/else
• Конструкция if/else в одну строку
• Имитация оператора switch/case
• while, цикл по условию
• Цикл for
• Числовые последовательности для цикла Python
• Практическое применение for/in/else циклов
• Инструкции break, continue и блок else в циклах Python
• Оператор pass
• Конструкция match/case, сопоставление с образцом

Множественное ветвление: if-elif-else. Оператор match в Python

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

Рассмотрим конкретный пример. Допустим, в зависимости от возраста пользователя, ему рекомендуется определенный видеоконтент. При этом выделяют группы от 3 до 6 лет, от 6 до 12, от 12 до 16, 16+. Итого 4 диапазона. Как бы мы стали реализовывать задачу, имея в наборе инструментов только конструкцию if-else?

Самый простой ответ – последовательно проверять вхождение введенного числа-возраста в определенный диапазон с помощью следующих друг за другом условных операторов:

old = int(input('Ваш возраст: ')) print('Рекомендовано:', end=' ') if 3  old  6: print('"Заяц в лабиринте"') if 6  old  12: print('"Марсианин"') if 12  old  16: print('"Загадочный остров"') if 16  old: print('"Поток сознания"')

Примечание. Названия фильмов выводятся на экран в двойных кавычках. Поэтому в программе для определения строк используются одинарные.

Предложенный код прекрасно работает, но есть одно существенное «но». Он не эффективен, так как каждый if в нем – это отдельно взятый оператор, никак не связанный с другими if . Процессор тратит время и «нервы» на обработку каждого из них, даже если в этом уже нет необходимости. Например, введено число 10. В первом if логическое выражение возвращает ложь, и поток выполнения переходит ко второму if . Логическое выражение в его заголовке возвращает истину, и его тело выполняется. Всё, на этом программа должна была остановиться.

Однако следующий if никак не связан с предыдущим, поэтому далее будет проверяться вхождение значения переменной old в диапазон от 12 до 16, в чем необходимости нет. И далее будет обрабатываться логическое выражение в последнем if , хотя уже понятно, что и там будет False .

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

old = int(input('Ваш возраст: ')) print('Рекомендовано:', end=' ') if 3  old  6: print('"Заяц в лабиринте"') else: if 6  old  12: print('"Марсианин"') else: if 12  old  16: print('"Загадочный остров"') else: if 16  old: print('"Поток сознания"')

Рассмотрим поток выполнения этого варианта кода. Сначала проверяется условие в первом if (он же самый внешний). Если здесь было получено True , то тело этого if выполняется, а в ветку else мы даже не заходим, так как она срабатывает только тогда, когда в условии if возникает ложь.

Если внешний if вернул False , поток выполнения программы заходит в соответствующий ему внешний else . В его теле находится другой if со своим else . Если введенное число попадает в диапазон от 6 до 12, то выполнится тело вложенного if , после чего программа завершается. Если же число не попадает в диапазон от 6 до 12, то произойдет переход к ветке else . В ее теле находится свой условный оператор, имеющий уже третий уровень вложенности.

Теперь зададимся следующим вопросом. Можно ли как-то оптимизировать код множественного ветвления и не строить лестницу из вложенных друг в друга условных операторов? Во многих языках программирования, где отступы используются только для удобства чтения программистом, но не имеют никакого синтаксического значения, часто используется подобный стиль:

if логическое_выражение < … ; >else if логическое_выражение < … ; >else if логическое_выражение < … ; >else

Может показаться, что имеется только один уровень вложенности, и появляется новое расширение для if , выглядящее как else if . Но это только кажется. На самом деле if , стоящее сразу после else , является вложенным в это else . Выше приведенная схема – то же самое, что

if логическое_выражение < … ; >else if логическое_выражение < … ; >else if логическое_выражение < … ; >else

Именно так ее «понимает» интерпретатор или компилятор. Однако считается, что человеку проще воспринимать первый вариант.

В Питоне такое поднятие вложенного if к внешнему else невозможно, потому что здесь отступы и переходы на новую строку имеют синтаксическое значение. Поэтому в язык Python встроена возможность настоящего множественного ветвления на одном уровне вложенности, которое реализуется с помощью веток elif.

Слово «elif» образовано от двух первых букв слова «else», к которым присоединено слово «if». Это можно перевести как «иначе если».

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

old = int(input('Ваш возраст: ')) print('Рекомендовано:', end=' ') if 3  old  6: print('"Заяц в лабиринте"') elif 6  old  12: print('"Марсианин"') elif 12  old  16: print('"Загадочный остров"') elif 16  old: print('"Поток сознания"')

Обратите внимание, в конце, после всех elif , может использоваться одна ветка else для обработки случаев, не попавших в условия ветки if и всех elif . Блок-схему полной конструкции if-elif-…-elif-else можно изобразить так:

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

Оператор match-case в Python

Начиная с версии 3.10 в Питоне появился оператор match , который можно использовать как аналог оператора switch , который есть в других языках. На самом деле возможности match немного шире.

В match множественное ветвление организуется с помощью веток case :

match имя_переменной: case значение_1: действия case значение_2: действия …

Слова match-case можно перевести как «соответствовать случаю». То есть, если значение переменной или выражения при match соответствует значению при каком-либо case , то выполнятся действия, вложенные в этот case .

В отличие от if-elif здесь нельзя использовать логические выражения. После case должен находится литерал, конкретное значение, выражение, возвращающее однозначный результат.

Рассмотрим программу, в которой реализовать множественное ветвление с помощью match-case удобнее, чем через if-elif-else:

sign = input('Знак операции: ') a = int(input('Число 1: ')) b = int(input('Число 2: ')) match sign: case '+': print(a + b) case '-': print(a - b) case '/': if b != 0: print(round(a / b, 2)) case '*': print(a * b) case _: print('Неверный знак операции')

Здесь значение переменной sign проверяется не на вхождение в какой-либо диапазон, а на точное соответствие заданным строковым литералам. При этом в ветках case уже не надо писать sign == ‘+’ или sign == ‘-‘ , как это пришлось бы делать в программе с if-elif:

if sign == '+': print(a + b) elif sign == '-': print(a - b) elif sign == '/': if b != 0: print(round(a / b, 2)) elif sign == '*': print(a * b) else: print('Неверный знак операции')

Код с match выглядит более ясным.

Оператор match языка Python не имеет ветки else . Вместо нее используется ветка case _ .

При одном case через оператор | можно перечислять несколько значений. Если значение переменной соответствует хотя бы одному из них, тело этого case выполнится.

sign = input('Знак операции: ') match sign: case '+' | '-' | '*': a = int(input('Число 1: ')) b = int(input('Число 2: ')) print(eval(f'  ')) case _: print('Неверный знак операции')

В коде выше с помощью функции eval() переданная ей строка выполняется как выражение. Например, если были введены числа 3, 5 и знак *, то получится строка «3 * 5» . Вызов eval(«3 * 5») возвращает число 15.

Практическая работа

1. Спишите вариант кода программы «про возраст» c if и тремя ветками elif из урока. Дополните его веткой else , обрабатывающие случаи, когда пользователь вводит числа не входящие в заданные четыре диапазона. Подумайте, почему в первой версии программы (когда использовались не связанные друг с другом условные операторы) нельзя было использовать else , а для обработки не входящих в диапазоны случаев пришлось бы писать еще один if ?
2. Усовершенствуйте предыдущую программу, обработав исключение ValueError , возникающее, когда вводится не целое число.
3. Напишите программу, которая запрашивает на ввод число. Если оно положительное, то на экран выводится цифра 1. Если число отрицательное, выводится -1. Если введенное число – это 0, то на экран выводится 0. Используйте в коде условный оператор множественного ветвления.

Примеры решения и дополнительные уроки в pdf-версии курса

X Скрыть Наверх

Python. Введение в программирование