How to retry after exception?


I have a loop starting with for i in range(0, 100). Normally it runs correctly, but sometimes it fails due to network conditions. Currently I have it set so that on failure, it will continue in the except clause (continue on to the next number for i).

Is it possible for me to reassign the same number to i and run through the failed iteration of the loop again?

Asked By: FurtiveFelon



Do a while True inside your for loop, put your try code inside, and break from that while loop only when your code succeeds.

for i in range(0,100):
    while True:
            # do stuff
        except SomeSpecificException:
Answered By: zneak

The clearest way would be to explicitly set i. For example:

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

    except MyException:
Answered By: Tomi Kyöstilä

increment your loop variable only when the try clause succeeds

Answered By: appusajeev

The more “functional” approach without using those ugly while loops:

def tryAgain(retries=0):
    if retries > 10: return
        # Do stuff

Answered By: restbeckett

There is something similar in the Python Decorator Library.

Please bear in mind that it does not test for exceptions, but the return value. It retries until the decorated function returns True.

A slightly modified version should do the trick.

Answered By: Michael

I prefer to limit the number of retries, so that if there’s a problem with that specific item you will eventually continue onto the next one, thus:

for i in range(100):
  for attempt in range(10):
      # do thing
      # perhaps reconnect, etc.
    # we failed all the attempts - deal with the consequences.
Answered By: xorsyst

UPDATE 2021-12-01:

As of June 2016, the retrying package is no longer being maintained.
Consider using the active fork, or alternatively

The retrying package is a nice way to retry a block of code on failure.

For example:

@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")
Answered By: goneri

A generic solution with a timeout:

import time

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


for retry in onerror_retry(SomeSpecificException, do_stuff):
Answered By: Laurent LAPORTE

Here’s my idea on how to fix this:

j = 19
def calc(y):
    global j
        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))
        j = j + 1   # when the exception happens, increment "j" and retry
for i in range(50):
Answered By: Amine

Here is a solution similar to others, but it will raise the exception if it doesn’t succeed in the prescribed number or retries.

tries = 3
for i in range(tries):
    except KeyError as e:
        if i < tries - 1: # i is zero indexed
Answered By: theherk

Using while and a counter:

count = 1
while count <= 3:  # try 3 times
        # do_the_logic()
    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:
        count += 1
Answered By: Ranju R

Using recursion

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

You can use Python retrying package.

It is written in Python to simplify the task of adding retry behavior to just about anything.

Answered By: ManJan

If you want a solution without nested loops and invoking break on success you could developer a quick wrap retriable for any iterable. Here’s an example of a networking issue that I run into often – saved authentication expires. The use of it would read like this:

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

for value in smart_loop:
    except ClientAuthExpired:
        client = get_client()
    except NetworkTimeout:
Answered By: Mikhail

I use following in my codes,

   for i in range(0, 10):
        #things I need to do
    except ValueError:
        print("Try #{} failed with ValueError: Sleeping for 2 secs before next try:".format(i))
Answered By: H S Rathore
for _ in range(5):
        # replace this with something that may fail
        raise ValueError("foo")

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

    # no exception, continue remainder of code

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

My version is similar to several of the above, but doesn’t use a separate while loop, and re-raises the latest exception if all retries fail. Could explicitly set err = None at the top, but not strictly necessary as it should only execute the final else block if there was an error and therefore err is set.

Answered By: n8henrie

i recently worked with my python on a solution to this problem and i am happy to share it with stackoverflow visitors please give feedback if it is needed.

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):
        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)}')
    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}')
Answered By: Rashad Kabir

attempts = 3
while attempts:
     <status ok>
    attempts -=1
else: # executed only break was not  raised
   <status failed>

Answered By: Voronin Roman

Here is my take on this issue. The following retry function supports the following features:

  • Returns the value of the invoked function when it succeeds
  • Raises the exception of the invoked function if attempts exhausted
  • Limit for the number of attempts (0 for unlimited)
  • Wait (linear or exponential) between attempts
  • Retry only if the exception is an instance of a specific exception type.
  • Optional logging of attempts
import time

def retry(func, ex_type=Exception, limit=0, wait_ms=100, wait_increase_ratio=2, logger=None):
    attempt = 1
    while True:
            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:
      "waiting %d ms before attempt #%d", wait_ms, attempt)
            time.sleep(wait_ms / 1000)
            wait_ms *= wait_increase_ratio


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

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

See my post for more info.

Answered By: dux2

Alternatives to retrying: tenacity and backoff (2020 update)

The retrying library was previously the way to go, but sadly it has some bugs and it hasn’t got any updates since 2016. Other alternatives seem to be backoff and tenacity. During the time of writing this, the tenacity had more GItHub stars (2.3k vs 1.2k) and was updated more recently, hence I chose to use it. Here is an example:

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

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

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

for i in range(100):

The above code outputs something like:

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.

More settings for the tenacity.retry are listed on the tenacity GitHub page.

Answered By: np8

Decorator is a good approach.

from functools import wraps
import time

class retry:
    def __init__(self, success=lambda r:True, times=3, delay=1, raiseexception=True, echo=True):
        self.success = success
        self.times = times
        self.raiseexception = raiseexception
        self.echo = echo
        self.delay = delay
    def retry(fun, *args, success=lambda r:True, times=3, delay=1, raiseexception=True, echo=True, **kwargs):
        ex = Exception(f"{fun} failed.")
        r = None
        for i in range(times):
            if i > 0:
                r = fun(*args, **kwargs)
                s = success(r)
            except Exception as e:
                s = False
                ex = e
                # raise e
            if not s:
            return r
            if echo:
                print(f"{fun} failed.", "args:", args, kwargs, "nresult: %s"%r)
            if raiseexception:
                raise ex
    def __call__(self, fun):
        def wraper(*args, retry=0, **kwargs):
            retry = retry if retry>0 else self.times
            return self.__class__.retry(fun, *args, 
                                        raiseexception = self.raiseexception,
                                        echo = self.echo,
        return wraper

some usage examples:

@retry(success=lambda x:x>3, times=4, delay=0.1)
def rf1(x=[]):
    return len(x)
> rf1()

[1, 1]
[1, 1, 1]
[1, 1, 1, 1]

@retry(success=lambda x:x>3, times=4, delay=0.1)
def rf2(l=[], v=1):
    assert len(l)>4
    return len(l)
> rf2(v=2, retry=10) #overwite times=4

[2, 2]
[2, 2, 2]
[2, 2, 2, 2]
[2, 2, 2, 2, 2]

> retry.retry(lambda a,b:a+b, 1, 2, times=2)

> retry.retry(lambda a,b:a+b, 1, "2", times=2)

TypeError: unsupported operand type(s) for +: 'int' and 'str'
Answered By: guoyongzhi

I like to use bool values for this, like so:

success = False
num_try = 0
while success is False:
    if num_try >= 10: # or any number
        # handle error how  you please
        # code
        success = True
    except Exception as e:
        # record or do something with exception if needed
        num_try += 1
Answered By: Yugenswitch

with this decorator, you can easily control errors

class catch:
    def __init__(self, max=1, callback=None):
        self.max = max 
        self.callback = callback 
    def set_max(self, max):
        self.max = max
    def handler(self, *args, **kwargs):
        self.index = 0
        while self.index < self.max: 
            self.index += 1
                self.func(self, *args, **kwargs)
            except Exception as error:
                if callable(self.callback):
                    self.callback(self, error, args, kwargs)
    def __call__(self, func):
        self.func = func
        return self.handler

import time
def callback(cls, error, args, kwargs):
    print('func args', args, 'func kwargs', kwargs)
    print('error', repr(error), 'trying', cls.index)
    if cls.index == 2:
@catch(max=2, callback=callback)  
def test(cls, ok, **kwargs):
    raise ValueError('ok')

test(1, message='hello')
Answered By: milad

I use this, which can be used on any function:

def run_with_retry(func: callable, max_retries: int = 3, wait_seconds: int = 2, **func_params):
num_retries = 1
while True:
        return func(*func_params.values())
    except Exception as e:
        if num_retries > max_retries:
            print('we have reached maximum errors and raising the exception')
            raise e
            print("Retrying error:", e)
            num_retries += 1

Call like this:

    def add(val1, val2):
        return val1 + val2

    run_with_retry(func=add, param1=10, param2=20)
Answered By: Fjurg

If retrying a failed attempt x number of times is what you are looking for, a single for else loop is probably what you want. Consider this example with 3 attempts:

attempts = 3

for attempt in range(1, attempts+1):
        if attempt < 4:
            raise TypeError(f"Error raised on attempt: {attempt}")
            print(f'Attempt {attempt} finally worked.')
    except (TypeError) as error:
        print(f'Attempt {attempt} hit the exception.')
    print(f'Exit after final attempt: {attempt}')

print(f'nGo on to execute other code ...')

Gives the output:

Attempt 1 hit the exception.
Attempt 2 hit the exception.
Attempt 3 hit the exception.
Exit after final attempt: 3

Go on to execute other code ...

And with one more attempt it succeeds:

attempts = 4

Gives the output:

Attempt 1 hit the exception.
Attempt 2 hit the exception.
Attempt 3 hit the exception.
Attempt 4 finally worked.

Go on to execute other code ...
Answered By: Kim Miller

You could have a dedicated function using return to short circuit the result. For example like this:

def my_function_with_retries(..., max_retries=100):
    for attempt in range(max_retries):
            return my_function(...)
        except SomeSpecificException as error:
            logging.warning(f"Retrying after failed execution: {error}")

    raise SomeOtherException()
Answered By: Didi Bear

Here is a quick decorator to handle this. 7 lines, no dependencies.

def retry(exception=Exception, retries=3, delay=0):
    def wrap(func):
        for i in range(retries):
                return func()
            except exception as e:
                print(f'Retrying {func.__name__}: {i}/{retries}')
        raise e
    return wrap

def do_something():
@retry(HTTPError, retries=100, delay=3)
def download_something():

An addition that could be made is extending exception to handle multiple exceptions (splat a list).

Answered By: fny

I liked laurent-laporte’s answer. Here’s my version of it wrapped in a class with static methods and some examples. I implemented a retry count as another way to retry. Also added kwargs.

from typing import List
import time

class Retry:
    def onerror_retry(exception, callback, retries: int = 0, timeout: float = 0, timedelta: float = 0,
                      errors: List = None, **kwargs):

        @param exception: The exception to trigger retry handling with.
        @param callback: The function that will potentially fail with an exception
        @param retries: Optional total number of retries, regardless of timing if this threshold is met, the call will
                        raise the exception.
        @param timeout: Optional total amount of time to do retries after which the call will raise an exception
        @param timedelta: Optional amount of time to sleep in between calls
        @param errors: A list to receive all the exceptions that were caught.
        @param kwargs: An optional key value parameters to pass to the function to retry.
        for retry in Retry.__onerror_retry(exception, callback, retries, timeout, timedelta, errors, **kwargs):
            if retry: retry(**kwargs)  # retry will be None when all retries fail.

    def __onerror_retry(exception, callback, retries: int = 0, timeout: float = 0, timedelta: float = 0,
                        errors: List = None, **kwargs):
        end_time = time.time() + timeout
        continues = 0
        while True:
                yield callback(**kwargs)
            except exception as ex:
                if errors:

                continues += 1
                if 0 < retries < continues:
                    print('ran out of retries')

                if timeout > 0 and time.time() > end_time:
                    print('ran out of time')
                elif timedelta > 0:

err = 0

# sample dumb fail function
def fail_many_times(**kwargs):
    global err
    err += 1
    max_errors = kwargs.pop('max_errors', '') or 1
    if err < max_errors:
        raise ValueError("I made boo boo.")
    print("Successfully did something.")

# Example calls
    # retries with a parameter that overrides retries... just because
    Retry.onerror_retry(ValueError, fail_many_times, retries=5, max_errors=3)
    err = 0
    # retries that run out of time, with 1 second sleep between retries.
    Retry.onerror_retry(ValueError, fail_many_times, timeout=5, timedelta=1, max_errors=30)
except Exception as err:

Answered By: Jacques Petit
Categories: questions Tags: , , ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.