Funktion aus anderer Klasse

[Poolboy]

Hi,

ich habe hier eine Klasse

Code: Alles auswählen

from Tkinter import *


class CFenster:
    
    
    def __init__(self):
        owadress = Tk()
        
        self.label = Label(owadress, text='Text bla...' )
        self.label.pack()
        
        self.ende = Button(owadress, text='Beenden', command=owadress.destroy)
        self.ende.pack(side=RIGHT)
        
        self.new = Button(owadress, text='Neu', command=self.add)
        self.new.pack()
        
        self.delete = Button(owadress, text='Loeschen', command=self.delete)
        self.delete.pack()
        
        self.change = Button(owadress, text='Aendern', command=self.change)
        self.change.pack()
.
.
.
.

Wie mach ich dem self.change klar, dass die Funktion bei command=self.change aus self.change = Button(owadress, text='Aendern', command=self.change) in einer ANDEREN Datei und einer ANDEREN Klasse liegt?

Also ich hab da dann z.B.:
CFunktionen (Klasse)

und dort hab ich eben setter und getter Methoden drin.

Was muss ich hier command= ... hin schreiben um dem Kollegen Button klar zu machen, dass er die Funktion aus der anderen Klasse aufrufen soll?

Und der Klasse CFenster muss ich ja auch noch irgendwie klar machen, dass es noch eine Klasse CFunktion in einer Datei CFunktion.py gibt oder nicht?

Gruß,
Poolboy

[EyDu]

Hallo,

erstmal solltest du den *-Import loswerden. Sieht zwar am Anfang praktisch aus, bringt aber nichts als Probleme mit sich.

Und dann gewöhnst du dir am besten noch ab Klassenamen mit "C" zu beginnen, sondern sie einfach "Fenster" oder "Funktion" zu nennen.

Zu deinem eigentlichen Problem:

An Objekte aus anderen Dateien/Modulen kommst du mit dem import-Statement, in deinem Fall also "import Funktion". Der Fenster-Klasse solltest du dann eine Instanz der Funktions-Klasse als Parameter übergeben und auf die Funktionen zugreifen.

Code: Alles auswählen

class Fenster:
    def __init__(self, function):
        ...
        self.change = Button(..., command=function.the_function)
        ...

[Poolboy]

Vielen herzlichen Dank für die schnelle Hilfe

Habs auch gleich gecheckt.
Ich hab mir das mit C so angewöhnt. Wieso soll ich mir das wieder abschminken? So seh ich auf den ersten Blick, dass es sich bei CIrgendwas um eine ganze Klasse handelt.

Gibt es in Python damit irgendwann Probleme? Ich komme von C++ und dort hab ich das immer so gemacht und hatte nie Probleme.

Zum Rest wie *-Import danke
Ich werd mir das mal genauer anschauen, was ich da brauche!

Danke!

[EyDu]

Das du von C++ kommst habe ich bei den Namen schon vermutet. Die Notation ist Python unüblich, da sie keinen Mehrwert bringt und der Name nur Auskunft über die Funktionalität liefern sollte. Bei Sprachen mit Duck-Typing macht es außerdem wenig Sinn so vorzugehen, da das Verhalten vorrangig von den Schnittstellen abhängt und nicht vom Typ. Wenn du die Suchfunktion anwirfst, wirst du hier genügend zu dem Thema finden.

Zu den *-Importen vielleicht noch ein Hinweis:

Code: Alles auswählen

import Tkinter as tk
tk.Button(...)

Auch zum Thema *-Importe liefert die Suche einige Treffer.

[BlackJack]

@Poolboy: Wie EyDu schon sagte bringt das `C` keinen Mehrwert. Das es eine Klasse ist, siehst Du schon daran, das es mit einem Grossbuchstaben beginnt. Das ist die in Python übliche Namenskonvention. Die ist übrigens auch bei C++ recht weit verbreitet.

Bei dem `CFenster`-Quelltext fällt noch auf, dass die `Button`\s an die gleichen Attributnamen gebunden werden, wie die Funktionen die sie aufrufen sollen. So erzeugt man keine leicht verständlichen Programme.

Getter und Setter sind in Python unüblich. Man greift in der Regel direkt auf Attribute zu. Sollte man irgend wann einmal das Bedürfnis haben Code "dazwischen zu schalten" ohne die Schnittstelle des Objekts zu verändern, gibt es `property()`.

Der Klassenname `CFunktionen` lässt böses ahnen. Falls da wirklich Funktionen drin stecken, warum sind die dann in einer Klasse und nicht in einem Modul definiert?

[Poolboy]

@Poolboy: Wie EyDu schon sagte bringt das `C` keinen Mehrwert. Das es eine Klasse ist, siehst Du schon daran, das es mit einem Grossbuchstaben beginnt. Das ist die in Python übliche Namenskonvention. Die ist übrigens auch bei C++ recht weit verbreitet.

Bei dem `CFenster`-Quelltext fällt noch auf, dass die `Button`\s an die gleichen Attributnamen gebunden werden, wie die Funktionen die sie aufrufen sollen. So erzeugt man keine leicht verständlichen Programme.

Getter und Setter sind in Python unüblich. Man greift in der Regel direkt auf Attribute zu. Sollte man irgend wann einmal das Bedürfnis haben Code "dazwischen zu schalten" ohne die Schnittstelle des Objekts zu verändern, gibt es `property()`.

Der Klassenname `CFunktionen` lässt böses ahnen. Falls da wirklich Funktionen drin stecken, warum sind die dann in einer Klasse und nicht in einem Modul definiert?

Danke für die Tipps
Ich werd mir property() mal ansehen!
Es gibt da von Video2Brain eine Python DVD. Dort werden auch setter und getter Methoden behandelt. Deshalb hab ich das mal so übernommen. Aber wenn man verhindern will, dass irgendwelche Funktionen böswillig aufgerufen werden können ist es doch besser __name() zu benutzen?

Danke für den Tipp mit den Modulen Das hab ich auch mal behandelt als ich mit Python angefangen habe (ist ja erst 2-3 Wochen her) aber man kann sich halt nicht alles merken

[BlackJack]

Wer sollte Funktionen "böswillig" aufrufen? Ein einfacher Unterstrich genügt, um zu zeigen, dass das Attribut Implementierungsdetail ist, und man es nur verwenden sollte, wenn man weiss was man tut. Wer das macht, ist für die Konsequenzen selbst verantwortlich. Und wer *unbedingt* an ein Attribut herankommen will, den halten auch zwei Unterstriche nicht auf.

Die doppelten Unterstriche sind dazu da, um bei Mehrfachvererbung Namenskollisionen zu vermeiden.