C'è un modo built-in o più Pythonic per provare ad analizzare una stringa su un intero

Question

Ho dovuto scrivere la seguente funzione per fallire con garbo quando si tenta di analizzare una stringa in un numero intero. Immagino che Python abbia qualcosa di costruito per farlo, ma non riesco a trovarlo. In caso contrario, esiste un modo più pitonico per fare ciò che non richiede una funzione separata?

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

La soluzione che ho utilizzato è stata una modifica della risposta di @ sharjeel. Quanto segue è funzionalmente identico, ma, penso, più leggibile.

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

Questo è uno scenario abbastanza regolare in modo ho scritto un decoratore "ignore_exception" che funziona per tutti i tipi di funzioni che gettano eccezioni invece di fallire con garbo:

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 nel tuo caso:

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

Answer 2

int() è il modo built-in e pythonic, proprio come si ha lì.

Di solito è più facile e più comune usare direttamente però:

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, è già perfetta. Tuttavia, il parametro val potrebbe essere definito come predefinito.

documentato nella documentazione ufficiale semplicemente come int(x) -- x converted to integer

Answer 4

vorrei andare per:

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

Ma è più o meno la stessa cosa.

Answer 5

Questo è il modo pitonico. In Python, è consuetudine usare lo stile EAFP: è più facile chiedere perdono che autorizzazione.
Ciò significa che proverai prima, e poi ripulisci il pasticcio se necessario.

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()]