Code: Alles auswählen
from __future__ import print_function
foo = 'foo'
def set_foo(value):
global foo
foo = value
def print_foo():
print(foo)Code: Alles auswählen
>>> import funwithfoo
>>> funwithfoo.print_foo()
foo
>>> funwithfoo.set_foo('bar')
>>> funwithfoo.print_foo()
bar
>>> import funwithfoo
>>> funwithfoo.print_foo()
bar
Hier.gNeandr hat geschrieben:wo finde ich gute Hinweise zu Getter/Setter in Python?
Code: Alles auswählen
>>> import funwithfoo
>>> funwithfoo.print_foo()
foo
>>> funwithfoo.set_foo('bar')
>>> funwithfoo.print_foo()
bar
>>> reload(funwithfoo)
<module 'funwithfoo' from 'funwithfoo.pyc'>
>>> funwithfoo.print_foo()
foo
.. so ein wenig raucht der Kopf. kann ich noch nicht damit lösen (oder nur noch nicht erkennen?).Eine allgemein gültige Handhabung dürfte sein statt globalen Zustand zu verwenden, den mit Argumenten/Parametern zu lokalem Zustand zu machen der herum gereicht wird.
Code: Alles auswählen
exit_event = Event()
Thread(target=print_time, args=(exit_event, 'myTimer', 2)).start()
serve(exit_event, 'myListener')
) folgt im wesentlichen dieser Idee. Im Idealfall sind Exemplare und Funktionen vollständig gekapselt - egal wo und zu welcher Zeit Du ein Exemplar erstellst oder ein Ergebnis einer Funktion erhältst - sie verhalten sich gleich und sind damit vorhersagbar.Ich sprach schon ganz bewusst vom ``import``-Statement und dem dafür typischen Verhalten. Wenn ich das selbe Modul in mehreren Untermodulen verwende, dann mache ich dies nicht mit einem ``reload``, sondern eben mit ``import``-Statements.derdon hat geschrieben:@snafu: Du hast beim zweiten `import` nicht das Modul nochmal importiert; die Zeile bewirkte nichts, weil sich das Modul noch im Cache befand. Mit `reload` wird es wirklich neu geladen und es gibt ein anderes Verhalten als du es dargestellt hast:
in C die main-Funktion. Python erzwingt diese nicht, dafür hat sich unter Python der `if __name__ == '__main__': Block etabliert. Von hier aus gibst Du Zuständigkeit an Funktionen oder Exemplare und deren Methoden ab (über Parameter). Innerhalb deren Implementation orchestrieren sie wiederum ihre Subaufrufe (sind eine Art lokales "main"). Das Scoping von Python (und der meisten anderen Sprachen
DankeMeine Definition "last resort = letzter Ausweg" (laut Wörterbuch). Dass dieser letzte Ausweg trotzdem oft genommen wird liegt einfach daran, dass C keine äquivalenten besseren Sprachmittel z.B. zur Fehlerbehandlung anbietet.snafu hat geschrieben:Dafür, dass ``goto`` ein "last resort" sein soll, wird es in echten Programmen - u.a. im C-Quelltext von Python und im Linux-Kernel - aber ganz schön oft verwendet. Wie passt das mit deiner Aussage zusammen? Sind das für dich allesamt schlechte Programmierer oder setzt du eine sehr spezielle Definition von "last resort" voraus?Darii hat geschrieben:global ist der "last resort". Genau wie goto in C.
Code: Alles auswählen
def gen():
global a
while a > 0:
yield a
a -= 1
print 'a as global'
a = 10
for i in gen():
print i, a, list(gen())
print a, list(gen())
#################################
def reentrant_gen(a):
while a > 0:
yield a
a -= 1
print 'a as parameter'
a = 10
for i in reentrant_gen(a):
print i, a, list(reentrant_gen(a))
print a, list(reentrant_gen(a))