terminar - for en python 3

¿Cómo se pueden crear dinámicamente variables a través de un ciclo while?

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo creo una cantidad variable de variables? 12 respuestas

Quiero crear variables dinámicamente a través de un ciclo while en Python. Alguien tiene algún medio creativo de hacer esto?

Answer 1

A menos que haya una abrumadora necesidad de crear un desorden de nombres de variables, solo usaría un diccionario, donde puedes crear dinámicamente los nombres de las claves y asociar un valor a cada uno.

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

También hay algunas estructuras de datos interesantes en el nuevo módulo ''colecciones'' que podrían ser aplicables:

http://docs.python.org/dev/library/collections.html

Answer 2

Por la libertad:

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)

Resultado

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

De otra manera:

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)

resultado:

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

Answer 3

Rellenar cosas en los espacios de nombres globales y / o locales no es una buena idea. El uso de un dict es para otro idioma-ish ... d[''constant-key''] = value simplemente se ve incómodo. Python es OO. En palabras de un maestro: "" "Los espacios de nombres son una gran idea que hace sonar la bocina: ¡hagamos más de eso!" ""

Me gusta esto:

>>> 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''}
>>>

Answer 4

Use el método exec (). Por ejemplo, supongamos que tiene un diccionario y desea convertir cada clave en una variable con su valor de diccionario original y hacer lo siguiente.

Python 2

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

Python 3

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

Answer 5

jugar con globals () lo hace posible:

import random
alphabet = tuple(''abcdefghijklmnopqrstuvwxyz'')
print ''/n''.join(repr(u) for u in globals() if not u.startswith(''__''))
for i in xrange(8):
globals()[''''.join(random.sample(alphabet,random.randint(3,26)))] = random.choice(alphabet)
print
print ''/n''.join(repr((u,globals()[u])) for u in globals() if not u.startswith(''__''))

un resultado:

''alphabet''
''random''
(''hadmgoixzkcptsbwjfyrelvnqu'', ''h'')
(''nzklv'', ''o'')
(''alphabet'', (''a'', ''b'', ''c'', ''d'', ''e'', ''f'', ''g'', ''h'', ''i'', ''j'', ''k'', ''l'', ''m'', ''n'', ''o'', ''p'', ''q'', ''r'', ''s'', ''t'', ''u'', ''v'', ''w'', ''x'', ''y'', ''z''))
(''random'', <module ''random'' from ''G:/Python27/lib/random.pyc''>)
(''ckpnwqguzyslmjveotxfbadh'', ''f'')
(''i'', 7)
(''xwbujzkicyd'', ''j'')
(''isjckyngxvaofdbeqwutl'', ''n'')
(''wmt'', ''g'')
(''aesyhvmw'', ''q'')
(''azfjndwhkqgmtyeb'', ''o'')

Usé al azar porque no explica qué nombres de "variables" dar y qué valores crear. Porque no creo que sea posible crear un nombre sin vincularlo a un objeto.

Answer 6

Los parámetros de palabras clave le permiten pasar variables de una función a otra. De esta forma, puede usar la clave de un diccionario como nombre de variable (que se puede llenar en su ciclo while). El nombre del diccionario solo debe ir precedido de ** cuando se llame.

# 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

Sin ** , kwargs es solo un diccionario:

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

Answer 7

NOTA: Esto debería considerarse una discusión en lugar de una respuesta real.

Un enfoque aproximado es operar __main__ en el módulo que desea crear variables. Por ejemplo, hay un 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

Ejecutarlo generaría

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

Pero este enfoque solo funciona en una secuencia de comandos de módulo único, porque la importación __main__ it siempre representará el módulo de la secuencia de comandos de entrada que está ejecutando python, esto significa que si b.py está involucrado por otro código, la variable B se creará en el alcance del script de entrada en lugar de b.py en b.py mismo. Supongamos que hay un script a.py :

#!/usr/bin/env python
# coding: utf-8
try:
import b
except NameError as e:
print e
print ''in a.py: B'', B

Ejecutarlo generaría

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

Tenga en cuenta que __main__ se cambia a ''a.py'' .

Answer 8

vars()[''meta_anio_2012''] = ''translate''