Условия (ветвления if-elif-else) и тернарные операторы

Содержание

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

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

Вот тут-то и появляются операторы управления. Операторы управления занимаются порядком выполнения выражений в программе (называемой потоком управления программы).

Вот что вы узнаете из этого урока: вы столкнетесь со своим первым оператором управления Python, оператором .

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

В программе на Python оператор — это способ принятия такого рода решений. Он допускает условное выполнение оператора или группы операторов на основе значения выражения.

В общих чертах этот урок выглядит следующим образом:

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

Готовы? Поехали!

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

Синтаксис конструкции

if выражение_1:    Тело ifelif выражение_2:    Тело elifelse:     Тело else

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

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

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

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

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

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

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

Что делают другие языки?

Возможно, Вам интересно, какие существуют альтернативы. Как определяются блоки в языках, которые не придерживаются правила off-side?

Тактика, используемая большинством языков программирования, заключается в назначении специальных маркеров, которые отмечают начало и конец блока. Например, в блоки определяются с помощью пар фигурных скобок ({}) следующим образом:


if (<expr>) {
    <statement>;
    <statement>;
    ...
    <statement>;
}
<following_statement>;

C/C++, Java и целый ряд других языков используют фигурные скобки таким образом.

Другие языки, такие как Algol и Pascal, используют ключевые слова begin и end для включения блоков.

Что делают другие языки?

Возможно, Вам интересно, какие существуют альтернативы. Как определяются блоки в языках, которые не придерживаются правила off‑side?


if (<expr>) {
    <statement>;
    <statement>;
    ...
    <statement>;
}
<following_statement>;

C/C++, Java и целый ряд других языков используют фигурные скобки таким образом.

Другие языки, такие как Algol и Pascal, используют ключевые слова begin и end для включения блоков.

Как работает if else

Синтаксис

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

Синтаксически конструкция выглядит следующим образом:

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

Принцип работы оператора выбора в Python

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

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

Отступы

Отступы – важная и показательная часть языка Python. Их смысл интуитивно понятен, а определить их можно, как размер или ширину пустого пространства слева от начала программного кода.

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

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

Примеры

Рассмотрим несколько практических примеров использования условного оператора.

Пример №1: создание ежедневного бэкапа (например базы данных):

Пример №2: Проверка доступа пользователя к системе. В данном примере проверяет наличие элемента в списке:

Пример №3: Валидация входных данных. В примере к нам приходят данные в формате . Нам необходимо выбрать все записи определенного формата:

Как работает оператор if else в Python?

Оператор запускает код только при выполнении условия. Иначе ничего не происходит.

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

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

if условие:
    выполнить, если условие истинно
else: 
    выполнить, если условие ложно

По сути оператор в Python говорит:

«Когда выражение после оценивается как истинное (), нужно выполнить следующий за ним код. Но если оно оценивается как ложное (), нужно выполнить код, следующий за оператором ».

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

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

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

a = 1
b = 2

if a < b:
    print(" b is in fact bigger than a")
else:
    print("a is in fact bigger than b")

Здесь строка кода, следующая за оператором , никогда не будет запущена. Условие в блоке имеет значение , поэтому выполняется только эта часть кода.

Блок запускается в следующем случае:

a = 1
b = 2

if a > b:
    print(" a is in fact bigger than b")
else:
    print("b is in fact bigger than a")
# Output: b is in fact bigger than a

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

if 1 > 2:
   print("1 is bigger than 2")
print("hello world")
else:
   print("1 is less than 2")
# Output:
# File "<stdin>", line 3
# print("hello world")
# ^
# SyntaxError: invalid syntax

От редакции Pythonist. Также рекомендуем почитать «Блок else в циклах».

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

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

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

# More

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

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

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

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

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

if x

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Команда elif в Python:

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

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

Например:

# Производится последовательное сравнение переменной num.
# Если num больше ста выполняется код в строке 4 и выполнение переходит на строку 13, иначе выполняется проверка в строке 6
if num > 100:
    print "Число больше ста"
# Если num больше пятидесяти - выполняется код в строке 7 и выполнение переходит на строку 13, иначе выполняется проверка в строке 8 и т.д.
elif num > 50:
    print "Число больше пятидесяти"
elif num > 25:
    print "Число больше двадцати пяти"
# Если результат всех проверок оказался ложным выполняется блок в строке 11, после чего переходим на строку 13 
else:
    print "Число меньше двадцати пяти"
print "Финальная строка"

Базовый Python не поддерживает конструкцию switch/case, как, например, JavaScript, но ее возможно реализовать при помощи if…elif…else конструкции.

Тестовые операторы

В Bash команда принимает одну из следующих синтаксических форм:

Чтобы сделать скрипт переносимым, предпочтите использовать старую команду test, которая доступна во всех оболочках POSIX. Новая обновленная версия команды (двойные скобки) поддерживается в большинстве современных систем, использующих Bash, Zsh и Ksh в качестве оболочки по умолчанию.

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

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

— Истина, если длина больше нуля.
— Правда, если пусто.
— Правда, если и равны.
— Правда если и не равны.
— Правда, если и равны.
— Верно, если больше чем .
— Правда, если меньше, чем .
— Истинно, если равно или больше, чем INTEGER2.
— Верно, если равно или меньше чем .
— Истина, если существует и является символической ссылкой.
— Истинно, если существует и доступно для чтения.
— Истина, если существует и доступна для записи.
— True, если существует и является исполняемым.
— True, если существует и является каталогом.
— Истинно, если существует и является файлом, независимо от типа (узел, каталог, сокет и т. Д.).
— True, если существует и является обычным файлом (не каталогом или устройством).

Оператор if elif else

Ключевое слово является сокращением от .

Оператор Python принимает следующую форму:

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

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

Условия оцениваются последовательно. Как только условие возвращает , остальные условия не выполняются, и управление программой перемещается в конец операторов .

Добавим в предыдущий скрипт предложение :

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

Одиночные проверки

Внутри условия
можно прописывать и такие одиночные выражения:

x = 4; y = True; z = False
if(x): print("x = ", x, " дает true")
if(not ): print("0 дает false")
if("0"): print("строка 0 дает true")
if(not ""): print("пустая строка дает false")
if(y): print("y = true дает true")
if(not z): print("z = false дает false")

Вот этот оператор
not – это отрицание
– НЕ, то есть, чтобы проверить, что 0 – это false мы
преобразовываем его в противоположное состояние с помощью оператора отрицания
НЕ в true и условие
срабатывает. Аналогично и с переменной z, которая равна false.

Из этих примеров
можно сделать такие выводы:

Любое число,
отличное от нуля, дает True. Число 0 преобразуется в False.
Пустая строка –
это False, любая другая
строка с символами – это True.
С помощью
оператора not можно менять
условие на противоположное (в частности, False превращать в True).

Итак, в условиях
мы можем использовать три оператора: and, or и not. Самый высокий
приоритет у операции not, следующий приоритет имеет операция and и самый
маленький приоритет у операции or. Вот так работает оператор if в Python.

Видео по теме

#1. Первое знакомство с Python Установка на компьютер

#2. Варианты исполнения команд. Переходим в PyCharm

#3. Переменные, оператор присваивания, функции type и id

#4. Числовые типы, арифметические операции

#5. Математические функции и работа с модулем math

#6. Функции print() и input(). Преобразование строк в числа int() и float()

#7. Логический тип bool. Операторы сравнения и операторы and, or, not

#8. Введение в строки. Базовые операции над строками

#9. Знакомство с индексами и срезами строк

#10. Основные методы строк

#11. Спецсимволы, экранирование символов, row-строки

#12. Форматирование строк: метод format и F-строки

#13. Списки — операторы и функции работы с ними

#14. Срезы списков и сравнение списков

#15. Основные методы списков

#16. Вложенные списки, многомерные списки

#17. Условный оператор if. Конструкция if-else

#18. Вложенные условия и множественный выбор. Конструкция if-elif-else

#19. Тернарный условный оператор. Вложенное тернарное условие

#20. Оператор цикла while

#21. Операторы циклов break, continue и else

#22. Оператор цикла for. Функция range()

#23. Примеры работы оператора цикла for. Функция enumerate()

#24. Итератор и итерируемые объекты. Функции iter() и next()

#25. Вложенные циклы. Примеры задач с вложенными циклами

#26. Треугольник Паскаля как пример работы вложенных циклов

#27. Генераторы списков (List comprehensions)

#28. Вложенные генераторы списков

#29. Введение в словари (dict). Базовые операции над словарями

#30. Методы словаря, перебор элементов словаря в цикле

#31. Кортежи (tuple) и их методы

#32. Множества (set) и их методы

#33. Операции над множествами, сравнение множеств

#34. Генераторы множеств и генераторы словарей

#35. Функции: первое знакомство, определение def и их вызов

#36. Оператор return в функциях. Функциональное программирование

#37. Алгоритм Евклида для нахождения НОД

#38. Именованные аргументы. Фактические и формальные параметры

#39. Функции с произвольным числом параметров *args и **kwargs

#40. Операторы * и ** для упаковки и распаковки коллекций

#41. Рекурсивные функции

#42. Анонимные (lambda) функции

#43. Области видимости переменных. Ключевые слова global и nonlocal

#44. Замыкания в Python

#45. Введение в декораторы функций

#46. Декораторы с параметрами. Сохранение свойств декорируемых функций

#47. Импорт стандартных модулей. Команды import и from

#48. Импорт собственных модулей

#49. Установка сторонних модулей (pip install). Пакетная установка

#50. Пакеты (package) в Python. Вложенные пакеты

#51. Функция open. Чтение данных из файла

#52. Исключение FileNotFoundError и менеджер контекста (with) для файлов

#53. Запись данных в файл в текстовом и бинарном режимах

#54. Выражения генераторы

#55. Функция-генератор. Оператор yield

#56. Функция map. Примеры ее использования

#57. Функция filter для отбора значений итерируемых объектов

#58. Функция zip. Примеры использования

#59. Сортировка с помощью метода sort и функции sorted

#60. Аргумент key для сортировки коллекций по ключу

#61. Функции isinstance и type для проверки типов данных

#62. Функции all и any. Примеры их использования

#63. Расширенное представление чисел. Системы счисления

#64. Битовые операции И, ИЛИ, НЕ, XOR. Сдвиговые операторы

#65. Модуль random стандартной библиотеки

Оператор If в одну строку

Принято писать, если и с отступом на следующей строке, как это:

if <expr>:
    <statement>

Но допустимо написать целое утверждение на одной строке. Будет выглядеть так:

if <expr>: <statement>

В одной строке может быть даже несколько , разделенных точкой с запятой:

if <expr>: <statement_1>; <statement_2>; ...; <statement_n>

Но что это значит? Есть два объяснения:

1) Если имеет значение true, выполняется .

Затем выполните команду … безусловно, независимо от того, является ли истинным или нет.

2) Если имеет значение true, выполните все действия … . В противном случае не выполняйте ни одного из них.

Python принимает последнее объяснение. Точка с запятой, разделяющая , имеет более высокий приоритет, чем двоеточие, следующее за — на компьютерном сленге точка с запятой, как говорят, связывается более плотно, чем двоеточие. Таким образом, рассматриваются как набор, либо все они выполняются, либо ни один из них не выполняется:

if 'f' in 'foo': print('1'); print('2'); print('3')


if 'z' in 'foo': print('1'); print('2'); print('3')

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

x = 2
if x == 1: print('foo'); print('bar'); print('baz')
elif x == 2: print('qux'); print('quux')
else: print('corge'); print('grault')


x = 3
if x == 1: print('foo'); print('bar'); print('baz')
elif x == 2: print('qux'); print('quux')
else: print('corge'); print('grault')

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

x = 3
if x == 1:
    print('foo')
    print('bar')
    print('baz')
elif x == 2:
    print('qux')
    print('quux')
else:
    print('corge')
    print('grault')

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

debugging = True  # Установите значение True, чтобы включить отладку.

    .
    .
    .

if debugging: print('About to call function foo()')
foo()

Оператор if

С английского название этого оператора переводится, как «если». То есть он задает условие. После данного оператора записывается само выражение. Если оно оказывается истинным, то программа переходит к выполнению инструкции, заданной в указанном операторе. Выражение считается истинным, когда оно:

не равно нулю;
не является пустым;
является логическим

Для ясности рассмотрим пример использования if — условия в Python 3:

if 3:
    print("Привет 3")

На экране перед пользователем появится запись: Привет 3.

Усложним код:

a = 6
if a == 6:
    print("Привет 2")

На дисплее компьютера отобразится: Привет 2.

Также можно задать условие формулой или условным выражением:

a = 5
if a > 2:
    print("Привет 3")

Переменная равна 5, условие, чтобы она была больше 2. Оно истинное, поэтому перед нами появится: Привет 3.

Еще более сложный вариант с несколькими переменными:

a = 0
b = 34
c = 10
if c < 100:
    a = b + c
print(a)

Поскольку с действительно меньше 100, а станет равным 44, и именно это число появится на дисплее при выполнении данного кода. Если бы с изначально было большее 100, например, 110, то на экране бы отобразился 0, переменная а просто не изменилась бы вообще.

Ключевое слово else и особенности его применения

Else – это также условие. Читается оно так: «если ни одно из предыдущих условий не оказалось истинным, то выполнять следующие действия». Описанная выше идея с тройной проверкой в данном случае может выполняться с использованием выражения if-elif-else, поскольку возможных комбинаций здесь только три. И если две из них оказываются ложными, то тогда писать выражение a больше, чем b.

a = 200

b = 33

if b > a:

    print("b больше, чем a")  

elif a == b:  

    print("a и b равны")  

else:  

    print("a больше, чем b")

В этом примере так и получается. Число a – 200, в то время как b – всего лишь 100. Следовательно, ни одно из двух условий в блоке if-elif не подходит. Поэтому выполняются те инструкции, которые указаны в блоке else.

В нашем случае можно вообще обойтись без elif, поскольку 200 и 33 никак не могут быть равными. Поэтому приведенный выше код можно сократить.

a = 200  

b = 33  

if b > a:  

    print("b больше, чем a")

else:

    print("b меньше, чем a")

Примеры решения задач

Проверить является ли клетка шахматной доски белой

# Два числа выбираются случайным образом (координаты клетки шахматного поля, от 1 до
# Вывести YES, если клетка белая, и NO, если клетка черная
from random import randint

x = randint(1,8)

y = randint(1,8)
print(x, y)
if (x + y) % 2 == 1:

print(‘YES’)
else:

print(‘NO’)

Во втором случаем числа вводятся с клавиатуры

x = int(input(‘Введите координату x: ‘))

y = int(input(‘Введите координату y: ‘))
if (x + y) % 2 == 1:

print(‘YES’)
else:

print(‘NO’)

Проверить может ли слон ходить с первой шахматной на вторую

# Четыре числа выбираются случайным образом (координаты клетки шахматного поля, от 1 до
# Вывести YES, если ладья может сходить с первой клетки на вторую, и NO, если не может
# Напомню, что ладья ходит так:
# Л ——X
# |
# |
# |
# X
from random import randint

x1 = randint(1,

x2 = randint(1,

y1 = randint(1,

y2 = randint(1,
print(x1, y1)
print(x2, y2)
if x1 == x2 and y1 != y2 or x1 != x2 and y1 == y2:

print(‘YES’)
else:

print(‘NO’)

То же самое, но с помощью ввода с клавиатуры

x1 = int(input(‘Введите координату x1: ‘))

x2 = int(input(‘Введите координату y1: ‘))

y1 = int(input(‘Введите координату x2: ‘))

y2 = int(input(‘Введите координату y2: ‘))
if x1 == x2 and y1 != y2 or x1 != x2 and y1 == y2:

print(‘YES’)
else:

print(‘NO’)

Использование оператора else в циклах for/in.

Оператор в циклах выполняется только если цикл закончился и не прервался оператором . Звучит как то бессмысленно. Как можно использовать такое поведение?

Цикл упрощает любой цикл, который использует логический флаг, подобный этому:

# флаг принятия дальнейшего решения
found = False   
for divisor in range(2, n):
    if n % divisor == 
        # если найден делитель, то меняем 
        # флаг на `True` и выходим из цикла
        found = True   
        break

# принимаем решение на основе значения флага
if found
    print(n, 'is composite')
else
    print(n, 'is prime')

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

for divisor in range(2, n):
    if n % divisor == 
        print(n, 'is composite')
        break
else
    # else сработает, если цикл не завершиться
    # по `break`, т.е. преждевременно
    print(n, 'is prime')

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

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

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

if any(n % divisor ==  for divisor in range(2, n)):
    print(n, 'is composite')
else
    print(n, "is prime")

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