2016-07-25 18 views
0

Ich bin neu in Python und in OO Programmierung, also weiß ich nicht, ob die folgende Frage Sinn macht (... aber ich denke, es ist eine gute Möglichkeit zu lernen):Wie werden die in einer bestimmten Klasse in einer anderen Klasse generierten Daten verwendet? (in Python)

I ' Ich versuche, zwei Klassen zu haben. Eine, die Daten erzeugt (nennen Sie es DataGen()) und eine andere, die in der Lage ist, diese Daten zu verarbeiten und mir einige Statistiken zu geben (nennen Sie es Stats()). Ich möchte beide in verschiedene py-Dateien schreiben, um sie sauberer zu halten, und so kann ich Methoden zu Stats.py hinzufügen, ohne DataGen.py zu berühren. Etwas wie folgt aus:
In DataGen.py

class DataGen(object): 
    def __init__(self, number_of_samples, arg2): 
     self.X = np.zeros([number_of_samples,1]) 
     # etc.. 
    def samples(self): 
     # do some sampling and save it in self.X 

In Stats.py

class Stats(object): 
    def __init__(self, something): 
     # something here to initialize 
     # etc.. 
    def mean(self): 
     # calculate the mean using something like DataGen.X 

Jetzt und hier kommt der Teil, wo ich verloren gehen. Ich möchte Stats() arbeiten auf die Daten zu einer Instanz von DataGen(), aber ich weiß nicht, wie die Daten in DataGen.X zu Stats, so dass ich die Daten verwenden kann jedes Mal, wenn ich mit DataGen.samples() Probe.

Ich habe versucht, eine Instanz von DG = DataGen(arg1,arg2) zu erstellen und dann dieses Objekt an S = Stats(DG) übergeben. Wenn ich auf diese Weise initialisiere, änderten sich die Daten, die zur Schätzung der Statistik verwendet wurden, nicht, nachdem ich erneut mit DataGen.samples() gesampelt hatte. Ich denke, jedes Mal, wenn ich sample, muss ich eine Instanz S = Stats(DG) mit den neuen Daten erstellen. Das scheint schlecht zu sein ... kann ich diese Klasse Stats() an die Daten von DataGen() anhängen? Ist das eine schlechte Idee/ein schreckliches Konstrukt?

Ich weiß auch nicht, wie ich darüber nachdenken sollte, wenn ich etwas konstruiere, wo DataGen die Methoden von Stats erbt, oder etwas ähnliches. Wenn DataGen von Stats erbt, aber Stats benötigt die Daten von DataGen, wie kann ich diese Schleife lösen? Wenn Stats von DataGen erbt, muss ich eine einzelne Instanz von Stats erstellen und dann mit der Probe statt DataGen, wie Stats.DataGen.samples() oder Stats.samples(). Ich würde das nicht mögen, weil der Rest meines Codes DataGen() verwendet und ich denke, dass es besser strukturiert ist, wenn ich Stats() nicht verwende, um zu probieren!

Macht das Obige Sinn? Jeder Kommentar dazu wäre sehr hilfreich!

+0

Ich würde Pandas Bibliothek ... (http://pandas.pydata.org/) – pez

+0

überprüfen, wenn Sie Datagen-Objekt im Konstruktor übergeben und dann .samples() ausführen, die die internen Werte des Dataget-Objekts ändern, sollte es gesehen werden nach stats class, aber du musst deinen stat wiederholen. Können Sie den Code zeigen, dass Sie das Datagen in Stats-Konstruktor und Beispiel übergeben, wenn es nicht funktioniert, da ich denke, dass das Problem dort ist. Ihr OOP-Verständnis sieht gut aus – Hani

Antwort

0

Für jemanden, der neu in Python und OO ist, bekommen Sie den Einfluss der Kapselung sehr gut. Sie werden dem Observer pattern hier folgen wollen, wo ein Objekt eine Information besitzt (DataGen) und ein anderes Objekt an dieser Information interessiert ist (Stats) und aktualisiert werden möchte, wenn es sich ändert.

Der Weg, dies zu tun, ist, eine Funktion vom interessierten Objekt zum Eigentümerobjekt zu übergeben, das dann aufgerufen werden kann, wenn sich diese Information ändert. Die Funktion wird entweder als Callback oder Listener bezeichnet.

class DataGen(object): 
    def __init__(self, number_of_samples, arg2): 
     self.X = np.zeros([number_of_samples,1]) 
     self.listeners = list() 

    def samples(self): 
     # do some sampling and save it in self.X 
     # Call back to the listener and let it know that your samples changed. 
     for listener in self.listeners: 
      listener.samples_changed(self.X) 

    def add_listener(self, listener): 
     listeners.append(listener) 

class Stats(object): 
    def __init__(self, data_gen): 
     # Register this 'observer' with the 'observable' 
     something.add_listener(self) 

    def samples_changed(self, samples): 
     # Recalculate mean. 

    def mean(self): 
     # calculate the mean using something like DataGen.X 

Hier ist ein Beispiel für ein Objekt, das sich selbst als Listener für ein anderes Objekt hinzufügt.

  1. Statistik registriert sich als Zuhörer mit DataGen
  2. rufen Sie samples() auf DataGen
  3. samples() iteriert durch alle seine Zuhörer (es kann mehr als eine Statistik sein) und ruft samples_changed(self.X) auf jeden, der vorbei neuer Satz von Proben.
  4. Einer dieser Listener (der einzige in diesem Fall) ist Stats, der seinen internen Status aktualisieren kann, um die neuen Beispiele zu behandeln.

Wenn irgendwann wollen Sie das Stats Objekt entfernen Sie sicher, dass Sie es aus der Liste entfernen DataGen.listeners machen müssen, sonst werden Sie mit einem Speicherverlust enden.

Verwandte Themen