Convertire una stringa in un oggetto di classe Python?

Data una stringa come input dell'utente a una funzione Python, mi piacerebbe estrarne un oggetto di classe se c'è una classe con quel nome nello spazio dei nomi attualmente definito. In sostanza, voglio l'implementazione di una funzione che produrrà questo tipo di risultato:

class Foo:
    pass

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

È possibile tutto questo?

Avvertenza : eval()può essere utilizzato per eseguire codice Python arbitrario. Non si dovrebbe mai usare eval()con stringhe non attendibili. (Vedi Security of Python's eval () su stringhe non attendibili? )

Questo sembra più semplice.

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

Questo potrebbe funzionare:

import sys

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

Potresti fare qualcosa del tipo:

globals()[class_name]

Vuoi la classe Baz, che vive nel modulo foo.bar. Con Python 2.7, si desidera utilizzare importlib.import_module(), poiché ciò renderà più semplice la transizione a Python 3:

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

Uso:

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)

Questo gestisce con precisione sia le lezioni di vecchio stile che quelle di nuovo stile.

Ho visto come django gestisce questo

django.utils.module_loading ha questo

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])

Puoi usarlo come import_string("module_path.to.all.the.way.to.your_class")

Si, puoi fare questo. Supponendo che le tue classi esistano nello spazio dei nomi globale, qualcosa del genere lo farà:

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>

In termini di esecuzione di codice arbitrario o di nomi utente non desiderati, potresti avere un elenco di nomi di funzioni / classi accettabili e se l'input corrisponde a uno nell'elenco, viene valutato.

PS: lo so .... un po 'tardi .... ma è per chiunque altro che si imbatte in questo in futuro.

L'uso di importlib ha funzionato al meglio per me.

import importlib

importlib.import_module('accounting.views') 

Questo utilizza la notazione a punti stringa per il modulo Python che si desidera importare.

Se vuoi veramente recuperare le classi che crei con una stringa, dovresti memorizzarle (o formarle correttamente, fare riferimento ) in un dizionario. Dopotutto, ciò consentirà anche di nominare le tue classi ad un livello superiore ed evitare di esporre le classi indesiderate.

Esempio, da un gioco in cui le classi di attori sono definite in Python e si desidera evitare che altre classi generali vengano raggiunte dall'input dell'utente.

Un altro approccio (come nell'esempio seguente) sarebbe quello di creare un'intera nuova classe, che contenga quanto dictsopra. Questo avrebbe:

• Consentire a più titolari di classi di essere creati per un'organizzazione più semplice (come, uno per le classi di attori e un altro per i tipi di suono);
• Apportare modifiche sia al titolare che alle classi tenute più facilmente;
• E puoi usare i metodi di classe per aggiungere classi al dict. (Anche se l'astrazione sotto non è davvero necessaria, è solo per ... "illustrazione" ).

Esempio:

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!"

Questo mi restituisce:

<__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!

Un altro esperimento divertente da fare con quelli è quello di aggiungere un metodo che sottaceti in ClassHoldermodo da non perdere mai tutte le classi che hai fatto: ^)