Necessity of using static methods instead of sub-functions in a function

Question

I've seen discussions about difference between @classmethod and @staticmethod and about that between @staticmethod and global functions, but I am still confused about the difference between @staticmethod and sub-function in a function.

Consider this example below (revised from The definitive guide on how to use static, class or abstract methods in Python):

class Pizza(object):
    def __init__(self, cheese, vegetables):
        self.cheese = cheese
        self.vegetables = vegetables

    @staticmethod
    def mix_ingredients(x, y):
        return x + y

    def cook(self):
        return self.mix_ingredients(self.cheese, self.vegetables)

Why not:

def cook_pizza(cheese, vegetables):
    def mix_ingredients(x, y):
        return x + y
    return mix_ingredients(cheese, vegetables)

In this example, the function I'd ever use is cook in Pizza. Let's say there's no any other functions I'd define in Pizza in the future, i.e. I do only cooking with pizza. Can't I simply define that as one single function cook_pizza? In this way mix_ingredients won't be global and won't have name conflicts with other instances either.

Is there any advantages or disadvantages written that as a @staticmethod in this case? For example, does Pizza(cheese, vegetables).cook() perform better than cook_pizza(cheese, vegetables) because the former doesn't need to define mix_ingredients every time in the process?

Answer 1

The basic difference is the fact that you can use a function decorated with staticmethod without instantiating the class,

but if you make a sub-function/inner-function you can not access it from outside function where it was definned.

Method

Without instantiating:

In [2]: Pizza.cook()
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-2-4a252d4e9619> in <module>()
----> 1 Pizza.cook()

TypeError: cook() missing 1 required positional argument: 'self'

With instance:

In [4]: Pizza('cheese', 'vegetables').cook()
Out[4]: 'cheesevegetables'

Static method

Without instantiating:

In [5]: Pizza.mix_ingredients(1,2)
Out[5]: 3

Performance:

Each time you call cook_pizza it defines the nested function, which causes an impact on execution time.

import timeit

def method():
    return 'method'

def method_with_inner():
    def inner():
        return 'inner'
    return inner()

Execution

 print(timeit.timeit("method()", setup="from __main__ import method"))

0.0910306089790538

print(timeit.timeit("method_with_inner()", setup="from __main__ import method_with_inner"))

0.24090809898916632

Side note

the cook_pizza could be a static method as it doesn't use any variable defined at class level or storage in self.

Thanks: @Shadow @abarnert for the contributions in the discussion thread of this answer.