在python循环中使用迭代器作为变量名

我一直在想，是否有一种方法可以在Python循环中使用迭代器作为变量名。例如，如果我想创建对象

v0

，

v1

，

v2

，有没有这样的方法：

for i in range(3):
    v + str(i) = i**2

globals()["v" + str(i)] = i**2

我知道语法是错误的，但是想法应该是清楚的。与R中的粘贴相当的东西？非常感谢，

内置方法返回表示当前全局符号表的字典

您可以向

globals

添加一个变量，如下所示：

for i in range(3):
    v + str(i) = i**2

globals()["v" + str(i)] = i**2

---

仅供参考：这是您问题的答案，但肯定不是推荐的方法。直接操纵

globals

是一种黑客解决方案，可以通过一些更干净的替代方案来避免。（参见本帖中的其他注释）

虽然这并不试图直接回答问题（参见geccos的答案），但这通常是此类操作的“批准”方法：

v = [i**2 for i in range(3)]

print v[0] # 0
print v[1] # 1
print v[2] # 4

一般来说，使用ADT（本例中的列表）来表示给定的问题比尝试创建“动态变量”或“变量变量”更简洁、更可扩展

快乐编码

---

虽然上面使用了索引，“变量”的更一般形式通常是通过字典完成的：

names = dict(("v" + str(i), i**2) for i in range(3))
print names["v2"] # 4

而且，对于固定的有限（且相对较小）变量集，也可以使用“解包”：

v0, v1, v2 = [i**2 for i in range(3)]
print v1 # 1

与range（）相比，我更喜欢xrange（）。 下面是您的代码：

for i in xrange(3):
    exec("v"+str(i)+" = i * i")

即使。。。

---

你应该考虑使用一个列表

。有几种方法可以做到这一点，最好的是取决于你在创建变量后实际上想做什么。

globals（）
exec（）
也可以工作，但比
globals（）
和
locals（）
更糟糕

如果
v1
、
v2
和
v3
是同质的，并且您只想通过索引访问它们，那么@user166390提到的列表理解是一个好主意

>>> v = [i ** 2 for i in range(3)]
>>> v[0]
0
>>> v[1]
1
>>> v[2]
4

您也可以这样做，如果它始终恰好是三个元素：

>>> v1, v2, v3 = [i ** 2 for i in range(3)]
>>> v1
0
>>> v2
1
>>> v3
2

如果对象更加独立，这很好，因为您可以为它们指定自己的名称

中间的另一个选项是使用
dict
：

d = {}
for i, val in enumerate(range(3)):
    d["v{}".format(i)] = val

>>> d["v0"]
0
>>> d["v1"]
1
>>> d["v2"]
4

或使用dict理解的上述快捷方式：

d = {"v{}".format(i): val for i, val in enumerate(range(3))}

使用globals（）创建变量名并使用exec（）解压元组：
输出：

Printing v1 to v10:
v1 = 10
v2 = 20
v3 = 30
v4 = 40
v5 = 50
v6 = 60
v7 = 70
v8 = 80
v9 = 90
v10 = 100
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) "Tuple to unpack"
v1, v2, v3, v4, v5, v6, v7, v8, v9, v10 = listA
Printing v1 to v10:
v1 = 1
v2 = 2
v3 = 3
v4 = 4
v5 = 5
v6 = 6
v7 = 7
v8 = 8
v9 = 9
v10 = 10

v0 = 0
v1 = 1
v2 = 4

v0 = 0
v1 = 1
v2 = 4

v0 = 0
v200 = 40000
v400 = 160000
v600 = 360000
v800 = 640000

v200 = 40000 (direct v200 value is unchanged)

v200 = 1999 (indirect value)
v200 = 1999 (indirect value)
v200 = 1999 (indirect value)

v200 = 2020 (direct value)
v200 = 2021 (direct value)

v0 = 0
v200 = 40000
v400 = 160000
v600 = 360000
v800 = 640000

v200 = 40000 (direct v200 value is unchanged)

v200 = 1999 (indirect value from key 40000)
{ '40000': 1999 }

They are equal!
They are equal!


请注意，可以使用locals（）、globals（）或vars（）
输出：

Printing v1 to v10:
v1 = 10
v2 = 20
v3 = 30
v4 = 40
v5 = 50
v6 = 60
v7 = 70
v8 = 80
v9 = 90
v10 = 100
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) "Tuple to unpack"
v1, v2, v3, v4, v5, v6, v7, v8, v9, v10 = listA
Printing v1 to v10:
v1 = 1
v2 = 2
v3 = 3
v4 = 4
v5 = 5
v6 = 6
v7 = 7
v8 = 8
v9 = 9
v10 = 10

v0 = 0
v1 = 1
v2 = 4

v0 = 0
v1 = 1
v2 = 4

v0 = 0
v200 = 40000
v400 = 160000
v600 = 360000
v800 = 640000

v200 = 40000 (direct v200 value is unchanged)

v200 = 1999 (indirect value)
v200 = 1999 (indirect value)
v200 = 1999 (indirect value)

v200 = 2020 (direct value)
v200 = 2021 (direct value)

v0 = 0
v200 = 40000
v400 = 160000
v600 = 360000
v800 = 640000

v200 = 40000 (direct v200 value is unchanged)

v200 = 1999 (indirect value from key 40000)
{ '40000': 1999 }

They are equal!
They are equal!


此示例使用字典而不是列表：
输出：

Printing v1 to v10:
v1 = 10
v2 = 20
v3 = 30
v4 = 40
v5 = 50
v6 = 60
v7 = 70
v8 = 80
v9 = 90
v10 = 100
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) "Tuple to unpack"
v1, v2, v3, v4, v5, v6, v7, v8, v9, v10 = listA
Printing v1 to v10:
v1 = 1
v2 = 2
v3 = 3
v4 = 4
v5 = 5
v6 = 6
v7 = 7
v8 = 8
v9 = 9
v10 = 10

v0 = 0
v1 = 1
v2 = 4

v0 = 0
v1 = 1
v2 = 4

v0 = 0
v200 = 40000
v400 = 160000
v600 = 360000
v800 = 640000

v200 = 40000 (direct v200 value is unchanged)

v200 = 1999 (indirect value)
v200 = 1999 (indirect value)
v200 = 1999 (indirect value)

v200 = 2020 (direct value)
v200 = 2021 (direct value)

v0 = 0
v200 = 40000
v400 = 160000
v600 = 360000
v800 = 640000

v200 = 40000 (direct v200 value is unchanged)

v200 = 1999 (indirect value from key 40000)
{ '40000': 1999 }

They are equal!
They are equal!


还要注意，无论是从字符串创建变量、分配直接值还是分配间接值，都可以互换使用locals（）、globals（）和vars（）
输出：

Printing v1 to v10:
v1 = 10
v2 = 20
v3 = 30
v4 = 40
v5 = 50
v6 = 60
v7 = 70
v8 = 80
v9 = 90
v10 = 100
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) "Tuple to unpack"
v1, v2, v3, v4, v5, v6, v7, v8, v9, v10 = listA
Printing v1 to v10:
v1 = 1
v2 = 2
v3 = 3
v4 = 4
v5 = 5
v6 = 6
v7 = 7
v8 = 8
v9 = 9
v10 = 10

v0 = 0
v1 = 1
v2 = 4

v0 = 0
v1 = 1
v2 = 4

v0 = 0
v200 = 40000
v400 = 160000
v600 = 360000
v800 = 640000

v200 = 40000 (direct v200 value is unchanged)

v200 = 1999 (indirect value)
v200 = 1999 (indirect value)
v200 = 1999 (indirect value)

v200 = 2020 (direct value)
v200 = 2021 (direct value)

v0 = 0
v200 = 40000
v400 = 160000
v600 = 360000
v800 = 640000

v200 = 40000 (direct v200 value is unchanged)

v200 = 1999 (indirect value from key 40000)
{ '40000': 1999 }

They are equal!
They are equal!

工作原理
输出：

Printing v1 to v10:
v1 = 10
v2 = 20
v3 = 30
v4 = 40
v5 = 50
v6 = 60
v7 = 70
v8 = 80
v9 = 90
v10 = 100
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) "Tuple to unpack"
v1, v2, v3, v4, v5, v6, v7, v8, v9, v10 = listA
Printing v1 to v10:
v1 = 1
v2 = 2
v3 = 3
v4 = 4
v5 = 5
v6 = 6
v7 = 7
v8 = 8
v9 = 9
v10 = 10

v0 = 0
v1 = 1
v2 = 4

v0 = 0
v1 = 1
v2 = 4

v0 = 0
v200 = 40000
v400 = 160000
v600 = 360000
v800 = 640000

v200 = 40000 (direct v200 value is unchanged)

v200 = 1999 (indirect value)
v200 = 1999 (indirect value)
v200 = 1999 (indirect value)

v200 = 2020 (direct value)
v200 = 2021 (direct value)

v0 = 0
v200 = 40000
v400 = 160000
v600 = 360000
v800 = 640000

v200 = 40000 (direct v200 value is unchanged)

v200 = 1999 (indirect value from key 40000)
{ '40000': 1999 }

They are equal!
They are equal!

这和你标题中的问题有什么关系？更好的是，你为什么要这样做？有很多方法可以做到这一点，但是你最好分配到另一个列表，然后通过索引访问该列表。我已经更改了问题名称。我遇到过这样一种情况，即以这种特定的方式存储或引用数据会很有帮助（我知道还有其他方法，但有时也会很有用）。请给我举一个例子，说明这种情况比
列表
更好。人们应该能够注意到[接受的]答案中的一个共同主题：，+1，因为这解决了它。我不建议这样做，但它解决了问题。您也可以对任何关联数组类型执行类似操作，而不仅仅是
globals
数组，尽管您必须访问数组才能提取它。我讨厌人们提供解决方案，允许人们做他们不应该做的事情。我不知道我是否应该因为鼓励一个坏主意而对此投反对票，因为这正是OP所要求的。有些人只是提供问题的答案，而另一些人则在讨论如何找到更好的方式来实现某件事。我认为，正是这两种答案的混合，才使它如此珍贵。（但我同意你的观点，使用
globals
不是推荐的方式）呵呵。好的，a+1回答问题：）但是，当建议某事时。。。“一般不赞成”。。。像这样，最好在答案中指出它的一般问题/局限性。（我以前使用过
globals（）
和
locals（）
，但都是在非常特殊的情况下使用的。）我不明白为什么有人想尝试用python创建变量？对我来说，你似乎没有办法处理你刚创建的变量，必须通过全局或局部挖掘才能找到它们。OP能否将问题改为“为什么有人会在py中创建变量？”这样我就可以看到答案了？