Question

Context: I’m making a Ren’py game. The value is Character(). Yes, I know this is a dumb idea outside of this context.

I need to create a variable from an input string inside of a class that exists outside of the class’ scope:

class Test:
    def __init__(self):
        self.dict = {} # used elsewhere to give the inputs for the function below.

    def create_global_var(self, variable, value):
        # the equivalent of exec("global {0}; {0} = {1}".format(str(variable), str(value)))
        # other functions in the class that require this.

Test().create_global_var("abc", "123") # hence abc = 123

I have tried vars()[], globals()[variable] = value, etc, and they simply do not work (they don’t even define anything) Edit: this was my problem.

I know that the following would work equally as well, but I want the variables in the correct scope:

setattr(self.__class__, variable, value) # d.abc = 123, now. but incorrect scope.

How can I create a variable in the global scope from within a class, using a string as the variable name, without using attributes or exec in python?

And yes, i’ll be sanity checking.

Answer 1

First things first: what we call the "global" scope in Python is actually the "module" scope
(on the good side, it diminishes the "evils" of using global vars).

Then, for creating a global var dynamically, although I still can’t see why that would
be better than using a module-level dictionary, just do:

globals()[variable] = value

This creates a variable in the current module. If you need to create a module variable on the module from which the method was called, you can peek at the globals dictionary from the caller frame using:

from inspect import currentframe
currentframe(1).f_globals[variable] = name

Now, the this seems especially useless since you may create a variable with a dynamic name, but you can’t access it dynamically (unless using the globals dictionary again)

Even in your test example, you create the "abc" variable passing the method a string, but then you have to access it by using a hardcoded "abc" – the language itself is designed to discourage this (hence the difference to Javascript, where array indexes and object attributes are interchangeable, while in Python you have distinct Mapping objects)

My suggestion is that you use a module-level explicit dictionary and create all your
dynamic variables as key/value pairs there:

names = {}
class Test(object):
    def __init__(self):
        self.dict = {} # used elsewhere to give the inputs for the function below.

    def create_global_var(self, variable, value):
         names[variable] = value

(on a side note, in Python 2 always inherit your classes from "object")