Python: creating a variable using retrieved string name

Question

This may be convoluted/unsafe, but I'd appreciate if someone could let me know if there is a way to do the following in Python or not.

1) Using a list of strings (henceforth called the alpha list), I would like to create other list variables named after the strings.

2) I'd like to be able to manipulate (but primarily append values to) these new list variables without calling them explicitly, i.e. calling them using the alpha list's indexes so that I can run them through a loop.

Below I'll provide code that hopefully conveys more clearly what I'm trying to do.

#1
alphaString = ['a', 'b', 'c', 'd', 'e']
for letter in alphaString:
    letter = []

#2
rowOfValues = ["alpha", "bravo", "charlie", "delta", "echo"] 
#Length of rowOfValues supposed to be same length as alphaString
#There would be many rows being run through a bigger loop that includes this code, but I'll keep it to just this one row for simplicity

for i in range (0, len(alphaString)):
    if rowOfValues[i] not in alphaString[i]: #Ex. if "alpha" not in list a
            alphaString[i].append(rowOfValues[i]) #Ex.  a.append("alpha")

Is what I'm trying to do not possible with Python, or am I just going about it the wrong way? Thank you!

http://stackoverflow.com/questions/1429814/how-to-programmatically-set-a-global-module-variable — Michael, Aug 14 '14 at 17:44

ely · Accepted Answer · 2014-08-14T17:53:04.810

You can do this in Python by tinkering with the dict that holds local or global variables, locals() and globals(). However, manipulating these structures is considered dangerous and in some cases it may not work as the programmer (or a later person reading the code) expects.

Usually, when a program needs to associate a particular string name with some value, the right Python data structure is a dict that uses the string values as the keys. In your case it could look like this:

letter_dict = {}
alphaString = ['a', 'b', 'c', 'd', 'e']
for letter in alphaString:
    letter_dict[letter] = []

rowOfValues = ["alpha", "bravo", "charlie", "delta", "echo"] 
#Length of rowOfValues supposed to be same length as alphaString
#There would be many rows being run through a bigger loop that includes this code, but I'll keep it to just this one row for simplicity

for i in range (0, len(alphaString)):
    if rowOfValues[i] not in letter_dict[alphaString[i]]: #Ex. if "alpha" not in list a
            letter_dict[alphaString[i]].append(rowOfValues[i]) #Ex.  a.append("alpha")

At the end, letter_dict would have entries such as:

{'a': ['alpha'], 'b': ['bravo'], ...}

There are much cleaner ways to write the code you have in your example as well, using dictionary comprehensions, for example. And if you need to reference the entire set of names that have been associated, you can just request the list of keys from the dictionary: letter_dict.keys().

The Python standard library collections also has a special kind of dict called defaultdict. This kind of data structure accepts a function that can be called whenever a particular key is not already found in the dictionary. If you chose to use that structure, you could get rid of the need to initialize the empty lists explicitly as you do:

from collections import defaultdict

# Make an empty dict where, if a key is requested and not found, an empty list
# will be stored for that key as the default.
letter_dict = defaultdict(lambda: [])

Then you can skip the loop of for letter in alphaString.

Is it dangerous enough that you would recommend not using this method (if possible), or are there some precautions to keep in mind/steps to take to avoid the dangers? — user3814426, Aug 14 '14 at 18:10
You mean the use of `locals` or `globals`? [Here is one explanation](http://www.diveintopython.net/html_processing/locals_and_globals.html), but also just search around this site because there are many questions and answers which outline pitfalls of `locals`, `globals`, and `eval`. For me, it's enough just that I want things to be robust to simple spelling errors. The difference between tracking down a `dict` key that is spelled wrong versus a variable that was programmatically created with the wrong name is huge. The `dict` approach is somewhat more encapsulated too. — ely, Aug 14 '14 at 18:15
The [Python documentation](https://docs.python.org/2/library/functions.html#locals) is quite explicit regarding `locals()`: "The contents of this dictionary should not be modified; changes may not affect the values of local and free variables used by the interpreter." — chepner, Aug 14 '14 at 18:50
It isn't so much that locals and globals is dangerous: it's that it's convoluted and confusing, and a dict is simpler. — Ned Batchelder, Aug 15 '14 at 12:39

score 0 · Answer 2 · answered Aug 14 '14 at 18:13

So it should be possible, only it would take some time figuring out how to do it (with dicts and eval maybe?), but it would be messy and unsafe.

This is a simple oneliner that (I think)does the job (I'm still not completely sure what you want).

dict(zip(alphaString,map(lambda x: [x],rowOfValues)))

This does not, however, make the values unique. But with some playing with for loops, set and lambda that shouldn't be a problem.

score -1 · Answer 3 · answered Aug 14 '14 at 18:05

Indeed, a dictionary structure, as suggested by @EMS is probably best suited. However, you can probably use the exec command for creating variables on the fly using string. For example, if you wish to set a=3 from a string, you can do.

exec('a=3')

In your case, you might want to try

nameList = ['a','b','c','d','e']
varList = []
for name in nameList:
    exec(name+'=[]') 
    exec('varList.append('+name+')')

etc...

Python: creating a variable using retrieved string name

3 Answers3