Gibt es eine eingebaute oder mehr Pythonic Weg zu versuchen, eine Zeichenfolge zu einer ganzen Zahl zu analysieren

Question

Ich musste die folgende Funktion schreiben, um beim Analysieren einer Zeichenfolge zu einer ganzen Zahl ordnungsgemäß fehlschlagen. Ich könnte mir vorstellen, dass Python etwas eingebaut hat, aber ich kann es nicht finden. Wenn nicht, gibt es einen pythonischen Weg, dies zu tun, der keine separate Funktion erfordert?

Die Lösung, die ich am Ende benutzte, war eine Modifikation von @ sharjeels Antwort. Das Folgende ist funktional identisch, aber ich denke, lesbarer.

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

Dies ist ein ziemlich normales Szenario so dass ich einen „ignore_exception“ Dekorateur habe geschrieben, die für alle Arten von Funktionen arbeitet, die anmutig Ausnahmen statt andernfalls werfen:

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 

Verwendung in Ihrem Fall:

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

Answer 2

int() ist der eingebaute und pythonische Weg, genau wie Sie dort haben.

Es ist in der Regel leichter und häufiger es aber direkt zu verwenden:

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

Nein, es bereits perfekt ist. Der Parameter val könnte jedoch besser als Standard benannt werden.

in den offiziellen Dokumenten Dokumentierten einfach als int(x) -- x converted to integer

Answer 4

ich gehen würde:

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

Aber es ist mehr oder weniger das gleiche.

Answer 5

Das ist der pythonische Weg. In Python ist es üblich, EAFP-Stil zu verwenden - Leichter zu Vergeben als Erlaubnis.
Das bedeutet, Sie würden zuerst versuchen, und dann die Unordnung aufräumen, wenn nötig.

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