Methods defined in a class are not accessible by bare name, except by code running directly in the class namespace (not inside another method). If you want to call a method, you usually have to look it up on some kind of object (either an instance, or the class itself). The different kinds of methods differ in how they behave when for different kinds of lookups.
class Test(object): def normal_method(self, foo): print("normal_method", self, foo) # none of the method names are valid here as bare names, only via self or Test try: class_method(type(self), foo) # raises NameError except NameError: pass self.class_method(foo) # this works Test.class_method(foo) # so does this @classmethod def class_method(cls, foo): print("class_method", cls, foo) # from a class method, you can call a method via the automatically provided cls cls.static_method(foo) @staticmethod def static_method(foo): print("static_method", foo) # a static method can only use the global class name to call other methods if isinstance(foo, int) and foo > 0: Test.static_method(foo - 1) # Class level code is perilous. #normal_method('x', 2) # could work in Python 3 (Python 2 checks the type of self) # but it probably won't be useful (since self is not an instance) #class_method('x', 2) # Won't work. A classmethod descriptor isn't directly callable #staticmethod(2) # Nor is a staticmethod# Top level code (these are all valid)Test().normal_method(2) # also could be Test.normal_method(Test(), 2)Test.class_method(2) # could also be Test().class_method(2) (type of the instance is used)Test.static_method(2) # could also be Test().static_method(2) (instance is ignored)