Zeichenfolge in Python-Klassenobjekt konvertieren?

Wenn eine Zeichenfolge als Benutzereingabe für eine Python-Funktion angegeben wird, möchte ich ein Klassenobjekt daraus entfernen, wenn sich im aktuell definierten Namespace eine Klasse mit diesem Namen befindet. Im Wesentlichen möchte ich die Implementierung für eine Funktion, die diese Art von Ergebnis erzeugt:

class Foo:
    pass

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

Ist das überhaupt möglich?

Warnung : eval()Kann verwendet werden, um beliebigen Python-Code auszuführen. Sie sollten nie verwenden eval()mit nicht vertrauenswürdigen Strings. (Siehe Sicherheit von Pythons eval () für nicht vertrauenswürdige Zeichenfolgen? )

Das scheint am einfachsten zu sein.

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

Das könnte funktionieren:

import sys

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

Sie könnten so etwas tun wie:

globals()[class_name]

Sie möchten die Klasse Baz, die im Modul lebt foo.bar. Mit Python 2.7 möchten Sie Folgendes verwenden importlib.import_module(), da dies den Übergang zu Python 3 erleichtert:

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

Mit 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

Verwenden:

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)

Dies behandelt sowohl Klassen im alten als auch im neuen Stil genau.

Ich habe mir angesehen, wie Django damit umgeht

django.utils.module_loading hat dies

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

Sie können es wie verwenden import_string("module_path.to.all.the.way.to.your_class")

Ja, das kannst du machen. Angenommen, Ihre Klassen befinden sich im globalen Namespace.

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 Bezug auf die Ausführung von beliebigem Code oder unerwünschte vom Benutzer übergebene Namen können Sie eine Liste akzeptabler Funktions- / Klassennamen haben. Wenn die Eingabe mit einer in der Liste übereinstimmt, wird sie ausgewertet.

PS: Ich weiß ... ein bisschen spät ... aber es ist für alle anderen, die in Zukunft darüber stolpern.

Die Verwendung von importlib hat für mich am besten funktioniert.

import importlib

importlib.import_module('accounting.views') 

Dies verwendet die Zeichenfolgenpunktnotation für das Python-Modul, das Sie importieren möchten.

Wenn Sie Klassen, die Sie mit einer Zeichenfolge erstellen, wirklich abrufen möchten, sollten Sie sie in einem Wörterbuch speichern (oder richtig formulieren, referenzieren ). Auf diese Weise können Sie Ihre Klassen auch auf einer höheren Ebene benennen und unerwünschte Klassen vermeiden.

Beispiel aus einem Spiel, in dem in Python Schauspielerklassen definiert sind und Sie vermeiden möchten, dass andere allgemeine Klassen durch Benutzereingaben erreicht werden.

Ein anderer Ansatz (wie im folgenden Beispiel) würde darin bestehen, eine völlig neue Klasse zu erstellen, die die dictoben genannten enthält. Das würde:

• Ermöglichen Sie, dass mehrere Klasseninhaber für eine einfachere Organisation erstellt werden (z. B. einer für Schauspielerklassen und einer für Klangarten).
• Erleichtern Sie Änderungen sowohl am Inhaber als auch an den Klassen, die abgehalten werden.
• Und Sie können Klassenmethoden verwenden, um dem Diktat Klassen hinzuzufügen. (Obwohl die folgende Abstraktion nicht wirklich notwendig ist, dient sie nur der ... "Illustration" ).

Beispiel:

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

Das bringt mich zurück:

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

Ein weiteres lustiges Experiment, das damit zu tun hat, ist das Hinzufügen einer Methode, die das einbindet, ClassHolderdamit Sie nie alle Klassen verlieren, die Sie gemacht haben: ^)