Ask for forgiveness or ask for permission? Performance Considerations

Depending on what the goal of the program is, if your goal is performance ( in time ), a try-catch block becomes expensive, compared to an if , when it catches an exception.

But if robustness is what you're after , good exception handling is always preferable. In addition, good exception handling helps code interpretation from a logical point of view.

Here is an example of the cpu processing time used by each block, you can see that the if block uses less cpu time when the try catches the exception compared to the conditional block

#!/usr/bin/python
import time

lista = []

def bloque():
  try:
    elemento = lista[0]
  except IndexError:
    elemento = None

def bloque_if():
  elemento = None
if len(lista) > 1:
    elemento = lista[0]


# tiempo de procesamiento
t0 = time.clock()
bloque()
print time.clock() - t0, "seg bloque try-catch "

t0 = time.clock()
bloque_if()
print time.clock() - t0, "seg bloque if"

I believe that @Santi92's answer is correct, the best way is to do a type of benchmark to know the result, but not with one iteration but with several thousand.

However, in the interest of sharing knowledge on this topic, I found the following using the timeitPython module:

import timeit

statements=["""\
try:
    b = 10/a
except ZeroDivisionError:
    pass""",
"""\
if a:
    b = 10/a""",
"b = 10/a"]

for a in (1,0):
    for s in statements:
        t = timeit.Timer(stmt=s, setup='a={}'.format(a))
        print("a = {}\n{}".format(a,s))
        print("%.2f usec/pass\n" % (1000000 * t.timeit(number=100000)/100000))

Result:

a = 1
try:
    b = 10/a
except ZeroDivisionError:
    pass
0.25 usec/pass

a = 1
if a:
    b = 10/a
0.29 usec/pass

a = 1
b = 10/a
0.22 usec/pass

a = 0
try:
    b = 10/a
except ZeroDivisionError:
    pass
0.57 usec/pass

a = 0
if a:
    b = 10/a
0.04 usec/pass

a = 0
b = 10/a
ZeroDivisionError: int division or modulo by zero

With which it can be concluded that "asking for forgiveness" is faster than "asking for permission" as long as the exception is not raised. Which affirms what some mentioned in the comments.

References:

• Cost of exception handlers in Python (answer from Tim Pietzcker )
• How fast are exceptions?

I commented that the try is only slower in general terms when it catches the exception, this is an example:

import timeit

   timeit.timeit(setup="a=1;b=1", stmt="a/b") 
   0.06870104099999708   

. This part shown below is the interesting one (the try is faster than the if when it doesn't jump)

   timeit.timeit(setup="a=1;b=1", stmt="try:\n a/b\nexcept ZeroDivisionError:\n pass")
   0.08890565000001516  
   timeit.timeit(setup="a=1;b=1", stmt="if b!=0:\n a/b")
   0.10628072599996585 

.this part that is shown below is a filler because the try jumps and also performs the operation, that's why it jumps ha, and in the if it only compares from there that it be faster

   timeit.timeit(setup="a=1;b=0", stmt="try:\n a/b\nexcept ZeroDivisionError:\n pass")
   0.3348089790000017    
   timeit.timeit(setup="a=1;b=0", stmt="if b!=0:\n a/b")
   0.042805305999991106

Taking your analogy at face value, we have two truths, until someone proves otherwise.

Just be sorry if you've made a mistake, however, you should ALWAYS ask for permission, out of courtesy ;).

Now, taking this into account, why mention which one is easier? Let's handle exceptions as you say, it is not more difficult or easier than validating the information, for example.

For me that would be the rule, as long as time allows you to ask for permission, and you should only ask for forgiveness in cases that are currently outside your preliminary analysis.

The best in "performance" is:

If you are never going to be wrong or almost never, ask for forgiveness, and don't waste time asking for permission.

If you are wrong many times, ask for permission, which will cost you less than asking for several forgiveness.

And keep in mind that 1 million permissions consumes much more than a pardon.

But that 1 million permits consumes much less than half a million pardons.

In your case, I would speculate, what is the tendency of your code. In performance matters , it is cheaper to apologize for making the assumption that the system is well analyzed, designed and coded.

This is very similar to the concept of branch prediction .

If you notice that the code throws more exceptions than following the programmed flow, then you must ask for permission each time you want to do the operation that throws the exception.

Now, if the operation doesn't tend to throw exceptions, then I apologize.