Wie versuche ich es nach einer Ausnahme erneut?

Ich habe eine Schleife beginnend mit for i in range(0, 100). Normalerweise läuft es korrekt, aber manchmal schlägt es aufgrund von Netzwerkbedingungen fehl. Derzeit habe ich es so eingestellt, dass es bei einem Fehler continuein der Ausnahmeklausel angezeigt wird (weiter mit der nächsten Nummer für i).

Kann ich die gleiche Nummer neu zuweisen iund die fehlgeschlagene Iteration der Schleife erneut durchlaufen?

Führen Sie eine while Truefor-Schleife durch, fügen Sie Ihren tryCode ein und brechen Sie diese whileSchleife erst ab, wenn Ihr Code erfolgreich ist.

for i in range(0,100):
    while True:
        try:
            # do stuff
        except SomeSpecificException:
            continue
        break

Ich ziehe es vor, die Anzahl der Wiederholungsversuche zu begrenzen, damit Sie, wenn es ein Problem mit diesem bestimmten Element gibt, schließlich mit dem nächsten fortfahren, also:

for i in range(100):
  for attempt in range(10):
    try:
      # do thing
    except:
      # perhaps reconnect, etc.
    else:
      break
  else:
    # we failed all the attempts - deal with the consequences.

Das Wiederholungspaket ist eine gute Möglichkeit, einen Codeblock bei einem Fehler erneut zu versuchen .

Beispielsweise:

@retry(wait_random_min=1000, wait_random_max=2000)
def wait_random_1_to_2_s():
    print("Randomly wait 1 to 2 seconds between retries")

Hier ist eine ähnliche Lösung wie bei anderen, die jedoch die Ausnahme auslöst, wenn die vorgeschriebene Anzahl nicht erreicht wird oder es erneut versucht wird.

tries = 3
for i in range(tries):
    try:
        do_the_thing()
    except KeyError as e:
        if i < tries - 1: # i is zero indexed
            continue
        else:
            raise
    break

Der "funktionalere" Ansatz, ohne diese hässlichen while-Schleifen zu verwenden:

def tryAgain(retries=0):
    if retries > 10: return
    try:
        # Do stuff
    except:
        retries+=1
        tryAgain(retries)

tryAgain()

Der klarste Weg wäre, explizit festzulegen i. Beispielsweise:

i = 0
while i < 100:
    i += 1
    try:
        # do stuff

    except MyException:
        continue

Eine generische Lösung mit Timeout:

import time

def onerror_retry(exception, callback, timeout=2, timedelta=.1):
    end_time = time.time() + timeout
    while True:
        try:
            yield callback()
            break
        except exception:
            if time.time() > end_time:
                raise
            elif timedelta > 0:
                time.sleep(timedelta)

Verwendung:

for retry in onerror_retry(SomeSpecificException, do_stuff):
    retry()

for _ in range(5):
    try:
        # replace this with something that may fail
        raise ValueError("foo")

    # replace Exception with a more specific exception
    except Exception as e:
        err = e
        continue

    # no exception, continue remainder of code
    else:
        break

# did not break the for loop, therefore all attempts
# raised an exception
else:
    raise err

Meine Version ähnelt mehreren der oben genannten, verwendet jedoch keine separate whileSchleife und löst die neueste Ausnahme erneut aus, wenn alle Wiederholungsversuche fehlschlagen. Könnte explizit err = Noneoben gesetzt werden, ist aber nicht unbedingt erforderlich, da es den letzten elseBlock nur ausführen sollte, wenn ein Fehler aufgetreten errist und daher gesetzt ist.

In der Python Decorator-Bibliothek gibt es etwas Ähnliches .

Bitte beachten Sie, dass nicht auf Ausnahmen geprüft wird, sondern auf den Rückgabewert. Es wird wiederholt, bis die dekorierte Funktion True zurückgibt.

Eine leicht modifizierte Version sollte den Trick machen.

Verwenden von while und einem Zähler:

count = 1
while count <= 3:  # try 3 times
    try:
        # do_the_logic()
        break
    except SomeSpecificException as e:
        # If trying 3rd time and still error?? 
        # Just throw the error- we don't have anything to hide :)
        if count == 3:
            raise
        count += 1

Rekursion verwenden

for i in range(100):
    def do():
        try:
            ## Network related scripts
        except SpecificException as ex:
            do()
    do() ## invoke do() whenever required inside this loop

Sie können das Python-Wiederholungspaket verwenden. Wiederholen

Es wurde in Python geschrieben, um das Hinzufügen von Wiederholungsverhalten zu nahezu allem zu vereinfachen.

Alternativen zu retrying: tenacityund backoff(Update 2020)

Die Wiederholungsbibliothek war früher der richtige Weg, hat aber leider einige Fehler und seit 2016 keine Updates mehr. Andere Alternativen scheinen Backoff und Hartnäckigkeit zu sein . Während des Schreibens hatte die Zähigkeit mehr GItHub-Sterne (2,3k gegenüber 1,2k) und wurde kürzlich aktualisiert, daher habe ich mich für die Verwendung entschieden. Hier ist ein Beispiel:

from functools import partial
import random # producing random errors for this example

from tenacity import retry, stop_after_delay, wait_fixed, retry_if_exception_type

# Custom error type for this example
class CommunicationError(Exception):
    pass

# Define shorthand decorator for the used settings.
retry_on_communication_error = partial(
    retry,
    stop=stop_after_delay(10),  # max. 10 seconds wait.
    wait=wait_fixed(0.4),  # wait 400ms 
    retry=retry_if_exception_type(CommunicationError),
)()


@retry_on_communication_error
def do_something_unreliable(i):
    if random.randint(1, 5) == 3:
        print('Run#', i, 'Error occured. Retrying.')
        raise CommunicationError()

Der obige Code gibt ungefähr Folgendes aus:

Run# 3 Error occured. Retrying.
Run# 5 Error occured. Retrying.
Run# 6 Error occured. Retrying.
Run# 6 Error occured. Retrying.
Run# 10 Error occured. Retrying.
.
.
.

Weitere Einstellungen für tenacity.retryfinden Sie auf der Seite mit der Hartnäckigkeit von GitHub .

Wenn Sie eine Lösung ohne verschachtelte Schleifen und breakmit Erfolg aufrufen möchten, können Sie einen schnellen Wrap retriablefür jedes iterable entwickeln. Hier ist ein Beispiel für ein Netzwerkproblem, auf das ich häufig stoße: Die gespeicherte Authentifizierung läuft ab. Die Verwendung würde so lauten:

client = get_client()
smart_loop = retriable(list_of_values):

for value in smart_loop:
    try:
        client.do_something_with(value)
    except ClientAuthExpired:
        client = get_client()
        smart_loop.retry()
        continue
    except NetworkTimeout:
        smart_loop.retry()
        continue

Ich benutze folgendes in meinen Codes,

   for i in range(0, 10):
    try:
        #things I need to do
    except ValueError:
        print("Try #{} failed with ValueError: Sleeping for 2 secs before next try:".format(i))
        time.sleep(2)
        continue
    break

Hier ist meine Meinung zu diesem Thema. Die folgende retryFunktion unterstützt die folgenden Funktionen:

• Gibt den Wert der aufgerufenen Funktion zurück, wenn sie erfolgreich ist
• Löst die Ausnahme der aufgerufenen Funktion aus, wenn die Versuche erschöpft sind
• Begrenzung der Anzahl der Versuche (0 für unbegrenzt)
• Warten Sie (linear oder exponentiell) zwischen den Versuchen
• Wiederholen Sie diesen Vorgang nur, wenn die Ausnahme eine Instanz eines bestimmten Ausnahmetyps ist.
• Optionale Protokollierung von Versuchen

import time

def retry(func, ex_type=Exception, limit=0, wait_ms=100, wait_increase_ratio=2, logger=None):
    attempt = 1
    while True:
        try:
            return func()
        except Exception as ex:
            if not isinstance(ex, ex_type):
                raise ex
            if 0 < limit <= attempt:
                if logger:
                    logger.warning("no more attempts")
                raise ex

            if logger:
                logger.error("failed execution attempt #%d", attempt, exc_info=ex)

            attempt += 1
            if logger:
                logger.info("waiting %d ms before attempt #%d", wait_ms, attempt)
            time.sleep(wait_ms / 1000)
            wait_ms *= wait_increase_ratio

Verwendung:

def fail_randomly():
    y = random.randint(0, 10)
    if y < 10:
        y = 0
    return x / y


logger = logging.getLogger()
logger.setLevel(logging.INFO)
logger.addHandler(logging.StreamHandler(stream=sys.stdout))

logger.info("starting")
result = retry.retry(fail_randomly, ex_type=ZeroDivisionError, limit=20, logger=logger)
logger.info("result is: %s", result)

Siehe meinen Beitrag für weitere Informationen.

Hier ist meine Idee, wie man das behebt:

j = 19
def calc(y):
    global j
    try:
        j = j + 8 - y
        x = int(y/j)   # this will eventually raise DIV/0 when j=0
        print("i = ", str(y), " j = ", str(j), " x = ", str(x))
    except:
        j = j + 1   # when the exception happens, increment "j" and retry
        calc(y)
for i in range(50):
    calc(i)

Ich habe kürzlich mit meinem Python an einer Lösung für dieses Problem gearbeitet und teile sie gerne mit Stackoverflow-Besuchern. Bitte geben Sie Feedback, wenn dies erforderlich ist.

print("\nmonthly salary per day and year converter".title())
print('==' * 25)


def income_counter(day, salary, month):
    global result2, result, is_ready, result3
    result = salary / month
    result2 = result * day
    result3 = salary * 12
    is_ready = True
    return result, result2, result3, is_ready


i = 0
for i in range(5):
    try:
        month = int(input("\ntotal days of the current month: "))
        salary = int(input("total salary per month: "))
        day = int(input("Total Days to calculate> "))
        income_counter(day=day, salary=salary, month=month)
        if is_ready:
            print(f'Your Salary per one day is: {round(result)}')
            print(f'your income in {day} days will be: {round(result2)}')
            print(f'your total income in one year will be: {round(result3)}')
            break
        else:
            continue
    except ZeroDivisionError:
        is_ready = False
        i += 1
        print("a month does'nt have 0 days, please try again")
        print(f'total chances left: {5 - i}')
    except ValueError:
        is_ready = False
        i += 1
        print("Invalid value, please type a number")
        print(f'total chances left: {5 - i}')

Erhöhen Sie Ihre Schleifenvariable nur, wenn die try-Klausel erfolgreich ist