programmazione creazione di variabili in Python

Question

Possible Duplicate:
How to programmatically set a global (module) variable?

ho una classe chiamata variabile definita come così:

class Variable(): 
    def __init__(self, name): 
     self.name = name 
     self._value = None 
    def value(self): 
     return self._value 
    def __repr__(self): 
     return self.name 

voglio creare istanze 26 capitali singola lettera di variabile in questo modo:

A = Variable('A') 
B = Variable('B') 
... 
Z = Variable('Z') 

Finora ho provato varie soluzioni, e il meglio che ho trovato è:

from string import uppercase 
for char in uppercase: 
    exec "%s = %s" % (char, Variable(str(char))) in None 

Tuttavia, questo non viene eseguito e mi dà questo errore:

Traceback (most recent call last): 
    File "C:\Users\Administrator\Dev\python\truthtable\truthtable.py", line 7, in <module> 
    exec "%s = %s" % (char, Variable(str(char))) in None 
    File "<string>", line 1, in <module> 
NameError: name 'A' is not defined 

Che cosa sto facendo di sbagliato?

Answer 1

from string import uppercase 
_g = globals() 
for char in uppercase: 
    _g[char] = Variable(char) 

Se questa è una buona idearimane discutibile :)

Questo funziona solo per globals() (cioè modulo assegnazioni di livello), come la definizione del linguaggio afferma esplicitamente che la modifica del dizionario restituito da locals() non possono in realtà cambia il valore di qualsiasi variabile locale.

È inoltre possibile eseguire operazioni simili con lo __dict__ di una classe o di un'istanza.

Answer 2

from string import uppercase 
for c in uppercase: 
    locals()[c] = Variable(c) 
print A 

Non sono sicuro del motivo per cui si desidera farlo.

Answer 3

Beh, non è abbastanza, ma è possibile accedere alla globals() dizionario direttamente:

for c in 'ABC': 
    globals()[c] = Variable(c) 

Answer 4

Non è necessario utilizzare exec per questo, come le altre risposte mostrano, ma qui è il problema con il vostro originale codice:

for char in uppercase: 
    exec "%s = %s" % (char, Variable(str(char))) in None 

Ciò exec A = A, B = B, ecc Mentre questo può essere interessante se sei un ardente seguace di oggettivismo, Python non si cura troppo per questo.

Volete avere la roba Variable() all'interno del exec per la sua importanza:

for char in uppercase: 
    exec "%s = Variable('%s')" % (char, char) 

In futuro, se si sta cercando di utilizzare exec, in primo luogo cercare di non farlo. In secondo luogo, stampa ciò che stai eseguendo - questo aiuterà a eseguire il debug.

Answer 5

L'approccio più pulito in assoluto che io abbia mai visto è quello di aggiungere direttamente le variabili (ad esempio gli attributi) al vostro programma (cioè modulo principale), come risposta in another question on StackOverflow:

import sys 
from string import ascii_uppercase 

this_module = sys.modules[__name__] 
for char in ascii_uppercase: 
    setattr(this_module, char, Variable(char)) 

print A # Works! 

PS: nucleo Python gli sviluppatori hanno lavorato sodo per rendere possibile la modifica di globals() (vedere i commenti alla risposta di ncoghlan). Quindi, la modifica di globals() è un'alternativa.Non sono sicuro del motivo per cui molte persone ritengono che non sia così pulito, anche se (forse perché il fatto che globals() può essere modificato non è esplicitamente documentato?).

Answer 6

Non tentare di inserirlo in una variabile globale. È orribile. Fallo invece.

import string 

variables = {} 
for x in string.ascii_uppercase: 
    variables[x] = Variable(x) 

La si accede da variables['Q'], per esempio.

Se si vuole attribuire l'accesso si può fare:

class Variables(object): pass 

e

variables = Variables() 
for x in string.ascii_uppercase: 
    setattr(variables, x) = Variable(x) 

Ma in questo caso preferisco creare dinamicamente in una classe di variabili container.

import string 

class Variable(object): 
    def __init__(self, value): 
     self.value = value 
    def __repr__(self): 
     return "<Variable %s>" % self.value 

class Variables(object): 
    def __getattr__(self, n): 
     if n in string.ascii_uppercase: 
      v = Variable(n) 
      setattr(self, n, v) 
      return v 
     raise AttributeError("Variables instance has no attribute %s" % n) 

Usage:

>>> v = Variables() 
>>> v.G 
<Variable G> 
>>> v.Y 
<Variable Y> 
>>> v.G is v.G 
True 

Semplice e pulito, nessun hack brutto (beh, tranne un getattr, e non è così brutto), e non hanno nemmeno bisogno di fare le variabili don ne ho bisogno