แปลงสตริงเป็นวัตถุคลาส Python หรือไม่

รับสตริงเป็นอินพุตของผู้ใช้ไปยังฟังก์ชั่น Python ฉันต้องการเอาคลาสอ็อบเจกต์ออกมาถ้ามีคลาสที่มีชื่อนั้นในเนมสเปซที่กำหนดในปัจจุบัน โดยพื้นฐานแล้วฉันต้องการการนำไปใช้งานสำหรับฟังก์ชั่นที่จะให้ผลลัพธ์แบบนี้:

class Foo:
    pass

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

เป็นไปได้ไหม?

คำเตือน : eval()สามารถใช้เพื่อเรียกใช้งานโค้ด Python โดยพลการ คุณไม่ควรใช้eval()กับสตริงที่ไม่น่าเชื่อถือ (ดูSecurity of Python eval () สำหรับสตริงที่ไม่น่าเชื่อถือ? )

ดูเหมือนง่ายที่สุด

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

สิ่งนี้สามารถใช้งานได้:

import sys

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

คุณสามารถทำสิ่งที่ชอบ:

globals()[class_name]

คุณต้องการที่ชั้นซึ่งอาศัยอยู่ในโมดูลBaz foo.barด้วย Python 2.7 คุณต้องการใช้importlib.import_module()เนื่องจากจะทำให้การเปลี่ยนเป็น 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

ด้วย 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

ใช้:

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)

วิธีนี้จัดการกับคลาสแบบเก่าและคลาสใหม่ได้อย่างแม่นยำ

ฉันได้ดูว่า django จัดการกับสิ่งนี้อย่างไร

django.utils.module_loading มีสิ่งนี้

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

คุณสามารถใช้มันเหมือน import_string("module_path.to.all.the.way.to.your_class")

ใช่คุณสามารถทำได้ สมมติว่าคลาสของคุณมีอยู่ในเนมสเปซส่วนกลางบางอย่างเช่นนี้จะทำ:

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>

ในแง่ของการใช้รหัสโดยอำเภอใจหรือชื่อผู้ใช้ที่ไม่ต้องการผ่านคุณอาจมีรายการชื่อฟังก์ชั่น / คลาสที่ยอมรับได้และถ้าอินพุตตรงกับหนึ่งในรายการมันจะถูกประเมิน

PS: ฉันรู้ว่า .... สายเกินไป .... แต่สำหรับคนอื่นที่เจอสิ่งนี้ในอนาคต

การใช้importlibทำงานได้ดีที่สุดสำหรับฉัน

import importlib

importlib.import_module('accounting.views') 

สิ่งนี้ใช้รูปแบบจุดสตริงสำหรับโมดูลหลามที่คุณต้องการนำเข้า

หากคุณต้องการดึงชั้นเรียนที่คุณสร้างขึ้นด้วยสตริงคุณควรเก็บ (หรือใช้คำอ้างอิงอย่างถูกต้อง ) ในพจนานุกรม ท้ายที่สุดแล้วมันจะอนุญาตให้ตั้งชื่อคลาสของคุณในระดับที่สูงขึ้นและหลีกเลี่ยงการเปิดเผยคลาสที่ไม่ต้องการ

ตัวอย่างจากเกมที่มีการกำหนดคลาสของนักแสดงใน Python และคุณต้องการหลีกเลี่ยงการเข้าถึงคลาสทั่วไปอื่น ๆ โดยการป้อนข้อมูลของผู้ใช้

อีกวิธีหนึ่ง (เช่นในตัวอย่างด้านล่าง) จะทำให้คลาสใหม่ทั้งหมดที่เก็บdictไว้ข้างต้น สิ่งนี้จะ:

• อนุญาตให้ผู้ถือคลาสหลายคนสร้างขึ้นเพื่อการจัดระเบียบที่ง่ายขึ้น (เช่นหนึ่งสำหรับชั้นเรียนของนักแสดงและอีกประเภทสำหรับประเภทเสียง);
• ทำการปรับเปลี่ยนทั้งผู้ถือและชั้นเรียนที่ถูกจัดขึ้นง่ายขึ้น;
• และคุณสามารถใช้วิธีการเรียนเพื่อเพิ่มชั้นเรียนเพื่อ Dict (แม้ว่าสิ่งที่เป็นนามธรรมด้านล่างไม่จำเป็นจริงๆมันเป็นเพียงสำหรับ ... "ภาพประกอบ" )

ตัวอย่าง:

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

สิ่งนี้ทำให้ฉัน:

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

การทดลองที่สนุกอีกอย่างหนึ่งเกี่ยวกับสิ่งเหล่านั้นคือการเพิ่มวิธีการที่จะดองClassHolderดังนั้นคุณจะไม่สูญเสียคลาสทั้งหมดที่คุณทำ: ^)