python essayer: à l'exception: de la passe, sur multi ligne try

J'ai un bloc d'instructions dans un try: except KeyError: pass bloc et je voulais savoir comment je pourrait avoir Python tentative d'exécuter du code après la ligne qui lève l'exception.

Pour l'e.g

try:
  print "entering try block"
  print this_var_does_not_exists
  print "past exception"
except:
  pass

Je veux essayer et d'impression "past exception".

Lorsque j'exécute le code ci-dessus, il n'imprime que 'entering try block'

Déplacer l'instruction print à except bloc.
exception levée moyen soulevé...il n'y a aucun moyen de faire ce que vous voulez.
Mais ensuite il l'habitude de l'exécuter si la variable n'existe pas. Je suis en fait l'analyse d'un fichier XML dans certaines réponses de certaines des principales existent et dans d'autres ils ne le font pas.
Et? C', il est facile de vérifier quelle que soit la condition est nécessaire, sans l'aide de l'essayer..sauf...votre code est appearently cassé

InformationsquelleAutor wholly_cow | 2013-09-29

exception-handling python

13

Python ne vous autorise pas à entrer de nouveau l'échec d'un bloc. Au lieu de cela, vous pouvez faire un imbriquée try bloc:
```
try:
    print "before"
    try:
        print d['not-exist']
    except KeyError:
        pass
    print "after"
except OtherError:
    print "OtherError"
```
Notez que vous pouvez souvent éviter KeyErrors à l'aide de .get:
```
try:
    x = d['key']
except KeyError:
    x = 0
```
est équivalent à
```
x = d.get('key', 0)
```
En général, essayez de faire de votre try blocs aussi court que logiquement possible, si vous avez une meilleure chance de traiter les erreurs dans un lieu, localisée la mode.
- Génial. C'est ce dont j'avais besoin! - .obtenir 🙂
InformationsquelleAutor nneonneo

python supporte finally de blocs, qui sera exécuté même si il y a une exception dans le bloc try:

try:
  print "entering try block"
  print this_var_does_not_exists
except:
  pass
finally:
  print "past exception"

InformationsquelleAutor SheetJS

Vous pouvez également utiliser 'd'autre' pour un try/except bloc:

d={'a':1, 'b':2, 'd':4}

for k in 'abcd':
     try:
        print k, d[k],
     except KeyError:
        print '{} not there'.format(k)
     else:
        print 'I did it! Found {}'.format(k)

Imprime:

a 1 I did it! Found a
b 2 I did it! Found b
c c not there
d 4 I did it! Found d

En général, la pleine try/except/else/final set go comme ceci:

try:
    potential_error()
except ExceptionType:
    handle_that_error_somehow()
else:                            # 'else' to the except is SUCCESS
    # There was no error
    # handle success!
    handle_success()
finally:
    # success or failure -- do this
    regardless_something_we_always_need_to_do()

InformationsquelleAutor dawg

1

Vous ne pouvez pas le faire avec cette structure. Vous devez déplacer les extra print de la try bloc. La façon dont un try/except bloc fonctionne est que si une exception est levée, elle saute à la appropriée except bloc. Il n'y a aucun moyen de revenir en arrière. Si vous voulez continuer, vous devez mettre votre code dans l'exception ou un finally, ou après le bloc entier. Voici un exemple:
```
try:
  print "entering try block"
  print this_var_does_not_exists
finally:
  print "past exception"
```
Aussi, ne pas former l'habitude dangereuse de l'aide à nu except: clauses, en particulier avec pass comme leur seul contenu. Vous devez attraper les types d'exceptions, vous pouvez gérer, et puis gérer, pas aveuglément silence toutes les exceptions.

InformationsquelleAutor BrenBarn
0

à imprimer avec une chaîne littérale n'augmentera pas exception à la règle. Mettre essayez-sauf que dans la deuxième instruction print.
```
print "entering try block"
try:
  print this_var_does_not_exists
except:
    pass
print "past exception"
```
InformationsquelleAutor falsetru
0

Il suffit de le mettre après l'essai, à l'exception du bloc

InformationsquelleAutor Israel Unterman
0

Je peux imaginer une situation, quand en fait, il peut être utile d'exécuter de nombreuses tel un de la ligne de essayer-si l'on excepte sans besoin d'ajouter d'essai à l'exception du bloc à chaque fois.

Disons que vous avez un dictionnaire d et un objet o. L'objet a trois attributs: 'a', 'b' et 'c'. Dictionnaire d est généré à l'aide d'une fonction generate_dict() et peuvent avoir les clés suivantes: 'x', 'y' et 'z', mais vous ne savez pas lequel d'entre eux sont présents dans un dictionnaire. Vous voulez affecter la valeur de la touche 'x' à l'attribut 'a', 'y' à l'attribut "b", etc. Dans de tels cas, vous devez vous entourer chaque mission avec un try-catch, comme ceci:
```
o = Object()
d = generate_dict()
try:
    o.a = d['x']
except:
    pass
try:
    o.b = d['y']
except:
    pass
```
etc. Vous pouvez aussi remplacer essayez-extraits de vérifier si une clé existe dans le dictionnaire, mais le problème est toujours là. Ce qui se passe, si vous avez des dizaines de clés-les mappages d'attributs? Le nombre de lignes augmente rapidement.

Un autre moyen de ce code est de générer deux tables d'attributs et les noms de clés et d'exécuter le code dans une boucle à l'aide de fonction exec, comme ceci:
```
o = Object()
d = generate_dict()

attributeNames = ['a', 'b', 'c']
dataDictKeys = ['x', 'y', 'z']
for (attr, key) in zip(attributeNames, dataDictKeys):
    try:
        exec("o.{attr} = d['{key}']".format(attr = attr, key = key))
    except:
        pass
```
Alors que ce n'est pas une bonne pratique de codage, de faire de telles choses, toujours présent d'une certaine manière peut résoudre votre problème. Mais de l'utiliser avec prudence.

InformationsquelleAutor ytzml

Vous devez vous connecter pour publier un commentaire.