How to avoid a mistake

If you want to prevent the program from terminating with an exception because of trying to index with an index out of range, none of the options you show will work, at the time you try to evaluate a[2]you will have the IndexError.

With a conditional that checks the length of the list and checks if the index is valid, something like this should be done:

a = [1, 2]

indice = 2

if not -len(a) <= indice < len(a):
    print('Fuera de Rango')
else:
    print(a[indice])

However you can use a block try-exceptto catch the exception and handle it as you see fit:

a = [1, 2]

indice = 2

try:
    print(a[indice])

except IndexError:
    print("Fuera de rango")

Basically the interpreter tries to carry out what is inside the try, in case of failure due to a IndexErrorit carries out what is inside the except. You can catch any exception if exceptit isn't explicitly followed by an error, although as you can imagine it can be a big cause of errors that are passed silently:

try:
    print(lista[indice])

except:
    print("Algún error ocurrió")

You can handle different errors differently by using multiple statements except:

try:
    print(lista[indice])

except IndexError:
    print("Índice fuera de rango")

except TypeError:
    print("Los indices de una lista han de ser enteros")

Or capture multiple types in the same block using a tuple:

try:
    print(lista[indice])

except (IndexError, TypeError):
    print("Índice no válido")

You can use a function that returns the element of the list if it exists, or a value that you want otherwise, without throwing an exception using the same idea (something similar to what the method does dict.getfor example).

a = [1, 2]


def get_list_element(lista, indice, default=None):
    try:
        return lista[indice]
    except IndexError:
        return default


elemento = get_list_element(a, 2)
print(elemento)  # None
elemento = get_list_element(a, 1)
print(elemento)  # 2
elemento = get_list_element(a, 2, default=0)
print(elemento)  # 0

More "fancy" options exist by creating our own wrapper class or inheriting (not recommended for reasons besides the point) / composing from list. However, if a container that implements the functionality of listbut is required, a good option is to inherit from collections.UserList:

import collections



class MyList(collections.UserList):
    def  __getitem__(self, item, *args):
        try:
            return self.data.__getitem__(item)
        except IndexError:
            return None



a = MyList((1, 2))
print(a[1])  # 2
print(a[2])  # None
a.append(4)
print(a[2])  # 4

The class MyListimplements all the functionalities of a list but if we index with an incorrect index it returns us None, it does not throw an exception.

Errors that occur at run time (that is, when a particular statement is being executed) trigger what is called an exception .

Exceptions can be caught from the code itself and a decision made in the code as to what to do. Only when they are not captured do they end up being visible to the user, showing a Traceback like the one you put in your question. In this Traceback , it is reported what exception occurred, and in what line of code, as well as what functions were in execution at that moment (that is, from what function the one that caused the exception had been called, and from which one had it been called). called in turn to the previous one, etc.)

In the documentation you have all the details on how to handle exceptions , or how to throw your own.

A brief summary would be the following.

handle exceptions

When you are going to execute a block of code that might fail with an exception, put that block of code inside a clause try:. Following that clause put another call except X:, being Xthe name of an exception. Inside this second block, you write code that will be executed in case the exception occurs X. The block except Xcan be repeated several times with different cases of X, to handle each exception differently.

So:

try:
    dato = a[2]
except IndexError:
    print("Fuera de rango")
    dato = 0

Note that when an exception occurs, in addition to (or instead of) printing what error occurred, you must take some corrective action. In the previous example I have assumed that we wanted to access a data, and that if we go out of range, the data is equal to zero. This may or may not make sense in your application. It depends on what you are going to do with that data later. Another option could be to make the datoequal to None. Yet another option could be to abort the execution of the program with quit()to prevent it from executing anything else (which is what python does when it encounters an exception not handled by code).

Throw your own exception

You may also be writing a function that is going to be called from another site, and you want to detect possible errors and inform the caller that one of those errors has occurred. When you want to do that, you can put raise X(), being Xthe name of the exception you want to raise. It can be one of those that python has already defined, or others that you have created (they would be classes that directly or indirectly inherit from the class Exception).

For example your code could contain something like:

def obtener_elemento(a, n):
    if len(a) < n:
        raise IndexError("n debe ser menor que {}".format(len(a)))
    else:
        return a[n]

Whoever calls that function passing an nincorrect would run into the exception IndexErrorthat has been thrown from your code when entering the if. If you haven't handled that exception using try/catch, the exception will go up to the next function that would have called the one that called yours. If at the end the main program is reached without anyone having handled the exception, the program will break and the user will be shown the message that we put when throwing the exception.

More details in the aforementioned documentation.