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

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

поэтому, если ничего не должно произойти в блоке кода, a pass необходимо, чтобы такой блок не производил IndentationError. Кроме того, любое заявление (в том числе просто термин будет оценивали, как то Ellipsis литерал ... или строку, чаще всего docstring) можно использовать, но 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
  

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

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

• в некоторых случаях pass используется в качестве заполнителя, чтобы сказать "Этот метод/класс/if-блок/... пока еще не реализовано, но это будет место, чтобы сделать это", хотя я лично предпочитаю Ellipsis литерал ... чтобы строго различать это и намеренное "no-op" в предыдущем примере. Например, если я пишу модель широкими штрихами, я мог бы пиши

  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-дела. Без использования 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-й итерации A for... в заявлениях. Итак:

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

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

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

class Error(Exception):
    pass

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

Если вы не знаете, что вы собираетесь поместить в определенный блок кода

try:
   int(someuserinput)
except ValueError:
   pass

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

class TestFunctions(unittest.TestCase):

   def test_some_feature(self):
      pass

   def test_some_other_feature(self):
      pass

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 не допускает пустой или нереализованный оператор class/function/conditional, он дает ошибку:

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

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

можно и так сказать передать означает НОП (без операции) операции. Вы получите четкую картину после этого примера : -

Программы 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 "

но ваш код даст ошибку, потому что он требует отступ блока после Элиф . Вот роль передать ключевое слово.

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 "

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

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

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

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

и затем позже заполните сценарий, где var == 2000

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

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

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

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

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

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

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

вот пример, когда я извлекал определенные данные из списка, где у меня было несколько типов данных (это то, что я бы назвал в 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 полезен, когда вы создали блок кода, но он больше не требуется.