How can I execute same code for a condition in try block without repeating code in except clause

Question

I am checking consecutive indices of a list and I want to execute same piece of code in case if the consecutive elements are not equal or if the list index is out of range. Here's what I'm trying

for n in range(len(myList))
    try:
         if myList[n]==myList[n+1]:
             #some code
         else:
             #if they are not equal then do something
             #same code should execute if exception raised: index error  --> how do i do this?

Is there a way to do this elegantly without having to repeat the same code in the except block somehow?

Answer 1

A simple way of doing this is to just modify the if statement to check that the candidate element isn't the last one, avoiding the need for a exception clause, and keeping the code short.

    for n, i in enumerate(myList):
       if n+1 != len(myList) and i == myList[n+1]:
           #some code
       else:
           #if they are not equal then do something
           #This block will also be exicuted when last element is reached

Answer 2

for n in range(1, len(myList))
    if myList[n]==myList[n-1]:
         #some code
    else:
         #foo_bar()
#foo_bar()

Answer 3

Check out this(As Tom Ron suggested):

def foobar():
    #the code you want to execute in both case
for n in range(len(myList)):
    try:
        if myList[n]==myList[n+1]:
            #some code
        else:
            foobar()
    except IndexError:
        foobar()

Answer 4

The other answers are good for the specific case where you can avoid raising the exception in the first place. The more general case where the exception cannot be avoided can be handled a lambda function as follows:

def test(expression, exception_list, on_exception):
    try:
        return expression()
    except exception_list:
        return on_exception

if test(lambda: some_function(data), SomeException, None) is None:
    report_error('Something happened')

The key point here is that making it a lambda defers evaluation of the expression that might raise an exception until inside the try/except block of the test() function where it can be caught. test() returns either the result of the evaluation, or, if an exception in exception_list is raised, the on_exception value.

This comes from an idea in the rejected PEP 463. lambda to the Rescue presents the same idea.

(I offered the same answer in response to this question, but I'm repeating it here because this isn't exactly a duplicate question.)