Looking for clarification related to performance

[Pymon]

I have come across statements saying that one should be careful about calling functions too frequently because of the performance overhead. Is this truly something that I need to be concerned about? I will assume for now that it is.

I have also come across statements warning about the use of "for" loops, also because of performance reasons, and that instead one ought to use the map feature.

However, almost all map examples call out to functions. While there are some examples with lambdas, this is probably not the best option when dealing larger and more complicated functions.

So, on the one hand, I can do a for loop and not repeatedly call function, therefore saving the function call overhead.

Or, I can use the allegedly more performant map feature in which I may have to do a function call and accept less than optimal performance.

What really are the things that I need to consider?

Thank you.

[deanhystad]

You should only worry about performance when you have a performance issue, not before.

[Pymon]

You should only worry about performance when you have a performance issue, not before.

While true, that is a very flippant answer to someone seeking a deeper knowledge of the language and, as a newcomer to this forum, I must say that it is these kinds of replies that make a community toxic and unwelcoming.

[deanhystad]

I am being sincere. I think it is good advice. Write code to be correct and easy to maintain. If there are performance issues, fix those when they occur. Often this will involve not writing code in Python at all, but instead using Python packages like numpy or pandas that are highly optimized and do much of their work in linked libraries. You are not going to see big changes in performance using a comprehension or map instead of a loop. They are good tools, but they don't turn Python into C. At least that is not my experience.

I use comprehensions and map and other functools because I can write a lot of function in a few lines of code. Potential performance benefits don't cross my mind. I often find a nice comprehension easier to read than a stretched out for loop.

As always, the best way to speed up code is run less code. Optimize the algorithm to get real speed gains.

[casevh]

It is difficult to provide a complete answer without understanding the context - both of the person making the statement "function calls are slow" and what your program does. So let's look at adding two numbers that are stored in the variables a and b. The easiest way is just t = a + b.

It is relatively fast.

$ python3.9 -m timeit -s "a=1;b=2" "t=a+b"
10000000 loops, best of 5: 20.7 nsec per loop

Now create a function and save it in a file called examples.py

def f_1(x, y):
    return x + y

Now measure the running time.

$ python3.9 -m timeit -s "import examples;a=1;b=1" "examples.f_1(a,b)"
5000000 loops, best of 5: 94.8 nsec per loop

Why is it so much slower? One reason is that Python uses dictionaries to store the names of functions. There are two additional dictionary lookups required to evaluate examples.f_1(a,b). Python first must find examples in the local namespace. Then it must find f_1 in the local namespace belonging to examples. A common trick is to lookup examples.f_1 once and cache the result. For example f=examples.f_1. That is faster.

$ python3.9 -m timeit -s "import examples;f=examples.f_1;a=1;b=1" "f(a,b)"
5000000 loops, best of 5: 70.2 nsec per loop

So there is an overhead for calling a function. So does that imply we minimize the use of functions? Nope. Surprisingly, code inside a function can run faster. Here is a contrived example. The code:

import time

big_list = [(i,i) for i in range(500)]

start = time.time()
total = 0
for a,b in big_list:
    total = total + a * b
end = time.time()
print("Elapsed time:", end - start)

def f_2(big_list):
    start = time.time()
    total = 0
    for a,b in big_list:
        total = total + a * b
    end = time.time()
    print("Elapsed time:", end - start)

f_2(big_list)

and the results:

$ python3.9 example2.py 
Elapsed time: 6.580352783203125e-05
Elapsed time: 3.337860107421875e-05

Why the difference? Name lookups that are in a function's own local namespace are faster than a dictionary lookup.

---

So what to do? Organize code as functions just because it is easier to write, understand, and maintain. If the program is running too slow, look carefully at "how" you are solving your problem. Better algorithms are, well, better. Identify what code is slow and understand why it slow. Learn itertools (see next section for why).

---

I added the following function to example2.

import itertools
import operator
def f_3(big_list):
    start = time.time()
    sum((itertools.starmap(operator.mul,big_list)))
    end = time.time()
    print("Elapsed time:", end - start)

f_3(big_list)

and the results:

$ python3.9 example2.py 
Elapsed time: 6.222724914550781e-05
Elapsed time: 3.314018249511719e-05
Elapsed time: 1.9311904907226562e-05

---

Lastly, there are many performance recommendations on the Internet. Don't trust their recommendations unless you measure it on _your_ code. (Don't trust me either. I chose my examples to illustrate specific behaviors.)

p.s. The fastest way to compute the sum of squares is the formula (n(n+1)(2n+1)) / 6. A better algorithm is, well, better.

casevh

[deanhystad]

Look at the times and think about how that affects your program. If something takes 95 nanoseconds to do, doing it one million times takes 95 milliseconds. For most purposes 95 milliseconds is the same as 21 milliseconds; no time at all. If you do something billions of times the difference is significant, but if you are doing billions of operations you are better off using a package that is optimized for the work you are trying to do.

I think the advice to do your own timing is excellent. Your results may vary is really true.