Python's static methods are intended for methods that are part of a class, and can be called as either a class method or an instance method: both Class.the_method() and self.the_method() would work. When the static method is called, it is not given an implicit first argument:

class Example:
  def instance_method_example(self, arguments):
    ...

  @classmethod
  def class_method_example(cls, arguments):
    ...

  @staticmethod
  def static_method_example(arguments):
    ...

If you merely want to create a helper function that is used within your class, do not use @staticmethod. Define a free function outside of the class. For example:

class Example:
  def some_method(self, argument):
    return _helper(argument, self.x)

def _helper(a, b):
  ...

The background of static methods in Python is the following: when you access an attribute of an object x.attribute or getattr(x, 'attribute'), then this name is looked up in the instance dict or the class dict. If an object is found in the class dict, it is checked whether that object is a “descriptor”: an object that describes how this attribute behaves, not an object that would be directly returned. Descriptors have dunder-methods like __get__, __set__, and __del__ that are invoked depending on whether the descriptor is accessed, assigned to, or deleted with the del operator.

Functions – the things you declare with def – are descriptors. By default, the __get__ descriptor binds the function to the instance argument (typically called self) and returns the bound function, so that it can be invoked as a method. But the various decorators change this behaviour:

• a @classmethod def binds to the class object, not the instance
• a @staticmethod def does not bind to any object and just returns the underlying function directly
• a @property invokes the underlying function to retrieve a value

These differences are (partially) visible when looking at the repr() of the bound methods. With the first Example class:

• instance_method_example
  • with class: Example.instance_method_example
    is <function Example.instance_method_example at 0x7f1dfdd6fd30>,
    the unbound function
  • with instance: <function Example.instance_method_example at 0x7f1dfdd6fd30>
    is <bound method Example.instance_method_example of <__main__.Example object at 0x7f1dfdddcb80>>,
    a method bound to the instance
• class_method_example
  • with class: Example.class_method_example
    is <bound method Example.class_method_example of <class '__main__.Example'>>,
    a method bound to the class
  • with instance: Example().class_method_example
    is <bound method Example.class_method_example of <class '__main__.Example'>>,
    also a method bound to the class
• static_method_example
  • with class: Example.static_method_example
    is <function Example.static_method_example at 0x7f1dfdd6fe50>,
    the unbound function
  • with instance: Example().static_method_example
    is <function Example.static_method_example at 0x7f1dfdd6fe50>,
    also the unbound function

As a table:

You can define a function outside of a class and then add it. However, there is a subtle difference in assigning the function to the class or to the instance object. Here is an example:

class MyClass1(object):
    def __init__(self, bar):
        self.foo = 'up'
        MyClass1.foobar = bar

class MyClass2(object):
    def __init__(self, bar):
        self.foo = 'up'
        self.foobar = bar

def bar(self):
    return "What's " + self.foo

Let's first look at what is happening in MyClass1. foobar in this class is similar to a normal method as though it was defined inside the class definition (i.e. it is a method bound to the instance of this class). Let's take a look at what this looks like...

In [2]: x = MyClass1(bar)

In [3]: x.foobar
Out[3]: <bound method MyClass1.bar of <__main__.MyClass1 object at 0x104346990>>

In [4]: x.foobar()
Out[4]: "What's up"

How does this differ from MyClass2? In MyClass2, foobar is simply a reference to the bar function and is NOT a bound method. Because of this we must pass the instance in for this function to work properly. e.g.

In [5]: y = MyClass2(bar)

In [6]: y.foobar
Out[6]: <function __main__.bar>

In [7]: y.foobar()
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-7-6feb04878e5f> in <module>()
----> 1 y.foobar()

TypeError: bar() takes exactly 1 argument (0 given)

In [8]: y.foobar(y)
Out[8]: "What's up"

Although I'm not sure if this is ever good practice to be doing it this way...

Add self as argument of func2. When calling myClass add ().

def func(self):
  self.func2()

class myClass:
  f = func
  def func2(self):
    print 'func2'

C = myClass()
C.f()