Convertir cadena a objeto de clase Python?

Dada una cadena como entrada del usuario a una función de Python, me gustaría obtener un objeto de clase si hay una clase con ese nombre en el espacio de nombres actualmente definido. Esencialmente, quiero la implementación de una función que produzca este tipo de resultado:

class Foo:
    pass

str_to_class("Foo")
==> <class __main__.Foo at 0x69ba0>

¿Es esto posible?

Advertencia : eval()se puede usar para ejecutar código arbitrario de Python. Usted debe nunca se utilice eval()con las cadenas no son de confianza. (Consulte Seguridad de eval () de Python en cadenas no confiables? )

Esto parece más simple.

>>> class Foo(object):
...     pass
... 
>>> eval("Foo")
<class '__main__.Foo'>

Esto podría funcionar:

import sys

def str_to_class(classname):
    return getattr(sys.modules[__name__], classname)

Podrías hacer algo como:

globals()[class_name]

Quieres la clase Baz, que vive en el módulo foo.bar. Con Python 2.7, desea usar importlib.import_module(), ya que esto hará que la transición a Python 3 sea más fácil:

import importlib

def class_for_name(module_name, class_name):
    # load the module, will raise ImportError if module cannot be loaded
    m = importlib.import_module(module_name)
    # get the class, will raise AttributeError if class cannot be found
    c = getattr(m, class_name)
    return c

Con Python <2.7:

def class_for_name(module_name, class_name):
    # load the module, will raise ImportError if module cannot be loaded
    m = __import__(module_name, globals(), locals(), class_name)
    # get the class, will raise AttributeError if class cannot be found
    c = getattr(m, class_name)
    return c

Utilizar:

loaded_class = class_for_name('foo.bar', 'Baz')

import sys
import types

def str_to_class(field):
    try:
        identifier = getattr(sys.modules[__name__], field)
    except AttributeError:
        raise NameError("%s doesn't exist." % field)
    if isinstance(identifier, (types.ClassType, types.TypeType)):
        return identifier
    raise TypeError("%s is not a class." % field)

Esto maneja con precisión las clases de estilo antiguo y nuevo.

He visto cómo django maneja esto

django.utils.module_loading tiene esto

def import_string(dotted_path):
    """
    Import a dotted module path and return the attribute/class designated by the
    last name in the path. Raise ImportError if the import failed.
    """
    try:
        module_path, class_name = dotted_path.rsplit('.', 1)
    except ValueError:
        msg = "%s doesn't look like a module path" % dotted_path
        six.reraise(ImportError, ImportError(msg), sys.exc_info()[2])

    module = import_module(module_path)

    try:
        return getattr(module, class_name)
    except AttributeError:
        msg = 'Module "%s" does not define a "%s" attribute/class' % (
            module_path, class_name)
        six.reraise(ImportError, ImportError(msg), sys.exc_info()[2])

Puedes usarlo como import_string("module_path.to.all.the.way.to.your_class")

Sí, usted puede hacer esto. Suponiendo que sus clases existan en el espacio de nombres global, algo como esto lo hará:

import types

class Foo:
    pass

def str_to_class(s):
    if s in globals() and isinstance(globals()[s], types.ClassType):
            return globals()[s]
    return None

str_to_class('Foo')

==> <class __main__.Foo at 0x340808cc>

En términos de ejecución de código arbitrario, o nombres de usuario no deseados, podría tener una lista de nombres de función / clase aceptables, y si la entrada coincide con uno en la lista, se evalúa.

PD: Lo sé ... un poco tarde ... pero es para cualquiera que se encuentre con esto en el futuro.

Usar importlib funcionó mejor para mí.

import importlib

importlib.import_module('accounting.views') 

Esto utiliza la notación de puntos de cadena para el módulo de Python que desea importar.

Si realmente desea recuperar las clases que realiza con una cadena, debe almacenarlas (o redactarlas correctamente, hacer referencia ) en un diccionario. Después de todo, eso también permitirá nombrar sus clases en un nivel superior y evitar exponer clases no deseadas.

Ejemplo, de un juego en el que las clases de actores se definen en Python y desea evitar que el usuario ingrese a otras clases generales.

Otro enfoque (como en el ejemplo a continuación) sería hacer una clase completamente nueva, que contenga lo dictanterior. Esto sería:

• Permitir que se hagan múltiples titulares de clase para una organización más fácil (como, una para clases de actores y otra para tipos de sonido);
• Hacer modificaciones tanto al titular como a las clases que se imparten más fácilmente;
• Y puede usar métodos de clase para agregar clases al dict. (Aunque la siguiente abstracción no es realmente necesaria, es meramente para ... "ilustración" ).

Ejemplo:

class ClassHolder(object):
    def __init__(self):
        self.classes = {}

    def add_class(self, c):
        self.classes[c.__name__] = c

    def __getitem__(self, n):
        return self.classes[n]

class Foo(object):
    def __init__(self):
        self.a = 0

    def bar(self):
        return self.a + 1

class Spam(Foo):
    def __init__(self):
        self.a = 2

    def bar(self):
        return self.a + 4

class SomethingDifferent(object):
    def __init__(self):
        self.a = "Hello"

    def add_world(self):
        self.a += " World"

    def add_word(self, w):
        self.a += " " + w

    def finish(self):
        self.a += "!"
        return self.a

aclasses = ClassHolder()
dclasses = ClassHolder()
aclasses.add_class(Foo)
aclasses.add_class(Spam)
dclasses.add_class(SomethingDifferent)

print aclasses
print dclasses

print "======="
print "o"
print aclasses["Foo"]
print aclasses["Spam"]
print "o"
print dclasses["SomethingDifferent"]

print "======="
g = dclasses["SomethingDifferent"]()
g.add_world()
print g.finish()

print "======="
s = []
s.append(aclasses["Foo"]())
s.append(aclasses["Spam"]())

for a in s:
    print a.a
    print a.bar()
    print "--"

print "Done experiment!"

Esto me devuelve:

<__main__.ClassHolder object at 0x02D9EEF0>
<__main__.ClassHolder object at 0x02D9EF30>
=======
o
<class '__main__.Foo'>
<class '__main__.Spam'>
o
<class '__main__.SomethingDifferent'>
=======
Hello World!
=======
0
1
--
2
6
--
Done experiment!

Otro experimento divertido que hacer con ellos es agregar un método que conserve el encurtido ClassHolderpara que nunca pierdas todas las clases que hiciste: ^)