Come usare l'istruzione pass?

Sto apprendendo Python e ho raggiunto la sezione passsull'affermazione. La guida che sto usando la definisce come Nullun'affermazione comunemente usata come segnaposto.

Comunque non capisco ancora cosa significhi. Qualcuno può mostrarmi una situazione semplice / di base in cui la passdichiarazione verrebbe utilizzata e perché è necessaria?

Supponiamo che tu stia progettando una nuova classe con alcuni metodi che non vuoi ancora implementare.

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

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

Se dovessi lasciare fuori il pass, il codice non verrebbe eseguito.

Riceverai quindi un:

IndentationError: expected an indented block

Per riassumere, l' passaffermazione non fa nulla di particolare, ma può fungere da segnaposto, come dimostrato qui.

Pitone ha l'esigenza sintattica che blocchi di codice (dopo if, except, def, classetc.) non possono essere vuoti. I blocchi di codice vuoti sono comunque utili in una varietà di contesti diversi, come negli esempi seguenti, che sono i casi d'uso più frequenti che ho visto.

Pertanto, se non si suppone che accada nulla in un blocco di codice, passè necessario che a tale blocco non produca un IndentationError. In alternativa, è possibile utilizzare qualsiasi istruzione (incluso solo un termine da valutare, come Ellipsisletterale ...o una stringa, il più delle volte un docstring), ma passciò chiarisce che effettivamente non dovrebbe succedere nulla e non deve essere effettivamente valutato e (almeno temporaneamente) memorizzato.

• Ignorando (tutto o) un certo tipo di Exception(esempio da xml):

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

  Nota: ignorare tutti i tipi di rilanci, come nell'esempio seguente pandas, è generalmente considerato una cattiva pratica, perché rileva anche le eccezioni che probabilmente dovrebbero essere passate al chiamante, ad esempio KeyboardInterrupto SystemExit(o anche HardwareIsOnFireError- Come fai a sapere che non lo sei in esecuzione su una casella personalizzata con errori specifici definiti, di cui l'applicazione chiamante vorrebbe sapere?).

  try:
      os.unlink(filename_larry)
  except:
      pass

  Invece usare almeno except Error:o in questo caso preferibilmente except OSError:è considerata una pratica molto migliore. Una rapida analisi di tutti i moduli Python che ho installato mi ha dato che oltre il 10% di tutte le except ...: passistruzioni rileva tutte le eccezioni, quindi è ancora un modello frequente nella programmazione di Python.

• Derivazione di una classe di eccezione che non aggiunge nuovi comportamenti (ad es. In scipy):

  class CompileError(Exception):
      pass

  Allo stesso modo, le classi intese come classe base astratta hanno spesso un vuoto esplicito __init__o altri metodi che si suppone derivino dalle sottoclassi. (ad es. pebl)

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

• Testare quel codice viene eseguito correttamente per alcuni valori di test, senza preoccuparsi dei risultati (da mpmath):

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

• Nelle definizioni di classe o funzione, spesso è già presente una docstring come istruzione obbligatoria da eseguire come unica cosa nel blocco. In tali casi, il blocco può contenere pass oltre alla docstring per dire "Questo è davvero destinato a non fare nulla". Ad esempio in pebl:

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

• In alcuni casi, passviene utilizzato come segnaposto per dire "Questo metodo / classe / if-block / ... non è stato ancora implementato, ma questo sarà il posto giusto per farlo", anche se preferisco personalmente il Ellipsisletterale ...per distinguere rigorosamente tra questo e il "no-op" intenzionale nell'esempio precedente. ( Notare che il valore letterale di Ellissi è un'espressione valida solo in Python 3 )
  Ad esempio, se scrivo un modello a grandi linee, potrei scrivere

  def update_agent(agent):
      ... 

  dove altri potrebbero avere

  def update_agent(agent):
      pass

  prima

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

  come promemoria per compilare la update_agentfunzione in un secondo momento, ma eseguire già alcuni test per vedere se il resto del codice si comporta come previsto. (Una terza opzione per questo caso è raise NotImplementedError. Ciò è utile in particolare per due casi: "Questo metodo astratto dovrebbe essere implementato da ogni sottoclasse, non esiste un modo generico per definirlo in questa classe di base" o "Questa funzione, con questo nome, non è ancora implementato in questa versione, ma è così che apparirà la sua firma ” )

Oltre al suo uso come segnaposto per funzioni non implementate, passpuò essere utile per compilare un'istruzione if-else ("Esplicito è meglio che implicito").

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

Naturalmente, in questo caso, si potrebbe probabilmente usare al returnposto del compito, ma nei casi in cui si desidera la mutazione, questo funziona meglio.

L'uso di passqui è particolarmente utile per avvertire i futuri manutentori (incluso te stesso!) Di non mettere passaggi ridondanti al di fuori delle dichiarazioni condizionali. Nell'esempio sopra, flagè impostato nei due casi specificamente menzionati, ma non in else-case. Senza usare pass, un futuro programmatore potrebbe spostarsi flag = Trueal di fuori della condizione, impostando così flagin tutti i casi.

Un altro caso riguarda la funzione boilerplate, spesso visualizzata nella parte inferiore di un file:

if __name__ == "__main__":
    pass

In alcuni file, potrebbe essere utile lasciarlo lì passper consentire una modifica più semplice in un secondo momento e rendere esplicito che non dovrebbe succedere nulla quando il file viene eseguito da solo.

Infine, come menzionato in altre risposte, può essere utile non fare nulla quando viene rilevata un'eccezione:

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

Il modo migliore e più accurato di pensare passè un modo per dire esplicitamente all'interprete di non fare nulla. Allo stesso modo il seguente codice:

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

significa "se chiamo la funzione foo (x, y), somma i due numeri che rappresentano le etichette xey e restituisco il risultato",

def bar():
    pass

significa "Se chiamo la barra delle funzioni (), non faccio assolutamente nulla."

Le altre risposte sono abbastanza corrette, ma è anche utile per alcune cose che non implicano il mantenimento del posto.

Ad esempio, in un po 'di codice su cui ho lavorato di recente, era necessario dividere due variabili ed era possibile che il divisore fosse zero.

c = a / b

produrrà ovviamente ZeroDivisionError se b è zero. In questa situazione particolare, lasciare c come zero era il comportamento desiderato nel caso in cui b fosse zero, quindi ho usato il seguente codice:

try:
    c = a / b
except ZeroDivisionError:
    pass

Un altro utilizzo meno standard è un comodo punto di riferimento per il debugger. Ad esempio, volevo che un po 'di codice entrasse nel debugger nella 20esima iterazione di una dichiarazione for ... in. Così:

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

con il punto di interruzione al passaggio.

Un caso d'uso comune in cui può essere usato "così com'è" è quello di sovrascrivere una classe solo per creare un tipo (che è altrimenti uguale alla superclasse), ad es.

class Error(Exception):
    pass

Quindi puoi sollevare e catturare Erroreccezioni. Ciò che conta qui è il tipo di eccezione, piuttosto che il contenuto.

passin Python praticamente non fa nulla, ma a differenza di un commento non viene ignorato dall'interprete. Quindi puoi trarne vantaggio in molti posti rendendolo un segnaposto:

1: può essere utilizzato in classe

   class TestClass: 
      pass

2: può essere utilizzato in istruzioni loop e condizionali:

   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: può essere utilizzato in funzione:

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

passviene utilizzato principalmente quando il programmatore non vuole dare l'implementazione al momento, ma desidera comunque creare una determinata istruzione di classe / funzione / condizionale che può essere utilizzata in seguito. Poiché l'interprete Python non consente l'istruzione di classe / funzione / condizionale vuota o non implementata, dà un errore:

IndentationError: previsto un blocco rientrato

pass può essere utilizzato in tali scenari.

Si può dire che passare significa operazione NOP (nessuna operazione). Otterrai un'immagine chiara dopo questo esempio: -

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

Ora come lo scriverai in 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 "

Ma il tuo codice darà errore perché ha richiesto un blocco rientrato dopo elif . Ecco il ruolo della parola chiave 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 "

Ora penso che sia chiaro per te.

Mi piace usarlo per superare i test. Spesso sono consapevole di ciò che vorrei testare, ma non so come farlo. L'esempio di test appare come suggerito da sebastian_oe

class TestFunctions(unittest.TestCase):

   def test_some_feature(self):
      pass

   def test_some_other_feature(self):
      pass

L'istruzione pass non fa nulla. Può essere utilizzato quando un'istruzione è richiesta sintatticamente ma il programma non richiede alcuna azione.

Onestamente, penso che i documenti ufficiali di Python lo descrivano abbastanza bene e forniscano alcuni esempi:

L' istruzione pass non fa nulla. Può essere utilizzato quando un'istruzione è richiesta sintatticamente ma il programma non richiede alcuna azione. Per esempio:

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

Questo è comunemente usato per creare classi minime:

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

Un altro segnaposto può essere utilizzato come segnaposto per una funzione o un corpo condizionale quando si lavora su un nuovo codice, consentendo di continuare a pensare a un livello più astratto. Il pass viene silenziosamente ignorato:

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

come diceva il libro, lo uso sempre e solo come segnaposto temporaneo, ovvero

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

e successivamente riempire lo scenario in cui var == 2000

Passa si riferisce a ignora .... per quanto sia semplice .... se la condizione data è vera e la successiva istruzione viene ignorata quel valore o iterazione e passa alla riga successiva ..... Esempio

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

Uscita: stampa tutti i numeri dispari da 1 a 100

Questo perché il modulo del numero pari è uguale a zero, quindi ignora il numero e procede al numero successivo, poiché il modulo dei numeri dispari non è uguale a zero viene eseguita la parte Else del ciclo e la sua stampa

Ecco un esempio in cui stavo estraendo dati particolari da un elenco in cui avevo più tipi di dati (è quello che chiamerei R in-- scusate se è la nomenclatura sbagliata) e volevo estrarre solo numeri interi / numerici e NON caratteri .

I dati sembravano:

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

Volevo rimuovere tutti i caratteri alfabetici, quindi l'ho fatto fare dalla macchina sottoponendo i dati e "passando" sopra i dati alfabetici:

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

L'istruzione pass in Python viene utilizzata quando un'istruzione è richiesta sintatticamente ma non si desidera eseguire alcun comando o codice.

L'istruzione pass è un'operazione nulla; non succede nulla quando viene eseguito. Il pass è utile anche nei luoghi in cui il tuo codice alla fine andrà, ma non è stato ancora scritto (ad esempio, negli stub per esempio):

`Esempio:

#!/usr/bin/python

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

print "Good bye!"

Questo produrrà il seguente risultato:

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

Il codice precedente non esegue alcuna istruzione o codice se il valore della lettera è 'h'. L'istruzione pass è utile quando è stato creato un blocco di codice ma non è più necessario.

È quindi possibile rimuovere le istruzioni all'interno del blocco ma lasciare che il blocco rimanga con un'istruzione pass in modo che non interferisca con altre parti del codice.

pass viene usato per evitare errori di rientro in python Se prendiamo lingue come c, c ++, java hanno parentesi graffe come

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

Ma in Python ha usato il rientro anziché le parentesi graffe, quindi per evitare tali errori usiamo pass. Ricordato mentre giocavi a un quiz e

 if(dont_know_the_answer)
      pass

Programma di esempio,

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