Содержание

if-elif-else. Урок 9 курса «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. В ее теле находится свой условный оператор, имеющий уже третий уровень вложенности.

Таким образом до последней проверки (16 <= old) интерпретатор доходит только тогда, когда все предыдущие возвращают False. Если же по ходу выполнения программы возникает True, то все последующие проверки опускаются, что экономит ресурсы процессора. Кроме того, такая логика выполнения программы более правильная.

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

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 пропускаются.

  1. Спишите последний вариант кода программы из урока. Дополните ее веткой

    else, обрабатывающие случаи, когда пользователь вводит числа не входящие в заданные четыре диапазона. Подумайте, почему в первой версии программы (когда использовались не связанные друг с другом условные операторы) нельзя было использовать else, а для обработки таких, не входящих в диапазоны, случаев пришлось бы писать еще один if?

  2. Усовершенствуйте предыдущую программу, обработав исключение ValueError, возникающее, когда вводится не целое число.

  3. Напишите программу, которая запрашивает на ввод число. Если оно положительное, то на экран выводится цифра 1. Если число отрицательное, выводится -1. Если введенное число – это 0, то на экран выводится 0. Используйте в коде условный оператор множественного ветвления.

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

if/elif/else — Python для сетевых инженеров

Toggle table of contents sidebar

Конструкция if/elif/else позволяет делать ответвления в ходе программы. Программа уходит в ветку при выполнении определенного условия.

В этой конструкции только if является обязательным, elif и else опциональны:

  • Проверка if всегда идет первой.

  • После оператора if должно быть какое-то условие: если это условие выполняется (возвращает True), то действия в блоке if выполняются.

  • С помощью elif можно сделать несколько разветвлений, то есть, проверять входящие данные на разные условия.

  • Блок elif это тот же if, но только следующая проверка. Грубо говоря, это «а если …»

  • Блоков elif может быть много.

  • Блок else выполняется в том случае, если ни одно из условий if или elif не было истинным.

Пример конструкции:

In [1]: a = 9
In [2]: if a == 10:
   ...:     print('a равно 10')
   ...: elif a < 10:
   ...:     print('a меньше 10')
   ...: else:
   ...:     print('a больше 10')
   ...:
a меньше 10

Условия

Конструкция if построена на условиях: после if и elif всегда пишется условие. Блоки if/elif выполняются только когда условие возвращает True, поэтому первое с чем надо разобраться — это что является истинным, а что ложным в Python.

True и False

В Python, кроме очевидных значений True и False, всем остальным объектам также соответствует ложное или истинное значение:

Например, так как пустой список это ложное значение, проверить, пустой ли список, можно таким образом:

In [12]: list_to_test = [1, 2, 3]
In [13]: if list_to_test:
   ....:     print("В списке есть объекты")
   ....:
В списке есть объекты

Тот же результат можно было бы получить несколько иначе:

In [14]: if len(list_to_test) != 0:
   ....:     print("В списке есть объекты")
   ....:
В списке есть объекты

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

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

In [3]: 5 > 6
Out[3]: False
In [4]: 5 > 2
Out[4]: True
In [5]: 5 < 2
Out[5]: False
In [6]: 5 == 2
Out[6]: False
In [7]: 5 == 5
Out[7]: True
In [8]: 5 >= 5
Out[8]: True
In [9]: 5 <= 10
Out[9]: True
In [10]: 8 != 10
Out[10]: True

Примечание

Обратите внимание, что равенство проверяется двойным ==.

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

In [1]: a = 9
In [2]: if a == 10:
   ...:     print('a равно 10')
   ...: elif a < 10:
   ...:     print('a меньше 10')
   ...: else:
   ...:     print('a больше 10')
   ...:
a меньше 10

Оператор in

Оператор in позволяет выполнять проверку на наличие элемента в последовательности (например, элемента в списке или подстроки в строке):

In [8]: 'Fast' in 'FastEthernet'
Out[8]: True
In [9]: 'Gigabit' in 'FastEthernet'
Out[9]: False
In [10]: vlan = [10, 20, 30, 40]
In [11]: 10 in vlan
Out[11]: True
In [12]: 50 in vlan
Out[12]: False

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

In [15]: r1 = {
   ....:  'IOS': '15.4',
   ....:  'IP': '10.255.0.1',
   ....:  'hostname': 'london_r1',
   ....:  'location': '21 New Globe Walk',
   ....:  'model': '4451',
   ....:  'vendor': 'Cisco'}
In [16]: 'IOS' in r1
Out[16]: True
In [17]: '4451' in r1
Out[17]: False

Операторы and, or, not

В условиях могут также использоваться логические операторы and, or, not:

In [15]: r1 = {
   . ...:  'IOS': '15.4',
   ....:  'IP': '10.255.0.1',
   ....:  'hostname': 'london_r1',
   ....:  'location': '21 New Globe Walk',
   ....:  'model': '4451',
   ....:  'vendor': 'Cisco'}
In [18]: vlan = [10, 20, 30, 40]
In [19]: 'IOS' in r1 and 10 in vlan
Out[19]: True
In [20]: '4451' in r1 and 10 in vlan
Out[20]: False
In [21]: '4451' in r1 or 10 in vlan
Out[21]: True
In [22]: not '4451' in r1
Out[22]: True
In [23]: '4451' not in r1
Out[23]: True
Оператор and

В Python оператор and возвращает не булево значение, а значение одного из операндов.

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

In [24]: 'string1' and 'string2'
Out[24]: 'string2'
In [25]: 'string1' and 'string2' and 'string3'
Out[25]: 'string3'

Если один из операторов является ложью, результатом выражения будет первое ложное значение:

In [26]: '' and 'string1'
Out[26]: ''
In [27]: '' and [] and 'string1'
Out[27]: ''
Оператор or

Оператор or, как и оператор and, возвращает значение одного из операндов.

При оценке операндов возвращается первый истинный операнд:

In [28]: '' or 'string1'
Out[28]: 'string1'
In [29]: '' or [] or 'string1'
Out[29]: 'string1'
In [30]: 'string1' or 'string2'
Out[30]: 'string1'

Если все значения являются ложными, возвращается последнее значение:

In [31]: '' or [] or {}
Out[31]: {}

Важная особенность работы оператора or — операнды, которые находятся после истинного, не вычисляются:

In [33]: '' or sorted([44, 1, 67])
Out[33]: [1, 44, 67]
In [34]: '' or 'string1' or sorted([44, 1, 67])
Out[34]: 'string1'

Пример использования конструкции if/elif/else

Пример скрипта check_password.py, который проверяет длину пароля и есть ли в пароле имя пользователя:

# -*- coding: utf-8 -*-
username = input('Введите имя пользователя: ')
password = input('Введите пароль: ')
if len(password) < 8:
    print('Пароль слишком короткий')
elif username in password:
    print('Пароль содержит имя пользователя')
else:
    print('Пароль для пользователя {} установлен'. format(username))

Проверка скрипта:

$ python check_password.py
Введите имя пользователя: nata
Введите пароль: nata1234
Пароль содержит имя пользователя
$ python check_password.py
Введите имя пользователя: nata
Введите пароль: 123nata123
Пароль содержит имя пользователя
$ python check_password.py
Введите имя пользователя: nata
Введите пароль: 1234
Пароль слишком короткий
$ python check_password.py
Введите имя пользователя: nata
Введите пароль: 123456789
Пароль для пользователя nata установлен

Тернарное выражение (Ternary expression)

Иногда удобнее использовать тернарный оператор, нежели развернутую форму:

s = [1, 2, 3, 4]
result = True if len(s) > 5 else False

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

Оператор if else Python

Изучив это руководство, вы научитесь использовать в Python различные формы if. .else.

  • Что такое if … else в Python?
  • Оператор if Python — синтаксис
  • Оператор if Python — блок-схема
  • Оператор if Python — пример
  • Оператор Python if … else
    • Синтаксис if … else
    • Блок-схема оператора  if else Python
    • Python if else — примеры
  • Оператор  if elif else Python
    • Синтаксис if…elif…else
    • Блок-схема if…elif…else
    • Пример if…elif…else
  • Вложенные операторы Python if
  • Пример вложенного оператора if

Выбор правильного варианта действия используется, когда мы хотим выполнить код, только если выполняется определенное условие. Для этого в Python применяется оператор if elif else.

if тестовое выражение:
    оператор(ы)

В примере программа оценивает тестовое выражение и выполняет оператор операторы, только если тестовое выражение равно True. Если тестовое выражение равно False, оператор операторы не выполняются.

В Python тело оператора if ограничивается отступом. Первая строка без отступа обозначает конец оператора.

Python интерпретирует ненулевые значения как истинное значение (true). None и 0 интерпретируются как False.

# Если число положительное, мы выводим соответствующее сообщение
num = 3
if num > 0:
    print(num, "is a positive number.")
print("This is alwaysprinted.")
num = -1
if num > 0:
    print(num, "is a positive number.")
print("This is alsoalwaysprinted.")

Результат работы кода:

3 is a positive number
This is alwaysprinted
This is alsoalwaysprinted.

В приведенном выше примере num > 0- это тестовое выражение. Тело if выполняется только в том случае, если оно равно True.

Когда переменная num равна 3, тестовое выражение истинно, и операторы внутри тела if выполняются. Если переменная num равна -1, тестовое выражение не истинно, а операторы внутри тела if пропускаются.

Оператор print() расположен за пределами блока if (не определен). Следовательно, он выполняется независимо от тестового выражения.

if тестовое выражение:
    тело if
else:
    тело else

Оператор if..else оценивает тестовое выражение и выполняет тело if, только если условие равно True.
Если условие равно False, выполняется тело else. Для разделения блоков используются отступы.

# Программа проверяет, является ли число положительным или отрицательным
# и отображает соответствующее выражение
num = 3
# Также попробуйте следующие два варианта. 
# num = -5
# num = 0
if num >= 0:
    print("Positive or Zero")
else:
    print("Negative number") 

В приведенном выше примере, когда num равно 3, тестовое выражение истинно и выполняется тело if, а тело else пропускается.

Если num равно -5, тестовое выражение является ложным и выполняется блок else, а тело if пропускается.

Если num равно 0, тестовое выражение истинно и выполняется блок if, а тело else пропускается.

if тестовое выражение:
    тело if
elif тестовое выражение:
    тело elif
else: 
    тело else

elif — это сокращение от else if. Этот оператор позволяет проверять несколько выражений.

Если условие if равно False, оно проверяет состояние следующего блока elif и так далее. Если все условия равны False, выполняется тело else.

Только один из нескольких блоков if…elif…else выполняется в соответствии с условием.
Блок if может быть только один. Но он может включать в себя несколько блоков elif.

# В этой программе 
# мы проверяем, является ли число положительным,
# отрицательным или нулем и 
# выводим соответствующее выражение.
num = 3.4
# Также попробуйте следующие два варианта:
# num = 0
# num = -4.5
if num > 0:
    print("Positive number")
elif num == 0:
    print("Zero")
else:
    print("Negative number") 

Когда переменная num положительная, отображается Positive number. Если num равно 0, отображается Zero. Если число отрицательное, отображается Negative number.

if…elif…else может размещаться внутри другого оператора if…elif…else. Любое количество этих операторов может быть вложено внутрь друг друга. Отступы — единственный способ выяснить уровень вложенности. Это может быть довольно запутанным, поэтому следует избегать вложенности.

# В этой программе мы вводим число,
# проверяем, является ли число положительным,
# отрицательным или нулем, и выводим
# соответствующее сообщение
# На этот раз мы используем вложенный if
num =float(input("Enter a number: "))
if num >=0:
if num ==0:
print("Zero")
else:
print("Positive number")
else:
print("Negative number")

Вывод 1

Enter a number: 5
Positive number

Вывод 2

Enter a number: -1
Negative number

Вывод 3

Enter a number: 0
Zero

Пожалуйста, опубликуйте свои отзывы по текущей теме статьи. Мы крайне благодарны вам за ваши комментарии, дизлайки, подписки, отклики, лайки!

Вадим Дворниковавтор-переводчик статьи «Python if…else Statement»

Условный оператор if…else в Python

Иногда нужно, чтобы кусок кода выполнялся только при выполнении определенного условия.
Для этого нужно уметь оценивать условия. Чтобы на основе оценки определенного выражения можно было принять решение, выполнять определенный код или нет, в Python существует условный оператор if...elif...else.

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

Синтаксис конструкции
if выражение:
    оператор(ы)

Программа, код которой вы видите выше, оценивает значение `выражение`, которое может быть равно True или False. Программа выполнит оператор(ы), только если выражение = True. Если выражение = False, этот кусок кода не будет выполняться.

В Python тело конструкции if обозначается отступами. Тело начинается с первой строки с отступом и заканчивается первой строкой без отступа. 

Работая с условной конструкцией, важно знать, что Python интерпретирует ненулевые значения как True. None и 0 интерпретируются как False.

Блок-схема конструкции

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

num = 3
if num > 0:
    print(num, "— положительное число.")
print("Это сообщение напечатается в любом случае.")

num = -1
if num > 0:
    print(num, "— положительное число.")
print("Это сообщение тоже напечатается в любом случае.")

Вывод: 

3 — положительное число. 
Это сообщение выведется в любом случае.
Это сообщение тоже выведется в любом случае. 

В примере выше num > 0 — выражение, которое проверяется на истинность. Только если это выражение окажется истинным, т.е. True, выполнится тело оператора if.

При num = 3 выражение num > 0 истинно, поэтому Python выполнит оператор, находящийся в теле if. Вот почему на экран выводится сообщение «3 — положительное число».

При num = -1 выражение num > 0 ложно, поэтому Python проигнорирует оператор, находящийся в теле if.

А вот функции вывода на экран print("Это сообщение выведется в любом случае. ") и print("Это сообщение тоже выведется в любом случае.") находятся вне блока if, поэтому выполняются при любых значениях num.

Конструкция if…else

Синтаксис конструкции
if выражение:
  Тело if
else:
    Тело else

Оператор if...else оценивает выражение и выполняет тело if только в том случае, если выражение (условие) истинно, то есть равно True.

Если выражение равно False, выполняется тело else. Для разделения этих блоков используются отступы.

Блок-схема конструкции

Пример использования конструкции
# Программа проверяет, является ли число положительным 
# или отрицательным и выводит соответствующее сообщение.  

num = 3

# Также попробуйте следующие два варианта. 
# num = -5
# num = 0

if num >= 0:
    print("Число больше либо равно 0")
else:
    print("Отрицательное число")

Вывод: 

Число больше либо равно 0

В приведенном выше примере при num = 3 выражение истинно, поэтому выполняется тело if, а тело else игнорируется.

При num =  -5 выражение ложно, поэтому выполняется тело else. В этом слуае  игнорируется тело if.

При num = 0 выражение истинно, поэтому выполняет тело равно if, а тело else игнорируется.

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

Синтаксис конструкции
if выражение_1:
  Тело if
elif выражение_2:
  Тело elif
else:
    Тело else

elif — это сокращение от else if. Этот оператор позволяет нам проверять сразу несколько выражений.

Если условие для if = False, Python оценивает условие блока elif и так далее. Если все условия = False, выполняется тело else.

Для одного if может быть только один else. Но внутри конструкции if...else может быть сколько угодно блоков elif.

Блок-схема конструкции

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

num = 3.4

# Также попробуйте такие варианты:
# num = 0
# num = -4.5

if num > 0:
    print("Положительное число")
elif num == 0:
    print("Ноль")
else:
    print("Отрицательное число")

Если переменная num содержит положительное значение, Python выведет на экран сообщение «Положительное число».

Если num равно 0, напечатается сообщение «Ноль».

Если num содержит отрицательное значение, Python выведет на экран сообщение «Отрицательное число».

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

Любое количество блоков if…elif…else можно разместить внутри другого оператора if…elif…else. Отступы — единственный способ отделять разные уровни вложенности. Это делает код сложнее для понимания, поэтому загроможденной вложенности желательно избегать.

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

num = float(input("Введите число: "))
if num >= 0:
    if num == 0:
        print("Ноль")
    else:
        print("Положительное число")
else:
    print("Отрицательное число")

Вывод 1:

Введите число: 5
Положительное число

Вывод 2:

Введите число: -1
Отрицательное число

Вывод 3:

Введите число: 0
Ноль

Операторы if, elif и else в Python 3

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

Содержание

  1. Введение
  2. Использование оператора if
  3. Использование оператора if и else
  4. Использование оператора if, elif и else
  5. Вложенность операторов
  6. Заключение

Введение

В разработке бывают моменты, когда мы хотим принять решения только при выполнении определенного условия. Для этого мы используем различные формы оператора if-elif-else.

Официальная документация на сайте Python.org

Использование оператора if

Рассмотрим пример использования одиночного оператора if.

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

if function_returned_true:
    other_function()

Здесь программа вычисляет function_returned_true — тестовое выражение, и выполняет условия оператора только в том случае, если тестовое выражение истинно — True.

Если function_returned_true ложно — False, оператор(ы) не выполняется.

В Python тело оператора if обозначается отступом. Тело начинается с углубления, и первая неиндентированная линия отмечает конец.

Python интерпретирует ненулевые значения как True. None и 0 интерпретируются как False.

Теперь рассмотрим конкретный пример в написании кода:

chislo = 12
if chislo > 0:
    print(chislo, "Положительное число.")
print("Этот текст будет напечатан всегда.")
chislo = -5
if chislo > 0:
    print(chislo, "Положительное число.")
print("Этот текст будет напечатан всегда.")

Вывод программы:

12 Положительное число. 
Этот текст будет напечатан всегда.
Этот текст будет напечатан всегда.

В приведенном выше примере chislo > 0 является тестовым выражением.

Тело if выполняется только в том случае, если оно имеет значение True.

Когда переменная chislo равна 12, тестовое выражение истинно и выполняются операторы внутри тела if.

Если переменная chislo равна -5, то тестовое выражение ложно и операторы внутри тела if пропускаются.

Оператор print выходит за пределы блока if. Следовательно, он выполняется независимо от тестового выражения.

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

Рассмотрим пример использования оператора if вместе с else.

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

if function_returned_true_or_false():
    function_true()
else:
    function_false()

Оператор if и else вычисляет тестовое выражение — function_returned_true_or_false и выполняет тело if только тогда, когда условие теста истинно — True.

Если условие ложно — False, выполняется тело else. Отступ используется для разделения блоков.

Рассмотрим пример:

numeric = 7
if numeric >= 0:
    print("Положительное число или ноль")
else:
    print("Отрицательное число")

Вывод программы:

Положительное число или ноль

В приведенном выше примере, когда numeric равно 7, тестовое выражение истинно, тело if выполняется, а тело else пропускается.

Если numeric равно -5, то тестовое выражение ложно, тело else выполняется, а тело if пропускается.

Если numeric равно 0, то тестовое выражение истинно, тело if выполняется, а тело else пропускается.

Использование оператора if, elif и else

Рассмотрим пример использования оператора if вместе с elif и else.

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

if test_one():
    run_test_one()
elif test_two():
    run_test_two()
else:
    run_test_else()

Elif — это сокращение от else..if. Это позволяет нам проверять наличие нескольких выражений.

Если условие if ложно, то оно проверяет состояние следующего блока elif и так далее.

Если все условия ложны — False, то тело else выполняется.

Только один блок из нескольких блоков if…elif…else выполняется в соответствии с условием.

Блок if может иметь только один блок else. Но он также может иметь несколько блоков elif.

Давайте рассмотрим конкретный пример:

numeric = 4.5
if numeric > 0:
    print("Положительное число")
elif numeric == 0:
    print("Ноль")
else:
    print("Отрицательное число")

Когда переменная numeric положительна, печатается положительное число.

Если numeric равно 0, то выводится ноль.

Если numeric отрицательно, то печатается отрицательное число.

Вложенность операторов

Мы можем иметь оператор if…elif…else внутри другого оператора if…elif…else. Это называется вложенностью в программировании.

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

numeric = float(input("Введите число: "))
if numeric >= 0:
    if numeric == 0:
        print("Ноль")
    else:
        print("Положительное число")
else:
    print("Отрицательное число")

Вывод программы № 1:

Введите число: 5
Положительное число

Вывод программы № 2:

Введите число: -2
Отрицательное число

Вывод программы № 3:

Введите число: 0
Ноль

Заключение

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

На этом всё!

синтаксис, блоки else/elif и примеры

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

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

Операторы управления бывают следующих типов:

  1. Оператор-выражение if
  2. Оператор-выражение if-else
  3. Оператор-выражение if-elif-else
  4. Цикл while
  5. Цикл for
  6. Оператор-выражение break
  7. Оператор-выражение continue

В этом уроке речь пойдет о первых трех операторах управления.

Оператор if

Синтаксис оператора if следующий:

if condition:
    <indented statement 1>
    <indented statement 2>
<non-indented statement>

Первая строчка оператора, то есть if condition: — это условие if, а condition — это логическое выражение, которое возвращает True или False. В следующей строке блок инструкций. Блок представляет собой одну или больше инструкций. Если он идет следом за условием if, такой блок называют блоком if.

Стоит обратить внимание, что у каждой инструкции в блоке if одинаковый отступ от слова if. Многие языки, такие как C, C++, Java и PHP, используют фигурные скобки ({}), чтобы определять начало и конец блока, но в Python используются отступы.

Каждая инструкция должна содержать одинаковое количество пробелов. В противном случае программа вернет синтаксическую ошибку. В документации Python рекомендуется делать отступ на 4 пробела. Такая рекомендация актуальная для и для этого .

Как это работает:

Когда выполняется инструкция if, проверяется условие. Если условие истинно, тогда все инструкции в блоке if выполняются. Но если условие оказывается неверным, тогда все инструкции внутри этого блока пропускаются.

Инструкции следом за условием if, у которых нет отступов, не относятся к блоку if. Например, <non-intenden statement> — это не часть блока if, поэтому она будет выполнена в любом случае.

Например:

number = int(input("Введите число: "))
if number > 10:
    print("Число больше 10")

Первый вывод:

Введите число: 100
Число больше 10

Второй вывод:

Введите число: 5

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

Рассмотрим следующий код:

number = int(input("Введите число: "))
if number > 10:
    print("первая строка")
    print("вторая строка")
    print("третья строка")
print("Выполняется каждый раз, когда вы запускаете программу")
print("Конец")

Первый вывод:

Введите число: 45
первая строка
вторая строка
третья строка
Выполняется каждый раз, когда вы запускаете программу
Конец

Второй вывод:

Введите число: 4
Выполняется каждый раз, когда вы запускаете программу
Конец

Здесь важно обратить внимание, что только выражения на строках 3, 4 и 5 относятся к блоку if. Следовательно, они будут исполнены только в том случае, когда условие if будет истинно. Но инструкции на строках 7 и 8 выполнятся в любом случае.

Консоль Python реагирует иначе при использовании операторов управления прямо в ней. Стоит напомнить, что для разбития выражения на несколько строк используется оператор продолжение (\). Но в этом нет необходимости с операторами управления. Интерпретатор Python автоматически активирует мультистрочный режим, если нажать Enter после условия if. Например:

>>>
>>> n = 100
>>> if n > 10:
...

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

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

>>>
>>> n = 100
>>> if n > 10:
. ..     print("n v 10")
...

Python не будет автоматически добавлять отступ. Это нужно сделать самостоятельно. Закончив ввод инструкции, нужно дважды нажать Enter, чтобы исполнить инструкцию. После этого консоль вернется к изначальному состоянию.

>>>
>>> n = 100
>>> if n > 10:
...     print("n больше чем 10")
...
n больше чем 10
>>>

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

Оператор if-else

Оператор if-else исполняет одну порцию инструкций, если условие истинно и другое — если нет. Таким образом этот оператор предлагает два направления действий. Синтаксис оператора if-else следующий:

if  condition:
    # блок if
    statement 1
    statement 2
    and so on
else:
    # блок else
    statement 3
    statement 4
    and so on:

Как это работает:

Когда оператор if-else исполняется, условие проверяется, и если оно возвращает True, когда инструкции в блоке if исполняются. Но если возвращается False, тогда исполняются инструкции из блока else.

Пример 1: программа для расчета площади и длины окружности круга.

radius = int(input("Введите радиус: "))
if radius >= 0:
    print("Длина окружности = ",  2  *  3.14  *  radius)
    print("Площадь = ", 3.14 * radius ** 2)
else:
    print("Пожалуйста, введите положительное число")

Первый вывод:

Введите радиус: 4
Длина окружности = 25.12
Площадь = 50.24

Второй вывод:


Введите радиус: -12
Пожалуйста, введите положительное число

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

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

radius = int(input("Введите радиус: "))
if radius >= 0:
    print("Длина окружности = ",  2  *  3.14  *  radius)
    print("Площадь = ", 3. 
SyntaxError: invalid syntax
$

Для исправления проблемы нужно вертикально выровнять if и else

Другой пример:

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

password = input("Введите пароль: ")
if password == "sshh":
    print("Добро пожаловать")
else:
    print("Доступ запрещен")

Первый вывод:

Введите пароль: sshh
Добро пожаловать

Второй вывод:

Введите пароль: abc
Доступ запрещен

Вложенные операторы if и if-else

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

Оператор if внутри другого if-оператора

Пример 1: программа, проверяющая, имеет ли студент право на кредит.

gre_score = int(input("Введите текущий лимит: "))
per_grad = int(input("Введите кредитный рейтинг: "))
if per_grad > 70:
    # внешний блок if
        if gre_score > 150:
            # внутренний блок if
	    print("Поздравляем, вам выдан кредит")
else:
    print("Извините, вы не имеете права на кредит")

Здесь оператор if используется внутри другого if-оператора. Внутренним называют вложенный оператором if. В этом случае внутренний оператор if относится к внешнему блоку if, а у внутреннего блока if есть только одна инструкция, которая выводит “Поздравляем, вам выдан кредит”.

Как это работает:

Сначала оценивается внешнее условие if, то есть per_grad > 70. Если оно возвращает True, тогда управление программой происходит внутри внешнего блока if. Там же проверяется условие gre_score > 150. Если оно возвращает True, тогда в консоль выводится "Congratulations you are eligible for loan". Если False, тогда программа выходит из инструкции if-else, чтобы исполнить следующие операции. Ничего при этом не выводится в консоль.

При этом если внешнее условие возвращает False, тогда выполнение инструкций внутри блока if пропускается, и контроль переходит к блоку else (9 строчка).

Первый вывод:

Введите текущий лимит: 160
Введите кредитный рейтинг: 75
Поздравляем, вам выдан кредит

Второй вывод:

Введите текущий лимит: 160
Введите кредитный рейтинг: 60
Извините, вы не имеете права на кредит

У этой программы есть одна маленькая проблема. Запустите ее заново и введите gre_score меньше чем 150, а per_grade — больше 70:


Вывод:

Введите текущий лимит: 140
Введите кредитный рейтинг: 80

Программа не выводит ничего. Причина в том, что у вложенного оператора if нет условия else. Добавим его в следующем примере.

Пример 2: инструкция if-else внутри другого оператора if.

gre_score = int(input("Введите текущий лимит: "))
per_grad = int(input("Введите кредитный рейтинг: "))
if per_grad > 70:
    if gre_score > 150:
        print("Поздравляем, вам выдан кредит")
    else:
        print("У вас низкий кредитный лимит")
else:
    print("Извините, вы не имеете права на кредит")

Вывод:

Введите текущий лимит: 140
Введите кредитный рейтинг: 80
У вас низкий кредитный лимит

Как это работает:

Эта программа работает та же, как и предыдущая. Единственное отличие — у вложенного оператора if теперь есть инструкция else. Теперь если ввести балл GRE меньше, чем 150, программа выведет: “У вас низкий кредитный лимит”

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

Оператор if-else внутри условия else

Пример 3: программа для определения оценки студента на основе введенных баллов.

score = int(input("Введите вашу оценку: "))
if score >= 90:
    print("Отлично! Ваша оценка А")
else:
    if score >= 80:
	print("Здорово! Ваша оценка - B")
    else:
	if score >= 70:
	    print("Хорошо! Ваша оценка - C")
	else:
	    if score >= 60:
		print("Ваша оценка - D. Стоит повторить материал.")
	    else:
		print("Вы не сдали экзамен")

Первый вывод:

Введите вашу оценку: 92
Отлично! Ваша оценка А

Второй вывод:

Введите вашу оценку: 72
Хорошо! Ваша оценка - C

Третий вывод:

Введите вашу оценку: 56
Вы не сдали экзамен

Как это работает:

Когда управление программой переходит к оператору if-else, проверяется условие на строке 3 (score >= 90). Если оно возвращает True, в консоль выводится “Отлично! Ваша оценка А”. Если значение неверное, управление переходит к условию else на 5 строке. Теперь проверяется условие score >= 80 (6 строка). Если оно верное, тогда в консоли выводится “Здорово! Ваша оценка — B”.

В противном случае управление программой переходит к условию else на 8 строке. И здесь снова имеется вложенный оператор if-else. Проверяется условие (score >= 70). Если оно истинно, тогда в консоль выводится “Хорошо! Ваша оценка — C”. В противном случае управление переходит к блоку else на 11 строке. В конце концов, проверяется условие (score >= 60). Если оно возвращает True, тогда в консоль выводится “Ваша оценка — D. Стоит повторить материал.” Если же False, тогда в консоли будет “Вы не сдали экзамен”. На этом этапе управление переходит к следующим инструкциям, написанным после внешнего if-else.

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

Оператор if-elif-else

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

if condition_1:
    # блок if
    statement
    statement
    more statement
elif condition_2:
    # первый блок elif
    statement
    statement
    more statement
elif condition_3:
    # второй блок elif
    statement
    statement
    more statement
...
else
    statement
    statement
    more statement

Примечание: означает, что можно писать сколько угодно условий eilf.

Как это работает:

Когда исполняется инструкция if-elif-else, в первую очередь проверяется condition_1. Если условие истинно, тогда исполняется блок инструкций if. Следующие условия и инструкции пропускаются, и управление переходит к операторам вне if-elif-else.

Если condition_1 оказывается ложным, тогда управление переходит к следующему условию elif, и проверяется condition_2. Если оно истинно, тогда исполняются инструкции внутри первого блока elif. Последующие инструкции внутри этого блока пропускаются.

Этот процесс повторяется, пока не находится условие elif, которое оказывается истинным. Если такого нет, тогда исполняется блок else в самом конце.

Перепишем программу с помощью if-elif-else.

score = int(input("Введите вашу оценку: "))
if score >= 90:
    print("Отлично! Ваша оценка А")
elif score >= 80:
    print("Здорово! Ваша оценка - B")
elif score >= 70:
    print("Хорошо! Ваша оценка - C")
elif score >= 60:
    print("Ваша оценка - D. Стоит повторить материал.")
else:
    print("Вы не сдали экзамен")

Первый вывод:


Введите вашу оценку: 78
Хорошо! Ваша оценка - C

Второй вывод:

Введите вашу оценку: 91
Отлично! Ваша оценка А

Третий вывод:

Введите вашу оценку: 55
Вы не сдали экзамен

Такую программу намного легче читать, чем в случае с вложенными if-else.

Python if, if…else, if…elif…else и вложенный оператор if

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

Что такое оператор if…else в Python?

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

Оператор if…elif…else используется в Python для принятия решений.

Синтаксис инструкции Python if

если тестовое выражение:
    оператор(ы) 

Здесь программа оценивает тестовое выражение и выполняет оператор(ы), только если тестовое выражение равно True .

Если тестовое выражение равно False , оператор(ы) не выполняется.

В Python тело оператора if обозначается отступом. Тело начинается с отступа, а первая строка без отступа отмечает конец.

Python интерпретирует ненулевые значения как Правда . Нет и 0 интерпретируются как False .

Блок-схема операторов Python if

Блок-схема операторов if в программировании на Python

Пример: Оператор Python if

 # Если число положительное, мы печатаем соответствующее сообщение
число = 3
если число > 0:
    print(num, "является положительным числом")
print("Это всегда печатается.")
число = -1
если число > 0:
    print(num, "является положительным числом")
print("Это тоже всегда печатается.") 

Когда вы запустите программу, вывод будет:

  3 - положительное число
Это всегда печатается
Это тоже всегда печатается.  

В приведенном выше примере num > 0 является проверочным выражением.

Тело if выполняется только в том случае, если оно оценивается как True .

Когда переменная num равна 3, тестовое выражение истинно и выполняются операторы внутри тела , если .

Если переменная num равна -1, тестовое выражение ложно и операторы внутри тела , если пропускаются.

Оператор print() выходит за пределы блока if (без отступа). Следовательно, он выполняется независимо от тестового выражения.


Python if…else Оператор

Синтаксис if…else

если тестовое выражение:
    Тело если
еще:
    Тело else 

Оператор if..else оценивает проверит выражение и выполнит тело , если , только если условие проверки True .

Если условие False , выполняется тело , иначе . Отступ используется для разделения блоков.

Python if..else Блок-схема

Блок-схема оператора if…else в Python

Пример if…else

 # Программа проверяет, является ли число положительным или отрицательным
# И выводит соответствующее сообщение
число = 3
# Попробуйте и эти два варианта. 
# число = -5
# число = 0
если число >= 0:
    print("Положительно или ноль")
еще:
    print("Отрицательное число") 

Выход

  Положительный или ноль  

В приведенном выше примере, когда число равно 3, тестовое выражение истинно и тело , если выполняется, а тело else пропускается.

Если число равно -5, проверочное выражение ложно и выполняется тело , иначе , а тело , если , пропускается.

Если число равно 0, тестовое выражение истинно и тело , если выполняется , а тело или иначе пропускается.


Python if…elif…else Оператор

Синтаксис if…elif…else

если тестовое выражение:
    Тело если
Элиф тестовое выражение:
    Тело Элиф
еще:
    Тело else 

elif — это сокращение от else if. Это позволяет нам проверять несколько выражений.

Если условие для if равно False , проверяется условие следующего elif 9блок 0010 и так далее.

Если все условия равны False , выполняется тело else.

Только один блок из нескольких блоков if...elif...else выполняется по условию.

Блок if может иметь только один блок else . Но он может иметь несколько блоков elif .

Блок-схема оператора if...elif...else

Блок-схема оператора if...elif....else в Python

Пример оператора if...elif...else

 '''В этой программе
мы проверяем, является ли число положительным или
отрицательный или нулевой и
отображать соответствующее сообщение'''
число = 3,4
# Попробуйте также эти два варианта:
# число = 0
# число = -4,5
если число > 0:
    печать("Положительное число")
Элиф номер == 0:
    распечатать("ноль")
еще:
    print("Отрицательное число") 

Когда переменная num положительна, печатается Положительное число .

Если число равно 0, печатается Ноль .

Если число является отрицательным, печатается отрицательное число .


Python Вложенные операторы if

У нас может быть оператор if...elif...else внутри другого оператора if...elif...else . Это называется вложением в компьютерном программировании.

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

Python Nested if Пример

 '''В этой программе мы вводим число
проверить, является ли число положительным или
отрицательный или нулевой и дисплей
соответствующее сообщение
На этот раз мы используем вложенный оператор if'''
num = float(input("Введите число:"))
если число >= 0:
    если число == 0:
        распечатать("ноль")
    еще:
        печать("Положительное число")
еще:
    print("Отрицательное число") 

Вывод 1

  Введите число: 5
Положительное число  

Выход 2

  Введите число: -1
Отрицательное число  

Выход 3

  Введите число: 0
Zero  

4.

Дополнительные инструменты потока управления — документация по Python 3.10.7

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

4.1.

если Операторы

Пожалуй, самый известный тип операторов — это 9.0009, если оператор . За пример:

 >>> x = int(input("Пожалуйста, введите целое число: "))
Пожалуйста, введите целое число: 42
>>> если х < 0:
... х = 0
... print('Отрицательное значение изменено на ноль')
... Элиф х == 0:
... печать('Ноль')
... элиф х == 1:
... печать('Одиночный')
... еще:
... печать('Еще')
...
Более
 

Может быть ноль или более частей elif , а часть else по желанию. Ключевое слово « elif » является сокращением от «иначе, если» и полезно. во избежание чрезмерного отступа. если элиф elif … последовательность заменяет переключатель или case операторы найдены на других языках.

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

4.2.

для Заявлений

Оператор for в Python немного отличается от того, что вы можете использовать. в C или Pascal. Вместо того, чтобы всегда повторять арифметическую прогрессию чисел (как в Паскале) или предоставление пользователю возможности определять как шаг итерации и условие остановки (как C), Python для оператора перебирает элементы любой последовательности (списка или строки) в том порядке, в котором они появляются в последовательности. Например (без каламбура):

.
 >>> # Измерить несколько строк:
...words = ['кот', 'окно', 'дефенестрировать']
>>> для w прописью:
... печатать (ш, лен (ш))
...
кошка 3
окно 6
открыть 12
 

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

 # Создать коллекцию образцов
users = {'Ганс': 'активный', 'Элеонора': 'неактивный', '景太郎': 'активный'}
# Стратегия: перебирать копию
для пользователя, статус в users.copy().items():
    если статус == 'неактивный':
        удалить пользователей [пользователь]
# Стратегия: создать новую коллекцию
активные_пользователи = {}
для пользователя, статус в users.items():
    если статус == 'активный':
        active_users[пользователь] = статус
 

4.3. Диапазон

() Функция

Если вам нужно перебрать последовательность чисел, встроенная функция range() пригодится. Генерирует арифметические прогрессии:

 >>> для i в диапазоне (5):
... печать (я)
...
0
1
2
3
4
 

Данная конечная точка никогда не является частью сгенерированной последовательности; диапазон(10) генерирует 10 значений, допустимые индексы для элементов последовательности длины 10. Это можно позволить диапазону начинаться с другого числа или указать другое приращение (даже отрицательное; иногда это называется «шагом»):

 >>> список (диапазон (5, 10))
[5, 6, 7, 8, 9]
>>> список (диапазон (0, 10, 3))
[0, 3, 6, 9]
>>> список(диапазон(-10,-100,-30))
[-10, -40, -70]
 

Для перебора индексов последовательности вы можете комбинировать range() и len() следующим образом:

 >>> a = ['Мария', 'была', 'а', 'маленькая', 'ягненок']
>>> для i в диапазоне (len(a)):
... печать (я, а [я])
...
0 Мария
1 было
2 часа
3 маленьких
4 ягненка
 

Однако в большинстве таких случаев удобно использовать enumerate() см. Техники зацикливания.

Странная вещь происходит, если вы просто печатаете диапазон:

 >>> диапазон(10)
диапазон(0, 10)
 

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

Мы говорим, что такой объект является итерируемым, то есть подходящим в качестве цели для функции и конструкции, которые ожидают чего-то, от чего они могут получать последовательные предметы, пока запас не будет исчерпан. Мы видели это 9Оператор 0009 for является такой конструкцией, а пример функции который принимает итерацию, составляет sum() :

 >>> сумма(диапазон(4)) # 0 + 1 + 2 + 3
6
 

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

4.4.

break и continue Операторы и else Пункты в циклах

Оператор break , как и в C, вырывается из самой внутренней оболочки. вместо или при цикле .

Операторы цикла

могут иметь предложение else ; он выполняется, когда цикл завершается из-за исчерпания итерации (с для ) или когда условие становится ложным (с в то время как ), но не тогда, когда цикл завершается оператором break . Примером этому служит следующий цикл, который ищет простые числа:

 >>> для n в диапазоне (2, 10):
... для x в диапазоне (2, n):
... если n % x == 0:
... print(n, 'равно', x, '*', n//x)
...             ломать
...     еще:
... # цикл сорвался, не найдя множителя
... print(n, 'является простым числом')
...
2 это простое число
3 это простое число
4 равно 2 * 2
5 это простое число
6 равно 2 * 3
7 это простое число
8 равно 2 * 4
9 равно 3 * 3
 

(Да, это правильный код. Посмотрите внимательно: иначе пункт принадлежит цикл for , не оператор if .)

При использовании с циклом предложение else имеет больше общего с предложением else предложение оператора try , чем с предложением if операторов: выполняется оператор try else . когда не возникает никаких исключений, и предложение цикла else выполняется, когда нет break имеет место. Подробнее о оператор try и исключения, см. Обработка исключений.

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

 >>> для числа в диапазоне (2, 10):
... если число% 2 == 0:
... print("Найдено четное число", число)
...         Продолжать
... print("Найдено нечетное число", число)
...
Нашел четное число 2
Нашел нечетное число 3
Нашел четное число 4
Нашел нечетное число 5
Нашел четное число 6
Нашел нечетное число 7
Нашел четное число 8
Нашел нечетное число 9

4.5.

проход Заявления

Оператор pass ничего не делает. Его можно использовать, когда заявление требуется синтаксически, но программа не требует никаких действий. Например:

 >>> пока верно:
... pass # Занят-ожидание прерывания клавиатуры (Ctrl+C)
...
 

Обычно используется для создания минимальных классов:

 >>> класс MyEmptyClass:
...     проходить
...
 

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

 >>> по умолчанию initlog(*args):
... pass # Не забудьте реализовать это!
...
 

4.6.

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

Оператор match принимает выражение и сравнивает его значение с последующим шаблоны, представленные в виде одного или нескольких блоков case. это на первый взгляд похож на оператор switch в C, Java или JavaScript (и многие других языках), но это больше похоже на сопоставление с образцом в языки, такие как Rust или Haskell. Только первый шаблон, который соответствует выполняется, а также может извлекать компоненты (элементы последовательности или атрибуты объекта) из значения в переменные.

Простейшая форма сравнивает предметное значение с одним или несколькими литералами:

 по умолчанию http_error(статус):
    статус матча:
        случай 400:
            вернуть "Неверный запрос"
        дело 404:
            вернуть "Не найдено"
        дело 418:
            вернуть "я чайник"
        кейс _:
            вернуть "Что-то не так с интернетом"
 

Обратите внимание на последний блок: «имя переменной» _ действует как подстановочный знак и никогда не перестает совпадать. Если ни один случай не совпадает, ни одна из ветвей не выполняется.

Вы можете объединить несколько литералов в один шаблон, используя | ("или"):

 кейс 401 | 403 | 404:
    вернуть "Не разрешено"
 

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

 # точка представляет собой кортеж (x, y)
пункт совпадения:
    случай (0, 0):
        печать("Происхождение")
    случай (0, у):
        печать (е "Y = {y}")
    случай (х, 0):
        распечатать (ф"Х={х}")
    случай (х, у):
        печать (f"X={x}, Y={y}")
    кейс _:
        поднять ValueError("Нет точки")
 

Внимательно изучите это! Первый шаблон имеет два литерала и может можно рассматривать как расширение буквального шаблона, показанного выше. Но следующие два шаблона объединяют литерал и переменную, а переменная связывает значение из субъекта ( точка ). Четвертый шаблон захватывает два значения, что делает его концептуально похожим на задание распаковки (x, y) = точка .

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

 класс Точка:
    х: интервал
    у: интервал
определение где_есть (точка):
    пункт совпадения:
        случай Point(x=0, y=0):
            печать("Происхождение")
        случай Point(x=0, y=y):
            печать (е "Y = {y}")
        случай Point(x=x, y=0):
            распечатать (ф"Х={х}")
        случай Точка():
            печатать("Где-то еще")
        кейс _:
            print("Ни за что")
 

Вы можете использовать позиционные параметры с некоторыми встроенными классами, которые предоставляют порядок их атрибутов (например, классы данных). Вы также можете определить конкретный положение атрибутов в паттернах, установив __match_args__ специальный атрибут в ваших классах. Если он установлен на («x», «y»), все следующие шаблоны эквивалентно (и все привязывают атрибут y к переменной var ):

 Точка(1, вар)
Точка(1, у=вар)
Точка(х=1, у=вар)
Точка (у = вар, х = 1)
 

Рекомендуемый способ чтения паттернов — смотреть на них как на расширенную форму того, что вы поставил бы слева от присваивания, чтобы понять, какие переменные будут установлены в какие. Только автономные имена (например, var выше) назначаются оператором соответствия. Имена с точками (например, foo.bar ), имена атрибутов ( x= и y= выше) или имена классов (обозначаются знаком «(…)» рядом с ними, например, Point выше) никогда не назначаются.

Шаблоны могут быть произвольно вложены друг в друга. Например, если у нас есть короткий список точек, мы могли бы сопоставить его так:

 очков матча:
    кейс []:
        print("Нет баллов")
    случай [Точка (0, 0)]:
        print("Происхождение")
    case [Точка (x, y)]:
        print(f"Одна точка {x}, {y}")
    случай [Точка (0, y1), Точка (0, y2)]:
        print(f"Два по оси Y в точках {y1}, {y2}")
    кейс _:
        печатать("Что-то еще")
 

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

 точка совпадения:
    case Point(x, y), если x == y:
        print(f"Y=X в {x}")
    случай Точка (х, у):
        print(f"Не по диагонали")
 

Несколько других ключевых особенностей этого утверждения:

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

  • Шаблоны последовательности поддерживают расширенную распаковку: [x, y, *rest] и (x, y, *остальное) работа аналогична распаковке заданий. имя после * также может быть _ , поэтому (x, y, *_) соответствует последовательности не менее чем из двух элементов без привязки остальных элементов.

  • Шаблоны сопоставления: {"полоса пропускания": b, "задержка": l} фиксирует "пропускная способность" и "задержка" значений из словаря. В отличие от последовательности шаблоны, лишние ключи игнорируются. Распаковка вроде ** остальные также поддерживается. (Но **_ было бы лишним, поэтому это недопустимо.)

  • Подшаблоны могут быть захвачены с использованием ключевого слова as :

    Случай
     (точка (x1, y1), точка (x2, y2) как p2): . ..
     

    захватит второй элемент ввода как p2 (пока ввод последовательность из двух точек)

  • Большинство литералов сравниваются на равенство, однако синглтоны True , Ложь и Нет сравниваются по идентичности.

  • Шаблоны могут использовать именованные константы. Это должны быть имена с точками чтобы предотвратить их интерпретацию как переменную захвата:

     из импорта enum Enum
    Цвет класса (перечисление):
        КРАСНЫЙ = «красный»
        ЗЕЛЕНЫЙ = «зеленый»
        СИНИЙ = «синий»
    color = Color(input("Введите по вашему выбору "красный", "синий" или "зеленый": "))
    соответствует цвету:
        чехол Цвет.КРАСНЫЙ:
            print("Я вижу красное!")
        цвет корпуса.ЗЕЛЕНЫЙ:
            print("Трава зеленая")
        чехол Цвет.СИНИЙ:
            print("Меня тошнит :(")
     

Более подробное объяснение и дополнительные примеры можно найти в PEP 636 , который написан в формате учебника.

4.7. Определение функций

Мы можем создать функцию, которая записывает ряд Фибоначчи в произвольное граница:

 >>> def fib(n): # записать ряд Фибоначчи до n
... """Выведите ряд Фибоначчи до n."""
... а, б = 0, 1
... в то время как a < n:
... печать (а, конец = '')
... а, б = б, а+б
...     Распечатать()
...
>>> # Теперь вызовите функцию, которую мы только что определили:
... выдумка (2000)
0 1 1 2 3 5 8 13 21 34 55 89144 233 377 610 987 1597
 

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

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

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

Фактические параметры (аргументы) вызова функции введены в локальный таблица символов вызываемой функции при ее вызове; таким образом, аргументы передается с использованием вызова по значению (где значение всегда является ссылкой объекта , не стоимость объекта). 1 Когда функция вызывает другую функцию, или вызывает себя рекурсивно, новый для этого вызова создается локальная таблица символов.

Определение функции связывает имя функции с объектом функции в Текущая таблица символов. Интерпретатор распознает объект, на который указывает это имя как определяемая пользователем функция. Другие имена также могут указывать на то же самое. функциональный объект, а также может использоваться для доступа к функции:

 >>> выдумка
<функция выдумки по адресу 10042ed0>
>>> f = выдумка
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89
 

Приходя из других языков, вы можете возразить, что фиб не функция, а процедура, так как она не возвращает значение. На самом деле, даже работает без Оператор return действительно возвращает значение, хотя и довольно скучное. Этот значение называется None (это встроенное имя). Запись значения Нет обычно подавляется интерпретатором, если это единственное записанное значение. Вы можете увидеть это, если действительно хотите использовать print() :

 >>> выдумка(0)
>>> печать (выдумка (0))
Никто
 

Несложно написать функцию, которая возвращает список номеров Ряд Фибоначчи вместо печати:

 >>> def fib2(n): # вернуть ряд Фибоначчи до n
... """Вернуть список, содержащий последовательность Фибоначчи до n."""
... результат = []
... а, б = 0, 1
... в то время как a < n:
... result.append(a) # см. ниже
... а, б = б, а+б
... вернуть результат
...
>>> f100 = fib2(100) # вызываем
>>> f100 # пишем результат
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
 

Этот пример, как обычно, демонстрирует некоторые новые возможности Python:

  • Оператор return возвращает значение из функции. возвращает без аргумента выражения возвращает None . Падает конец функции также возвращает None .

  • Оператор result.append(a) вызывает метод объекта списка результат . Метод — это функция, которая «принадлежит» объекту и называется obj.methodname , где obj — некоторый объект (это может быть выражение), а имя_метода — это имя метода, определяемого типом объекта. Разные типы определяют разные методы. Методы разных типов могут иметь одно и то же имя, не вызывая двусмысленности. (Можно определить самостоятельно типы объектов и методы, используя классы , см. Классы) Метод append() , показанный в примере, определен для объектов списка; Это добавляет новый элемент в конец списка. В этом примере это эквивалентно результат = результат + [a] , но более эффективный.

4.8. Подробнее об определении функций

Также можно определять функции с переменным числом аргументов. Есть три формы, которые можно комбинировать.

4.8.1. Значения аргумента по умолчанию

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

 def ask_ok(приглашение, повторных попыток=4, напоминание='Пожалуйста, попробуйте еще раз!'):
    пока верно:
        ок = ввод (подсказка)
        если все в порядке ('y', 'ye', 'yes'):
            вернуть Истина
        если все в порядке ('n', 'нет', 'нет', 'нет'):
            вернуть ложь
        повторы = повторы - 1
        если повторных попыток < 0:
            поднять ValueError('неверный ответ пользователя')
        распечатать (напоминание)
 

Эту функцию можно вызвать несколькими способами:

  • с указанием только обязательного аргумента: ask_ok('Вы действительно хотите выйти?')

  • с одним из необязательных аргументов: ask_ok('Можно перезаписать файл?', 2)

  • или даже со всеми аргументами: ask_ok('Хорошо перезаписать файл?', 2, 'Давай, только да или нет!')

В этом примере также вводится ключевое слово в . Это проверяет, является ли или не последовательность содержит определенное значение.

Значения по умолчанию оцениваются в точке определения функции в , определяющий область действия , так что

 я = 5
защита f (аргумент = я):
    печать (аргумент)
я = 6
е()
 

напечатает 5 .

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

 по определению f(a, L=[]):
    L. добавить (а)
    вернуть л
печать (ф (1))
печать (ф (2))
печать (ф (3))
 

Это напечатает

 [1]
[1, 2]
[1, 2, 3]
 

Если вы не хотите, чтобы значение по умолчанию использовалось для последующих вызовов, вы можете вместо этого напишите такую ​​функцию:

 по определению f(a, L=Нет):
    если L равно None:
        Л = []
    L.  добавить (а)
    вернуть л
 

4.8.2. Аргументы ключевых слов

Функции также можно вызывать с помощью аргументов ключевого слова. вида kwarg=значение . Например, следующая функция:

 def parrot (напряжение, состояние = 'жесткий', действие = 'voom', тип = 'Норвежский синий'):
    print("-- Этот попугай не стал бы", action, end=' ')
    print("если вы поместите", напряжение, "вольты через него.")
    print("-- Красивое оперение, тип")
    print("-- Это", состояние, "!")
 

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

 попугай(1000) # 1 позиционный аргумент
parrot(voltage=1000) # 1 ключевой аргумент
parrot(voltage=1000000, action='VOOOOOM') # 2 ключевых аргумента
parrot(action='VOOOOOM', voltage=1000000) # 2 ключевых аргумента
parrot('миллион', 'лишенный жизни', 'прыжок') # 3 позиционных аргумента
parrot('тысяча', state='раздвигает ромашки') # 1 позиция, 1 ключевое слово
 

, но все следующие вызовы будут недействительны:

 parrot() # отсутствует обязательный аргумент
parrot(voltage=5. 0, 'dead') # аргумент без ключевого слова после аргумента ключевого слова
parrot(110, voltage=220) # повторяющееся значение для одного и того же аргумента
parrot(actor='John Cleese') # неизвестный ключевой аргумент
 

В вызове функции аргументы ключевого слова должны следовать за позиционными аргументами. Все переданные аргументы ключевого слова должны соответствовать одному из аргументов принимается функцией (например, актор не является действительным аргументом в пользу функция попугая ), и их порядок не важен. Это также включает необязательные аргументы (например, попугай (напряжение = 1000) тоже допустимо). Ни один аргумент не может принимать значение более одного раза. Вот пример, который не работает из-за этого ограничения:

 >>> функция определения (а):
...     проходить
...
>>> функция(0, а=0)
Traceback (последний последний вызов):
  Файл "", строка 1, в 
TypeError: функция() получила несколько значений для аргумента 'a'
 

При наличии окончательного формального параметра вида **имя он получает словарь (см. Типы сопоставления — dict), содержащий все аргументы ключевого слова, кроме те, которые соответствуют формальному параметру. Это может сочетаться с формальным параметр вида *имя (описано в следующем подразделе), который получает кортеж, содержащий позиционный аргументы вне списка формальных параметров. ( *имя должно встречаться до **имя .) Например, если мы определим такую ​​функцию:

 def cheeseshop(вид, *аргументы, **ключевые слова):
    print("-- У вас есть", kind, "?")
    print("-- Извините, у нас все кончилось", kind)
    для arg в аргументах:
        печать (аргумент)
    печать("-" * 40)
    для кВт в ключевых словах:
        печать (квт, ":", ключевые слова [квт])
 

Можно было бы назвать так:

 cheeseshop("Лимбургер", "Очень жидко, сэр.",
           «Он действительно очень, ОЧЕНЬ жидкий, сэр».
           владелец магазина = "Майкл Пэйлин",
           клиент = "Джон Клиз",
           sketch="Эскиз сырной лавки")
 

и, конечно же, будет напечатано:

.
 -- У вас есть Лимбургер ?
-- Извините, мы все из Лимбургера
Он очень жидкий, сэр.
Он действительно очень, ОЧЕНЬ жидкий, сэр.
----------------------------------------
владелец магазина: Майкл Пэйлин
клиент: Джон Клиз
эскиз : Эскиз сырного магазина
 

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

4.8.3. Специальные параметры

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

Определение функции может выглядеть так:

 def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
      ----------- ---------- ----------
        | | |
        | Позиционное или ключевое слово |
        | - Только ключевое слово
         -- Только позиционное
 

, где / и * являются необязательными. Если они используются, эти символы указывают на тип параметр тем, как аргументы могут быть переданы в функцию: только позиционные, позиционные или ключевые слова и только ключевые слова. Параметры ключевого слова также называются именованными параметрами.

4.8.3.1. Позиционные или ключевые аргументы

Если / и * отсутствуют в определении функции, аргументы могут передаваться в функцию по позиции или по ключевому слову.

4.8.3.2. Только позиционные параметры

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

Параметры, следующие за /, могут быть позиционными или ключевыми словами или только ключевыми словами .

4.8.3.3. Аргументы, содержащие только ключевые слова

Чтобы пометить параметры как только ключевое слово , указав, что параметры должны быть переданы по аргументу ключевого слова, поместите * в список аргументов непосредственно перед первым Параметр , содержащий только ключевое слово.

4.8.3.4. Примеры функций

Рассмотрим следующие примеры определений функций, обращая особое внимание на маркеры / и *:

 >>> по умолчанию стандартный_аргумент (аргумент):
... печать (аргумент)
...
>>> def pos_only_arg(arg, /):
... печать (аргумент)
...
>>> def kwd_only_arg(*, arg):
... печать (аргумент)
...
>>> def Combined_example(pos_only, /, standard, *, kwd_only):
... print(pos_only, standard, kwd_only)
 

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

 >>> стандартный_аргумент(2)
2
>>> стандартный_аргумент (аргумент = 2)
2
 

Вторая функция pos_only_arg ограничена использованием только позиционных параметры, так как в определении функции есть /:

 >>> pos_only_arg(1)
1
>>> pos_only_arg(arg=1)
Traceback (последний последний вызов):
  Файл "", строка 1, в 
TypeError: pos_only_arg() получил некоторые позиционные аргументы, переданные как аргументы ключевого слова: 'arg'
 

Третья функция kwd_only_args разрешает только аргументы ключевого слова, как указано на * в определении функции:

 >>> kwd_only_arg(3)
Traceback (последний последний вызов):
  Файл "", строка 1, в 
TypeError: kwd_only_arg() принимает 0 позиционных аргументов, но был задан 1
>>> kwd_only_arg(arg=3)
3
 

И последний использует все три соглашения о вызовах в одной и той же функции определение:

 >>> комбинированный_пример (1, 2, 3)
Traceback (последний последний вызов):
  Файл "", строка 1, в 
TypeError: Combine_example() принимает 2 позиционных аргумента, но было задано 3
>>> комбинированный_пример(1, 2, kwd_only=3)
1 2 3
>>> комбинированный_пример(1, стандартный=2, kwd_only=3)
1 2 3
>>> комбинированный_пример (pos_only=1, стандарт=2, kwd_only=3)
Traceback (последний последний вызов):
  Файл "", строка 1, в 
TypeError: в Combined_example() некоторые позиционные аргументы передаются как аргументы ключевого слова: 'pos_only'
 

Наконец, рассмотрим это определение функции, которое имеет потенциальную коллизию между позиционным аргументом name и **kwds , у которого name в качестве ключа:

 определение foo(имя, **kwds):
    вернуть «имя» в kwds
 

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

 >>> foo(1, **{'имя': 2})
Traceback (последний последний вызов):
  Файл "", строка 1, в 
TypeError: foo() получил несколько значений для аргумента «имя»
>>>
 

Но использование / (только позиционные аргументы) возможно, так как это позволяет имя в качестве позиционного аргумента и «имя» в качестве ключа в аргументах ключевого слова:

 def foo(имя, /, **kwds):
    вернуть «имя» в kwds
>>> foo(1, **{'имя': 2})
Истинный
 

Другими словами, имена позиционных параметров могут использоваться в **kwds без двусмысленности.

4.8.3.5. Резюме

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

 def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
 

В качестве руководства:

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

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

  • Для API используйте только позиционирование, чтобы предотвратить критические изменения API если имя параметра будет изменено в будущем.

4.8.4. Списки произвольных аргументов

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

 def write_multiple_items(файл, разделитель, *аргументы):
    file.write(разделитель.join(аргументы))
 

Обычно эти вариативные аргументы будут последними в списке формальных параметры, потому что они собирают все оставшиеся входные аргументы, которые передается в функцию. Любые формальные параметры, которые встречаются после *args являются аргументами «только для ключевого слова», что означает, что они могут использоваться только как ключевые слова, а не позиционные аргументы.

 >>> def concat(*args, sep="/"):
... вернуть sep.join(аргументы)
...
>>> concat("земля", "марс", "венера")
'земля/марс/венера'
>>> concat("Земля", "Марс", "Венера", sep=".")
'земля.марс.венера'
 

4.8.5. Распаковка списков аргументов

Обратная ситуация возникает, когда аргументы уже находятся в списке или кортеже но должны быть распакованы для вызова функции, требующей отдельного позиционного аргументы. Например, встроенная функция range() ожидает отдельного запускают и останавливают аргументы. Если их нет отдельно, напишите вызов функции с оператором * для распаковки аргументов из списка или кортеж:

 >>> list(range(3, 6)) # обычный вызов с отдельными аргументами
[3, 4, 5]
>>> аргументы = [3, 6]
>>> list(range(*args)) # вызов с аргументами, распакованными из списка
[3, 4, 5]
 

Таким же образом словари могут предоставлять аргументы ключевых слов с ** -оператор:

 >>> def parrot(voltage, state='a hard', action='voom'):
. .. print("-- Этот попугай не стал бы", action, end=' ')
... print("если положить", напряжение, "вольт через него.", end=' ')
... print("Е", состояние, "!")
...
>>> d = {"voltage": "четыре миллиона", "state": "погиб", "action": "VOOM"}
>>> попугай(**d)
-- Этот попугай не БУДЕТ, если через него пропустить четыре миллиона вольт. E's bleedin 'умер!
 

4.8.6. Лямбда-выражения

Небольшие анонимные функции можно создавать с помощью ключевого слова lambda . Эта функция возвращает сумму двух своих аргументов: lambda a, b: a+b . Лямбда-функции можно использовать везде, где требуются функциональные объекты. Они есть синтаксически ограничивается одним выражением. Семантически они просто синтаксический сахар для нормального определения функции. Как вложенная функция определений, лямбда-функции могут ссылаться на переменные из содержащего объем:

 >>> по умолчанию make_incrementor(n):
... вернуть лямбда x: x + n
...
>>> f = make_incrementor(42)
>>> ф(0)
42
>>> ф(1)
43
 

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

 >>> пары = [(1, 'один'), (2, 'два'), (3, 'три'), (4, 'четыре')]
>>> pairs.sort (ключ = лямбда-пара: пара [1])
>>> пары
[(4, 'четыре'), (1, 'один'), (3, 'три'), (2, 'два')]
 

4.8.7. Строки документации

Вот некоторые соглашения о содержании и форматировании документации струны.

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

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

Синтаксический анализатор Python не удаляет отступы из многострочных строковых литералов в Python, поэтому инструменты, обрабатывающие документацию, должны удалять отступы, если желанный. Это делается с использованием следующего соглашения. Первая непустая строка после первая строка строки определяет величину отступа для вся строка документации. (Мы не можем использовать первую строку, так как она обычно рядом с открывающими кавычками строки, поэтому ее отступ не очевидно в строковом литерале.) Пробелы, «эквивалентные» этому отступу, затем с самого начала удаляются все строки строки. Линии, которые отступ меньше не должен встречаться, но если они встречаются, все их начальные пробелы следует раздеться. Эквивалентность пробелов должна быть проверена после расширения табов (до 8 пробелов, обычно).

Вот пример многострочной строки документации:

 >>> определение my_function():
..."""Ничего не делайте, но документируйте это.
...
... Нет, правда, ничего не делает.
... """
...     проходить
...
>>> print(my_function.__doc__)
Ничего не делайте, но документируйте это.
    Нет, правда, ничего не делает.
 

4.8.8. Аннотации функций

Аннотации функций являются полностью необязательными метаданными. информация о типах, используемых пользовательскими функциями (см. ПЭП 3107 и PEP 484 для получения дополнительной информации).

Аннотации хранятся в __аннотациях__ атрибут функции как словарь и не влияет ни на какую другую часть функция. Аннотации параметров определяются двоеточием после имени параметра, за которым следует выражением, вычисляющим значение аннотации. Возвращаемые аннотации определяется литералом -> , за которым следует выражение между параметром список и двоеточие, обозначающее конец 9Заявление 0009 по умолчанию . следующий пример имеет обязательный аргумент, необязательный аргумент и возвращаемое значение аннотированное значение:

 >>> def f(ветчина: ул, яйца: ул = 'яйца') -> ул:
... print("Аннотации:", f.__annotations__)
... print("Аргументы:", ветчина, яйца)
... вернуть ветчину + ' и ' + яйца
...
>>> f('спам')
Аннотации: {'ветчина': , 'return': <класс 'str'>, 'яйца': }
Аргументы: спам-яйца
спам и яйца
 

4.

9. Интермеццо: стиль кодирования

Теперь, когда вы собираетесь писать более длинные и сложные фрагменты Python, самое время поговорить о стиле кодирования . На большинстве языков можно писать (или более лаконичный, отформатированный ) в разных стилях; некоторые более читабельны, чем другие. Всегда полезно сделать так, чтобы другие могли легко читать ваш код. хороший стиль кодирования очень помогает в этом.

Для Python PEP 8 стал руководством по стилю, которого придерживается большинство проектов; он способствует очень читабельному и приятному для глаз стилю кодирования. Каждый питон разработчик должен прочитать его в какой-то момент; вот самые важные моменты извлечено для вас:

  • Используйте отступы в 4 пробела и без табуляции.

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

  • Переносите строки так, чтобы их длина не превышала 79 символов.

    Это помогает пользователям с небольшими дисплеями и позволяет иметь несколько файлы кода рядом на больших дисплеях.

  • Используйте пустые строки для разделения функций и классов, а также больших блоков код внутри функций.

  • По возможности размещайте комментарии на отдельной строке.

  • Использовать строки документации.

  • Используйте пробелы вокруг операторов и после запятых, но не непосредственно внутри конструкции скобок: a = f(1, 2) + g(3, 4) .

  • Назовите свои классы и функции последовательно; соглашение заключается в использовании UpperCamelCase для классов и lowercase_with_underscores для функций и методы. Всегда используйте self как имя для первого аргумента метода (дополнительную информацию о классах и методах см. в разделе Первый взгляд на классы).

  • Не используйте причудливые кодировки, если ваш код предназначен для использования в международных среды. Python по умолчанию, UTF-8 или даже простой ASCII лучше всего работают в любом кейс.

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

Сноски

1

На самом деле, вызов по ссылке на объект был бы лучшим описанием, поскольку при передаче изменяемого объекта вызывающая сторона увидит любые изменения вызываемый объект обращается к нему (элементы, вставленные в список).

Python3 - if , if..else, вложенные операторы if, if-elif

Просмотреть обсуждение

Улучшить статью

Сохранить статью

  • Уровень сложности: Средний
  • Последнее обновление: 11 апр, 2022

  • Читать
  • Обсудить
  • Посмотреть обсуждение

    Улучшить статью

    Сохранить статью

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

    • if
    • if..else
    • Вложенные операторы if
    • if-elif.

    Давайте рассмотрим их все.

    if Оператор

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

    Синтаксис:  

     если условие:
       # Операторы для выполнения, если
       # условие верно 

    Flowchart:-  

    Example:   

    Python3

    if 10 > 5 :

        print ( "10 больше 5" )

    Печать ( "Программа закончилась" )

    Выходность:

    :

    0111  

     10 больше 5
    Программа завершена 

    Отступ (пробел) используется для разделения блока кода. Как показано в приведенном выше примере, использование отступов в кодировании Python3 является обязательным.

    if..else Оператор

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

    Синтаксис :  

     if (условие):
        # Выполняет этот блок, если
        # условие верно
    еще:
        # Выполняет этот блок, если
        # условие ложно 

    Flow Chart:-  

    Example 1:   

    Python3

    x = 3

    if x = = 4 :

    Печать ( "Да" )

    Else :

    : 3

    : 3

    : 3

    0009 ( "NO" )

    Выход:

     no 

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

    Python3

    letter = "A"

     

    if letter = = "B" :

       print ( "letter is B" )

        

    else :

          

       if letter = = "C" :

    Печать ( "Письмо C" )

    ELS0010 :

            

         if letter = = "A" :

           print ( "letter is A" )

    Else :

    Печать ( "Не является A, B и C" )

    Вывод:  

     буква A 

    Вложенный оператор if

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

    Синтаксис :  

     if (условие1):
       # Выполняется, когда условие 1 истинно
       если (условие2):
          # Выполняется, когда условие 2 истинно
       # если блок здесь заканчивается
    # если Блок заканчивается здесь 

    Flow chart:-  

    Example:  

    Python3

    num = 10

     

    if num > 5 :

    Печать ( "больше 5" )

    IF NUM < = IF < = 0010 15 :

    Печать ( "между 5 и 15" )

    Выходность:

     Биггер. 
    Между 5 и 15 

    Оператор if-elif

    Оператор if-elif является сокращением цепочки if..else. При использовании оператора if-elif в конце добавляется блок else, который выполняется, если ни один из приведенных выше операторов if-elif не является истинным.

    Синтаксис :-  

     если (условие):
        утверждение
    Элиф (состояние):
        утверждение
    .
    .
    еще:
        statement 

    Flow Chart:-   

    Example:-   

    Python3

     

    letter = "A"

     

    if letter = = B:

        печать ( "Письмо IS B" )

    ELIF Буква = = "C" :

    (

    9 (

    9 (

    9 (

    (

    " C " )

    ELIF NUM = = " A " :

    Печать ( " AITAR0010 )

    Else :

    Печать ( ».

     буква A 

     


    Python Условия

    ❮ Предыдущая Далее ❯


    Условия Python и операторы If

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

    • Равно: а == б
    • Не равно: а != б
    • Меньше чем: а < b
    • Меньше или равно: a <= b
    • Больше чем: a > b
    • Больше или равно: a >= b

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

    Оператор if записывается с использованием ключевого слова if.

    Пример

    Оператор If:

    a = 33
    b = 200
    , если b > a:
      print("b больше, чем a")

    Попробуйте сами »

    В этом примере мы используем две переменные, a и b, которые используются как часть оператора if для проверки того, больше ли b, чем а. Поскольку a равно 33, а b равно 200, мы знаем, что 200 больше, чем 33, поэтому мы выводим на экран, что «b больше, чем a».

    Отступ

    Python использует отступы (пробелы в начале строки) для определения области действия в коде. Другие языки программирования часто используют для этой цели фигурные скобки.

    Пример

    Оператор If без отступа (вызовет ошибку):

    a = 33
    b = 200
    , если b > a:
    print("b больше, чем a") # вы получите сообщение об ошибке

    Попробуйте сами »



    Elif

    Ключевое слово elif — это способ pythons сказать «если предыдущие условия неверны, то попробуйте это условие".

    Пример

    a = 33
    b = 33
    если b > a:
    print("b больше, чем a")
    элиф а == б:
    print("a и b равны")

    Попробуйте сами »

    В этом примере a равно b, поэтому первое условие неверно, но условие elif верно, поэтому мы выводим на экран, что " а и b равны».


    Else

    Ключевое слово else перехватывает все, что не перехвачено предыдущими условиями.

    Пример

    a = 200
    b = 33
    если b > a:
    print("b больше, чем a")
    elif a == b:
    print("a и b равны")
    еще:
    print("a больше b")

    Попробуйте сами »

    В этом примере a больше b, поэтому первое условие неверно, также условие элифа неверно, поэтому мы переходим к условию else и выводим на экран, что «a больше, чем b».

    Вы также можете иметь иначе без elif :

    Пример

    a = 200
    b = 33
    , если b > a:
    print("b больше, чем a")
    еще:
    print("b не больше, чем a")

    Попробуйте сами »


    Short Hand If

    Если вам нужно выполнить только один оператор, вы можете поместить его в ту же строку, что и оператор if.

    Пример

    Однострочный оператор if:

    if a > b: print("a больше b")

    Попробуйте сами »


    Short Hand If .

    .. Else

    Если у вас есть только один оператор для выполнения, один для if и один для else, вы можете поместить его все в одной строке:

    Пример

    Одна строка оператора if else:

    a = 2
    b = 330
    print("A") if a > b else print("B")

    Попробуйте сами »

    Этот метод известен как Тернарные операторы или Условные Выражения .

    Вы также можете иметь несколько операторов else в одной строке:

    Пример

    Одна строка оператора if else с 3 условиями:

    a = 330
    b = 330
    print("A") if a > b else print("=") if a == b else print("B")

    Попробуйте сами »


    And

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

    Пример

    Проверка, если a больше, чем б , И если с больше a :

    a = 200
    b = 33
    c = 500
    если a > b и c > a:
    print("Оба условия верны")

    Попробуйте сами »


    Или

    9Ключевое слово 0009 или является логическим оператором, а используется для объединения условных операторов:

    Пример

    Проверка, если a больше, чем b ИЛИ если a больше c :

    a = 200
    b = 33
    c = 500
    если a > b или a > c:
    print("По крайней мере одно из условий истинно")

    Попробуйте сами »


    Вложенный If

    Вы можете иметь if операторов внутри если утверждений, это называется вложенным , если утверждений.

    Пример

    х = 41

    , если х > 10:
    print("Более десяти")
      если x > 20:
        print("и также больше 20!")
      else:
        print("но не выше 20")

    Попробуйте сами »


    Оператор pass

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

    Пример

    a = 33
    b = 200

    если b > a:
      пройти

    Попробуйте сами »


    Проверьте себя с помощью упражнений

    Упражнение:

    Выведите «Hello World», если a больше, чем b .

    а = 50
    б = 10
     а б
      печать("Привет, мир")
     

    Начать упражнение


    ❮ Предыдущий Далее ❯


    Условия: если, то, иначе - Learn Python 3


    • Теория
    • шагов
    • Проблемы

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

    Рассмотрим следующую задачу: по заданному целому X определить его абсолютное значение. Если X>0, то программа должна вывести значение X, в противном случае он должен напечатать -X. Это поведение не может быть достигнуто с помощью последовательного программа. Программа должна условно выбрать следующий шаг. Вот где условия помогают:

     х = целое (ввод ())
    если х > 0:
        печать (х)
    еще:
        печать (-х)
     

    Эта программа использует условный оператор if . После если мы ставим условие (x > 0) после двоеточия. После этого ставим блок инструкций, который будет выполняться только при выполнении условия истинно (т. е. оценивается как True ). За этим блоком может следовать слово иначе , двоеточие и еще один блок инструкций, который будет выполняться, только если условие ложно (т.е. оценивается в Ложь ). В приведенном выше случае условие ложно, поэтому блок else выполняется. Каждый блок должен иметь отступ с использованием пробелов.

    Подводя итог, условный оператор в Python имеет следующий синтаксис:

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

    еще 9Ключевое слово 0010 с блоком false может быть опущено, если ничего не нужно делается, если условие ложно. Например, мы можем заменить переменную x с его абсолютным значением следующим образом:

     x = int(input())
    если х < 0:
        х = -х
    печать (х)
     

    В этом примере переменной x присваивается значение -x , только если x < 0 . Напротив, инструкция print(x) выполняется каждый раз, потому что она не имеет отступа, поэтому он не принадлежит к «истинному» блоку.

    Отступ — это общий способ разделения блоков кода в Python. Все инструкции в одном блок должен иметь одинаковый отступ, т.е. в них должно быть одинаковое количество пробелов в начале строки. Для отступа рекомендуется использовать 4 пробела.

    Отступ — это то, что отличает Python от большинства других языков, в которых фигурные скобки { и } используются для формирования блоков.

    Кстати, в Python есть встроенная функция для абсолютного значения:

     х = целое (ввод ())
    печать (абс (х))
     

    Реклама Google, может основываться на ваших интересах

    Любая инструкция Python может быть помещена в блоки «true» и «false», включая другой условный блок утверждение. Таким образом, мы получаем вложенные условия. Блоки внутренних условий имеют отступ используя в два раза больше пробелов (например, 8 пробелов). Давайте посмотрим пример. Учитывая координаты точки на плоскости выведите его квадрант.

     х = целое (ввод ())
    у = интервал (ввод ())
    если х > 0:
        если у > 0:
            # x больше 0, y больше 0
            print("Квадрант I")
        еще:
            # x больше 0, y меньше или равно 0
            print("Квадрант IV")
    еще:
        если у > 0:
            # x меньше или равно 0, y больше 0
            print("Квадрант 2")
        еще:
            # x меньше или равно 0, y меньше или равно 0
            печать("Квадрант III")
     

    В этом примере мы используем комментарии: пояснительный текст, который не влияет на выполнение программы. Этот текст начинается с хеша # и длится до конца строки.

    Реклама Google, может основываться на ваших интересах

    Обычно условие после , если имеет один или несколько из следующих операторов:

    <
    меньше — условие верно, если левая сторона меньше правой.
    >
    больше — условие выполняется, если левая сторона больше правой.
    <=
    меньше или равно.
    >=
    больше или равно.
    ==
    равно.
    !=
    не равно.

    Например, условие x * x < 1000 означает «значение выражения x * x меньше 1000», а условие 2 * x != y означает «удвоенное значение переменной x не равно значению переменной y ”.

    Операторы сравнения в Python могут быть сгруппированы следующим образом: a == b == c или x <= y >= 10 . Это редкость среди языков программирования.

    Реклама Google, может основываться на ваших интересах

    Когда мы суммируем два целочисленных объекта, используя 9Оператор 0009 + , как 2 + 5 , получаем новый объект: 7 . Точно так же, когда мы сравниваем два целых числа, используя оператор < , например 2 < 5 , мы получаем новый объект: True .

     печать (2 < 5)
    печать (2 > 5)
     

    Объекты True и False имеют специальный тип, называемый bool . Поскольку любое имя типа можно использовать для приведения объектов к этому типу, давайте посмотрим, что дает это приведение. для чисел:

     print(bool(-10)) # Истинно
    print(bool(0)) # False - ноль - единственное ложное число
    print(bool(10)) # Истинно
    print(bool('')) # False - пустая строка является единственной ложной строкой
    print(bool('abc')) # Верно
     

    Иногда нужно проверить сразу несколько условий. Например, вы можете проверить, делится ли число n на 2, используя условие н % 2 == 0 ( n дает остаток 0 при делении на 2 ). Если вам нужно проверить, что два числа n и m оба делятся на 2, вы должны проверить оба n % 2 == 0 и м % 2 == 0 . Для этого вы присоединяетесь к ним с помощью оператора и . (логическое И): n % 2 == 0 и m % 2 == 0 .

    Python имеет логическое И, логическое ИЛИ и отрицание.

    Оператор и — это бинарный оператор, результатом которого является True тогда и только тогда, когда его левая и правая части равны True .

    Оператор или — это бинарный оператор, результатом которого является True если хотя бы одна из его сторон равна True .

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

    Проверим, что хотя бы одно из двух чисел заканчивается на 0:

     a = int(input())
    б = интервал (ввод ())
    если a % 10 == 0 или b % 10 == 0:
        распечатать('ДА')
    еще:
        распечатать('НЕТ')
     

    Проверим, что число a положительно и число b неотрицательно:

    , если a > 0 и не (b < 0):
     

    Вместо не (b < 0) мы можем написать (b >= 0) .

    Реклама Google, может основываться на ваших интересах

    Если у вас есть более двух вариантов, чтобы различить их с помощью условного оператора, вы можете использовать if... elif... else утверждение.

    Давайте покажем, как это работает, переписав пример с точкой (x,y) на плоскости и квадрантами сверху:

     x = int(input())
    у = интервал (ввод ())
    если х > 0 и у > 0:
        print("Квадрант I")
    элиф х > 0 и у < 0:
        print("Квадрант IV")
    Эли у > 0:
        print("Квадрант 2")
    еще:
        печать("Квадрант III")
     

    В этом случае условия в if и elif проверяются друг за другом до тех пор, пока найдено первое истинное условие. Затем выполняется только истинный блок для этого условия. Если все условия ложны, выполняется блок else, если он присутствует.

    Реклама Google, может основываться на ваших интересах

    Понимание инструкции Python If-Else [обновлено]

    Принятие решений является важным понятием в любом языке программирования и требуется, когда вы хотите выполнить код при определенном условии удовлетворен. В этом блоге вы узнаете о знаменитом операторе if-else в Python. Мы будем использовать Jupyter Notebook для демонстрации кода.

    Существует несколько форм операторов if-else. Давайте рассмотрим их один за другим.

    Используется ключевое слово if , за которым следует условие.

    Синтаксис:

    если условие:

    #оператор для выполнения, если условие истинно

    Ниже приведен весь рабочий процесс работы операторов if:

    Сначала проверяется тестовое выражение. Если выражение истинно, выполняется тело оператора if. Если оно ложно, оператор, присутствующий после оператора if, выполняется. В любом случае любая строка кода, присутствующая снаружи, если оператор оценивается по умолчанию.

    Чтобы лучше понять это, мы будем использовать пример:

    а=20

    если а>50:

        print("Это тело if")

    print("Это вне блока if")

    Поскольку 20 не больше 50, оператор внутри блока if не будет выполняться. Вместо этого выполняется оператор, находящийся вне блока if.

    В приведенном ниже коде будут выполнены оба оператора печати, поскольку a больше 50.

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

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

    Синтаксис:

    если(условие):

    #Выполняет этот блок, если условие истинно

    иначе:

    #Выполняет этот блок, если условие ложно

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

    Ниже приведен весь рабочий процесс, показывающий, как работает оператор if-else.

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

    Ниже приведен пример, который лучше иллюстрирует, как работает if-else:

    Поскольку значение «i» делится на два, выполняется оператор if.

    Поскольку значение «i» не делится на два, выполняется оператор else.

    Давайте теперь посмотрим, что такое вложенный оператор IF и как он работает.

    Если оператор if присутствует внутри другого оператора if, он называется вложенным оператором IF. Такая ситуация возникает, когда вам нужно фильтровать переменную несколько раз.

    Синтаксис:

    если (условие1):

        #Выполняется, если условие1 истинно

        если (условие2):

            #Выполняется, если условие2 истинно

        #Условие2 заканчивается здесь

    #Condition1 заканчивается здесь

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

    Приведенный ниже рабочий процесс демонстрирует, как работают вложенные операторы IF:

    Ниже приведен еще один пример, показывающий, как работает вложенный ЕСЛИ: У нас есть число, и мы собираемся проверить, больше оно или меньше 25. Если число меньше 25, мы проверим, является ли оно нечетное число или четное число. Если число больше 25, мы напечатаем, что число больше 25.

    До сих пор с IF и if-else мы видели только бинарный подход. Предположим, у нас есть проблема, которая имеет несколько условий. В этом сценарии 9На помощь приходит оператор 0110 if-elif-else .

    Проверяет условие оператора if. Если это ложно, оператор elif оценивается. Если условие elif ложно, оценивается оператор else.

    Синтаксис:

    если (условие):

        выписка

    элиф (состояние):

        выписка

    .

    .

    иначе:

        Выписка

    Ниже приведена блок-схема, показывающая, как работает лестница if-elif-else. Проверяется тестовое выражение1. Если это подтверждается, тело if оценивается. Если оно ложно, то управление переходит к продолжающемуся Test Expression2. Если это правда, выполняется тело elif1. Если оно ложно, проверяется тестовое выражение3. Если это правда, выполняется тело elif2. Если оно ложно, вычисляется тело else. Затем проверяется любой оператор ниже в if-elif.

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

    Теперь, когда мы рассмотрели основы if, else, elif и вложенных IF, давайте сделаем несколько упражнений.

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

     

    В приведенном выше коде мы сначала проверяем, выше ли «a», чем «b» и «c». Затем мы печатаем «a» как наибольшее число.

    В случае, если оно ложно, мы затем проверяем, больше ли «b», чем «a» и «c». Если это так, мы печатаем 'b' как наибольшее число. В противном случае 'c' является наибольшим числом.

    Добавить комментарий

    Ваш адрес email не будет опубликован.