我有一个以for i in range(0, 100)开头的循环。通常它运行正常，但有时它会因网络状况而失败。目前我已将其设置为在失败时，它将在except子句中continue（继续到i的下一个数字）。
我是否可以将相同的号码重新分配给i并再次完成循环失败的迭代？
答案 0 :(得分：299)
在for循环中执行while True，将try代码放入其中，并在代码成功时从while循环中断。
for i in range(0,100):
while True:
try:
# do stuff
except SomeSpecificException:
continue
break
答案 1 :(得分：146)
我更喜欢限制重试次数，因此如果该特定项目出现问题，您最终会继续进行下一次重试，因此：
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.
答案 2 :(得分：55)
retrying package是一种在失败时重试代码块的好方法。
例如：
@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")
答案 3 :(得分：16)
这是一个类似于其他解决方案的解决方案，但如果它没有在规定的数量或重试中取得成功，它将引发异常。
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
答案 4 :(得分：14)
更多“功能性”方法，而不使用那些丑陋的while循环：
def tryAgain(retries=0):
if retries > 10: return
try:
# Do stuff
except:
retries+=1
tryAgain(retries)
tryAgain()
答案 5 :(得分：9)
最明确的方法是明确设置i。例如：
i = 0
while i < 100:
i += 1
try:
# do stuff
except MyException:
continue
答案 6 :(得分：6)
retrying的替代方案：tenacity和backoff（2020年更新）retrying库以前是要走的路，但可悲的是它存在一些错误，自2016年以来未进行任何更新。其他选择似乎是backoff和tenacity 。在撰写本文时，坚韧程度更高的GItHub星（2.3k对1.2k）并已更新，因此我选择使用它。这是一个示例：
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()
for i in range(100):
do_something_unreliable(i)
上面的代码输出类似：
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.
.
.
.
tenacity GitHub page上列出了tenacity.retry的更多设置。
答案 7 :(得分：5)
Using recursion
for i in range(100):
def do():
try:
## Network related scripts
except SpecificException as ex:
do()
do() ## invoke do() whenever required inside this loop
答案 8 :(得分：5)
具有超时的通用解决方案：
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)
用法：
for retry in onerror_retry(SomeSpecificException, do_stuff):
retry()
答案 9 :(得分：4)
答案 10 :(得分：2)
使用while和counter：
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
答案 11 :(得分：2)
您可以使用Python重试包。 Retrying
它是用Python编写的，用于简化将重试行为添加到任何内容的任务。
答案 12 :(得分：2)
attempts = 3
while attempts:
try:
...
...
<status ok>
break
except:
attempts -=1
else: # executed only break was not raised
<status failed>
答案 13 :(得分：2)
装饰器是一个很好的方法。
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:
time.sleep(delay*2**(i-1))
try:
r = fun(*args, **kwargs)
s = success(r)
except Exception as e:
s = False
ex = e
# raise e
if not s:
continue
return r
else:
if echo:
print(f"{fun} failed.", "args:", args, kwargs, "\nresult: %s"%r)
if raiseexception:
raise ex
def __call__(self, fun):
@wraps(fun)
def wraper(*args, retry=0, **kwargs):
retry = retry if retry>0 else self.times
return self.__class__.retry(fun, *args,
success=self.success,
times=retry,
delay=self.delay,
raiseexception = self.raiseexception,
echo = self.echo,
**kwargs)
return wraper
一些用法示例：
@retry(success=lambda x:x>3, times=4, delay=0.1)
def rf1(x=[]):
x.append(1)
print(x)
return len(x)
> rf1()
[1]
[1, 1]
[1, 1, 1]
[1, 1, 1, 1]
4
@retry(success=lambda x:x>3, times=4, delay=0.1)
def rf2(l=[], v=1):
l.append(v)
print(l)
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, 2]
5
> retry.retry(lambda a,b:a+b, 1, 2, times=2)
3
> retry.retry(lambda a,b:a+b, 1, "2", times=2)
TypeError: unsupported operand type(s) for +: 'int' and 'str'
答案 14 :(得分：1)
如果您想要一个没有嵌套循环且成功调用break的解决方案，则可以为所有可迭代的项目开发一个快速包装retriable。这是我经常遇到的网络问题的示例-保存的身份验证过期。它的用法如下：
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
答案 15 :(得分：1)
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
我的版本与上述几种类似，但是不使用单独的while循环，并且如果所有重试均失败，则会重新引发最新的异常。可以在顶部显式设置err = None，但不是绝对必要的，因为只有在出现错误并因此设置了else时，它才应执行最后的err块。
答案 16 :(得分：0)
我在代码中使用了以下代码，
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
答案 17 :(得分：0)
这是我对这个问题的看法。以下retry函数支持以下功能：
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
用法：
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)
有关更多信息，请参见我的post。
答案 18 :(得分：0)
我喜欢为此使用 bool 值，如下所示：
success = False
num_try = 0
while success is False:
if num_try >= 10: # or any number
# handle error how you please
try:
# code
success = True
except Exception as e:
# record or do something with exception if needed
num_try += 1
答案 19 :(得分：-2)
以下是关于如何解决此问题的想法：
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)
答案 20 :(得分：-2)
我最近与我的python合作解决了这个问题，很高兴与stackoverflow访问者分享它，如果需要的话，请提供反馈。
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}')
答案 21 :(得分：-9)
仅当try子句成功时才增加循环变量