Как использовать инструкцию pass?

Я нахожусь в процессе изучения Python, и я дошел до раздела об passутверждении. Руководство, которое я использую, определяет его как Nullутверждение, которое обычно используется в качестве заполнителя.

Я до сих пор не до конца понимаю, что это значит. Может кто-нибудь показать мне простую / базовую ситуацию, где passбудет использоваться утверждение и зачем оно нужно?

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

class MyClass(object):
    def meth_a(self):
        pass

    def meth_b(self):
        print "I'm meth_b"

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

Затем вы получите:

IndentationError: expected an indented block

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

Python имеет синтаксическое требование , чтобы блоки кода (после того, как if, except, def, и classт.д.) не может быть пустым. Пустые блоки кода, однако, полезны в различных контекстах, например, в примерах ниже, которые являются наиболее частыми случаями использования, которые я видел.

Следовательно, если в блоке кода ничего не должно происходить, passдля такого блока не требуется a IndentationError. В качестве альтернативы можно использовать любое утверждение (включая только оцениваемый термин, например, Ellipsisлитерал ...или строку, чаще всего строку документации), но из этого passстановится ясно, что на самом деле ничего не должно происходить, и его не нужно фактически оценивать и (хотя бы временно) хранится в памяти.

• Игнорирование (все или) определенного типа Exception(пример из xml):

  try:
      self.version = "Expat %d.%d.%d" % expat.version_info
  except AttributeError:
      pass # unknown

  Примечание: Игнорирование всех типов повышений, как в следующем примере из pandas, обычно считается плохой практикой, потому что оно также ловит исключения, которые, вероятно, должны быть переданы вызывающей стороне, например, KeyboardInterruptили SystemExit(или даже HardwareIsOnFireError- откуда вы знаете, что это не так запуск на пользовательском ящике с определенными определенными ошибками, о которых некоторые вызывающие приложения хотели бы знать?).

  try:
      os.unlink(filename_larry)
  except:
      pass

  Вместо этого использование по крайней мере except Error:или в этом случае предпочтительно except OSError:считается намного лучшей практикой. Быстрый анализ всех модулей Python, которые я установил, дал мне понять, что более 10% всех except ...: passоператоров перехватывают все исключения, так что это все еще частый шаблон в программировании на Python.

• Вывод класса исключения, который не добавляет новое поведение (например, в scipy):

  class CompileError(Exception):
      pass

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

  class _BaseSubmittingController(_BaseController):
      def submit(self, tasks): pass
      def retrieve(self, deferred_results): pass

• Тестирование этого кода выполняется правильно для нескольких тестовых значений, не заботясь о результатах (из mpmath):

  for x, error in MDNewton(mp, f, (1,-2), verbose=0,
                           norm=lambda x: norm(x, inf)):
      pass

• В определениях классов или функций часто строка документа уже существует в качестве обязательного оператора, выполняемого как единственная вещь в блоке. В таких случаях блок может содержать pass в дополнение к строке документации, чтобы сказать: «Это действительно предназначено для того, чтобы ничего не делать». Например, в pebl:

  class ParsingError(Exception): 
      """Error encountered while parsing an ill-formed datafile."""
      pass

• В некоторых случаях passиспользуется как заполнитель, чтобы сказать: «Этот метод / класс / if-block / ... еще не был реализован, но это будет место, где это сделать», хотя я лично предпочитаю Ellipsisлитерал ...для того, чтобы строго разграничить это и преднамеренное «без операции» в предыдущем примере. ( Обратите внимание, что литерал Ellipsis является допустимым выражением только в Python 3 ).
  Например, если я пишу модель широкими штрихами, я мог бы написать

  def update_agent(agent):
      ... 

  где другие могут иметь

  def update_agent(agent):
      pass

  перед

  def time_step(agents):
      for agent in agents:
          update_agent(agent)

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

Помимо его использования в качестве заполнителя для нереализованных функций, он passможет быть полезен при заполнении оператора if-else («Явный лучше, чем неявный».)

def some_silly_transform(n):
    # Even numbers should be divided by 2
    if n % 2 == 0:
        n /= 2
        flag = True
    # Negative odd numbers should return their absolute value
    elif n < 0:
        n = -n
        flag = True
    # Otherwise, number should remain unchanged
    else:
        pass

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

Использование passздесь особенно полезно, чтобы предупредить будущих сопровождающих (включая вас!) О том, чтобы не ставить лишние шаги за пределами условных операторов. В приведенном выше примере flagустанавливается в двух конкретно упомянутых случаях, но не в else-case. Без использования passбудущий программист может выйти flag = Trueза пределы условия - таким образом, устанавливая flagво всех случаях.

Другой случай с шаблонной функцией, часто видимой внизу файла:

if __name__ == "__main__":
    pass

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

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

try:
    n[i] = 0
except IndexError:
    pass

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

def foo(x,y):
    return x+y

означает «если я вызову функцию foo (x, y), суммирую два числа, которые представляют метки x и y, и верну результат»,

def bar():
    pass

означает «Если я вызываю функцию bar (), то ничего не делаю».

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

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

c = a / b

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

try:
    c = a / b
except ZeroDivisionError:
    pass

Другое, менее стандартное использование - удобное место для установки точки останова для вашего отладчика. Например, я хотел, чтобы часть кода врезалась в отладчик на 20-й итерации оператора for ... in. Так:

for t in range(25):
    do_a_thing(t)
    if t == 20:
        pass

с точкой останова на проходе.

Обычный вариант использования, где его можно использовать «как есть», это переопределение класса только для создания типа (который в остальном совпадает с суперклассом), например

class Error(Exception):
    pass

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

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

1: Может использоваться в классе

   class TestClass: 
      pass

2: можно использовать в цикле и условных выражениях:

   if (something == true):  # used in conditional statement
       pass

   while (some condition is true):  # user is not sure about the body of the loop
       pass

3: Может использоваться в функции:

   def testFunction(args): # programmer wants to implement the body of the function later
       pass

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

IndentationError: ожидается блок с отступом

pass можно использовать в таких сценариях.

Вы можете сказать, что pass означает операцию NOP (No Operation). После этого примера вы получите ясную картину:

Программа C

#include<stdio.h>

void main()
{
    int age = 12;

    if( age < 18 )
    {
         printf("You are not adult, so you can't do that task ");
    }
    else if( age >= 18 && age < 60)
    {
        // I will add more code later inside it 
    }
    else
    {
         printf("You are too old to do anything , sorry ");
    }
}

Теперь, как вы напишите это на Python:

age = 12

if age < 18:

    print "You are not adult, so you can't do that task"

elif age >= 18 and age < 60:

else:

    print "You are too old to do anything , sorry "

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

age = 12

if age < 18:

    print "You are not adult, so you can't do that task"

elif age >= 18 and age < 60:

    pass

else:

    print "You are too old to do anything , sorry "

Теперь я думаю, что вам ясно.

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

class TestFunctions(unittest.TestCase):

   def test_some_feature(self):
      pass

   def test_some_other_feature(self):
      pass

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

Честно говоря, я думаю, что официальные документы Python описывают это довольно хорошо и приводят несколько примеров:

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

>>> while True: ... pass # Busy-wait for keyboard interrupt (Ctrl+C) ...

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

>>> class MyEmptyClass: ... pass ...

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

>>> def initlog(*args): ... pass # Remember to implement this! ...

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

# code that does something to to a variable, var
if var == 2000:
    pass
else:
    var += 1

а затем заполните сценарий, в котором var == 2000

Pass ссылается на ignore .... так просто, как есть .... если данное условие истинно, а следующий оператор - pass, он игнорирует это значение или итерацию и переходит к следующей строке ..... Пример

For i in range (1,100):
    If i%2==0:
                  Pass 
    Else:
                  Print(i)

Вывод: печатает все нечетные числа от 1 до 100

Это потому, что модуль четного числа равен нулю, следовательно, он игнорирует число и переходит к следующему числу, так как модуль нечетных чисел не равен нулю, остальная часть цикла выполняется и печатается

Вот пример, где я извлекал определенные данные из списка, где у меня было несколько типов данных (это то, что я бы назвал в R - извините, если это неправильная номенклатура), и я хотел извлечь только целые / числовые и НЕ символьные данные ,

Данные выглядели так:

>>> a = ['1', 'env', '2', 'gag', '1.234', 'nef']
>>> data = []
>>> type(a)
<class 'list'>
>>> type(a[1])
<class 'str'>
>>> type(a[0])
<class 'str'>

Я хотел удалить все алфавитные символы, поэтому я сделал так, чтобы машина делала это путем поднабора данных и «передавая» алфавитные данные:

a = ['1', 'env', '2', 'gag', '1.234', 'nef']
data = []
for i in range(0, len(a)):
    if a[i].isalpha():
        pass
    else:
        data.append(a[i])
print(data)
['1', '2', '1.234']

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

Оператор pass является нулевой операцией; ничего не происходит, когда он выполняется. Этот проход также полезен в тех местах, где ваш код в конечном итоге будет отправлен, но еще не написан (например, в заглушках, например):

`Пример:

#!/usr/bin/python

for letter in 'Python': 
   if letter == 'h':
      pass
      print 'This is pass block'
   print 'Current Letter :', letter

print "Good bye!"

Это даст следующий результат:

Current Letter : P
Current Letter : y
Current Letter : t
This is pass block
Current Letter : h
Current Letter : o
Current Letter : n
Good bye!

Предыдущий код не выполняет никаких операторов или кодов, если значение буквы равно «h». Оператор pass полезен, когда вы создали блок кода, но он больше не требуется.

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

pass используется, чтобы избежать ошибок отступа в python. Если мы возьмем такие языки, как c, c ++, java, они будут иметь такие скобки, как

 if(i==0)
 {}
 else
 {//some code}

Но в python он использовал отступы вместо фигурных скобок, поэтому, чтобы избежать таких ошибок, мы используем pass. Помните, как вы играли в викторину и

 if(dont_know_the_answer)
      pass

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

  for letter in 'geeksforgeeks':
        pass
  print 'Last Letter :', letter