global oder nicht global

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Benutzeravatar
snafu
User
Beiträge: 6030
Registriert: Donnerstag 21. Februar 2008, 17:31
Wohnort: Gelsenkirchen

Samstag 31. Mai 2014, 12:18

@gNeandr: Benenne doch mal konkret, wo du den Einsatz globaler Variablen benötigst. Ist dir z.B. klar, dass bei mehrfachen Importen des selben Moduls sich globale Zustandsveränderungen immer auf alle Stellen auswirken, wo das Modul benutzt wird? Ein ``import`` initialisiert ein Modul nämlich nur einmal. Nachfolgende Importe verwenden das bereits initialisierte Modul und damit auch dessen Zustand. Das kann zu äußerst merkwürdigem Verhalten führen. Beispiel:

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
Es ist zwar ungewöhnlich, dass man im selben Modul ein anderes Modul mehrfach importiert, aber bei Projekten mit vielen Untermodulen kommt es ziemlich häufig vor, dass z.B. in mehreren Modulen das ``os``-Modul importiert wird. Und da kann einem dieses Verhalten durchaus um die Ohren fliegen.
Zuletzt geändert von snafu am Samstag 31. Mai 2014, 12:23, insgesamt 1-mal geändert.
Benutzeravatar
pillmuncher
User
Beiträge: 1165
Registriert: Samstag 21. März 2009, 22:59
Wohnort: München

Samstag 31. Mai 2014, 12:22

gNeandr hat geschrieben:wo finde ich gute Hinweise zu Getter/Setter in Python?
Hier.
In specifications, Murphy's Law supersedes Ohm's.
gNeandr
User
Beiträge: 68
Registriert: Sonntag 11. Mai 2014, 16:48

Samstag 31. Mai 2014, 12:28

@pillmuncher .. werde das mal durcharbeiten, Danke

@snafu
Die global Diskussion wurde angestoßen in diesem Thread:
http://www.python-forum.de/viewtopic.php?f=1&t=33895
Dort verwende ich verschiedene 'Parameter' in unterschiedlichen Routinen, aber das ganze wird (immer) ein einziges py Programm bleiben (soweit ich es momentan sehe)
BlackJack

Samstag 31. Mai 2014, 13:07

@gNeandr: 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.

Zum Closure: Anstelle eines solchen würde man in Python eine Klasse schreiben. Allerdings ist das ja letztendlich nur ein Wörterbuch, also könnte man auch gleich ein solches verwenden. Was wieder unschön ist, weil es ja eine globale Datenstruktur wäre.
Benutzeravatar
snafu
User
Beiträge: 6030
Registriert: Donnerstag 21. Februar 2008, 17:31
Wohnort: Gelsenkirchen

Samstag 31. Mai 2014, 14:15

Wenn man viele Werte herumreichen muss, aber Klassen einem noch zu hoch sind oder man die aus anderen Gründen nicht verwenden möchte, dann bietet Python diverse Möglichkeiten an: BlackJack hatte ja schon Wörterbücher genannt. Was noch geht, wären ``namedtuple``s oder ggf auch ``Namespace``-Objekte (wird von ``argparse`` so gemacht). Und die erstellt man dann natürlich nicht global, sondern lässt sich einmalig einen Kontext mit Default-Werten erzeugen ("options", "settings", "configuration", was-auch-immer), den man dann herumreichen kann.
derdon
User
Beiträge: 1316
Registriert: Freitag 24. Oktober 2008, 14:32

Samstag 31. Mai 2014, 17:00

@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:

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
gNeandr
User
Beiträge: 68
Registriert: Sonntag 11. Mai 2014, 16:48

Samstag 31. Mai 2014, 17:50

:? .. so ein wenig raucht der Kopf.
Die Lektüre über Namespaces, descriptoren usw usw sind alle schön & gut, aber die grundsätzliche Methodik wie zB von BlackJack beschrieben
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.
kann ich noch nicht damit lösen (oder nur noch nicht erkennen?).

Da ich innerhalb eines Programms zwei/ggf. mehrere Threads haben werde, aber bestimmte Parameter in den Threads verwendet oder auch in diesen verändert werden müssen, war mein erster Gedanke diese als 'global' aufzusetzen. Und ja, ich sehe die Gefahr, dass deren Zustand nicht immer überschaubar ist (wer hat wann was geändert).
Und hat ev. ein Programm/Modul 'unbeabsichtigten' Schreib-Zugriff (Nameskonflikte).

Aus Javascript kenne ich Closures und letztlich ist das doch in Python auch möglich?!

Warum das "herumreichen" der Daten die bessere Lösung ist erschließt sich mir noch nicht, insbesondere mit den erforderlichen Threads .. siehe oben.
Sorry ...
Sirius3
User
Beiträge: 11534
Registriert: Sonntag 21. Oktober 2012, 17:20

Samstag 31. Mai 2014, 18:09

Und schon hast Du den nächsten Punkt getroffen, wann man niemals globale Variablen benutzen darf: Threads. Da Threads zu nicht kontrollierbaren Zeitpunkten globale Variablen ändern können, ist es auch unmöglich, Fehler, die dadurch entstehen zu finden, zu reproduzieren und zu beseitigen. Threads müssen in ihrer eigenen Welt leben und der Kontakt zu anderen Threads muß genau geplant werden (z.B. mit Queues).
gNeandr
User
Beiträge: 68
Registriert: Sonntag 11. Mai 2014, 16:48

Samstag 31. Mai 2014, 18:12

Sirius3 hat geschrieben:Und schon hast Du den nächsten Punkt getroffen, ... (z.B. mit Queues).
Um des Himmels Willen ... was mach ich denn jetzt damit?????
BlackJack

Samstag 31. Mai 2014, 18:12

@gNeandr: Closures sind in Python „vollwertig” erst ab 3.0 möglich weil es vorher noch kein ``nonlocal``-Schlüsselwort gibt, aber auch damit wäre es nicht „pythonisch”, denn der eine, offensichtliche Weg, sind nun mal Klassen. Python hat und hatte schon immer Klassen dafür, also wäre es komisch die mit Closures nachzubauen, als wenn es diese Möglichkeit nicht gäbe.

Ich verstehe ehrlich gesagt nicht so ganz wo das Problem liegt. Es gibt keine technische Lösung die irgendwie einen tollen Namen hat, oder die man irgendwie genauer beschreiben könnte als: Verwende einfach keinen globalen Zustand. Was doch in vielen Fällen auch überhaupt gar kein Problem ist. Wenn zwei Threads sich Zustand teilen, dann übergibt man den einfach beiden vor dem bzw. beim Start und schon hat man keinen globalen Zustand. Genau das habe ich doch zum Beispiel in dem anderen Thema mit dem „exit flag” gemacht.

Und das hat auch nichts mit Closures zu tun, denn auch bei Sprachen in denen *das* der bevorzugte Weg ist um Objekte zu erstellen, möchte man nach Möglichkeit keinen globalen Zustand damit modellieren, das heisst diese beiden Themen sind orthogonal.
gNeandr
User
Beiträge: 68
Registriert: Sonntag 11. Mai 2014, 16:48

Samstag 31. Mai 2014, 18:32

@BlackJack
OK, mit dem Hinweis auf das andere Thema meinst du sicher diese Zeilen #50 .. 53:

Code: Alles auswählen

    exit_event = Event()
    Thread(target=print_time, args=(exit_event, 'myTimer', 2)).start()
    serve(exit_event, 'myListener')
und als 'Zustand' ist hier "exit_event" gemeint.
Soweit verstanden. Aber irgendwie sehe ich halt nicht den "Vorteil" Zustände (was ja nix anderes als Daten sind) rumzureichen. Das kann meiner Meinung nach auch recht unübersichtlich werden.

Mein Beispiel hier im Thread kapselt die als global benutzten Daten ja innerhalb 'def gParam():' und sind nur über 'gSet,gGet' ansprechbar. Mag sein, dass es nicht der reinen pythonischen Lehre entspricht, aber sollte besser sein als global Datennamen wie 'server'; dh. meine Lösung schützt diesen Wert durch gSet('server', '192.....') bzw gGet('server').
Und geht das nicht in Richtung pythonischer Wörterbuch Funktion .. wie ja auch vorgeschlagen?
BlackJack

Samstag 31. Mai 2014, 19:13

@gNeandr: Wenn man einfach nachvollziehen kann welche Daten von einem Stück Code benutzt werden ohne dass man dazu das ganze Programm durchlesen muss, oder bei Daten einfach(er) sehen kann welcher Code die benutzt und verändern kann, ohne dass man das ganze Programm durchlesen muss, dann ist das IMHO immer ein Vorteil. Das Programm ist dadurch einfacher nachvollziehbar, testbar, wart- und erweiterbar. Aber das hatten wir doch alles schon.

Ob Du globale Daten nun kapselst, oder besser gesagt wie Du die kapselst, ist egal, es bleiben ja globale Daten, und die werden durch keine Art der Kapselung besser. Wie schon gesagt, die beiden Themen sind orthogonal. Ich sehe auch nicht wo Deine Lösung etwas ”schützt”, und wovor? Ob man nun ein Modul für die Konfiguration anlegt (``import config; config.server = '123...'; print config.server``), das in einem globalen Wörterbuch ablegt (``config['server'] = '123...'; print config['server']``), oder über ein Closure darauf zugreift (``g_set('server', '123...'); print g_get('server')``) ändert semantisch ja nichts daran, dass es globale Daten sind.
jerch
User
Beiträge: 1633
Registriert: Mittwoch 4. März 2009, 14:19

Samstag 31. Mai 2014, 21:04

@gNeandr:
So war mein Hinweis oben auf Closures natürlich nicht gemeint. Selbst wenn Du Zustände in Dateien rausschreibst um sie später tief im Code vergraben wieder zu laden und zu manipulieren, bleibts beim globalen Charakter der Zustände und ist ein Hinweis auf einen schlechten Entwurf, der Dir irgendwann um die Ohren fliegen wird.

Mir scheint, dass Dir nicht klar ist, warum globale Zustände, egal in welcher Form sie daher kommen, zum Problem werden. Idee ist doch, die Ablaufsteuerung möglichst zentral zu orchestrieren. Diese zentrale "Anlaufstelle" ist zB. 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 ;) ) 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.

Globale/Semiglobale Zustände führen in dieses Modell das Problem der "Nebenabsprachen" ein. Übrigens sind auch Konstanten eine Art Nebenabsprache, weichen aber obiges Prinzip nicht auf, da sie konstant sind (erzwungen oder per Konvention). Auch gibt es mit den Objektattributen eine gewollte Abweichung von diesem Prinzip ("objektglobal" - sind objektweit manipulierbar). Dadurch wird es möglich, Objekte imperativ zum Leben zu erwecken.

Da Du von Javascript sprachst - auch in der ereignisbasierten Programmierung sollte man kapseln (gut geschriebene JQuery-Plugins zeigen das ganz gut). Man steigt dort idR nicht mit "main" ein, da die Rahmenwerke bzw. der Browser diese Funktion mit der Ereignisschleife besetzen.
Benutzeravatar
snafu
User
Beiträge: 6030
Registriert: Donnerstag 21. Februar 2008, 17:31
Wohnort: Gelsenkirchen

Samstag 31. Mai 2014, 23:09

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:
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.
gNeandr
User
Beiträge: 68
Registriert: Sonntag 11. Mai 2014, 16:48

Sonntag 1. Juni 2014, 16:49

@jerch
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 ;) ) 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.

Dieses Konstruktion würde ich mir gerne näher ansehen, kannst du mir ein Beispiel geben .. Link ..

:D Danke
Antworten