我要回答的问题是：如何得到一个字符串中给定名称的变量的值？它以副本形式关闭，并带有指向此问题的链接。
如果所讨论的变量是对象的一部分（例如类的一部分），那么要实现这些变量，一些有用的函数是 hasattr , getattr ，和 setattr .
例如，你可以有：

class Variables(object):
    def __init__(self):
        self.foo = "initial_variable"
    def create_new_var(self,name,value):
        setattr(self,name,value)
    def get_var(self,name):
        if hasattr(self,name):
            return getattr(self,name)
        else:
            raise("Class does not have a variable named: "+name)

然后你可以做：

v = Variables()
v.get_var("foo")

“初始变量”

v.create_new_var(v.foo,"is actually not initial")
v.initial_variable

“实际上不是首字母”

你必须使用 globals() 实现该行为的内置方法：

def var_of_var(k, v):
    globals()[k] = v

print variable_name # NameError: name 'variable_name' is not defined
some_name = 'variable_name'
globals()[some_name] = 123
print(variable_name) # 123

some_name = 'variable_name2'
var_of_var(some_name, 456)
print(variable_name2) # 456

我在python3.7.3中都试过了，可以使用globals（）或vars（）

>>> food #Error
>>> milkshake #Error
>>> food="bread"
>>> drink="milkshake"
>>> globals()[food] = "strawberry flavor"
>>> vars()[drink] = "chocolate flavor"
>>> bread
'strawberry flavor'
>>> milkshake
'chocolate flavor'
>>> globals()[drink]
'chocolate flavor'
>>> vars()[food]
'strawberry flavor'

参考文献：
https://www.daniweb.com/programming/software-development/threads/111526/setting-a-string-as-a-variable-name#post548936

大家一致认为应该用字典来解释这个问题——看看其他的答案。对于大多数情况，这是一个好主意，但是，由此产生了许多方面：
您将自己负责这本字典，包括垃圾收集（在dict变量中）等。
变量要么没有局部性，要么没有全局性，这取决于字典的全局性
如果要重命名变量名，则必须手动重命名
不过，你要灵活得多。
您可以决定覆盖现有变量或。。。
... 选择实现常量变量
为不同类型引发重写异常
等。
也就是说，我实现了一个变量管理器类，它提供了上面的一些思想。它适用于python2和python3。
你可以这样使用这个类：

from variableVariablesManager import VariableVariablesManager

myVars = VariableVariablesManager()
myVars['test'] = 25
print(myVars['test'])

# define a const variable

myVars.defineConstVariable('myconst', 13)
try:
    myVars['myconst'] = 14 # <- this raises an error, since 'myconst' must not be changed
    print("not allowed")
except AttributeError as e:
    pass

# rename a variable

myVars.renameVariable('myconst', 'myconstOther')

# preserve locality

def testLocalVar():
    myVars = VariableVariablesManager()
    myVars['test'] = 13
    print("inside function myVars['test']:", myVars['test'])
testLocalVar()
print("outside function myVars['test']:", myVars['test'])

# define a global variable

myVars.defineGlobalVariable('globalVar', 12)
def testGlobalVar():
    myVars = VariableVariablesManager()
    print("inside function myVars['globalVar']:", myVars['globalVar'])
    myVars['globalVar'] = 13
    print("inside function myVars['globalVar'] (having been changed):", myVars['globalVar'])
testGlobalVar()
print("outside function myVars['globalVar']:", myVars['globalVar'])

如果希望只允许覆盖相同类型的变量：

myVars = VariableVariablesManager(enforceSameTypeOnOverride = True)
myVars['test'] = 25
myVars['test'] = "Cat" # <- raises Exception (different type on overwriting)

任何一组变量也可以封装在一个类中。”variable“变量可以在运行时通过dict属性直接访问内置字典添加到类示例中。
下面的代码定义了variables类，它在构造过程中将变量（在本例中是属性）添加到其示例中。变量名取自指定的列表（例如，该列表可能由程序代码生成）：

# some list of variable names

L = ['a', 'b', 'c']

class Variables:
    def __init__(self, L):
        for item in L:
            self.__dict__[item] = 100

v = Variables(L)
print(v.a, v.b, v.c)

# will produce 100 100 100

这应该是非常危险的。。。但您可以使用exec（）：

a = 'b=5'
exec(a)
c = b*2
print (c)

结果：10

# Python 3.8.2 (default, Feb 26 2020, 02:56:10)

python中的变量

"""
<?php
$a = 'hello';
$e = 'wow'
?>
<?php
$$a = 'world';
?>
<?php
echo "$a ${$a}\n";
echo "$a ${$a[1]}\n";
?>
<?php
echo "$a $hello";
?>
"""

a = 'hello'  #<?php $a = 'hello'; ?>
e = 'wow'   #<?php $e = 'wow'; ?>
vars()[a] = 'world' #<?php $$a = 'world'; ?>
print(a, vars()[a]) #<?php echo "$a ${$a}\n"; ?>
print(a, vars()[vars()['a'][1]]) #<?php echo "$a ${$a[1]}\n"; ?>
print(a, hello) #<?php echo "$a $hello"; ?>

输出：

hello world
hello wow
hello world

使用globals（）、locals（）或vars（）将产生相同的结果

# Python 3.8.2 (default, Feb 26 2020, 02:56:10)

# <?php $a = 'hello'; ?>

# <?php $e = 'wow'; ?>

# <?php $$a = 'world'; ?>

# <?php echo "$a ${$a}\n"; ?>

# <?php echo "$a ${$a[1]}\n"; ?>

# <?php echo "$a $hello"; ?>

print('locals():\n')
a = 'hello'
e = 'wow'
locals()[a] = 'world'
print(a, locals()[a])
print(a, locals()[locals()['a'][1]])
print(a, hello)

print('\n\nglobals():\n')
a = 'hello'
e = 'wow'
globals()[a] = 'world'
print(a, globals()[a])
print(a, globals()[globals()['a'][1]])
print(a, hello)

输出：

locals():

hello world
hello wow
hello world

globals():

hello world
hello wow
hello world

奖励（从字符串创建变量）

# Python 2.7.16 (default, Jul 13 2019, 16:01:51)

# [GCC 8.3.0] on linux2

创建变量和解包元组：

g = globals()
listB = []
for i in range(10):
    g["num%s" % i] = i**10
    listB.append("num{0}".format(i))

def printNum():
    print "Printing num0 to num9:"
    for i in range(10):
        print "num%s = " % i, 
        print g["num%s" % i]

printNum()

listA = []
for i in range(10):
    listA.append(i)

listA = tuple(listA)
print listA, '"Tuple to unpack"'

listB = str(str(listB).strip("[]").replace("'", "") + " = listA")

print listB

exec listB

printNum()

输出：

Printing num0 to num9:
num0 =  0
num1 =  1
num2 =  1024
num3 =  59049
num4 =  1048576
num5 =  9765625
num6 =  60466176
num7 =  282475249
num8 =  1073741824
num9 =  3486784401
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) "Tuple to unpack"
num0, num1, num2, num3, num4, num5, num6, num7, num8, num9 = listA
Printing num0 to num9:
num0 =  0
num1 =  1
num2 =  2
num3 =  3
num4 =  4
num5 =  5
num6 =  6
num7 =  7
num8 =  8
num9 =  9

你可以使用字典来完成这项工作。字典是键和值的存储库。

>>> dct = {'x': 1, 'y': 2, 'z': 3}
>>> dct
{'y': 2, 'x': 1, 'z': 3}
>>> dct["y"]
2

您可以使用变量密钥名来实现变量的效果，而不存在安全风险。

>>> x = "spam"
>>> z = {x: "eggs"}
>>> z["spam"]
'eggs'

如果你想做这样的事情

var1 = 'foo'
var2 = 'bar'
var3 = 'baz'
...

列表可能比dict更合适。列表表示对象的有序序列，具有整数索引：

lst = ['foo', 'bar', 'baz']
print(lst[1])           # prints bar, because indices start at 0
lst.append('potatoes')  # lst is now ['foo', 'bar', 'baz', 'potatoes']

对于有序序列，列表比带整数键的dict更方便，因为列表支持按索引顺序迭代，切片， append ，以及其他需要使用dict进行笨拙的密钥管理的操作。

使用内置 getattr 函数以按名称获取对象上的属性。根据需要修改名称。

obj.spam = 'eggs'
name = 'spam'
getattr(obj, name)  # returns 'eggs'

这不是个好主意。如果要访问全局变量，可以使用 globals() .

>>> a = 10
>>> globals()['a']
10

如果要访问本地范围中的变量，可以使用 locals() ，但不能为返回的dict赋值。
更好的解决办法是使用 getattr 或者将变量存储在字典中，然后按名称访问它们。

新的程序员有时会写这样的代码：

my_calculator.button_0 = tkinter.Button(root, text=0)
my_calculator.button_1 = tkinter.Button(root, text=1)
my_calculator.button_2 = tkinter.Button(root, text=2)
...

然后留给编码器一堆命名变量，编码工作量为o（m*n），其中m是命名变量的数量，n是需要访问（包括创建）变量组的次数。更精明的初学者注意到，每一行的唯一区别是一个根据规则变化的数字，并决定使用循环。但是，他们在如何动态创建这些变量名方面遇到了困难，可能会尝试以下方法：

for i in range(10):
    my_calculator.('button_%d' % i) = tkinter.Button(root, text=i)

他们很快发现这是行不通的。
如果程序需要任意变量“名称”，字典是最佳选择，如其他答案所述。然而，如果您只是试图创建许多变量，并且不介意用整数序列引用它们，那么您可能正在寻找一个 list . 如果你的数据是同质的，比如每天的温度读数，每周的测验分数，或者一个图形部件的网格，这一点尤其正确。
可按如下方式组装：

my_calculator.buttons = []
for i in range(10):
    my_calculator.buttons.append(tkinter.Button(root, text=i))

这个 list 也可以在一行中创建一个理解：

my_calculator.buttons = [tkinter.Button(root, text=i) for i in range(10)]

任何一种情况下的结果都是填充的 list ，使用 my_calculator.buttons[0] ，下一个 my_calculator.buttons[1] ，等等。“base”变量名成为 list 使用不同的标识符来访问它。
最后，不要忘记其他数据结构，例如 set -这类似于字典，只是每个“名称”没有附加值。如果你只是需要一个“袋子”的对象，这可以是一个伟大的选择。而不是像这样：

keyword_1 = 'apple'
keyword_2 = 'banana'

if query == keyword_1 or query == keyword_2:
    print('Match.')

您将拥有：

keywords = {'apple', 'banana'}
if query in keywords:
    print('Match.')

使用 list 对于一系列相似的对象 set 对于任意订购的物品袋，或 dict 对于包含关联值的名称包。

当你想使用变量时，最好使用字典。所以与其写作

$foo = "bar"
$$foo = "baz"

你在写什么

mydict = {}
foo = "bar"
mydict[foo] = "baz"

这样，您就不会意外地覆盖以前存在的变量（这是安全方面），并且您可以拥有不同的“名称空间”。

你也可以不用字典 namedtuple 从collections模块，这使得访问更容易。
例如：

# using dictionary

variables = {}
variables["first"] = 34
variables["second"] = 45
print(variables["first"], variables["second"])

# using namedtuple

Variables = namedtuple('Variables', ['first', 'second'])
vars = Variables(34, 45)
print(vars.first, vars.second)

使用 globals() 实际上，您可以动态地将变量分配给全局作用域，例如，如果您想要10个可以在全局作用域上访问的变量 i_1 , i_2 ... i_10 :

for i in range(10):
    globals()['i_{}'.format(i)] = 'a'

这将为所有这10个变量分配'a'，当然您也可以动态更改值。现在可以像其他全局声明的变量一样访问所有这些变量：

>>> i_5
'a'

如果您不想使用任何对象，您仍然可以使用 setattr() 在当前模块中：

import sys
current_module = module = sys.modules[__name__]  # i.e the "file" where your code is written
setattr(current_module, 'variable_name', 15)  # 15 is the value you assign to the var
print(variable_name)  # >>> 15, created from a string