你可以使用字典来实现这一点。字典是键和值的存储。

>>> 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更合适。list表示对象的有序序列，索引为整数:

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

对于有序序列，列表比使用整数键的字典更方便，因为列表支持索引顺序迭代、切片、append和其他需要使用字典进行笨拙的键管理的操作。

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

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

你写

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

这样就不会意外地覆盖先前存在的变量(这是安全方面的问题)，并且可以使用不同的“名称空间”。

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

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

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

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

如果想要访问局部作用域中的变量，可以使用locals()，但不能为返回的dict赋值。

更好的解决方案是使用getattr或将变量存储在字典中，然后按名称访问它们。

大家的共识是使用字典来进行查询-请参阅其他答案。在大多数情况下，这是一个好主意，然而，这产生了许多方面:

• 您将自己负责这个字典，包括垃圾收集(indict变量)等。
• 变量变量没有局部性或全局性，这取决于字典的全局性
• 如果要重命名变量名，则必须手动执行
然而，你要灵活得多，例如:
• 您可以决定覆盖现有变量或…
• ．.． 选择实现const变量
• 针对不同类型的重写引发异常
• 等。
李< / ul > < / >

也就是说，我已经实现了一个__abc0类，它提供了上面的一些想法。它适用于python 2和3。

你可以像这样使用类:

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)

你必须使用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

你也可以使用collections模块中的namedtuple来代替字典，这使得访问更容易。

例如:

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

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

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(米 * n)，其中米是命名变量的数量，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用于带有关联值的名称包。

我正在回答的问题:如何得到一个变量的值给定它的名字在一个字符串? 这是一个带有问题链接的副本。< / p >

如果所讨论的变量是对象的一部分(例如类的一部分)，则可以使用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")

“initial_variable”

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

"实际上不是首字母"

下面的代码定义了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

SimpleNamespace类可以用setattr或SimpleNamespace子类创建新属性，并创建自己的函数来添加新的属性名(变量)。

from types import SimpleNamespace


variables = {"b":"B","c":"C"}
a = SimpleNamespace(**variables)
setattr(a,"g","G")
a.g = "G+"
something = a.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

使用globals()(免责声明:这是一个糟糕的做法，但这是对你的问题最直接的答案，请使用其他数据结构作为接受的答案)。

实际上，你可以动态地将变量分配给全局作用域，例如，如果你想要在全局作用域中访问10个变量i_1， i_2…i_10:

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

这将给所有这10个变量赋值“a”，当然你也可以动态地改变这个值。所有这些变量现在都可以像其他全局声明的变量一样访问:

>>> i_5
'a'

我已经尝试了python 3.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'

< br >

# 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

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

setattr ()方法设置指定对象的指定属性的值。

语法是这样的-

setattr(object, name, value)
Example –


setattr(self,id,123)

它等价于self.id = 123

正如您可能已经观察到的，setattr()期望将一个对象与值一起传递，以生成/修改一个新属性。

我们可以将setattr()与一个解决方案一起使用，以便能够在模块中使用。这里怎么——

import sys
x = "pikachu"
value = 46
thismodule = sys.modules[__name__]
setattr(thismodule, x, value)
print(pikachu)