Python ont un équivalent à la Classe Java.forName()?

Réflexion en python est beaucoup plus facile et beaucoup plus souples que c'est en Java.

Je vous recommande la lecture de ce tutoriel

Il n'y a pas de fonction directe (que je connais) qui prend un nom de classe entièrement qualifié et retourne la classe, cependant, vous avez toutes les pièces nécessaires à la construction, et vous pouvez les connecter entre eux.

Un petit conseil cependant: n'essayez pas de programmer en Java de style lorsque vous êtes en python.

Si vous pouvez expliquer qu'est-ce que vous êtes en train de faire, peut-être nous pouvons vous aider à trouver un plus pythonic façon de faire.

Voici une fonction qui fait ce que vous voulez:

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

Vous pouvez utiliser la valeur de retour de cette fonction, comme si c'était la classe elle-même.

Voici un exemple d'utilisation:

>>> 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 )
>>> a
datetime.datetime(2010, 4, 22, 0, 0)
>>> 

Comment cela fonctionne?

Nous utilisons __import__ importer le module qui contient la classe, qui a exigé que nous avons d'abord extraire le nom du module à partir du nom complet. Ensuite, nous importons le module:

m = __import__( module )

Dans ce cas, m ne fait référence qu'à haut niveau module,

Par exemple, si votre classe vit dans foo.baz module, puis m sera le module foo

Nous pouvons facilement obtenir une référence à foo.baz à l'aide de getattr( m, 'baz' )

Pour obtenir à partir du niveau supérieur du module de la classe, ont récursive de l'utilisation gettatr sur les parties du nom de la classe

Dire par exemple, si vous avez un nom de classe est foo.baz.bar.Model puis nous faisons cela:

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

C'est ce qui se passe dans cette boucle:

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

À la fin de la boucle, m sera une référence à la classe. Cela signifie que m est en fait la classe itslef, vous pouvez le faire par exemple:

a = m() #instantiate a new instance of the class    
b = m( arg1, arg2 ) # pass arguments to the 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

Utilisation

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: 

Il semble que vous vous approchez de ce partir du milieu au lieu du début. De quoi êtes-vous vraiment essayer de faire? Trouver la classe associée à une chaîne de caractères est un moyen pour une fin.

Si vous préciser votre problème, qui pourrait avoir besoin de votre propre mental refactoring, une meilleure solution peut présenter lui-même.

Par exemple: Êtes-vous essayer de charger une version sauvegardée de l'objet en fonction de son type nom et un ensemble de paramètres? Python sorts de cette unpickling et vous devriez regarder la module pickle. Et même si le unpickling processus est exactement ce que vous décrivez, vous n'avez pas à vous soucier de la façon dont il fonctionne en interne:

>>> class A(object):
...   def __init__(self, v):
...     self.v = v
...   def __reduce__(self):
...     return (self.__class__, (self.v,))
>>> a = A("example")
>>> import pickle
>>> b = pickle.loads(pickle.dumps(a))
>>> a.v, b.v
('example', 'example')
>>> a is b
False