'Enfin' équivalent pour les instructions If / Elif en Python

Python ont une finally équivalent pour ses if/else états, semblable à ses try/except/finally déclarations? Quelque chose qui nous permettrait de simplifier ce:

 if condition1:
      do stuff
      clean up
 elif condition2:
      do stuff
      clean up
 elif condition3:
      do stuff
      clean up
 ...
 ...

 if condition1:
      do stuff
 elif condition2:
      do stuff
 elif condition3:
      do stuff
 ...
 ...
 finally:
      clean up

Où finally ne serait appelé seulement après qu'une condition est remplie et son "faire des trucs" exécuter? A l'inverse, si aucune condition n'est remplie, l' finally code n'est pas exécuté.

J'ai hate de le bec sur le blasphème, mais la meilleure façon dont je peux le décrire, c'est l'existence d'un GOTO déclaration à la fin de chaque bloc de "faire les choses" qui conduit à finally.

Essentiellement, il fonctionne comme le contraire d'un else déclaration. Alors que else n'est exécutée que si pas d'autres conditions sont remplies, ce serait être exécuté UNIQUEMENT SI une autre condition a été remplie.

source d'informationauteur nobillygreen | 2014-02-06

finally python

10

Il peut être fait totalement non-hackily comme ceci:
```
def function(x,y,z):
    if condition1:
        blah
    elif condition2:
        blah2
    else:
        return False

    #finally!
    clean up stuff.
```
À certains égards, pas aussi pratique, que vous devez utiliser une fonction distincte. Cependant, la bonne pratique de ne pas le faire trop longtemps les fonctions, de toute façon. La séparation de la logique en petits facilement lisible (généralement de maximum 1 page) les fonctions de test, de documenter et de comprendre les flux d'exécution est beaucoup plus facile.

Une chose d'être conscient, c'est que le finally clause ne sera pas obtenir de l'exécuter en cas d'exception. Pour faire ainsi, vous devez ajouter try: trucs là.

Votre logique est semblable à ceci:

cleanup = True
if condition1:
    do stuff
elif condition2:
    do stuff
elif condition3:
    do stuff
....
else:
    cleanup = False

if cleanup:
    do the cleanup

Moche, mais c'est ce que vous avez demandé

1

Une autre suggestion, qui pourrait vous convenir si les conditions sont pré-calculés.
```
if condition1:
    do stuff
elif condition2:
    do stuff
...
if any([condition1, condition2, ...]):
    clean_up
```
Ce serait une douleur si vous étiez l'évaluation des conditions dans le cadre de votre si déclarations, parce que dans ce cas, vous devez évaluer une seconde fois pour le any fonction...à moins que Python est plus intelligent que je ne le réalisent.

La réponse de mhlester a code répétitif, une version améliorée pourrait être comme suit:

class NoCleanUp(Exception):
    pass

try:
    if condition1:
        do stuff
    elif condition2:
        do stuff
    else:
        raise NoCleanUp
except NoCleanUp:
    pass
else:
    cleanup

Est cette horrible?

for _ in range(1):
    if condition1:
        do stuff
        break
    elif condition2:
        do stuff
        break
else:
    finally stuff

Comment à ce sujet?

class NoFinally(Exception):
    pass

try:
    if condition1:
        do stuff
        raise NoFinally
    elif condition2:
        do stuff
        raise NoFinally
except NoFinally:
    pass
else:
    finally

Honnêtement, je déteste ces deux

0

Comme ceci:
```
def stuff1:
  pass

def stuff2:
  pass

actions={condition1:stuff1, condition2:stuff2}

action = actions.get(condition, None)
if action:
  action()
  cleanup()
```
Mises en garde sont bien sûr que votre condition clés doivent être uniques. Vous pouvez contourner ce problème en ayant un ordre de priorité hiérarchie des actions dicts.

Un peu en retard à la fête, mais la question a été actif.

Habituellement je voudrais faire un gestionnaire de contexte comme ce

class CleanUp(object):

    class Cancel(Exception):
        pass

    def __init__(self, f_cleanup):
        self.f_cleanup = f_cleanup

    def __enter__(self):
        return self

    def __exit__(self, exception_type, exception_value, traceback):

        cancelled = exception_type and issubclass(exception_type, self.__class__.Cancel)

        if not cancelled:
            self.f_cleanup()

        return not exception_type or cancelled

    def cancel(self):
        raise self.__class__.Cancel

Et puis vous pouvez l'utiliser comme cette

def cleanup():
    print "Doing housekeeping"


with CleanUp(cleanup) as manager:
    if condition1:
        do stuff
    elif condition2:
        do stuff
    else:
        manager.cancel()

Vous devez vous connecter pour publier un commentaire.