Compare the speed of in-class Statistic Method and out-class Function: Which one will be faster?

Question

Dear experienced friends, I have a question about the speed of calling a function when I use the Python class. Suppose we have two scenarios:

1. We define the function inside the class, and run this function when we use the class.

class play_in():

    def __init__(self, n):
        super().__init__()
        self.running_time = n
        
    def __call__(self):
        output = play_in.calculate_running_time_in(self.running_time)
        return print(output)
        
    @staticmethod
    def calculate_running_time_in(n):
        t1 = time.time()
        for _ in range(n):
            c = 9999*9999/32
        return time.time()-t1

2. We define the function outside the class, and call this function inside the class.

# define fun outside
def calculate_running_time_out(n):
    t1 = time.time()
    for _ in range(n):
        c = 9999*9999/32
    return time.time()-t1

class play_out():

    def __init__(self, n):
        super().__init__()
        self.running_time = n
        
    def __call__(self):
        output = calculate_running_time_out(self.running_time)
        return print(output)

Then I run these two function-calling methods several times. However, the difference between them is not stable. Sometimes the in-calling is faster, sometimes the out-calling is faster.

test_time = 10000000

test_model_in = play_in(test_time)
test_model_in()

test_model_out = play_out(test_time)
test_model_out()

So I am wondering: Is there a difference (or theoretical difference) between these two calling methods? If so, which one is better?

Thank you so much in advance!

Answer 1

Adding to Iain Shelvington's answer, decompiling shows the static method option has more op codes

  6           0 LOAD_FAST                0 (self)
              2 LOAD_METHOD              0 (calc)
              4 CALL_METHOD              0
              6 RETURN_VALUE

than the global

 15           0 LOAD_GLOBAL              0 (calc)
              2 CALL_FUNCTION            0
              4 RETURN_VALUE

The LOAD_METHOD op code needs to traverse the class tree to find the right version of the static method. I suppose that means the static method slows as class inheritance increases. But polymorphism is a primary reason for static methods in the first place, so you gotta pay to play.

Less obvious is that you run through some staticmethod C code (see https://github.com/python/cpython/blob/main/Objects/funcobject.c). Decorators add a bit of overhead to calls.

Answer 2

Here is a way to test the difference between using a staticmethod and a separate function, the function and method do nothing so this should be a good enough way to isolate just the behaviour we want to test. On my Python I consistently get better results when not using staticmethod

import timeit


class play_in:

    def __call__(self):
        return self.calc()

    @staticmethod
    def calc():
        pass


class play_out:

    def __call__(self):
        return calc()


def calc():
    pass


play_in_test = play_in()
print(timeit.timeit('play_in_test()', number=1000000, globals=globals()))

play_out_test = play_out()
print(timeit.timeit('play_out_test()', number=1000000, globals=globals()))