Comment utiliser l'instruction pass?

Je suis en train d'apprendre Python et j'ai atteint la section concernant la passdéclaration. Le guide que j'utilise le définit comme étant une Nullinstruction couramment utilisée comme espace réservé.

Je ne comprends toujours pas bien ce que cela signifie. Quelqu'un peut-il me montrer une situation simple / basique où la passdéclaration serait utilisée et pourquoi elle est nécessaire?

Supposons que vous concevez une nouvelle classe avec des méthodes que vous ne souhaitez pas encore implémenter.

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

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

Si vous omettiez le pass, le code ne s'exécuterait pas.

Vous obtiendrez alors un:

IndentationError: expected an indented block

Pour résumer, la passdéclaration n'a rien de particulier, mais elle peut agir comme un espace réservé, comme démontré ici.

Python a l'exigence syntaxiques blocs de code (après if, except, def, classetc.) ne peuvent pas être vides. Les blocs de code vides sont cependant utiles dans une variété de contextes différents, comme dans les exemples ci-dessous, qui sont les cas d'utilisation les plus fréquents que j'ai vus.

Par conséquent, si rien n'est censé se produire dans un bloc de code, un passest nécessaire pour qu'un tel bloc ne produise pas de IndentationError. Alternativement, n'importe quelle instruction (y compris juste un terme à évaluer, comme le Ellipsislittéral ...ou une chaîne, le plus souvent une docstring) peut être utilisée, mais cela passindique clairement que rien n'est censé se produire et n'a pas besoin d'être réellement évalué et (au moins temporairement) stocké en mémoire.

• Ignorer (tout ou) un certain type de Exception(exemple de xml):

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

  Remarque: Ignorer tous les types de relances, comme dans l'exemple suivant de pandas, est généralement considéré comme une mauvaise pratique, car il intercepte également les exceptions qui devraient probablement être transmises à l'appelant, par exemple KeyboardInterruptou SystemExit(ou même HardwareIsOnFireError- Comment savez-vous que vous n'êtes pas s'exécutant sur une boîte personnalisée avec des erreurs spécifiques définies, que certaines applications appelantes voudraient connaître?).

  try:
      os.unlink(filename_larry)
  except:
      pass
  

  Au lieu de cela, utiliser au moins except Error:ou dans ce cas de préférence except OSError:est considéré comme une bien meilleure pratique. Une analyse rapide de tous les modules python que j'ai installés m'a donné que plus de 10% de toutes les except ...: passinstructions interceptent toutes les exceptions, donc c'est toujours un modèle fréquent dans la programmation python.

• Dériver une classe d'exception qui n'ajoute pas de nouveau comportement (par exemple dans scipy):

  class CompileError(Exception):
      pass
  

  De même, les classes conçues comme classe de base abstraite ont souvent une __init__méthode explicite vide ou autre que les sous-classes sont censées dériver. (par exemple pebl)

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

• Tester ce code s'exécute correctement pour quelques valeurs de test, sans se soucier des résultats (de mpmath):

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

• Dans les définitions de classe ou de fonction, souvent une docstring est déjà en place comme instruction obligatoire à exécuter comme seule chose dans le bloc. Dans de tels cas, le bloc peut contenir pass en plus de la docstring afin de dire «Ceci est en effet destiné à ne rien faire», par exemple dans pebl:

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

• Dans certains cas, passest utilisé comme espace réservé pour dire "Cette méthode / classe / if-block / ... n'a pas encore été implémentée, mais ce sera l'endroit pour le faire", bien que je préfère personnellement le Ellipsislittéral ...afin de faire une distinction stricte entre ceci et le «no-op» intentionnel dans l'exemple précédent. ( Notez que le littéral Ellipsis est une expression valide uniquement en Python 3 )
  Par exemple, si j'écris un modèle en traits larges, je pourrais écrire

  def update_agent(agent):
      ... 
  

  où d'autres pourraient avoir

  def update_agent(agent):
      pass
  

  avant

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

  comme rappel pour remplir la update_agentfonction ultérieurement, mais exécutez déjà quelques tests pour voir si le reste du code se comporte comme prévu. (Une troisième option pour ce cas est raise NotImplementedError. Ceci est utile en particulier pour deux cas: Soit «Cette méthode abstraite doit être implémentée par chaque sous-classe, il n'y a pas de façon générique de la définir dans cette classe de base» , ou «Cette fonction, avec ce nom n'est pas encore implémenté dans cette version, mais voici à quoi ressemblera sa signature » )

Outre son utilisation comme espace réservé pour les fonctions non implémentées, passpeut être utile pour remplir une instruction if-else ("Explicit vaut mieux qu'implicite.")

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

Bien sûr, dans ce cas, on utiliserait probablement returnau lieu d'une affectation, mais dans les cas où une mutation est souhaitée, cela fonctionne mieux.

L'utilisation de passici est particulièrement utile pour avertir les futurs responsables (y compris vous-même!) De ne pas mettre des étapes redondantes en dehors des instructions conditionnelles. Dans l'exemple ci-dessus, flagest défini dans les deux cas spécifiquement mentionnés, mais pas dans le cas else. Sans utilisation pass, un futur programmeur pourrait se déplacer flag = Trueen dehors de la condition, ce qui se produira flagdans tous les cas.

Un autre cas est avec la fonction passe-partout souvent vue au bas d'un fichier:

if __name__ == "__main__":
    pass

Dans certains fichiers, il peut être judicieux de laisser cela passpour permettre une édition plus facile plus tard, et pour rendre explicite que rien ne devrait se produire lorsque le fichier est exécuté seul.

Enfin, comme mentionné dans d'autres réponses, il peut être utile de ne rien faire lorsqu'une exception est interceptée:

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

La façon la meilleure et la plus précise de penser passest de dire explicitement à l'interprète de ne rien faire. De la même manière le code suivant:

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

signifie "si j'appelle la fonction foo (x, y), additionne les deux nombres que les étiquettes x et y représentent et restitue le résultat",

def bar():
    pass

signifie "Si j'appelle la barre de fonctions (), ne faites absolument rien."

Les autres réponses sont tout à fait correctes, mais elles sont également utiles pour certaines choses qui n'impliquent pas de conservation de place.

Par exemple, dans un peu de code sur lequel j'ai travaillé récemment, il était nécessaire de diviser deux variables, et il était possible que le diviseur soit nul.

c = a / b

produira évidemment une ZeroDivisionError si b vaut zéro. Dans cette situation particulière, laisser c comme zéro était le comportement souhaité dans le cas où b était zéro, j'ai donc utilisé le code suivant:

try:
    c = a / b
except ZeroDivisionError:
    pass

Une autre utilisation, moins standard, est un endroit pratique pour mettre un point d'arrêt pour votre débogueur. Par exemple, je voulais qu'un peu de code pénètre dans le débogueur à la 20e itération d'une instruction for ... in. Donc:

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

avec le point d'arrêt sur passe.

Un cas d'utilisation courant où il peut être utilisé «tel quel» est de remplacer une classe juste pour créer un type (qui est par ailleurs le même que la superclasse), par exemple

class Error(Exception):
    pass

Vous pouvez donc lever et intercepter des Errorexceptions. Ce qui importe ici, c'est le type d'exception plutôt que le contenu.

passen Python ne fait fondamentalement rien, mais contrairement à un commentaire, il n'est pas ignoré par l'interpréteur. Vous pouvez donc en profiter dans de nombreux endroits en en faisant un espace réservé:

1: Peut être utilisé en classe

   class TestClass: 
      pass

2: Peut être utilisé dans les instructions en boucle et conditionnelles:

   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: Peut être utilisé en fonction:

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

passest surtout utilisé lorsque le programmeur ne veut pas donner d'implémentation pour le moment mais veut toujours créer une certaine classe / fonction / instruction conditionnelle qui peut être utilisée plus tard. Étant donné que l'interpréteur Python ne permet pas l'instruction classe / fonction / conditionnelle vide ou non implémentée, il donne une erreur:

IndentationError: attendu un bloc en retrait

pass peut être utilisé dans de tels scénarios.

Vous pouvez dire que passer signifie une opération NOP (No Operation). Vous obtiendrez une image claire après cet exemple: -

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

Maintenant, comment allez-vous écrire cela en 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 "

Mais votre code donnera une erreur car il nécessitait un bloc en retrait après elif . Voici le rôle du mot - clé 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 "

Maintenant, je pense que c'est clair pour vous.

J'aime l'utiliser lors de la suppression de tests. Je suis souvent conscient de ce que j'aimerais tester, mais je ne sais pas trop comment le faire. L'exemple de test ressemble à ce que sebastian_oe a suggéré

class TestFunctions(unittest.TestCase):

   def test_some_feature(self):
      pass

   def test_some_other_feature(self):
      pass

L'instruction pass ne fait rien. Il peut être utilisé lorsqu'une instruction est requise syntaxiquement mais que le programme ne nécessite aucune action.

Honnêtement, je pense que les documents officiels de Python le décrivent assez bien et fournissent quelques exemples:

L' instruction pass ne fait rien. Il peut être utilisé lorsqu'une instruction est requise syntaxiquement mais que le programme ne nécessite aucune action. Par exemple:

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

Ceci est couramment utilisé pour créer des classes minimales:

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

Un autre espace pass peut être utilisé comme un espace réservé pour une fonction ou un corps conditionnel lorsque vous travaillez sur un nouveau code, vous permettant de continuer à penser à un niveau plus abstrait. La passe est silencieusement ignorée:

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

comme le dit le livre, je ne l'utilise que comme un espace réservé temporaire, à savoir,

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

puis remplir plus tard le scénario où var == 2000

Pass fait référence à ignorer .... aussi simple que cela soit .... si la condition donnée est vraie et que la prochaine instruction est pass, elle ignore cette valeur ou itération et passe à la ligne suivante ..... Exemple

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

Sortie: imprime tous les nombres impairs de 1 à 100

C'est parce que le module du nombre pair est égal à zéro, donc il ignore le nombre et passe au nombre suivant, puisque le module des nombres impairs n'est pas égal à zéro, la partie Else de la boucle est exécutée et imprimée

Voici un exemple où j'extrayais des données particulières d'une liste où j'avais plusieurs types de données (c'est ce que j'appellerais dans R-- désolé si c'est la mauvaise nomenclature) et je voulais extraire uniquement des entiers / des données numériques et NON des caractères .

Les données ressemblaient à:

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

Je voulais supprimer tous les caractères alphabétiques, j'ai donc demandé à la machine de le faire en sous-configurant les données et en "passant" les données alphabétiques:

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'instruction pass en Python est utilisée lorsqu'une instruction est requise syntaxiquement mais que vous ne voulez exécuter aucune commande ni aucun code.

L'instruction pass est une opération nulle; rien ne se passe quand il s'exécute. Le pass est également utile dans les endroits où votre code finira par aller, mais n'a pas encore été écrit (par exemple, dans les talons par exemple):

`Exemple:

#!/usr/bin/python

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

print "Good bye!"

Cela produira le résultat suivant:

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

Le code précédent n'exécute aucune instruction ou code si la valeur de la lettre est «h». L'instruction pass est utile lorsque vous avez créé un bloc de code mais qu'il n'est plus nécessaire.

Vous pouvez ensuite supprimer les instructions à l'intérieur du bloc, mais laisser le bloc avec une instruction pass afin qu'il n'interfère pas avec les autres parties du code.

pass est utilisé pour éviter les erreurs d'indentation en python Si nous prenons des langages comme c, c ++, java, ils ont des accolades comme

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

Mais en python, il a utilisé l'indentation au lieu des accolades, donc pour éviter de telles erreurs, nous utilisons pass. Souvenez-vous que vous jouiez à un quiz et

 if(dont_know_the_answer)
      pass

Exemple de programme,

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