¿Hay una forma incorporada o más de Pythonic para intentar analizar una cadena a un número entero

Question

Tuve que escribir la siguiente función para que fallara graciosamente al intentar analizar una cadena en un entero. Me imagino que Python tiene algo incorporado para hacer esto, pero no puedo encontrarlo. Si no, ¿hay una forma más Pythonic de hacer esto que no requiere una función separada?

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

La solución que terminé usando fue una modificación de la respuesta de @ sharjeel. Lo siguiente es funcionalmente idéntico, pero, creo, más legible.

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

Este es un escenario bastante regular por lo que he escrito un decorador "ignore_exception" que funciona para todo tipo de funciones que generen excepciones en lugar de fallar con gracia:

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 

Uso en su caso:

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

Answer 2

int() es la manera incorporada y pitonica, como la que tiene allí.

Por lo general es más fácil y más común utilizar directamente sin embargo:

def show_square(user_input): 
    """Example of using int().""" 
    try: 
    num = int(user_input, 10) 
    except ValueError: 
    print "Error" # handle not-an-integer case 
    # or you may just want to raise an exception here 
    # or re-raise the ValueError 
    else: 
    print "Times two is", num * 2 

def another_example(user_input): 
    try: 
    num = int(user_input, 10) 
    except ValueError: 
    num = default 
    print "Times two is", num * 2 

Answer 3

No, ya es perfecto. Sin embargo, el parámetro val podría nombrarse mejor por defecto.

documentado en los documentos oficiales simplemente como int(x) -- x converted to integer

Answer 4

Yo iría por:

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

Pero es más o menos lo mismo.

Answer 5

Esa es la manera pitónica. En python, es costumbre utilizar el estilo EAFP: es más fácil pedir perdón que el permiso.
Eso significa que deberías probar primero y luego limpiar el desorden si es necesario.

Answer 6

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

Answer 7

def parseint(string): 
    result = '0' 
    for x in string: 
     if x.isdigit(): 
     result+=x 
    else: 
     return int(result) 
    return int(result) 

Answer 8

myList = ['12', '13', '5', 'hope', 'despair', '69','0', '1.2'] 

myInts = [int(x) for x in myList if x.isdigit()]