Jak ponowić próbę po wyjątku?

Mam pętlę zaczynającą się od for i in range(0, 100). Zwykle działa poprawnie, ale czasami zawodzi z powodu warunków sieciowych. Obecnie mam to ustawione tak, że w przypadku awarii będzie continuew klauzuli wyjątku (przejdź do następnej liczby dla i).

Czy mogę ponownie przypisać ten sam numer ii ponownie przejść przez nieudaną iterację pętli?

Wykonaj while Truewewnątrz pętli for, umieść trykod w środku i zrywaj z whilepętli tylko wtedy, gdy kod się powiedzie.

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

Wolę ograniczyć liczbę ponownych prób, aby w przypadku problemu z tym konkretnym elementem ostatecznie przejść do następnego, a zatem:

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.

Pakiet Ponowna próba jest to dobry sposób, aby ponowić próbę blok kodu na niepowodzenie.

Na przykład:

@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")

Oto rozwiązanie podobne do innych, ale podniesie wyjątek, jeśli nie powiedzie się w przepisanej liczbie lub próbach.

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

Bardziej „funkcjonalne” podejście bez użycia tych brzydkich pętli while:

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

tryAgain()

Najwyraźniejszym sposobem byłoby jawne ustawienie i. Na przykład:

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

    except MyException:
        continue

Ogólne rozwiązanie z limitem czasu:

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)

Stosowanie:

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

Moja wersja jest podobna do kilku powyższych, ale nie używa osobnej whilepętli i ponownie podnosi ostatni wyjątek, jeśli wszystkie próby się nie powiodą. Można jawnie ustawić err = Nonena górze, ale nie jest to absolutnie konieczne, ponieważ powinien wykonać ostatni elseblok tylko wtedy, gdy wystąpił błąd i dlatego errjest ustawiony.

Jest coś podobnego w Python Decorator Library .

Pamiętaj, że nie testuje wyjątków, ale wartość zwracaną. Spróbuje, dopóki dekorowana funkcja nie zwróci True.

Lekko zmodyfikowana wersja powinna załatwić sprawę.

Korzystanie z rekurencji

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

Używanie while i licznika:

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

Możesz użyć pakietu ponownej próby w Pythonie. Ponowna próba

Jest napisany w Pythonie, aby uprościć zadanie dodawania zachowania ponownych prób do niemal wszystkiego.

Alternatywy dla retrying: tenacityi backoff(aktualizacja 2020)

Ponawianie biblioteka była poprzednio do zrobienia, ale niestety ma kilka błędów i nie ma żadnych nowości od 2016. Inne alternatywy wydają się być ograniczania i wytrzymałości . W czasie pisania tego upór miał więcej gwiazd GItHub (2,3k vs 1,2k) i został zaktualizowany niedawno, dlatego postanowiłem go użyć. Oto przykład:

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

Powyższy kod wyświetla coś takiego:

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.
.
.
.

Więcej ustawień dla tych tenacity.retrymożna znaleźć na stronie GitHub poświęconej wytrzymałości .

Jeśli chcesz rozwiązania bez zagnieżdżonych pętli i powoływania się breakna sukces, możesz opracować szybkie opakowanie retriabledla dowolnej iterowalnej. Oto przykład problemu z siecią, na który często wpadam - zapisane uwierzytelnianie wygasa. Jego użycie brzmiałoby następująco:

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

Używam następujących w moich kodach,

   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

Oto moje zdanie na ten temat. Następująca retryfunkcja obsługuje następujące funkcje:

• Zwraca wartość wywołanej funkcji, gdy się powiedzie
• Podnosi wyjątek wywołanej funkcji, jeśli próby zostaną wyczerpane
• Limit liczby prób (0 dla nieograniczonej)
• Poczekaj (liniowo lub wykładniczo) między próbami
• Spróbuj ponownie tylko wtedy, gdy wyjątek jest instancją określonego typu wyjątku.
• Opcjonalne rejestrowanie prób

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

Stosowanie:

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)

Zobacz mój post, aby uzyskać więcej informacji.

Oto mój pomysł, jak to naprawić:

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)

Niedawno pracowałem z moim pytonem nad rozwiązaniem tego problemu i chętnie podzielę się nim z gośćmi stosu przepływów. W razie potrzeby przekaż opinię.

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}')

zwiększaj zmienną pętli tylko wtedy, gdy klauzula try się powiedzie