Programowe tworzenie zmiennych w Pythonie

Question

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

Mam klasy o nazwie zmienna zdefiniowana jako tak:

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

Chcę utworzyć instancje 26 kapitał jednoliterowe zmiennej tak:

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

Do tej pory próbowałem różnych rozwiązań, a najlepsze, co wymyśliłem, to:

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

Jednak to nie działa i daje mi ten błąd:

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 

Co robię źle?

Answer 1

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

Czy jest to dobry idea pozostaje wątpliwa :)

Zadziała tylko dla globals() (tj moduł przypisania stopnia), jak definicja język wyraźnie stwierdza, że ​​modyfikowanie słownika zwrócony przez locals() nie może właściwie zmieniają wartość dowolnych zmiennych lokalnych.

Możesz także zrobić coś podobnego z klasą lub instancją klasy __dict__.

Answer 2

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

Nie jestem pewien, dlaczego chcesz to zrobić.

Answer 3

Cóż, to nie jest ładne, ale można uzyskać dostęp do słownika globals() bezpośrednio:

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

Answer 4

Nie trzeba używać exec na to, jak inni odpowiedzi pokazują, ale tutaj jest problem z oryginałem Kod:

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

będzie exec A = A, B = B itd Choć może to być interesujące, jeśli jesteś gorącym zwolennikiem obiektywizmu, pyton nie obchodzi zbyt wiele dla niego.

Chcesz mieć Variable() rzeczy wewnątrz Exec dla jej znaczenia:

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

W przyszłości, jeśli starasz się używać exec, najpierw spróbuj nie. Po drugie, wydrukuj to, co robisz - to pomoże w debugowaniu.

Answer 5

Najczystsze podejście zdecydowanie, jaki kiedykolwiek widziałem jest bezpośrednio dodać zmienne (tj atrybuty) do programu (czyli główny moduł), jako odpowiedzi 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: Python rdzeń programiści ciężko pracowali, aby umożliwić modyfikację globals() (patrz komentarze do odpowiedzi ncoghlan). Zatem modyfikowanie globals() jest alternatywą.Nie jestem pewien, dlaczego wielu ludzi uważa, że ​​nie jest to tak czyste, chociaż (być może dlatego, że modyfikacja globals() może być modyfikowana, to nie jest to udokumentowane w postaci ?).

Answer 6

Nie próbuj umieszczać tego w globalnej zmiennej. To jest okropne. Zrób to zamiast tego.

import string 

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

Dostęp do niego można uzyskać na przykład z variables['Q'].

Jeśli chcesz otrzymać dostęp przypisać można zrobić:

class Variables(object): pass 

i

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

Ale w takim razie wolałbym utworzyć je dynamicznie w klasie Zmienne pojemnika.

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) 

Zastosowanie:

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

Prosty i czysty, bez brzydkich hacki (dobrze, z wyjątkiem getattr, a to nie jest tak brzydki), a ty nawet nie trzeba wprowadzać zmiennych don nie potrzebuję.