python exception de catch et de continuer à essayer de bloquer

Non, vous ne pouvez pas le faire. C'est juste la façon Python a sa syntaxe. Une fois que vous quittez un essai bloc à cause d'une exception, il est impossible de revenir en.

À propos d'une boucle for si?

funcs = do_smth1, do_smth2

for func in funcs:
    try:
        func()
    except Exception:
        pass  # or you could use 'continue'

Notez cependant qu'il est considéré comme une mauvaise pratique d'avoir un nu -except. Vous devez attraper d'une exception spécifique au lieu. J'ai capturé pour Exception parce que c'est aussi bien que je peux le faire sans savoir de quoi exceptions près, les méthodes de pourrait lancer.

Vous pouvez obtenir ce que vous voulez, mais avec une syntaxe différente. Vous pouvez utiliser un "enfin" bloc après le try/except. Faire de cette façon, python va exécuter le bloc de code, quelle que soit la levée de l'exception, ou pas.

Comme ceci:

try:
    do_smth1()
except:
    pass
finally:
    do_smth2()

Mais, si vous voulez exécuter do_smth2() uniquement si l'exception n'était pas levée, l'utilisation d'un "autre" bloc:

try:
    do_smth1()
except:
    pass
else:
    do_smth2()

Vous pouvez les mélanger trop, dans un try/except/else/clause finally.
Amusez-vous!

une façon pour vous de le gérer est avec un générateur. Au lieu d'appeler la fonction, le rendement; ensuite, quelle est la consommation de la génératrice peut envoyer le résultat de l'appel de nouveau dans le générateur, ou une sentinelle si le générateur a échoué: Le trampoline qui accomplit le ci-dessus ne ressemble à:

def consume_exceptions(gen):
    action = next(gen)
    while True:
        try:
            result = action()
        except Exception:
            # if the action fails, send a sentinel
            result = None

        try:
            action = gen.send(result)
        except StopIteration:
            # if the generator is all used up, result is the return value.
            return result

un générateur qui serait compatible avec ce ressemblerait à ceci:

def do_smth1():
    1 / 0

def do_smth2():
    print "YAY"

def do_many_things():
    a = yield do_smth1
    b = yield do_smth2
    yield "Done"

>>> consume_exceptions(do_many_things())
YAY

Noter que do_many_things() ne pas appel do_smth*, c'seulement les rendements, et consume_exceptions appels sur son nom

En fonction de où et comment vous devez le faire, vous pourriez aussi écrire une fonction qui le fait pour vous:

def live_dangerously(fn, *args, **kw):
    try:
        return fn(*args, **kw)
    except Exception:
        pass

live_dangerously(do_smth1)
live_dangerously(do_smth2)

Mais comme d'autres réponses ont noté, ayant une valeur null except est généralement un signe de quelque chose d'autre qui est erroné avec votre code.

special_func pour éviter essayez-à l'exception de la répétition:

def special_func(test_case_dict):
    final_dict = {}
    exception_dict = {}

    def try_except_avoider(test_case_dict):

        try:
            for k,v in test_case_dict.items():
                final_dict[k]=eval(v) #If no exception evaluate the function and add it to final_dict

        except Exception as e:
            exception_dict[k]=e #extract exception
            test_case_dict.pop(k)
            try_except_avoider(test_case_dict) #recursive function to handle remaining functions

        finally:  #cleanup
            final_dict.update(exception_dict)
            return final_dict #combine exception dict and  final dict

    return try_except_avoider(test_case_dict) 

Exécuter du code:

def add(a,b):
    return (a+b)
def sub(a,b):
    return (a-b)
def mul(a,b):
    return (a*b)

case = {"AddFunc":"add(8,8)","SubFunc":"sub(p,5)","MulFunc":"mul(9,6)"}
solution = special_func(case)

De sortie ressemble à ceci:

{'AddFunc': 16, 'MulFunc': 54, 'SubFunc': NameError("name 'p' is not defined")}

Pour convertir des variables:

locals().update(solution)

Variables ressemblerait à:

AddFunc = 16, MulFunc = 54, SubFunc = NameError("name 'p' is not defined")