Инструкция pass в python

Публикация представляет собой сокращенный перевод статьи Моше Задка The pass Statement: How to Do Nothing in Python.

***

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

Иногда pass можно встретить в финальном коде на продакшене, но чаще инструкцию используют в процессе разработки. Заметим, что в некоторых случаях сделать что-то – лучше, чем ничего, и pass является не лучшим решением.

В этом туториале мы изучим:

• что собой представляет pass и чем полезна эта инструкция;
• как использовать pass в продакшене;
• как применять pass в разработке;
• какие есть альтернативы этой инструкции и когда их следует использовать.

Синтаксис Python предполагает, что в некоторых случаях после двоеточия новые блоки кода идут с отступом. Например, после объявления цикла for или условия if:

        >>> for x in [1, 2, 3]:
...     y = x + 1
...     print(x, y)
...
1 2
2 3
3 4
    

Тело условия или цикла не может быть пустым:

        >>> if 1 + 1 == 3:
...
  File "<stdin>", line 2

    ^
IndentationError: expected an indented block

    

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

        >>> if 1 + 1 == 3:
...     pass
...

    

В первом случае из-за невалидного синтаксиса вызывается исключение, во втором – pass позволяет соблюсти требования Python.

Временное использование pass

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

Будущий код

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

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

        def get_and_save_middle(data, fname):
    middle = data[len(data)//3:2*len(data)//3]
    save_to_file(middle, fname)
    return middle

    

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

Можно закомментировать вызов save_to_file(), но тогда придется держать в уме: это не просто комментарий – соответствующую функцию когда-то придется реализовать. Лучше сделать заготовку сразу же:

        def save_to_file(data, fname):
    pass # TODO: заполнить позже

    

Теперь функцию get_and_save_middle() можно тестировать.

Другой вариант использования pass – когда мы пишем сложную структуру управления потоком и нужен заполнитель для будущего кода. Например, для реализации fizz-buzz полезно сначала набросать структуру кода:

        if idx % 15 == 0:
    pass # Fizz-Buzz
elif idx % 3 == 0:
    pass # Fizz
elif idx % 5 == 0:
    pass # Buzz
else:
    pass # Idx

    

Такие структурные скелеты выстраивают логику и порядок ветвления. В приведенном примере первый оператор if должен проверять делимость на 15, потому что любое число, которое делится на 15, также делится на 5 и 3. Предварительное понимание общей структуры полезно независимо от реализации конкретного вывода.

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

        def fizz_buzz(idx):
    if idx % 15 == 0:
        print("fizz-buzz")
    elif idx % 3 == 0:
        print("fizz")
    elif idx % 5 == 0:
        print("buzz")
    else:
        print(idx)

    

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

        def fizz_buzz(idx):
    if idx % 15 == 0:
        return "fizz-buzz"
    elif idx % 3 == 0:
        return "fizz"
    elif idx % 5 == 0:
        return "buzz"
    else:
        return str(idx)

    

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

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

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

        class Candy:
    pass

    

Такой код даже позволит создавать экземпляры класса.

Закомментированный код

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

        def process(context, input_value):
    if input_value is not None:
        expensive_computation(context, input_value)
    else:
        logging.info("skipping expensive: %s", input_value)

    

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

        def process(context, input_value):
    if input_value is not None:
        # Временно невыполняемые длительные расчеты
        # expensive_computation(context, input_value)
        # Добавляем pass, чтобы сделать код валидным
        pass
    else:
        logging.info("skipping expensive: %s", input_value)

    

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

Маркеры для отладчиков

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

        for line in filep:
    if line == line[::-1]:
        pass  # Устанавливаем здесь breakpoint
    process(line)

    

Хотя инструкция pass ничего не делает, она позволяет установить здесь маркер. Теперь код можно запустить в отладчике и отлавливать строки-палиндромы.

Пустые функции и методы

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

        >>> def ignore_arguments(record, status):
...     pass
...

    

        class DiscardingIO:
    def write(self, data):
        pass

    

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

Пустые классы на примере исключений

Python поддерживает концепцию наследования исключений. Например, встроенное исключение LookupError является родительским для KeyError:

        >>> empty={}
>>> try:
...     empty["some key"]
... except LookupError as exc:
...     print("got exception", repr(exc))
...
got exception KeyError('some key')
>>> issubclass(KeyError, LookupError)
True

    

При поиске несуществующего ключа в словаре возникает исключение KeyError. Исключение KeyError перехватывается, хотя в инструкции except указано LookupError. Так происходит потому, что KeyError является подклассом LookupError.

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

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

1. Не менее 8 символов.
2. По крайней мере один символ – цифра.
3. По крайней мере один специальный символ (?!. и др.).

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

        class InvalidPasswordError(ValueError):
    pass

class ShortPasswordError(InvalidPasswordError):
    pass

class NoNumbersInPasswordError(InvalidPasswordError):
    pass

class NoSpecialInPasswordError(InvalidPasswordError):
    pass

def check_password(password):
    if len(password) < 8:
        raise ShortPasswordError(password)
    for n in "0123456789":
        if n in password:
            break
    else:
        raise NoNumbersInPasswordError(password)
    for s in "?!.":
        if s in password:
            break
    else:
        raise NoSpecialInPasswordError(password)

    

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

        >>> from password_checker import check_password
>>> def friendly_check(password):
...     try:
...         check_password(password)
...     except InvalidPasswordError as exc:
...         print("Invalid password", repr(exc))
...
>>> friendly_check("hello")
Invalid password ShortPasswordError('hello')
>>> friendly_check("helloworld")
Invalid password NoNumbersInPasswordError('helloworld')
>>> friendly_check("helloworld1")
Invalid password NoSpecialInPasswordError('helloworld1')

    

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

Маркирующие методы

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

Представим, что вы пишете код для анализа шаблонов использования веб-сервера. Требуется различать запросы, поступающие от пользователей, вошедших в систему, и запросы от неаутентифицированных подключений. Ситуацию можно смоделировать, имея суперкласс Origin с двумя подклассами: LoggedIn и NotLoggedIn. Каждый запрос должен исходить либо из источника LoggedIn, либо из NotLoggedIn, но ничто не должно напрямую создавать экземпляр класса Origin. Вот минималистичная реализация:

        import abc

class Origin(abc.ABC):
    @abc.abstractmethod
    def description(self):
        # Этот метод никогда не будет вызван
        pass

class NotLoggedIn(Origin):
    def description(self):
        return "unauthenticated connection"

class LoggedIn(Origin):
    def description(self):
        return "authenticated connection"

    

Хотя реалистичный класс Origin выглядел бы сложнее, в этом примере показана его основа. Метод Origin.description() никогда не будет вызван – все подклассы его переопределяют.

        >>> Origin()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Origin with abstract...
>>> logged_in.description()
'authenticated connection'
>>> not_logged_in.description()
'unauthenticated connection'

    

Классы с декораторами методов abstractmethod не могут быть созданы. Любой объект, имеющий Origin в качестве суперкласса, будет экземпляром класса, который переопределяет description(). Из-за этого тело в Origin.description() не имеет значения и его можно заменить инструкцией pass.

Есть и другие примеры использования таких маркеров вне стандартной библиотеки Python. Например, они используются в пакете zope.interface для обозначения методов интерфейса и в automat для входных данных конечного автомата. Во всех этих случаях классы должны иметь методы, но никогда не вызывают их.

Альтернативы pass

Инструкция pass – не единственный способ «ничего не делать». Любое выражение в Python это валидная инструкция, как и любая константа. Фактически следующие инструкции тоже сами по себе ничего не делают:

• None
• True
• 0
• "hello I do nothing"

Основная причина, почему стоит избегать использования таких инструкций вместо pass – они не идиоматичны. Люди, читающие ваш код, не сразу поймут, зачем вы их использовали. Хотя для записи инструкции pass требуется больше символов, чем, скажем для 0, она явным образом показывает, что блок кода намеренно оставлен пустым.

Docstrings

Есть одно важное исключение из идиомы использования pass в качестве инструкции бездействия. В классах, функциях и методах использование константного строкового выражения приведет к тому, что выражение будет использоваться как атрибут объекта .__ doc__. Этот атрибут используется функцией интерпретатора help(), различными генераторами документации и многими IDE.

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

        class StringReader(Protocol):
      def read(self, length: int) -> str:
          """
          Считывает строку.
          """

class Origin(abc.ABC):
    @abc.abstractmethod
    def description(self):
        """
        Человекочитаемое описание источника.
        """

class TooManyOpenParens(ParseError):
    """
    Не все круглые скобки закрыты.
    """

class DiscardingIO:
    def write(self, data):
        """
        Игнорируем данные.
        """

    

Во всех приведенных случаях строка документации делает код понятнее, а работу с ним – более удобной.

Ellipsis

В pyi-файлах рекомендуется использовать в качестве выражения многоточие (...). Эта константа определяется с помощью синглтона Ellipsis:

        >>> ...
Ellipsis
>>> x = ...
>>> type(x), x
(<class 'ellipsis'>, Ellipsis)

    

Первоначально объект Ellipsis использовался для создания многомерных срезов. Однако теперь это также рекомендуемый синтаксис для заполнения блоков в stub-файлах c расширением .pyi:

        # В `.pyi` файле:
def add(a: int, b: int)-> int:
    ...

    

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

Вызов исключения

В тех случаях, когда функции или методы пусты, потому что они никогда не выполняются, иногда лучшим телом будет вызов исключения raise NotImplementedError("this should never happen"). Вызов исключения в этом случае даст дополнительную информацию.

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

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

Применение pass в try … except

При использовании try ... except для определенных исключений нет необходимости как-либо его обрабатывать – главное, чтобы программа продолжала работу. В такой ситуации pass как нельзя кстати.

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

        import os

def ensure_nonexistence(fname):
    try:
        os.remove(fname)
    except FileNotFoundError:
        pass

    

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

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

Вы также можете использовать диспетчер контекста contextlib.suppress() для подавления исключения. Если нужно обрабатывать одни исключения, игнорируя другие, то проще использовать инструкцию pass.

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

        import os
import shutil

def ensure_nonexistence(fname):
    try:
       os.remove(fname)
    except FileNotFoundError:
       pass
    except IsADirectoryError:
       shutil.rmtree(fname)

    

Здесь происходит игнорирование исключения FileNotFoundError и обработка исключения IsADirectoryError.

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

Использование pass в цепочках if … elif

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

Представьте, что рекрутер попросил вас написать fizz-buzz с такимиусловиями:

1. Если число делится на 20, программа должна печать "twist".
2. В остальных случаях, если число делится на 15, ничего не печатать.
3. В остальных случаях, если число делится на 5, печатать "fizz".
4. В остальных случаях, если число делится на 3, печатать "buzz".
5. Во всех остальных случаях печатать само число.

Как и во всех вопросах по кодингу, есть много способов решить эту проблему. Один из них – использовать цикл for с цепочкой, которая имитирует само описание:

        for x in range(100):
    if x % 20 == 0:
       print("twist")
    elif x % 15 == 0:
       pass
    elif x % 5 == 0:
       print("fizz")
    elif x % 3 == 0:
       print("buzz")
    else:
       print(x)

    

Цепочка if … elif отражает логику перехода между ограничениями задачи. В этом примере, если мы полностью удалим выражение if x % 15, мы изменим поведение программы. То есть такой вариант использования оператора pass позволяет не только решить задачу, но и сохранить логику кода в соответствии с логикой задачи.

Заключение

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

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

• Тест на знание языка Python (15 вопросов)
• Всё, что нужно знать о декораторах Python
• Как хранить объекты Python со сложной структурой
• Итерируем правильно: 20 приемов использования в Python модуля itertools
• Введение в объектно-ориентированное программирование (ООП) на Python

Быстрый ответ

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

Взгляните на пример:

Картинка с сайта: sky.pro

Когда использовать оператор «pass»

При создании структуры кода

На этапе проектирования pass помогает быстро создать контур для ваших классов и функций, формируя основу для кода, который впоследствии будет наполнен конкретикой.

Для обработки исключений

В блоках try-except pass позволяет без лишнего шума игнорировать исключения, которые могли бы возникнуть, не влияя на ход выполнения программы.

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

При определении собственных классов и исключений

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

Визуализация

pass — это ваш пустой лист перед началом воплощения идей:

Считайте, что каждый pass — это свободное пространство для ваших будущих шедевров.

«Многоточие» вместо pass – альтернативная заглушка

Начиная с Python 3, ... (многоточие) также может выполнять роль «заглушки», аналогично pass.

Применение в процессе отладки

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

Придание эстетики коду

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

Используйте «pass» с умом

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

Полезные материалы

1. Больше о инструментах управления потоком – документация Python 3.12.2 — Профессиональное руководство по инструментам управления потоком в Python.
2. Оператор pass: Как «ничего не делать» в Python – Real Python — Глубокий дайджест об эффективном использовании pass в Python.
3. Ключевое слово pass в Python — Краткое руководство по ключевому слову pass в Python.
4. Оператор pass в Python (с примерами) — Инструкция с практическими примерами использования pass.
5. Оператор pass в Python — Доступная для понимания информация об операторе pass в Python.

В этой статье вы узнаете об инструкции pass. Она используется в качестве «заполнителя» в теле функции или цикла.

Что такое инструкция pass в Python

Инструкция pass — «пустой» оператор. Это значит, что pass ничего не делает. Тем не менее, Python не игнорирует инструкцию pass в отличие от комментариев. Результатом выполнения pass является отсутствие операции — NOP.

Синтаксис pass

pass

В начале статьи мы сказали, что инструкцию pass используют как «заполнитель». Давайте разберемся, что это значит.

Допустим, у нас есть цикл или функция, которые мы еще не реализовали, но хотим сделать это в будущем. В Python у циклов и функций не может быть «пустого» тела — интерпретатор выведет ошибку. Поэтому в тело можно поместить инструкцию pass, и все заработает.

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

'''pass — заполняет место в цикле,
которое мы заполним позже.'''
sequence = {'p', 'a', 's', 's'}
for val in sequence:
    pass

Точно так же можно делать с пустой функцией или классом:

def function(args):
    pass

class Example:
    pass

При работе с циклами while и for бывает необходимо выполнить принудительный выход, пропустить часть или игнорировать заданные условия. Для первых двух случаев используются операторы break и continue Python, а для игнорирования условий — инструкция pass. Давайте посмотрим на примерах, как работают эти операторы.

that cloud

Инструкция break в языке программирования Python прерывает выполнение блока кода. Простейший пример:

for j in 'bananafishbones':
    if j == 'f':
        break
    print(j)

Получаем такой вывод:

b
a
n
a
n
a

Как только программа после нескольких итераций доходит до элемента последовательности, обозначенного буквой f, цикл (loop) прерывается, поскольку действует оператор break. Теперь рассмотрим работу этой инструкции в цикле while:

x = 0
while x < 5:
    print(x)
    x += 0.5
print('Выход')

Вывод будет следующий (приводим с сокращениями):

0
0.5
…
4.0
4.5
Выход

Как только перестает выполняться условие и x становится равным 5, программа завершает цикл. А теперь перепишем код с использованием инструкции break:

x = 0
while True:
    print(x)
    if x >= 4.5:
        break
    x += 0.5
print('Выход')

Результат тот же:

0
0.5
…
4.0
4.5
Выход

Мы точно так же присвоили x значение 0 и задали условие: пока значение x истинно (True), продолжать выводить его. Код, правда, получился немного длиннее, но бывают ситуации, когда использование оператора прерывания оправданно: например, при сложных условиях или для того, чтобы подстраховаться от создания бесконечного цикла. Уберите из кода выше две строчки:

x = 0
while True:
    print(x)
    x += 0.5
print('Выход')

И перед нами бесконечный вывод:

0
0.5
…
100
100.5
…
1000000
1000000.5
…

И слово в конце (‘Выход’), таким образом, никогда не будет выведено, поскольку цикл не закончится. Поэтому при работе с последовательностями чисел использование оператора break убережет вас от сбоев в работе программ, вызываемых попаданием в бесконечный цикл.

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

Иногда необходимо проверить, был ли цикл исполнен до конца или выход произошел с использованием инструкции break. Для этого добавляется проверка по условию с else. Напишем программу, которая проверяет фразу на наличие запрещенных элементов:

word = input('Введите слово: ')
for i in word:
    if i == 'я':
        print('Цикл был прерван, обнаружена буква я')
        break
else:
    print('Успешное завершение, запрещенных букв не обнаружено')
print('Проверка завершена')

Теперь, если пользователь введет, например, «Привет!», программа выдаст следующее:

Успешное завершение, запрещенных букв не обнаружено
Проверка завершена

Но если во введенном слове будет буква «я», то вывод примет такой вид:

Цикл был прерван, обнаружена буква я
Проверка завершена

Небольшое пояснение: функция input принимает значение из пользовательского ввода (выражение 'Введите слово: ' необходимо только для пользователя, для корректной программы хватило бы и такой строки: word = input ()) и присваивает его переменной word. Последняя при помощи for поэлементно (в данном случае — побуквенно) анализируется с учетом условия, вводимого if.

Оператор continue в Python

Если break дает команду на прерывание, то continue действует более гибко. Его функция заключается в пропуске определенных элементов последовательности, но без завершения цикла. Давайте напишем программу, которая «не любит» букву «я»:

word = input('Введите слово: ')
for i in word:
    if i == 'я':
        continue
    print(i)

Попробуйте ввести, например, «яблоко», в этом случае вывод будет таким:

б
л
о
к
о

Это происходит потому, что мы задали условие, по которому элемент с определенным значением (в данном случае буква «я») не выводится на экран, но благодаря тому, что мы используем инструкцию continue, цикл доходит до последней итерации и все «разрешенные» элементы выводятся на экран. Но в коде выше есть одна проблема: если пользователь введет, например, «Яблоко», программа выведет слово полностью, поскольку не учтен регистр:

Я
б
л
о
к
о

Наиболее очевидное решение в данном случае состоит в добавлении и заглавной буквы в блок if таким образом:

word = input('Введите слово: ')
for i in word:
    if i == 'я' or i == 'Я':
        continue
    print(i)

Оператор pass в Python

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

word = input('Введите слово: ')
for i in word:
    if i == 'я':
        pass
else:
    print('Цикл завершен, запрещенных букв не обнаружено')
print('Проверка завершена')

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

Вот и всё, надеемся, скоро break, continue и pass станут вашими верными друзьями в разработке интересных приложений. Успехов!