python try sauf en tant que fonction pour évaluer des expressions

Passez l'argument à function dans str et exécutez la fonction exec à l'intérieur

def try_or_zero(exp):
    try:
        exec(exp)
        return exp
    except:
        return 0

donc votre appel à la fonction sera comme ci-dessous try_or_zero ('1 == 2')

Pas besoin de s'embêter avec exec et d'autres choses, utilisez le fait que les fonctions python sont des objets et peuvent donc être passées en arguments

def try_or_zero(exp):
    try:
       return exp()
    except:
       return 0

Et appelez simplement try_or_zero(my_awesome_func) (sans le () pour votre méthode)

Vous pouvez y parvenir en enveloppant vos expressions dans une fonction. Par exemple:

try_or_zero(exp):
    try:
        eval(exp)  # exp must be a string, for example 'raise ValueError'
    except:
        return 0

Votre fonction try devrait également ressembler à ceci:

try_or_zero(ErrorTest)

OutPut: 0

Et mettez-le dans la fonction

 def try_catch(exp):
    try :
        exp()  # note the paranthesis
    except:
        return 0

Vous pouvez également le faire en utilisant la fonction eval (), mais vous devrez mettre votre code dans String.

def ErrorTest():
    # the expression you want to try
    raise Exception

Il semble que le problème soit que python n'a aucune forme d'évaluation paresseuse

Euh ... oui, mais peut-être pas sous la forme que vous attendez. Les arguments de fonction SONT en effet évalués avant d'être passés à la fonction, donc

# XXX : python3 only, python2 doesn't accept
# keyword args after *args

def try_or(func, *exceptions, default=0):
    if not exceptions:
        exceptions = (Exception,)  
    try:
        return func()
    except exceptions as e:
        return default

# adding lists is legit too,
# so here you may want an empty list as the return value
# instead
a = [1, 2, 3]
# but only to lists
b = ""

result = try_or(lambda: a + b, TypeError, default=[]))

sera en effet exécuté comme:

def try_or_zero(func, *exceptions):
    if not exceptions:
        exceptions = (Exception,)  
    try:
        return func()
    except exceptions as e:
        return 0


a = 42
b = "c"

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

result = try_or_zero(lambda: add(a, b), TypeError))

Maintenant, les fonctions python sont des objets simples (elles peuvent être utilisées comme variables, transmises comme arguments aux fonctions, etc.), et elles ne sont invoquées que lors de l'application de l'opérateur d'appel (les parenthèses, avec ou sans arguments) afin que vous puissiez passer une fonction à try_or_zero et laissez try_or_zero appeler la fonction:

a = 42
b = "c"

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

result = try_or_zero(lambda: add(a, b))

Maintenant, vous allez objecter que 1 / cela ne fonctionnera pas si la fonction attend des arguments et 2 / avoir à écrire une fonction juste pour cela est un PITA - et les deux objections sont valides. Espérons que Python dispose également d'un raccourci pour créer des fonctions anonymes simples constituées d'une seule expression (même si elle est arbitrairement complexe): lambda . De plus, les fonctions python (y compris les «fonctions lambda» - qui sont, techniquement, des fonctions simples) sont fermées - elles capturent le contexte dans lequel elles sont définies - il est donc assez facile de regrouper tout cela:

def try_or_zero(func):
    try:
        return func()
    except Exception as e:
        return 0

Une note latérale sur la gestion des exceptions:

D'abord, n'utilisez pas d'exception nue, au moins attrapez l' Exception (sinon vous pourriez empêcher certaines exceptions - comme SysExit - de fonctionner comme prévu).

De préférence également, n'attrapez que les exceptions exactes que vous attendez à un moment donné. Dans votre cas, vous voudrez peut-être passer un tuple d'exceptions que vous souhaitez ignorer, c'est-à-dire:

param = foo.bar()
try_or_zero(param)

ce qui empêchera votre code de masquer les erreurs inattendues.

Et enfin: vous pouvez également ajouter la prise en charge d'une valeur de retour différente de zéro dans le cas d'une exception (toutes les expressions ne sont pas censées renvoyer un int):

try_or_zero(foo.bar())