Existe-t-il une méthode Pythonique intégrée ou plus pour essayer d'analyser une chaîne en un entier

Question

J'ai dû écrire la fonction suivante pour échouer gracieusement en essayant d'analyser une chaîne en un entier. J'imagine que Python a quelque chose de intégré pour le faire, mais je ne le trouve pas. Sinon, y a-t-il une façon plus Pythonique de faire cela qui ne nécessite pas de fonction séparée?

 def try_parse_int(s, base=10, val=None):
  try:
    return int(s, base)
  except ValueError:
    return val
 

La solution que j'ai finalement utilisée était une modification de la réponse de @ sharjeel. Ce qui suit est fonctionnellement identique, mais, je pense, plus lisible.

 def ignore_exception(exception=Exception, default_val=None):
  """Returns a decorator that ignores an exception raised by the function it
  decorates.

  Using it as a decorator:

    @ignore_exception(ValueError)
    def my_function():
      pass

  Using it as a function wrapper:

    int_try_parse = ignore_exception(ValueError)(int)
  """
  def decorator(function):
    def wrapper(*args, **kwargs):
      try:
        return function(*args, **kwargs)
      except exception:
        return default_val
    return wrapper
  return decorator
 

Answer 1

Ceci est un scénario assez régulier, j'ai donc écrit un décorateur "ignore_exception" qui fonctionne pour toutes sortes de fonctions qui, grâce à des excpetions, au lieu d'échouer gracieusement:

 def ignore_exception(IgnoreException=Exception,DefaultVal=None):
    """ Decorator for ignoring exception from a function
    e.g.   @ignore_exception(DivideByZero)
    e.g.2. ignore_exception(DivideByZero)(Divide)(2/0)
    """
    def dec(function):
        def _dec(*args, **kwargs):
            try:
                return function(*args, **kwargs)
            except IgnoreException:
                return DefaultVal
        return _dec
    return dec
 

Utilisation dans votre cas:

 sint = ignore_exception(ValueError)(int)
print sint("Hello World") # prints none
print sint("1340") # prints 1340
 

Answer 2

def intTryParse(value):
    try:
        return int(value), True
    except ValueError:
        return value, False

Answer 3

C'est la voie pythonique. En python, il est habituel d'utiliser le style EAFP - Plus facile à demander pardon qu'à l'autorisation.
Cela signifie que vous essayez d'abord, puis nettoyez le gâchis si nécessaire.

Answer 4

J'irais pour:

 def parse_int(s, base=10, val=None):
 if s.isdigit():
  return int(s, base)
 else:
  return val
 

Mais c'est plus ou moins la même chose.

Answer 5

Non, c'est déjà parfait. Cependant, le paramètre val pourrait être mieux nommé par défaut.

Documenté dans les documents officiels simplement comme int (x) - x converti en entier