Does python have an equivalent to Java Class.forName()?

Reflection in python is a lot easier and far more flexible than it is in Java.

I recommend reading this tutorial

There's no direct function (that I know of) which takes a fully qualified class name and returns the class, however you have all the pieces needed to build that, and you can connect them together.

One bit of advice though: don't try to program in Java style when you're in python.

If you can explain what is it that you're trying to do, maybe we can help you find a more pythonic way of doing it.

Here's a function that does what you want:

def get_class( kls ):    parts = kls.split('.')    module = ".".join(parts[:-1])    m = __import__( module )    for comp in parts[1:]:        m = getattr(m, comp)                return m

You can use the return value of this function as if it were the class itself.

Here's a usage example:

>>> D = get_class("datetime.datetime")>>> D<type 'datetime.datetime'>>>> D.now()datetime.datetime(2009, 1, 17, 2, 15, 58, 883000)>>> a = D( 2010, 4, 22 )>>> adatetime.datetime(2010, 4, 22, 0, 0)>>> 

How does that work?

We're using __import__ to import the module that holds the class, which required that we first extract the module name from the fully qualified name. Then we import the module:

m = __import__( module )

In this case, m will only refer to the top level module,

For example, if your class lives in foo.baz module, then m will be the module foo
We can easily obtain a reference to foo.baz using getattr( m, 'baz' )

To get from the top level module to the class, have to recursively use gettatr on the parts of the class name

Say for example, if you class name is foo.baz.bar.Model then we do this:

m = __import__( "foo.baz.bar" ) #m is package foom = getattr( m, "baz" ) #m is package bazm = getattr( m, "bar" ) #m is module barm = getattr( m, "Model" ) #m is class Model

This is what's happening in this loop:

for comp in parts[1:]:    m = getattr(m, comp)    

At the end of the loop, m will be a reference to the class. This means that m is actually the class itslef, you can do for instance:

a = m() #instantiate a new instance of the class    b = m( arg1, arg2 ) # pass arguments to the constructor

Assuming the class is in your scope:

globals()['classname'](args, to, constructor)

Otherwise:

getattr(someModule, 'classname')(args, to, constructor)

Edit: Note, you can't give a name like 'foo.bar' to getattr. You'll need to split it by . and call getattr() on each piece left-to-right. This will handle that:

module, rest = 'foo.bar.baz'.split('.', 1)fooBar = reduce(lambda a, b: getattr(a, b), rest.split('.'), globals()[module])someVar = fooBar(args, to, constructor)

def import_class_from_string(path):    from importlib import import_module    module_path, _, class_name = path.rpartition('.')    mod = import_module(module_path)    klass = getattr(mod, class_name)    return klass

Usage

In [59]: raise import_class_from_string('google.appengine.runtime.apiproxy_errors.DeadlineExceededError')()---------------------------------------------------------------------------DeadlineExceededError                     Traceback (most recent call last)<ipython-input-59-b4e59d809b2f> in <module>()----> 1 raise import_class_from_string('google.appengine.runtime.apiproxy_errors.DeadlineExceededError')()DeadlineExceededError: