Ich bin mir ziemlich sicher, dass man einfach von einer vorhandenen Klasse erbt und sich dann um so einen Schabernack gar nicht kümmern mussAlfons Mittelmeyer hat geschrieben:Deswegen soll man aber auch __del__() implementieren für den Fall, dass man vergisst destroy auftzurufen
Ja so macht man es meistens, von tk.Canvas ableiten, obwohl man gar keine Methoden von tk.Canvas überschreibt und damit gar keine Ableitung bräuchte.sparrow hat geschrieben:Ich bin mir ziemlich sicher, dass man einfach von einer vorhandenen Klasse erbt und sich dann um so einen Schabernack gar nicht kümmern muss
Doch. Man braucht sich keine unter anderem keine __del__-Methoden zusammen zu frickeln und kann sich darauf verlassen, dass alle benötigten Methoden vorhanden sind, und bei Bedarf überschrieben werden können.Alfons Mittelmeyer hat geschrieben:Ja so macht man es meistens, von tk.Canvas ableiten, obwohl man gar keine Methoden von tk.Canvas überschreibt und damit gar keine Ableitung bräuchte.
Ja, aber nur solange Du nicht selber etwas dazu machst, was der Aufhebung bedarf - da bitte es nicht vergessen. Bei nur Widgets mit GUI Callbacks brauchst Du in der Regel nichts mit __del__() tun.sparrow hat geschrieben:Doch. Man braucht sich keine unter anderem keine __del__-Methoden zusammen zu frickeln und kann sich darauf verlassen, dass alle benötigten Methoden vorhanden sind, und bei Bedarf überschrieben werden können. Das ist ja das tolle an Vererbung in der OOP
Also, das mit der Klasse habe ich nicht richtig verstanden. Ich fange immer ganz sauber an, und mache alles lokal, etwa:Sirius3 hat geschrieben:Am besten fängt man mit einer einfachen Klasse an, ohne global, ohne Sternchenimporten und ohne ausführbaren Code auf Modulebene.
Code: Alles auswählen
def main(parent):
tk.Label(parent,text='Hello',command = (lambda: print('Hello'))).pack()
main(root)Code: Alles auswählen
def main(parent):
class MyClass:
def __init__(self,parent):
tk.Label(parent,text='Hello',command = (lambda: print('Hello'))).pack()
MyClass(parent)
main(root)Dann braucht man also doch keine Klasse, denn mit einer Funktion hat man ja auch keine globalen Variablen. Allerdings ist dann der Zugriff nicht schön, weil man dann eine Liste odef etwas Ähnliches nehmen muss. Wer keine Liste nehmen will, der definiert sich eben eine Klasse. Die könnte aber auch innerhalb der Funktion und nur für die Variablen sein.Sirius3 hat geschrieben:@Alfons Mittelmeyer: man macht eine Klasse, damit man globale Variablen wie activeWindow nicht braucht. Die Klassendefinition sollte aus der Funktion main raus.
Hoffentlich nicht, denn das ist großer Unsinn.Alfons Mittelmeyer hat geschrieben:@tsaG: ich habe es jetzt mit einer Funktion gemacht und nicht mehr verschachtelt. Vielleicht gefällt Dir das ja besser
Das brauchst Du mir bestimmt nicht sagen. Aber stimmt, das war schlecht programmiert, denn wir haben eine globale Variable 'root':sparrow hat geschrieben:@Alfons: Weißt du warum man globale Variablen vermeiden soll?
Code: Alles auswählen
root = tk.Tk()
def main(parent):
xxx
main(root)
root.mainloop()Code: Alles auswählen
def main(parent):
xxx
return parent
main(tk.Tk()).mainloop()Code: Alles auswählen
# zu Beginn ==========
loadActiveWindow = None
# und später ==========
def do_loadActiveWindow(windowtype):
...
loadActiveWindow = do_loadActiveWindowJetzt habe ich nochmals nachgeschaut, und habe gemerkt, man braucht es doch nicht. Ursprünglich wollte ich es aber drawButtons diese Funktion als Parameter übergeben. Und diese Funktion do_loadActiveWindow ist nach Bottom Up die letzte Funktion, Steht daher ür andere Funktionen gar nicht zur Verfügung.BlackJack hat geschrieben:@Alfons Mittelmeyer: Den notwendigen ”Trick” habe ich nicht verstanden. Da fehlt irgendwie der Grund warum man den Namen am Anfang an `None` binden muss. Das müsste man doch nur wenn man den Wert, also wirklich das `None` vor der Definition von `do_loadActiveWindow()` irgendwie tatsächlich *benutzt*, aber wofür?
Code: Alles auswählen
#!/usr/bin/env python
# coding: utf8
import Tkinter as tk
from tkFont import Font
FONT_OPTIONS = {'family': 'Helvetica', 'size': 10}
class MeasuredItem(object):
OK, WARNING, CRITICAL = 'OK', 'WARNING', 'CRITICAL'
def __init__(self, name, max_value):
self.name = name
self.max_value = max_value
self.value = 2000
self.state = self.OK
@property
def is_ok(self):
return self.state == self.OK
MEASURED_ITEM_STATE_TO_COLOR = {
MeasuredItem.OK: 'green',
MeasuredItem.WARNING: 'yellow',
MeasuredItem.CRITICAL: 'red',
}
class ErrorFrame(tk.Frame):
def __init__(self, measured_items, parent, **kwargs):
tk.Frame.__init__(self, parent, **kwargs)
self.font = Font(**FONT_OPTIONS)
self.font['size'] = 20
self.labels = list()
self.measured_items = measured_items
self.update()
def update(self):
for label in self.labels:
label.destroy()
for item in self.measured_items:
if not item.is_ok:
label = tk.Label(
self,
text=item.name,
background=self['background'],
foreground=MEASURED_ITEM_STATE_TO_COLOR[item.state],
font=self.font,
)
label.pack(side=tk.TOP)
class MainWindow(tk.Tk):
def __init__(self):
tk.Tk.__init__(self)
self.font = Font(**FONT_OPTIONS)
self.canvas = tk.Canvas(self, bg='black', height=480, width=320)
self.canvas.pack()
self.measured_items = [
MeasuredItem(name, 6000)
for name in [
'RPM', 'Water', 'EGT', 'Fuel Cap.', 'Fuel Flow', 'Oil Temp'
]
]
self.error_frame = ErrorFrame(
self.measured_items, self, width=120, background='black'
)
self.error_frame.place(x=190, y=0)
self._create_main_buttons(
[
('MAIN', self.draw_main_screen),
('ENG', self.not_implemented),
('NAV', self.not_implemented),
('STAT', self.not_implemented),
],
0,
)
self._create_main_buttons(
[
('PERF.', self.not_implemented),
('MEDIA', self.not_implemented),
('NET', self.not_implemented),
('SETTINGS', self.not_implemented),
],
290,
)
self._draw_boot_screen()
def _create_main_buttons(self, names_and_callbacks, x_offset):
for i, (name, callback) in enumerate(names_and_callbacks):
tk.Button(
self,
text=name,
wraplength=1,
command=callback,
pady=6,
font=self.font,
).place(x=x_offset, y=i * 120)
def draw_gauge(self, x, y, measured_item, scale_factor=0.8):
gauge_value = measured_item.max_value / float(measured_item.value)
#
# Draw hand.
#
self.canvas.create_arc(
x,
y,
x + 100 * scale_factor,
y + 100 * scale_factor,
start=0,
extent=-(220 / gauge_value),
fill=MEASURED_ITEM_STATE_TO_COLOR[measured_item.state],
)
#
# Draw outline.
#
self.canvas.create_arc(
x - 3,
y - 3,
x + 100 * scale_factor + 3,
y + 100 * scale_factor + 3,
start=0,
extent=-220,
style=tk.ARC,
outline='white',
width=2,
)
#
# Draw value box.
#
self.canvas.create_rectangle(
x + 50 * scale_factor,
y + 20 * scale_factor,
x + 100 * scale_factor + 3,
y + 50 * scale_factor,
outline='white',
width=2,
)
font = self.font.copy()
font['size'] = int(14 * scale_factor)
self.canvas.create_text(
x + 52 * scale_factor,
y + 20 * scale_factor,
anchor=tk.NW,
text=measured_item.value,
fill='turquoise',
font=font,
)
font = self.font.copy()
font['size'] = int(20 * scale_factor)
self.canvas.create_text(
x,
y - 15,
anchor=tk.NW,
text=measured_item.name,
fill='white',
font=font,
)
def not_implemented(self):
pass
def _draw_boot_screen(self):
self.canvas.delete(tk.ALL)
self.draw_gauge(70, 50, self.measured_items[0])
def draw_main_screen(self):
self.canvas.delete(tk.ALL)
for i, measured_item in enumerate(self.measured_items[:3]):
self.draw_gauge(50, 20 + i * 100, measured_item)
def main():
main_window = MainWindow()
main_window.mainloop()
if __name__ == '__main__':
main()