Como usar a declaração de passe?

Estou aprendendo Python e cheguei à seção sobre a passdeclaração. O guia que estou usando define como sendo uma Nulldeclaração comumente usada como espaço reservado.

Ainda não entendo completamente o que isso significa. Alguém pode me mostrar uma situação simples / básica em que a passdeclaração seria usada e por que é necessária?

Suponha que você esteja projetando uma nova classe com alguns métodos que ainda não deseja implementar.

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

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

Se você deixar de fora passo código não será executado.

Você então obteria:

IndentationError: expected an indented block

Para resumir, a passdeclaração não faz nada em particular, mas pode atuar como um espaço reservado, conforme demonstrado aqui.

Python tem o requisito sintática que blocos de código (após if, except, def, classetc.) não podem estar vazio. No entanto, blocos de código vazios são úteis em vários contextos diferentes, como nos exemplos abaixo, que são os casos de uso mais frequentes que já vi.

Portanto, se nada deve acontecer em um bloco de código, passé necessário a para que esse bloco não produza um IndentationError. Como alternativa, qualquer declaração (incluindo apenas um termo a ser avaliado, como Ellipsisliteral ...ou uma string, na maioria das vezes uma docstring) pode ser usada, mas passdeixa claro que realmente nada deve acontecer e não precisa ser realmente avaliado e (pelo menos temporariamente) armazenado na memória.

• Ignorando (todos ou) um determinado 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 raises, como no exemplo a seguir pandas, geralmente é considerado uma prática ruim, porque também captura exceções que provavelmente devem ser repassadas ao chamador, por exemplo, KeyboardInterruptou SystemExit(ou mesmo HardwareIsOnFireError- Como você sabe que não é executando em uma caixa personalizada com erros específicos definidos, sobre os quais alguns aplicativos de chamada gostariam de saber?).

  try:
      os.unlink(filename_larry)
  except:
      pass

  Em vez disso, usar pelo menos except Error:ou nesse caso de preferência except OSError:é considerado 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 except ...: passinstruções capturam todas as exceções, por isso ainda é um padrão frequente na programação python.

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

  class CompileError(Exception):
      pass

  Da mesma forma, as classes designadas como classe base abstrata geralmente têm __init__métodos vazios explícitos ou outros que as subclasses devem derivar. (por exemplo pebl)

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

• Testar esse código é executado corretamente para alguns valores de teste, sem se preocupar com os resultados (de mpmath):

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

• Nas definições de classe ou função, muitas vezes já existe uma doutrina como a declaração obrigatória a ser executada como a única coisa no bloco. Nesses casos, o bloco pode conter pass , além da doutrina, para dizer "Isso realmente não deve fazer nada". Por exemplo, em pebl:

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

• Em alguns casos, passé usado como espaço reservado para dizer "Este método / classe / se-bloco / ... ainda não foi implementado, mas este será o local para fazê-lo", embora eu pessoalmente prefira o Ellipsisliteral ...para estritamente diferencie isso e o intencional "não-op" no exemplo anterior. ( Observe que o literal de reticências é uma expressão válida apenas no Python 3 ).
  Por exemplo, se eu escrever um modelo em traços largos, talvez eu escreva

  def update_agent(agent):
      ... 

  onde outros possam ter

  def update_agent(agent):
      pass

  antes

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

  como um lembrete para preencher a update_agentfunção posteriormente, mas execute alguns testes já para verificar se o restante do código se comporta como pretendido. (Uma terceira opção para este caso é raise NotImplementedError. Isso é útil em particular em dois casos: “Esse método abstrato deve ser implementado por todas as subclasses, não há uma maneira genérica de defini-lo nessa classe base” ou “Esta função, com esse nome ainda não foi implementado nesta versão, mas é assim que será sua assinatura ” )

Além de seu uso como espaço reservado para funções não implementadas, passpode ser útil no preenchimento de uma declaração if-else ("Explícito é melhor 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

Obviamente, nesse caso, provavelmente seria usado em returnvez de atribuição, mas nos casos em que a mutação é desejada, isso funciona melhor.

O uso passaqui é especialmente útil para avisar futuros mantenedores (inclusive você!) Para não colocar etapas redundantes fora das instruções condicionais. No exemplo acima, flagé definido nos dois casos mencionados especificamente, mas não na elsecaixa. Sem usar pass, um programador futuro pode passar flag = Truepara fora da condição - configurando assim flagem todos os casos.

Outro caso é com a função clichê, geralmente vista na parte inferior de um arquivo:

if __name__ == "__main__":
    pass

Em alguns arquivos, pode ser bom deixar isso passpara permitir uma edição mais fácil mais tarde e deixar explícito que nada deve acontecer quando o arquivo for executado por si próprio.

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

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

A melhor e mais precisa maneira de pensar pass é como dizer explicitamente ao intérprete que não faça nada. Da mesma maneira, o seguinte código:

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

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

def bar():
    pass

significa "Se eu chamar a função bar (), não faça absolutamente nada."

As outras respostas são bastante corretas, mas também são úteis para algumas coisas que não envolvem a troca de lugar.

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

c = a / b

obviamente produzirá um ZeroDivisionError se b for zero. Nessa situação em particular, deixar c como zero era o comportamento desejado no caso de b ser zero, então usei o seguinte código:

try:
    c = a / b
except ZeroDivisionError:
    pass

Outro uso menos padrão é um local útil para colocar um ponto de interrupção no seu depurador. Por exemplo, eu queria que um pouco de código invadisse o depurador na 20ª iteração de uma declaração for for .... Assim:

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

com o ponto de interrupção de passagem.

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

class Error(Exception):
    pass

Então você pode criar e capturar Errorexceções. O que importa aqui é o tipo de exceção, e não o conteúdo.

passno Python basicamente não faz nada, mas, diferentemente de um comentário, ele não é ignorado pelo intérprete. Assim, você pode tirar proveito disso em muitos lugares, tornando-o um marcador de posição:

1: Pode ser usado em aula

   class TestClass: 
      pass

2: Pode ser usado em loop e em instruçõ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 em função:

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

passé usado principalmente quando o programador não deseja dar implementação no momento, mas ainda deseja criar uma determinada instrução de classe / função / condicional que pode ser usada posteriormente. Como o intérprete Python não permite uma instrução em branco / não implementada de classe / função / condicional, ocorre um erro:

IndentationError: esperado um bloco recuado

pass pode ser usado em tais cenários.

Você pode dizer que passe significa operação NOP (sem operação). Você obterá 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 ");
    }
}

Agora, como você escreverá isso em 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 "

Mas seu código dará erro porque exigiu um bloco recuado 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 "

Agora eu acho que está claro para você.

Eu gosto de usá-lo ao remover testes. Muitas vezes, tenho consciência do que gostaria de testar, mas não sei exatamente como fazê-lo. O exemplo de teste se parece com o que sebastian_oe sugeriu

class TestFunctions(unittest.TestCase):

   def test_some_feature(self):
      pass

   def test_some_other_feature(self):
      pass

A declaração de aprovação não faz nada. Pode ser usado quando uma declaração é necessária sintaticamente, mas o programa não requer nenhuma ação.

Honestamente, acho que os documentos oficiais do Python o descrevem muito bem e fornecem alguns exemplos:

A declaração de aprovação não faz nada. Pode ser usada 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) ...

Isso é comumente usado para criar classes mínimas:

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

Outro passe de local pode ser usado como um espaço reservado para uma função ou corpo condicional quando você estiver trabalhando em um novo código, permitindo que você continue pensando em um nível mais abstrato. O passe é ignorado silenciosamente:

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

como o livro dizia, eu só o uso como espaço reservado temporário, ou seja,

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

e depois preencha o cenário em que var == 2000

Passagem refere-se a ignorar .... por mais simples que seja .... se a condição fornecida for verdadeira e a próxima instrução for aprovada, ela ignora esse valor ou iteração e prossegue para a próxima linha ..... Exemplo

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

Saída: Imprime todos os números ímpares de 1 a 100

Isso ocorre porque o módulo do número par é igual a zero; portanto, ele ignora o número e prossegue para o próximo número, pois o módulo de números ímpares não é igual a zero, a parte Else do loop é executada e é impressa.

Aqui está um exemplo em que eu estava extraindo dados específicos de uma lista onde eu tinha vários tipos de dados (é o que eu chamaria em R - desculpe se é a nomenclatura errada) e eu queria extrair apenas dados inteiros / numéricos e NÃO 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, então fiz com que a máquina o fizesse subconjuntando 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 instrução pass no Python é usada quando uma instrução é necessária sintaticamente, mas você não deseja que nenhum comando ou código seja executado.

A declaração de aprovação é uma operação nula; nada acontece quando é executado. O passe também é útil em locais onde seu código acabará indo, mas ainda não foi gravado (por exemplo, em stubs, 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!"

Isso produzirá o seguinte resultado:

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 nenhuma instrução ou código se o valor da letra for 'h'. A declaração de aprovação é útil quando você cria um bloco de código, mas não é mais necessário.

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

pass é usado para evitar erros de indentação em python Se usarmos linguagens como c, c ++, java, elas têm chaves como

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

Mas em python, ele usava indentação em vez de chaves, para evitar esses erros que usamos pass. Lembrado como você estava jogando um questionário e

 if(dont_know_the_answer)
      pass

Programa de exemplo,

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