Como usar a declaração de passagem?

O Python tem o requisito sintático de que os blocos de código (após if, except, def, class etc.) não pode estar vazio. Blocos de código vazios são, no entanto, úteis em uma variedade de contextos diferentes, como em exemplos abaixo, que são os casos de uso mais freqüentes que eu já vi.

• Ignorando (todos ou) um certo tipo de Exception (exemplo de xml):

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

  Nota: ignorar todos os tipos de aumentos, como no exemplo seguinte de pandas, é geralmente considerado uma má prática, porque também apanha exceções que provavelmente devem ser passadas para o chamador, por exemplo KeyboardInterrupt ou SystemExit (ou mesmo HardwareIsOnFireError – Como é que sabe que não está a correr numa caixa personalizada com erros específicos definidos, que alguma aplicação de chamadas gostaria de saber?).

  try:
      os.unlink(filename_larry)
  except:
      pass
  

  Em vez disso, a utilização de pelo menos except Error: ou, neste caso, de preferência except OSError: é considerada uma prática muito melhor. Uma análise rápida de todos os módulos python que instalei me deu que mais de 10% de todas as declarações except ...: pass capturam todas as exceções, então ainda é um padrão frequente na programação python.

• Derivando uma classe de excepção que não adiciona um novo comportamento (por exemplo, em scipy):

  class CompileError(Exception):
      pass
  

  Similarmente, classes destinadas como classe base abstrata muitas vezes têm um vazio explícito __init__ ou outros métodos que subclasses supostamente derivam. (ex. pebl)

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

• Testar esse código funciona adequadamente para alguns valores de teste, sem se importar com os resultados (de mpmath):

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

• Em Definições de classe ou função, muitas vezes uma docstring já está no lugar como a declaração obrigatória para ser executada como a única coisa no bloco. Neste caso, a casa pode conter:pass além disso para a docstring, a fim de dizer " isso realmente não pretende fazer nada.", por exemplo em pebl:

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

• Em alguns casos, pass é usado como substituição para dizer "este método/Classe/bloco if/... não foi implementado ainda, mas este será o lugar para fazê-lo", embora eu pessoalmente prefira o Ellipsis literal ... a fim de estritamente diferenciar entre este e o" no-op " intencional no exemplo anterior. Por exemplo, se eu escrever um modelo em linhas gerais, eu poderia escrever

  def update_agent(agent):
      ... 
  

  Onde outros possam ter

  def update_agent(agent):
      pass
  

  Antes de

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

  Como um lembrete para preencher a função update_agent num ponto posterior, mas execute alguns testes já para ver se o resto do código se comporta como destinar. (Uma terceira opção para este caso é raise NotImplementedError. Isso é útil em especial para dois casos: "Este método abstrato deve ser implementado por cada subclasse, não há nenhuma maneira genérica para definir isso na classe base", ou "Esta função, com este nome, ainda não está implementada nesta versão, mas isto é o que sua assinatura será parecido")

Além do seu uso como substituto para funções não implementadas, pass pode ser útil para preencher uma declaração if-else ("explícito é melhor do que implícito.")

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

Claro que, neste caso, provavelmente se usaria return em vez de atribuição, mas nos casos em que a mutação é desejada, isto funciona melhor.

Outro caso é com a função boilerplate frequentemente vista no fundo de um ficheiro:

if __name__ == "__main__":
    pass

Em alguns arquivos, pode ser bom deixar isso lá com pass para permitir uma edição mais fácil mais tarde, e para tornar explícito que nada é esperado acontece quando o arquivo é executado por conta própria.

Finalmente, como mencionado em outras respostas, pode ser útil não fazer nada quando uma exceção é pego:

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

A melhor e mais precisa maneira de pensar em pass é como uma forma de dizer explicitamente ao intérprete para não fazer nada. Da mesma forma, o seguinte código:

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

Significa "se eu chamar a função foo (x, y), soma os dois números que os rótulos x e y representam e devolve o resultado",

def bar():
    pass

Significa " Se eu chamar a barra de funções (), não faça absolutamente nada."

Por exemplo, em um pouco de código que eu trabalhei recentemente, era necessário dividir duas variáveis, e era possível que o divisor fosse zero.

c = a / b

try:
    c = a / b
except ZeroDivisionError:
    pass

Outro, menos uso padrão é como um lugar útil para colocar um ponto de paragem para o seu depurador. Para por exemplo, eu queria um pouco de código para quebrar o depurador na 20ª iteração de A for... em declaração. Então:

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

Um caso de uso comum em que pode ser usado 'como está' é substituir uma classe apenas para criar um tipo (que é o mesmo que a superclasse), por exemplo

class Error(Exception):
    pass

Assim você pode levantar e pegar Error exceções. O que importa aqui é o tipo de excepção, e não o conteúdo.

Se não sabes o que vais colocar num certo bloco de código

try:
   int(someuserinput)
except ValueError:
   pass

class TestFunctions(unittest.TestCase):

   def test_some_feature(self):
      pass

   def test_some_other_feature(self):
      pass

pass em Python basicamente não faz nada, mas ao contrário de um comentário não é ignorado pelo interpretador. Então você pode tirar proveito disso em muitos lugares, tornando-o um titular de lugar:

1: pode ser usado na classe

   class TestClass: 
      pass

2: pode ser usado em laço e em declarações condicionais:

   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: pode ser usado na função:

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

pass é usado principalmente quando o programador não quer dar implementação no momento, mas ainda quer criar um certo class/function / conditional statement which can be used later on. Uma vez que o interpretador de Python não permite a class/function/condicional em branco ou Não implementado, ele dá um erro:

IndentationError: espera-se um bloco indentado

pass pode ser usado em tais cenários.

Pode dizer-se que passar significa Operação NOP (sem operação). Você terá uma imagem clara após este exemplo: -

Programa 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 ");
    }
}

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 "

Mas o seu código irá dar um erro porque necessitava de um bloco indentado após elif . Aqui está o papel da palavra-chave 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 "

Como dizia o livro, eu só o uso como substituto temporário, ou seja,

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

E depois preencher o cenário onde var == 2000

Honestamente, acho que os documentos oficiais em Python descrevem-no muito bem e fornecem alguns exemplos:

A declaração passa não faz nada. Ele pode ser usado quando uma declaração é necessária sintaticamente, mas o programa não requer nenhuma ação. Por exemplo:

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

Isto é normalmente usado para criar classes mínimas:

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

Outro lugar passa pode ser usado como suporte de lugar para uma função ou corpo condicional quando você está trabalhando em novo código, permitindo que você continue pensando em um nível mais abstrato. A passagem é silenciosamente ignorada:

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

Aqui está um exemplo onde eu estava extraindo dados particulares de uma lista onde eu tinha vários tipos de dados (que é o que eu chamaria em R-- desculpe se é a nomenclatura errada) e eu queria extrair apenas números inteiros/numéricos e não dados de caracteres.

Os dados pareciam:

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

Eu queria remover todos os caracteres alfabéticos, por isso pedi à máquina para o fazer Sub-definindo os dados, e "passando" os dados alfabéticos:

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']

A declaração de passagem em Python é usada quando uma declaração é necessária sintaticamente, mas você não quer que nenhum comando ou código seja executado.

A declaração de passagem é uma operação nula; nada acontece quando é executada. O passe também é útil em lugares onde seu código acabará por ir, mas ainda não foi escrito (por exemplo, em pubs, por exemplo):

`Exemplo:

#!/usr/bin/python

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

print "Good bye!"

Isto produzirá os seguintes resultados:

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

O código anterior não executa qualquer declaração ou código se o valor da letra for "h". A declaração pass é útil quando você criou um bloco de código, mas não é mais necessário.

Você pode então remover as declarações dentro do bloco, mas deixar o bloco permanecer com uma declaração de passe para que ele não interfira com outras partes do Código.