Globale Variablen in mehreren Dateien benutzen?

[antaeus]

Hi zusammen,

ich habe ein (Verständnis)Problem mit globalen Variablen:

Momentan habe ich zwei Klassen in einer Datei. Beide Klassen greifen auf eine globale Variable zu

Code: Alles auswählen

class A(object):
    global tolleVariable

    ... usw



class B(object):
    global tolleVariable

    ... usw


tolleVariable = 0
a = A()
b = B()

Das funktioniert problemlos so.

Die Klassen sind aber etwas gewachsen und zur Übersichtlichkeit möchte sie in zwei verschienene Dateien packen und in einer dritten Datei folgendes machen:

Code: Alles auswählen

import a, b

tolleVariable = 0
a.a = A()
b.b = B()

Jetzt schreit allerdings der Interpreter beim ersten Vorkommen von tolleVariable in Klasse a, dass er die nicht kennt.

Kann man dem abhelfen, oder muss man das dann irgendwie anderst lösen?

Danke für eure Mühe!

[Leonidas]

Das liegt daran, dass Variablen nur modulglobal sein können. Am besten du vergisst nun dass es sowas wie global überhaupt gibt und überlegst dir wie man sowas "sauber" implementieren kann, d.h. ohne die Verwendung von global.

[Nirven]

Hilfe ist einfach: Keine globalen Variablen benutzen.

Einfach die Variable übergeben, und dann auch zurück geben... (kann __init__ was zurück geben?)

Code: Alles auswählen

class A(object):
    def __init__(self, tolleVariable):
        usw
        return tolleVariable



class B(object):
    def __init__(self, tolleVariable):
        usw
        return tolleVariable

Code: Alles auswählen

import a, b

tolleVariable = 0
a.a = A(tolleVariable)
b.b = B(tolleVariable) 

[Rebecca]

kann __init__ was zurück geben?

Nein!

[Nirven]

Schade

[Leonidas]

Schade

Wo sollte der Rückgabewert denn landen?

A() gibt eine Instanz von A zurück, das ist nun mal in Python so.

[Nirven]

Ich weiß, zumindestens wenn ich nachdenke...

Hätte es doch funktioniert wäre mein mangelndes Nachdenken nicht aufgefallen. Also Schade

Bin wohl doch nicht so multitaskingfähig wie ich dachte.

[Y0Gi]

Nach dem (indirekten) Aufruf von __init__ erhält man eine Instanz der Klasse zurück, reicht dir das nicht?

Für modulglobale Variablen in Multithread-Web-Anwendungen, auf die aus mehreren Modulen zugegriffen werden kann, gibt es u.a. im Paste-Paket mit paste.registry Abhilfe.

[jens]

Einfach die Variable übergeben, und dann auch zurück geben... (kann __init__ was zurück geben?)

Warum nicht eine Methode aufrufen und den Rückgabewert da erhalten? Also so:

Code: Alles auswählen

class A(object):
    def __init__(self, tolleVariable):
        self.tolleVariable = tolleVariable

    def tuwas(self):
        ...
        return self.tolleVariable

a = A("blabla")
b = a.tuwas()
print b

[sauterle]

Hallo
Ich habe das selbe Problem wie oben geschildert nur mit dem unterschied dass beide Klassen in eigenen Threads laufen und während dem laufen Informationen austauschen müssen. Kann man es irgendwie schaffen das beide Klassen in einer eigenen Datei liegen und trotzdem auf die selbe globale variable zugreifen können. wie auch oben geschildert funktioniert es in der selben Datei
LG Sauterle

[Sirius3]

Globale Variablen sollte man nicht benutzen, vor allem nicht, wenn man mit Threads arbeitet, dafür gibt es spezielle Datenstrukturen für den Austausch, z.b. Queues.
Dann ist es auch egal, wie Du Deine Klassen in Module aufteilst, Du hast das Problem nicht, das Du anscheinend jetzt hast.

Am besten Du fängst eine neue Frage an, und zeigst dort Deinen Code, den Du bisher hast, dann können wir am effektivsten helfen.

[sauterle]

ok danke

[DeaD_EyE]

kostanten.py

Code: Alles auswählen

CONST_A = 33
CONST_B = 33

Wenn du "Konstanten" importierst, kannst du Objekte sogar neu zuweisen, was sich dann aber auf dein gesamtes Programm auswirkt.

Code: Alles auswählen

import konstanten

print(konstanten.CONST_A)

# Zuweisung ginge auch
# Man könnte es auch sich in den Fuß schießen Modus nennen
konstanten.CONST_A = 12
# aber hier müssten schon die Augenbrauen nach oben gehen, denn
# laut Konvention sind große geschriebene Namen Konstanten, die nicht verändert werden sollen.
# man kann, aber es wird vom Entwickler nicht erwartet, dass sowas gemacht wird.

Ein Beispiel ist z.B. das Paket gpiozero, welches einfachen Zugriff auf die GPIOs des Raspberry Pi ermöglicht.
Wenn man aber keine Hardware hat und dennoch testen will, kann man in der Bibliothek eine globale Variable zur Laufzeit des Programms zuweisen,
was dann die darunterliegende Funktionalität so ändert, dass nur noch simuliert wird.