Цикл if python: if-elif-else. Оператор match в Python

if-elif-else. Оператор match в Python

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

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

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

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

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

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

Однако следующий if

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

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

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

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

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

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

Таким образом до последней проверки (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 пропускаются.

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

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

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

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

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

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

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

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

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

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

При этом в ветках case уже не надо писать sign == '+' или sign == '-', как это пришлось бы делать в программе с if-elif:

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

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

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

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

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

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

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

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

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

   ValueError, возникающее, когда вводится не целое число.

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

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

Язык программирования «Python». Условный оператор if

Оператор if

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

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

В простейшем варианте использование оператора if выглядит так:

if условие:
    блок команд 1
блок команд 2

После оператора if обязательно записывается условие. После условия необходимо поставить знак двоеточия “:”. Если данное условие будет истинно, то выполняется блок команд 1. Вне зависимости от условия блок команд 2 будет выполняться в любом случае.

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

if a==777:
    print("Этот принт сработает, если а будет равно 777.")
    print("И так же этот принт.")
    print("И этот.")

print("А это сообщение выведется в любом случае")

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

Еще пример

money = 100
ticket = 90
if money > ticket:
    print("УРАААА!!!")
    print("Я иду в кино!")
print("Пора идти домой")

Что касается отступов. Внутри блока инструкции должны находиться на одинаковом уровне отступов. В противном случае будет ошибка.

if 5>1:
  print("Тут оступ в 2 пробела.")
    print("А здесь в четыре.  Будет ошибка.")

Пример программы:

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

a=int(input())
b=int(input())
if b>a:
    a,b = b,a
print(a,b)

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

В состав оператора if может входить необязательный оператор else. Схема использования выглядит следующим образом:

if условие:
    блок команд 1
else:
    блок команд 2
блок команд 3

Инструкции, входящие в блок команд 1, будут выполняться только в случае, если условие будет истинно. В противном случае будет выполняться блок команд 2. А блок команд 3 выполнится после этого в любом случае.

Пример программы на if-else

Вводится одно число и необходимо вывести сообщение «Четное», если число делится на 2 без остатка, или «Нечетное» — в противном случае

a = int(input())
if a%2==0:
    print('Четное')
else:
    print('Нечетное')

Еще пример программы на if-else

Вводится два числа и необходимо вывести самое большое значение среди них.

a = int(input())
b = int(input())
if a>b:
    print(a)
else:
    print(b)

Вопросы для проверки пройденного:

1. 1 Исправьте следующий код:

   score = int(input("Ваш балл за экзамен")
   if score > 80:
       print("Хороший результат.")

2. 2 В этом коде две ошибки. Найдите и исправьте их:

   x == 7
   if x % 2 !=0:
       print("x - нечетное число.")
   else
       print("x - четное число.")

   3 В этом коде четыре ошибки. Скопируйте код в IDLE и найдите ошибки.

   day = input("Как называется 5й день недели?")
   if day = "Friday" or d=="friday":
       print("Верно!")
       else
       print("Неверно!")

   4 Подумайте почему эта программа неправильно работает.

   x=input("Как настроение?")
   if x=="Хорошо" or "Прекрасно":
       print("Приятно слышать!")

Python If Else — GeeksforGeeks

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

Типы потока управления в Python

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

1. Оператор if
2. Оператор if-else
3. Оператор вложенного if
4. Лестница if-elif-else

Оператор if

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

Синтаксис : 

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

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

Как мы знаем, Python использует отступ для идентификации блока. Таким образом, блок под оператором if будет идентифицирован, как показано в следующем примере:  

, если условие:
   заявление1
заявление2

# Здесь, если условие истинно, если блок
# будет считать, что внутри находится только оператор 1
# его блок. 

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

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

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

Поскольку условие, присутствующее в операторе if, ложно. Итак, блок под оператором if выполняется.

Python3

i = 10 90 003     если (i > 15 ):      печать ( "10 меньше 15" ) print ( "Я не в "если" )

Вывод:  

 Я не нахожусь в if 

оператор if-else

Оператор if сам по себе говорит нам, что если условие истинно, он выполнит блок операторов, а если условие ложно, он выиграет ‘т. Но если мы хотим сделать что-то еще, если условие ложно, мы можем использовать 9Оператор 0029 else с оператором if для выполнения блока кода, когда условие if ложно.

Синтаксис : 

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

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

Блок-схема оператора Python is-else

Пример оператора Python if-else

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

Python3

i = 20 900 03 если (i < 15 ):      напечатать ( 90 055 "i меньше 15" )      print ( "я в блоке if" ) 900 03 еще :      печать ( "i больше 15" )      печать 90 056 ( "я в другом блоке" ) печать ( "Я не в блоке if и not in else" )

Вывод:  

 i больше 15
я в другом блоке
я не в if и не в else Блок 

Пример оператора Python if else в понимании списка 

dsum = 0

     для ele in str (n):

         dsum + = целое число (эл. )

9Список 90 056 = [ 367 , 111 , 562 , 900 55 945 , 6726 , 873 ]

   

newList = [digitSum(i) для i в Список если i и 1 ]

   

печать (newList)

Вывод

 [16, 3, 18, 18] 

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

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

Синтаксис : 

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

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

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

Пример вложенного оператора if Python

Python3

i = 10 если (i = = 10 ):                 если (i < 15 ):          печать ( "i меньше 15" )                                 если (i < 12 ): 9 0055          печать ( "я тоже меньше 12" )      else :          print ( "i больше 15" )

Вывод:  

 i меньше 15
я тоже меньше 12 

лестница if-elif-else

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

Синтаксис : 

 если (условие):
    заявление
Элиф (состояние):
    заявление
.
.
еще:
    заявление 

Блок-схема лестницы if-elif-else Python

Блок-схема лестницы if-elif-else

Пример лестницы Python if-elif-else

Python3

9005 0    

i = 20

если (i = = 10 ):

     напечатать ( "i is 10" )

elif (i = = 15 ):

     печать ( "мне 15" )

elif (i = = 20 ):

     печать 9005 5 ( "мне 20" )

еще :

     печать ( "я нет" )

Вывод:  

 i is 20 

Сокращенное выражение if

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

Синтаксис:  

 если условие: инструкция 

Пример Python, если сокращенно

Python3

i = 10 9 0054 если i < 15 : напечатать ( "i меньше 15 дюймов )

Вывод:

 i меньше 15 

Сокращенное выражение if-else

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

Синтаксис:

 statement_when_True if condition else statement_when_False 

Пример Python if else сокращение  

Python3

9005 1

i = 10 печать ( Верно ) если i < 15 иначе печатать ( Ложь 9005 5 )

Вывод:  

 True 

Объединение циклов For и операторов if (учебник по Data Science)

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

Примечание. Это практическое руководство. Настоятельно рекомендую заняться программированием вместе со мной — и, если у вас есть время, решить упражнения в конце статьи! Если вы еще этого не сделали, сначала прочитайте эти статьи:

• Как установить Python, R, SQL и bash для практики обработки данных!
• Python для обработки данных №1 — Учебное пособие для начинающих — Основы Python
• Python для обработки данных №2 — Структуры данных
• Python для обработки данных №3 — Функции и методы
• Питон для Наука о данных № 4 — операторы If
• Python для науки о данных № 5 — циклы For

Примечание 2. На мобильных устройствах разрывы строк в фрагментах кода могут показаться сложными. Но если вы скопируете и вставите их в блокнот Jupyter, вы увидите, что фактические разрывы строк будут намного четче!

Цикл for внутри цикла for — также известный как вложенный цикл for

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

Допустим, у вас есть девять названий телешоу, разделенных на три категории: комедии, мультфильмы, драмы. Они представлены во вложенном списке Python («списки в списке»):

 my_movies = [['Как я встретил вашу маму', 'Друзья', 'Кремниевая долина'],
    [«Гриффины», «Южный парк», «Рик и Морти»],
    [«Во все тяжкие», «Игра престолов», «Прослушка»]]
 

Вы хотите подсчитать количество символов во всех этих заголовках и вывести результаты один за другим на экран в следующем формате:

"Название [movie_title] состоит из [X] символов. "

Как бы вы это сделали? Поскольку у вас есть три списка в вашем основном списке, чтобы получить названия фильмов, вам нужно выполнить итерацию по списку my_movies — и внутри этого списка также по каждому подсписку:

 для подсписка в my_movies:
    для movie_name в подсписке:
        char_num = длина (имя_фильма)
        print("Заголовок " + movie_name + " имеет длину " + str(char_num) + " символов.")
 

Примечание: запомнить len()  – это функция Python, возвращающая целое число. Чтобы поместить это целое число в «печатное» предложение, мы должны сначала превратить его в строку. Я писал об этом в предыдущем руководстве по Python For Loops.

Я знаю, циклы for в Python могут быть трудны для понимания в первый раз… Вложенные циклы for еще сложнее. Если у вас есть проблемы с пониманием того, что именно происходит выше, возьмите ручку и бумагу и попробуйте смоделировать весь сценарий, как если бы вы были компьютером — шаг за шагом выполните свой цикл и запишите результаты.

Еще одно:
Синтаксис! Правила те же, что вы узнали, когда мы обсуждали простые циклы for — единственное, что я хотел бы подчеркнуть и на что вам обязательно следует обратить внимание, — это отступов . Использование правильных отступов — единственный способ сообщить Python, в каком цикле for (внутреннем или внешнем) вы хотели бы применить свой блок кода. Просто проверьте и попытайтесь найти различия между этими тремя примерами:

Пример 1Пример 2Пример 3

Оператор if внутри цикла for

Внутри цикла for вы также можете использовать операторы if.

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

Задача:
Перебрать все числа до 99. Выведите «fizz» для каждого числа, которое делится на 3, выведите «buzz» для каждого числа, кратного 5, и выведите «fizzbuzz» для каждого числа, которое делится на 3. 3 и на 5! Если число не делится ни на 3, ни на 5, выведите прочерк ('-')!

Вот решение!

 для i в диапазоне (100):
    если я % 3 == 0 и я % 5 == 0:
        печать('шипение')
    Элиф я% 3 == 0:
        печать ('шипение')
    Элиф я% 5 == 0:
        распечатать('жужжание')
    еще:
        Распечатать('-')
 

Как видите, оператор if в цикле for идеально подходит для оценки списка чисел в диапазоне (или элементов в списке) и помещения их в разные корзины, маркировки их или применения к ним функций — или просто просто распечатайте их.

Еще раз: когда вы используете оператор if в цикле for, будьте предельно осторожны с отступы , потому что, если вы их перепутаете, вы можете получить ошибки или поддельные результаты!

Break

В Python есть специальный инструмент управления потоком , который довольно часто оказывается полезным при использовании операторов if в циклах for. А это оператор break .

Сможете ли вы найти первое семизначное число, которое делится на 137? (Первый и только первый.)

Вот одно решение:

 для i в диапазоне (0, 10000000, 137):
    если len(str(i)) == 7:
        печать (я)
        перерыв
 

Этот цикл принимает каждое 137-е число ( для i в диапазоне (0, 10000000, 137) ) и проверяет во время каждой итерации, имеет ли число 7 цифр или нет ( если len(str(i) ) == 7). Как только он доберется до первого 7-значного числа, оператор if будет иметь вид True , и произойдут две вещи:

1. print(i) —» Число будет напечатано на экране.
2. break выходит из цикла for, поэтому мы можем убедиться, что первое 7-значное число было также последним 7-значным числом, напечатанным на экране.

Узнайте больше об операторе break (и его брате-близнеце: операторе continue ) в оригинальной документации Python3: здесь.

Примечание: вы можете решить эту задачу более элегантно с помощью цикла while. Однако я еще не написал учебник по циклу while, поэтому я выбрал решение цикла for + break !

Проверь себя!

Пришло время проверить, удалось ли вам освоить оператор if, циклы for и их комбинацию! Давайте попробуем решить это небольшое тестовое задание!

Создайте скрипт Python, который определяет ваш возраст максимум за 8 попыток! Скрипт может задать вам только один тип вопроса: угадать ваш возраст! (например, «Вам 67 лет?») И вы можете ответить только на один из этих трех вариантов:

• меньше
• больше
• правильно
9 0840

На основании вашего ответа компьютер может придумайте еще одну догадку, пока она не узнает ваш точный возраст.

Примечание: для решения этой задачи вам также придется выучить новую функцию. Это функция input() ! Подробнее: здесь.

Готов? 3. 2. 1. Вперёд!

Решение

Вот мой код.

Примечание 1: Задачу можно решить и с помощью цикла while. Еще раз: поскольку я еще не писал о циклах while, я покажу вам решение цикла for.
Примечание 2: Если у вас есть альтернативное решение, поделитесь им со мной по электронной почте!

 вниз = 0
вверх = 100
для я в диапазоне (1,10):
    угаданный_возраст = int((вверх + вниз) / 2)
    answer = input('Вам ' + str(guessed_age) + "лет?")
    если ответ == 'правильно':
        печатать("Красиво")
        перерыв
    Элиф ответ == 'меньше':
        вверх = предполагаемый_возраст
    Элиф ответ == 'больше':
        вниз = предполагаемый_возраст
    еще:
        распечатать('неправильный ответ')
 

Моя логика такова:
ШАГ 1) Я устанавливаю диапазон от 0 до 100 и предполагаю, что возраст «игрока» будет между этими двумя значениями.
down = 0
up = 100

ШАГ 2) Скрипт всегда запрашивает среднее значение этого диапазона (для первой попытки это 50 ):

agged_age = int((up + down ) / 2)
answer = input('Вам ' + str(guessed_age) + "лет?")
 

ШАГ 3) Как только мы получим ответ «игрока», есть четыре возможных сценария:

• Если угаданный возраст правильный, то скрипт завершает работу и возвращает какой-то ответ.

  , если ответ == 'правильный':
      печатать("Красиво")
      перерыв
   

• Если ответ «меньше», то начинаем итерацию сначала — но перед этим устанавливаем максимальное значение возрастного диапазона в угаданном возрасте. (Поэтому во второй итерации скрипт будет угадывать среднее значение от 0 до 50.)

   elif ответ == 'меньше':
      вверх = предполагаемый_возраст
   

• Делаем то же самое для ответа «больше», только в этом случае меняем минимальное (а не максимальное) значение:

   elif ответ == 'больше':
      вниз = предполагаемый_возраст
   

• И в конце концов мы обрабатываем неправильные ответы и опечатки:

   еще:
      печать('неправильный ответ') 

Вы нашли лучшее решение?
Поделись со мной — напиши письмо, и я проверю его для тебя!

Заключение

Теперь у вас есть представление о:

• Python вложенных циклах for и
• for циклах и операторах if вместе.

Они не обязательно считаются основами Python; это больше похоже на переход на средний уровень.