How to correctly create an instance of a class with exec() function?

I'm making a GUI using the TKinter library from Python. I want the user to select an option from a Combobox and then, to press a Button, which should create an instance of a class named as the selected option. In order to save code, I decided to use the exec() fuction in this way: exec('instance = ' + comboExample.get() + '()'). This starts the __init__() method of the class, but when I try to call an other method (in this case from an inherited class) using instance.method() it displays the following error: NameError: name 'instance' is not defined. Here you have an example of the script:

from tkinter import *
from tkinter import ttk

master = Tk()

#Create classes
class Base():
    def method(self):
        self.label = Label(master, text = self.sentence)
        self.label.pack()

class Example1(Base):
    def __init__(self):
        print('Example1 created')
        self.sentence = 'This is example 1.'

class Example2(Base):
    def __init__(self):
        print('Example2 created')
        self.sentence = 'This is example 2'

#Create Combobox and Button
combo = ttk.Combobox(master, state = 'readonly')
combo['values'] = ['Example1', 'Example2']
combo.pack()

def callback():
    exec('instance = ' + combo.get() + '()')
    #Here is the error
    instance.method()

button = Button(master, command = callback, text = 'Button')
button.pack()

master.mainloop()

I don't now why but when I try with the following code it works properly:

class Example():
    def __init__(self):
        self.text = 'This is an example'
    def add_text(self):
        print(self.text)

exec('instance = Example()')
instance.add_text()

At the moment, I've only found one solution, which consists in not using exec(), but makes me waste more code than using it, especially if I want to create a lot of classes like Example1 and Example2. It's all like the previous big script, but changing the callback() function:

def callback():
    if combo.get() == 'Example1':
        instance = Example1()
    if combo.get() == 'Example2':
        instance = Example2()
    instance.method()

That's all. I started programming in Python only 2 months ago and I'm also new in stackoverflow, so if I've made some mistake in the explanation or anything, please tell me and I'll fix it. Thanks for your time. Any help would be appreciated.

Solution

The issue isn’t your syntax; it’s that you’re trying to do something illegal. You can’t create new local variables with exec. (The reason the same code outside a function works is that in general you can create a new global variable with exec, but it’s still a bad idea.)

But you also don’t need to do that. In Python, everything is an object, including classes. So, you just need the get the class from the name. Then you can create an instance of that class, and store it in a local variable, by just using the same normal syntax you’d use for instantiating a class statically and storing it in a local variable.

The right way to do this is to store a dictionary mapping names to class objects. If you want to get clever, you can write a decorator that registers classes with that dictionary, but if that sounds like Greek to you, just do it explicitly:

classes = {'Spam': Spam, 'Eggs': Eggs}

If you have dozens of these, you can avoid the repetition with a comprehension like this:

from your_module import Spam, Eggs
classes = {cls.__name__: cls for cls in (Spam, Eggs)}

… but at that point you’re probably better off learning how to write the decorator.

Either way, you can fill your combo box with the keys of that dictionary instead of repeating yourself in the combo['values'] line.

And then, to create an instance, you just do this:

cls = classes[comboExample.get()]
instance = cls()

(Obviously you can collapse that into a single line, but I thought it would be easier to understand if we keep the two parts separate.)

If you really want to do this in a hacky way, you can. Every class that you’ve created in this module is already stored in a dictionary by name—the module’s global namespace. That’s the same place you were trying to find it implicitly with exec, but you can find it explicitly by just looking it up in globals(). However, the global namespace also has the names of all of your functions, imported modules, top-level constants and variables, etc., so this is usually a bad idea. (Obviously, exec has the exact same problems.)