How to call a static method of a class using method name and class name

Question

Starting with a class like this:

class FooClass(object):
    @staticmethod
    def static_method(x):
        print x

normally, I would call the static method of the class with:

FooClass.static_method('bar')

Is it possible to invoke this static method having just the class name and the method name?

class_name = 'FooClass'
method_name = 'static_method'

Answer 1

If the class type is accessible from the current module, you can access the class in the globals() dict and the method using getattr:

class FooClass(object):
    @staticmethod
    def static_method(x):
        print x

class_name = 'FooClass'
method_name = 'static_method'

getattr(globals()[class_name], method_name)("test")

Answer 2

Here is a crude way:

>>> class FooClass(object):
    @staticmethod
    def static_method(x):
        print x


>>> class_name = 'FooClass'
>>> method_name = 'static_method'
>>> getattr(locals().get(class_name), method_name)("bar")
bar

Breakup:

locals().get(class_name)

First, locate the class. In this case I'm using locals() as I know that the class is available in the local dictionary. This will fail if the class is not present in the local dictionary.

Next, find the method of the class.

getattr(locals().get(class_name), method_name)

This uses getattr().

Finally, call the method.

getattr(locals().get(class_name), method_name)("bar")

Answer 3

You shouldn't mess with locals() as suggested in other answers. If you have your classname as a string and need to resolve it, use registry of some sort. A dictionary will work fine. E.g.

class FooClass(object):
    @staticmethod
    def static_method(x):
        print x

registry = {'FooClass':FooClass}

(I assume you will want to add many more classes to this registry)

the lookup then becomes almost trivial:

getattr(registry['FooClass'], 'static_method')("bar")

Answer 4

you can use getattr twice. the first time on the module that contains the class and the second time on the class itself

class_name = 'Foo'
method_name = 'Bar'

cls = getattr(mod, clsname)
method = getattr(cls, method_name)
method(args)

This is not as flexible as building a registry (which you can do with a decorator) but if you are not going to do that, than this is a far better alternative than messing with the stack and stylistically, cleaner than messing with sys.modules.

Note that a module can import itself with no adverse effects. so the classes don't have to be in a different module for this to work.