Python 如何通过while循环动态创建变量？

我想通过Python中的while循环动态创建变量。有没有人有任何创造性的方法来做到这一点？

除非有大量的需要创建一堆变量名，否则我只会使用字典，在字典中，您可以动态创建键名，并为每个键名关联一个值

a = {}
k = 0
while k < 10:
    # dynamically create key
    key = ...
    # calculate value
    value = ...
    a[key] = value 
    k += 1

a={}
k=0
当k<10时：
#动态创建密钥
键=。。。
#计算值
值=。。。
a[键]=值
k+=1

新版本中还有一些有趣的数据结构可能适用。

返回模块变量的字典。可以通过在该字典上创建键来创建新变量：

>>> print_name(kwargs)
{'name': 'python'}

默认情况下，模块定义了一些隐藏变量 打印（{k:v代表k，v在globals（）.items（）中，如果不是k.startswith（“”）}） 对于范围（1,11）内的i： globals（）[f“my_variable_{i}”]=i 打印（） 打印（my_变量_1） 打印（my_变量_2） #等等 打印（） 打印（{k:v代表k，v在globals（）.items（）中，如果不是k.startswith（“”）}） 结果:

{}
1.
2.
{'i'：10，'my_variable_1'：1，'my_variable_2'：2，'my_variable_3'：3，'my_variable_4'：4，'my_variable_5'：5，'my_variable_6'：6，'my_variable_7'：7，'my_variable_8'：8，'my_variable_9'：9，'my_variable_10'：10}

将内容填充到全局和/或本地名称空间不是一个好主意。使用口述是一种很好的语言

d['constant-key']=value

看起来很尴尬。Python是面向对象的。用一位大师的话说：“名称空间是一个非常好的主意——让我们做更多的工作吧！”

像这样：

>>> class Record(object):
...     pass
...
>>> r = Record()
>>> r.foo = 'oof'
>>> setattr(r, 'bar', 'rab')
>>> r.foo
'oof'
>>> r.bar
'rab'
>>> names = 'id description price'.split()
>>> values = [666, 'duct tape', 3.45]
>>> s = Record()
>>> for name, value in zip(names, values):
...     setattr(s, name, value)
...
>>> s.__dict__ # If you are suffering from dict withdrawal symptoms
{'price': 3.45, 'id': 666, 'description': 'duct tape'}
>>>

免费dom：

import random

alphabet = tuple('abcdefghijklmnopqrstuvwxyz')

globkeys = globals().keys()
globkeys.append('globkeys') # because name 'globkeys' is now also in globals()

print 'globkeys==',globkeys
print
print "globals().keys()==",globals().keys()

for i in xrange(8):
    globals()[''.join(random.sample(alphabet,random.randint(3,26)))] = random.choice(alphabet)
del i

newnames = [ x for x in globals().keys() if x not in globkeys ]
print
print 'newnames==',newnames

print
print "globals().keys()==",globals().keys()

print
print '\n'.join(repr((u,globals()[u])) for u in newnames)

结果

globkeys== ['__builtins__', 'alphabet', 'random', '__package__', '__name__', '__doc__', 'globkeys']

globals().keys()== ['__builtins__', 'alphabet', 'random', '__package__', '__name__', 'globkeys', '__doc__']

newnames== ['fztkebyrdwcigsmulnoaph', 'umkfcvztleoij', 'kbutmzfgpcdqanrivwsxly', 'lxzmaysuornvdpjqfetbchgik', 'wznptbyermclfdghqxjvki', 'lwg', 'vsolxgkz', 'yobtlkqh']

globals().keys()== ['fztkebyrdwcigsmulnoaph', 'umkfcvztleoij', 'newnames', 'kbutmzfgpcdqanrivwsxly', '__builtins__', 'alphabet', 'random', 'lxzmaysuornvdpjqfetbchgik', '__package__', 'wznptbyermclfdghqxjvki', 'lwg', 'x', 'vsolxgkz', '__name__', 'globkeys', '__doc__', 'yobtlkqh']

('fztkebyrdwcigsmulnoaph', 't')
('umkfcvztleoij', 'p')
('kbutmzfgpcdqanrivwsxly', 'a')
('lxzmaysuornvdpjqfetbchgik', 'n')
('wznptbyermclfdghqxjvki', 't')
('lwg', 'j')
('vsolxgkz', 'w')
('yobtlkqh', 'c')

另一种方式：

import random

pool_of_names = []
for i in xrange(1000):
    v = 'LXM'+str(random.randrange(10,100000))
    if v not in globals():
        pool_of_names.append(v)

alphabet = 'abcdefghijklmnopqrstuvwxyz' 

print 'globals().keys()==',globals().keys()

print
for j in xrange(8):
    globals()[pool_of_names[j]] = random.choice(alphabet)
newnames = pool_of_names[0:j+1]

print
print 'globals().keys()==',globals().keys()

print
print '\n'.join(repr((u,globals()[u])) for u in newnames)

结果:

globals().keys()== ['__builtins__', 'alphabet', 'random', '__package__', 'i', 'v', '__name__', '__doc__', 'pool_of_names']


globals().keys()== ['LXM7646', 'random', 'newnames', 'LXM95826', 'pool_of_names', 'LXM66380', 'alphabet', 'LXM84070', '__package__', 'LXM8644', '__doc__', 'LXM33579', '__builtins__', '__name__', 'LXM58418', 'i', 'j', 'LXM24703', 'v']

('LXM66380', 'v')
('LXM7646', 'a')
('LXM8644', 'm')
('LXM24703', 'r')
('LXM58418', 'g')
('LXM84070', 'c')
('LXM95826', 'e')
('LXM33579', 'j')

使用该方法运行任意代码。例如，假设您有一个字典，并且希望将每个键转换为具有其原始字典值的变量，则可以执行以下操作：

>>> c = {"one": 1, "two": 2}
>>> for k, v in c.items():
...     exec(f"{k} = {v}")
... 
>>> one
1
>>> two
2

允许您将变量从一个函数传递到另一个函数。通过这种方式，您可以使用字典的键作为变量名（可以在

while

循环中填充）。调用字典名称时，只需在其前面加上

**

# create a dictionary
>>> kwargs = {}
# add a key of name and assign it a value, later we'll use this key as a variable
>>> kwargs['name'] = 'python'

# an example function to use the variable
>>> def print_name(name):
...   print name

# call the example function
>>> print_name(**kwargs)
python

没有

**

，

kwargs

只是一本字典：

>>> print_name(kwargs)
{'name': 'python'}

---

注意：这应该被视为一次讨论，而不是一个实际的答案。

一种近似方法是在要创建变量的模块中操作

\uuuuu main\uuuu

。例如，有一个

b.py

：

#!/usr/bin/env python
# coding: utf-8


def set_vars():
    import __main__
    print '__main__', __main__
    __main__.B = 1

try:
    print B
except NameError as e:
    print e

set_vars()

print 'B: %s' % B

#!/usr/bin/env python
# coding: utf-8

try:
    import b
except NameError as e:
    print e

print 'in a.py: B', B

运行它将输出

$ python b.py
name 'B' is not defined
__main__ <module '__main__' from 'b.py'>
B: 1

$ python a.py
name 'B' is not defined
__main__ <module '__main__' from 'a.py'>
name 'B' is not defined
in a.py: B 1

运行它将输出

$ python b.py
name 'B' is not defined
__main__ <module '__main__' from 'b.py'>
B: 1

$ python a.py
name 'B' is not defined
__main__ <module '__main__' from 'a.py'>
name 'B' is not defined
in a.py: B 1

$python a.py
未定义名称“B”
__主要的
未定义名称“B”
在a.py:b1中

---

请注意，

\uuuuu main\uuuuu

已更改为

'a.py'

能否解释一下“通过while循环？”我不知道这意味着什么。要解决什么问题？需要一些上下文。我想创建一个while循环，在这个循环中，让它一遍又一遍地创建变量，直到我告诉它停止。这有意义吗？你说的“动态创建变量”是什么意思？如何动态创建？你能使用一个字典并分配它的各种值吗？@Trivikram:不正确，变量范围是整个函数，而不仅仅是while循环。@Josh和其他人。。。在字典

a

中创建项（键、值）与在作为字典实现的

locals（）

或

globals（）

中创建项（键、值）没有太大区别。我想知道为什么我的答案在

globals（）中创建了一个条目，却被一些投反对票的狙击手否决了

而Gintautas Miliauskas的答案被提升，而这个没有给出

操作方法的答案被提升了3次。@eyquem我没有给出任何具体的方法来创建密钥，因为我对OP在实践中需要的命名方案一无所知。相反，我只是给出了最通用、最简洁的方案来解决这个问题。@eyquem局部变量不是作为字典实现的。几乎总是，

locals（）

函数从局部变量创建字典，但字典不存在，除非调用

locals（）

@eyquem，否则本地名称空间被实现为堆栈上的插槽，因此字节码可以直接引用它们作为堆栈帧中的偏移量（加上调用

locals（）时也包含的自由变量）

。在Python2.x中，当您在函数中使用

exec

而不为exec指定本地名称空间时，会出现例外情况。我不确定这是在哪里记录的：它不是语言定义的一部分，因为不同的实现可以选择不同的方式实现本地名称空间。这是最好的答案。t因此，他的问题应该是一个规范性的问题。OP需要一种方法来创建与许多名称关联的许多值。他将其表述为“动态创建变量”但是使用字典是解决他真正问题的正确方法。@Ned Batchelder也许这个问题被误导了。但我认为他最好能得到两个答案：1-是的，你可以做你想做的事情2-但是你想进入的方式不是上帝的方式，因为这个原因。这样做，OP会学到两件事：Python就是pow相反，如果任何人被阻止独立思考和思考问题，这是对头脑风暴和反应的限制。我认为你被否决的原因是因为滥发全球指令的密钥通常不被认为是最佳做法。事实上，在你自己的代码中例如，如果您的随机密钥生成器生成一个已经在全局dict中的密钥（例如密钥“字母表”），您认为会发生什么情况。此外，我认为OPs问题暗示他需要获取他的“变量”创建后。他如何使用您的解决方案将其动态变量与全局范围内已经存在的变量区分开来？在这种情况下，单独的dict更好。它