Zugreifen auf Objekte die mit Funktion erstellt wurden

[Spedex]

Hey,
folgendes Programm:

Code: Alles auswählen

from tkinter import *
def setupWindow(rootobj, windowtitle):
    rootobj = Tk()
    rootobj.geometry("1450x770+0+0")
    rootobj.title(windowtitle)
    rootobj.resizable(False, False)
setupWindow("root_malay", "Malay")
root_malay.mainloop()

Hierbei ergibt sich folgendes Problem:
Ich erstelle ein Objekt mit Tkinter und weise dem Objekt innerhalb der Funktion setupWindow Paramter zu.
Doch wenn ich jetzt root_malay.mainloop() ausführen möchte, ist root_malay noch gar nicht definiert.
Es ergibt sich folgende Fehlermeldung:

Code: Alles auswählen

Traceback (most recent call last):
  File "c:/Users/xx/Documents/Python/gui2/gui2.py", line 101, in <module>
    root_malay.mainloop()
NameError: name 'root_malay' is not defined

Das gleiche Problem würde sich natürlich für andere Datentypen wie Strings oder Integers ergeben.
Ich hätte auch schon folgendes probiert:

Code: Alles auswählen

def setupWindow(rootobj, windowtitle):
    global rootobj
    rootobj = Tk()
    rootobj.geometry("1450x770+0+0")
    rootobj.title(windowtitle)
    rootobj.resizable(False, False)

Das ändert jedoch den Sachverhalt leider nicht.
Wie kann ich dieses Problem verhindern?
LG Spedex

[sparrow]

Indem du etwas an den Namen root_malay bindest.
Vergiss gleich wieder, dass es global gibt.

Funktionen können etwas mit "return" zurückgeben. Und sollten das in der Regel auch tun.

[Sirius3]

`rootobj` ist in setupWindow erst ein String, wird aber dann gleich an eine Tk-Instanz gebunden. Der Parameter ist also überflüssig. Dass ein Mensch raten kann, was Du eigentlich machen willst, hilft nicht viel, solange Du nicht so programmierst, wie es der Python-Interpreter versteht.

*-Importe sind böse, weil sie unkontrolliert Namen in den eigenen Namensraum schaufeln. Funktionsnamen schreibt man wie Variablen klein_mit_unterstrich. `obj´ ist alles in Python, so dass der Namenszusatz keinen Mehrwert bietet.
Man benutzt Rückgabewerte um etwas zurückzugeben.

Code: Alles auswählen

import tkinter as tk
def setup_window(windowtitle):
    root = tk.Tk()
    root.geometry("1450x770+0+0")
    root.title(windowtitle)
    root.resizable(False, False)
    return root

def main():
    root_malay = setup_window("Malay")
    root_malay.mainloop()

if __name__ == '__main__':
    main()

[Spedex]

Alles klar. Vielen Dank!

[Spedex]

Ich häng jetzt hier einfach mal was hinten dran:
Folgender Code:

Code: Alles auswählen

from tkinter import *
def setup_window(windowtitle):
    root = Tk()
    root.geometry("1450x770+0+0")
    root.title(windowtitle)
    root.resizable(False, False)
    return root
root2 = setup_window("Name")
def open_malay():
    root_malay = setup_window("Malay")
    root_malay.mainloop()
    root2.destroy()
button_malay = Button(root2, text="", bg="LightGrey", image=button_pic_1, command=open_malay)
button_malay.place(x=364, y=49)
root2.mainloop()

Wenn ich also auf einen Button drücke, möchte ich, dass sich ein neues Fenster öffnet (Das wäre dann Fenster root_malay) und dass sich dass aktuelle Fenster schließt (Das wäre dann Fenster root2). Beim Drücken des Buttons button_malay öffnet sich zwar neues Fenster (root_malay), allerdings wird das Fenster root2 nicht geschlossen.
Ich hab es auch schon mit root2.quit() probiert, was jedoch auch nichts ändert. Eigentlich sollte das schon meiner Meinung nach so funktionieren. Warum liege ich hier falsch?

[__blackjack__]

@Spedex: Es darf nur ein Tk-Objekt geben. Das ist *das* Hauptfenster an dem *der* Tcl-Interpreter dran hängt. Zusätzliche Fenster erstellt man mit `tkinter.Toplevel`.

Hauptprogramm und Funktionsdefinitionen sollte man nicht auf Modulebene vermischen. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst.

`button_pic_1` scheint nicht definiert zu sein. Und man nummeriert keine Namen durch.

[Sirius3]

@Spedex: `alles klar` schreiben und dann fast nichts von dem, was ich geschrieben habe umsetzen, das paßt nicht zusammen. Es darf nur ein Tk-Objekt geben und am besten auch nur ein mainloop. Globale Variablen sind schlecht, was die Übersichtlichkeit betrifft, von daher muss alles, was eine Funktion braucht auch über ihre Argumente übergeben werden. Daher auch die main-Funktion, damit solche Fehler erst gar nicht passieren können.

[Spedex]

@Spedex: Es darf nur ein Tk-Objekt geben. Das ist *das* Hauptfenster an dem *der* Tcl-Interpreter dran hängt. Zusätzliche Fenster erstellt man mit `tkinter.Toplevel`.

Hauptprogramm und Funktionsdefinitionen sollte man nicht auf Modulebene vermischen. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst.

`button_pic_1` scheint nicht definiert zu sein. Und man nummeriert keine Namen durch.

button_pic_1 ist definiert. Der Code, den ich in der Frage gezeigt habe war nur ein Ausschnitt. Hier ist einmal aktuell das ganze Programm, ist aber nicht wichtig und ich sag schonmal gleich: Für Profi-Informatiker herrscht Herzinfakt-Gefahr!

Code: Alles auswählen

from tkinter import *
from PIL import Image, ImageTk
from pathlib import Path

BASEPATH = Path(__file__).parent

def setup_window(windowtitle):
    root = Tk()
    root.geometry("1450x770+0+0")
    root.title(windowtitle)
    root.resizable(False, False)
    return root

root1 = Tk()
root1.geometry("1450x770+0+0")
root1.title("Warnung!")
root1.resizable(False, False)
root1.iconbitmap(BASEPATH / "662218.ico")
label1_1 = Label(root1, text="Dieses Spiel wurde für eine Anzeigen-Skalierung von 125 Prozent optimiert. \nEs kann auch mit einer anderen Größen-Einstellung fortgefahren werden, jedoch können dabei möglicherweise Fehler auftreten.", font=20)
label1_1.place(x=100, y=300)
button1_1 = Button(root1, text="Verstanden", fg="green", font=20, command=root1.destroy)
button1_1.place(x=680, y=380)
scaleimage1 = ImageTk.PhotoImage(Image.open(BASEPATH / "Anmerkung192106.png"))
label1_2 = Label(root1, image=scaleimage1)
label1_2.place(x=550,y=440)
root1.mainloop()

root2 = setup_window("Name")
mainimage = ImageTk.PhotoImage(Image.open(BASEPATH / "MapGanzRoh.png"))
button_pic_go_city = ImageTk.PhotoImage(Image.open(BASEPATH / "b12121212neu.png"))
label2_1 = Label(root2, image=mainimage)
label2_1.place(x=0,y=0)
button_2_1 = Button(root2, text="Spiel Beenden", fg="red", command=root2.destroy)
button_2_1.place(x=1310, y=725)
def open_malay():
    root_malay = setup_window("Malay")
    root_malay.mainloop()
    root2.destroy()
button_malay = Button(root2, text="", bg="LightGrey", image=button_pic_go_city, command=open_malay)
button_malay.place(x=364, y=49)
button_nabas = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_nabas.place(x=402, y=75)
button_libertad = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_libertad.place(x=370, y=112)
button_pandan = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_pandan.place(x=445, y=134)
button_kalibo = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_kalibo.place(x=587, y=167)
button_banga = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_banga.place(x=562, y=226)
button_batan = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_batan.place(x=670, y=231)
button_roxas_city = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_roxas_city.place(x=805, y=241)
button_sapi_an = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_sapi_an.place(x=712, y=268)
button_estancia = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_estancia.place(x=1015, y=291)
button_pontevedra = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_pontevedra.place(x=879, y=315)
button_culasi = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_culasi.place(x=445, y=307)
button_panay = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_panay.place(x=678, y=368)
button_sara = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_sara.place(x=923, y=382)
button_tibiao = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_tibiao.place(x=420, y=380)
button_barbaza = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_barbaza.place(x=422, y=420)
button_dumarao = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_dumarao.place(x=772, y=410)
button_concepcion = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_concepcion.place(x=1003, y=425)
button_passi_city = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_passi_city.place(x=751, y=450)
button_ajuy = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_ajuy.place(x=929, y=475)
button_bugasong = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_bugasong.place(x=474, y=488)
button_lambunao = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_lambunao.place(x=632, y=499)
button_banate = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_banate.place(x=831, y=543)
button_cabatuan = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_cabatuan.place(x=677, y=594)
button_patnongon = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_patnongon.place(x=436, y=587)
button_belison = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_belison.place(x=383, y=628)
button_san_jose = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_san_jose.place(x=366, y=683)
button_iloilo_city = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_iloilo_city.place(x=707, y=698)
button_hamtic = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_hamtic.place(x=400, y=735)
button_miagao = Button(root2, text="", bg="LightGrey", image=button_pic_go_city)
button_miagao.place(x=498, y=726)

root2.mainloop()

Ist es hier überhaupt möglich Funktions-Definitions-Teil und main() voneinander zu trennen? Denn die Funktionen liegen oftmals zwischen dem Code, denn sie benötigen Variablen, die weiter oben im Code definiert wurden, und müssen dann aber wiederum zum Beispiel vor einem Button liegen, der die Funktion ausführt.
Dies lässt sich wie folgt vorstellen:

Code: Alles auswählen

main()
func1()
main()
func2()
main()

und eben nicht:

Code: Alles auswählen

func1()
func2()
func3()
main()

Bezüglich Herzinfakt-Gefahr:
Der Button-Definitions-Teil würde sich meiner Meinung nach"nur" um die Hälfte verkürzen lassen, wenn man es ordentlich macht. Ich leg nunmal in meiner Anfangsphase im Programmieren weniger Wert auf Aussehen als auf Funktionalität.
Im gezeigten Programm wurden noch keine Änderungen bezüglich den mehreren root-Objekten gemacht, da kümmer ich mich gleich darum.

[Spedex]

@Spedex: `alles klar` schreiben und dann fast nichts von dem, was ich geschrieben habe umsetzen, das paßt nicht zusammen. Es darf nur ein Tk-Objekt geben und am besten auch nur ein mainloop. Globale Variablen sind schlecht, was die Übersichtlichkeit betrifft, von daher muss alles, was eine Funktion braucht auch über ihre Argumente übergeben werden. Daher auch die main-Funktion, damit solche Fehler erst gar nicht passieren können.

Ich denke schon, dass ich einen Großteil, von dem, was du geschrieben hast, umgesetzt habe.
Was hast du mir mitgegeben:
1. Der String-Paramter rootobj ist überflüssig --> Umgesetzt
2. Das "obj" in "rootobj" ist überflüssig --> Umgesetzt
3. from Tkinter import * ist semioptimal --> Noch nicht umgesetzt, da meiner Meinung nach die Vorteile dieser Methode die Nachteile derzeit überwiegen.
4. Funktionsnamen schreibt man klein und mit Unterstrich --> Umgesetzt
5. return --> Umgesetzt

Versteh mich also bitte nicht falsch, ich bin sehr dankbar über deine Hilfe und probier, alles, was ich hier lerne in die Tat umzusetzen.
Gleiches gilt für jeden anderen Nutzer und Helfer: Ich ignoriere keine Ratschläge bewusst, sondern versteh möglicherweise nicht, wie ich sie anwende, und zögere erstmal deswegen sie anzuwenden.

[Sirius3]

Ja, das mit der `main`-Funktion funktioniert nur, wenn man sich daran hält, keine globalen Variablen zu benutzen. Aber jede nicht triviale GUI-Anwendung braucht auch Klassen-Definitionen, um zu viele Funktionsargumente wieder zu vermeiden.
Statt der vielen Button-Aufrufe wäre es besser eine passende Datenstruktur zu benutzen und vielleicht statt der place-Aufrufe das ganze durch ein Canvas ersetzen.

[Spedex]

@Spedex: Es darf nur ein Tk-Objekt geben. Das ist *das* Hauptfenster an dem *der* Tcl-Interpreter dran hängt. Zusätzliche Fenster erstellt man mit `tkinter.Toplevel`.

Hauptprogramm und Funktionsdefinitionen sollte man nicht auf Modulebene vermischen. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst.

`button_pic_1` scheint nicht definiert zu sein. Und man nummeriert keine Namen durch.

Kann man auch nur mit TopLevel arbeiten? Oder ist ein root-Objekt unbedingt notwendig? Denn wenn man ein TopLevel erstellt, muss man diesem kein root-Objekt zuordnen.

Edit: Ok wenn ich es nur mit TopLevel mache, ist es eigentlich noch schlechter wie mit root, denn jetzt ist es so, dass sich immer noch so ein kleines Fenster öffnet und beim Drücken des Buttons wird das TopLevel, nachdem sich ein neues geöffnet hat, immer noch nicht geschlossen.

[Spedex]

Also ich hab jetzt ein wenig im Internet nachgeschaut. Dort habe ich zum Beispiel ein Beispiel-Tutorial gefunden. Ich habe den Code kopiert und ausgeführt. Auch dort öffnen sich immer zwei Fenster anstatt nur eines.
Der Code schaut zum Beispiel so aus (vollständiges Programm):

Code: Alles auswählen

from tkinter import *

top = Toplevel()
top.mainloop()

Wie oben erwähnt öffnen sich auch hier zwei Fenster.
Ein root-Objekt ist, so wie ich das jetzt sehe, glaube ich nicht notwendig.
Lässt sich das doppelte Öffnen von Fenster vermeiden?
Ist doch ein root-Objekt notwendig?

[Sirius3]

Wenn Du kein Tk-Objekt erzeugst, wird trotzdem eins angelegt. Es ist besser, Du machst das selbst und nutzt das Fenster auch.

[__blackjack__]

@Spedex: Wie schon geschrieben hängt an dem `Tk`-Objekt der Tcl-Interpreter — ohne den gibt's keine Fenster.

Ich würde grundsätzlich mal in Frage stellen das man eine GUI aus mehreren nacheinander geschalteten Fenstern macht. Das macht man nicht. Weil die Fensterverwaltung ja jedes Fenster woanders hin platzieren kann. Ja ich weiss, Du gibst Grösse und Position fest vor. Wieder etwas was man nicht macht. Wenn Du komische Lösung umsetzen willst, bekommst Du halt auch komische Probleme.

[Spedex]

Naja also meine Vorhaben sind ein Programm, genauer genommen eine Art Computerspiel, bei dem man ein Ausgangsfenster hat, eine Karte mit Städten, und man dort auf die Städte klicken kann (Buttons). Wenn man auf einen Stadt-Button gedrückt hat, öffnet sich die Karte der Stadt, wo dann weitere Interaktionen möglich sind.
Dementsprechend die mehreren Fenster. Oder fällt dir ein anderer Weg ein, das zu lösen? Zum Beispiel, dass man das Fenster beibehält, den Inhalt löscht und neuen Inhalt erschafft.

[__blackjack__]

@Spedex: Ja, man könnte ein Fenster mit wechselndem Inhalt machen, oder man hat ein Hauptfenster und öffnet zusätzliche Detailfenster, eventuell modal, also so dass man an dem Hauptfenster nichts machen kann solange das Dialogfenster offen ist.

[Spedex]

Bezüglich des wechselnden Inhalts:
Folgende Grafik:
https://ibb.co/QMxw1CL
Angenommen es wir auf ein Button gedrückt, dann soll ja ein neuer Inhalt erscheinen. Dementsprechend wäre es gut wenn der alte Inhalt im Fenster gelöscht wird. Das löschen kann natürlich mit xxx.destroy() erfolgen. Allerdings gibt es da zwei Punkte, die etwas ungünstig sind.
1) Wenn im aktuellen Fenster, welches dann auch gelöscht werden soll, einige Buttons, Labels, usw. liegen, dann wir das mit dem Löschen jedes einzelnen Elements ziemlich mühsam. Ich hab schon probiert mit Tkinter.Frame(root) einen Frame zu erstellen und die Buttons, Labels, usw. dann auf diese Frames zu setzten. Dann könnte das löschen nämlich ziemlich kurz umgesetzt werden mit Frame.destroy(). Allerdings funktioniert das nicht wirklich. Das Löschen der Frames funktioniert zwar denke ich mal schon, aber wenn ich das Programm ausführe sind keine Buttons, Labels, usw. zu sehen.
Dieser Sachverhalt mit dem Löschen ist zwar ungünstig, aber meiner Meinung nach nicht so schlimm. Schlecht wird das Ganze erst in Kombination mit dem zweiten "Problem":
2) Hierauf bezieht sich auch die Info-Grafik. Es geht darum, dass ich von vielen verschiedenen Fenstern, oder ich sag einfach mal "Layouts", da ich ja eigentlich nur ein Fenster habe, wieder zurück auf das Hauptfenster (Die Karte mit den Städten) möchte. Ich müsste also Funktionen erstellen für das Löschen der Buttons, Labels, etc. des alten Layouts, allerdings hat jedes "Nebenfenster" ("Anderes Fenster 1", "Anderes Fenster 2" und "Anderes Fenster 3") ja unterschiedliche Buttons, Labels, etc. Dementsprechend müsste ich eine "Löschfunktion" für das Wechseln von Nebenfenster1 auf Hauptfenster programmieren, dann für das Wechseln von Nebenfenster2 auf Hauptfenster, dann für das Wechseln von Nebenfenster3 auf Hauptfenster, und so weiter. Das würde dermaßen viele Zeilen enden, dass ich mir nicht vorstellen kann, das überhaupt umzusetzen.
Dementsprechend die Frage: Lassen sich Buttons, Labels, etc. zusammenfassen, um die Lösch-Anweisung kurz zu halten und gibt es eine Lösung für das zweite Problem?
Eine Möglichkeit, die mir bekannt ist, wäre, dass keine Buttons, Labels, etc. gelöscht werden. Es werden einfach die neuen Buttons, Labels, etc, erschaffen, sodass diese über dem alten Layout liegen. Das alter Layout ist damit bedeckt und nicht mehr zu sehen, unter der Voraussetzung, dass das neue Layout das alte Layout komplett überdeckt, was aber der Fall sein wird. Der Nachteil hierbei ist für mich hier ganz klar, dass immer mehr und mehr Elemente erschaffen werden, allerdings keine Elemente gelöscht werden. Das kann, beim längeren Benutzen des Programms, zu Lags führen.

[__blackjack__]

@Spedex: Also erst einmal sollte das löschen eines Frames mit Inhalt kein Problem darstellen. Der übliche Weg ist aber jedes ”Fenster” genau einmal zu erstellen und zwar als Frame und die dann alle übereinander zu legen. Und dann holt man einfach immer den jeweils aktuellen nach vorne.

[Spedex]

Beim Erstellen des Fenster als Frame gibt es irgendwie Probleme:
Folgender Code-Ausschnitt:

Code: Alles auswählen

root = Tk()
root.geometry("1450x770+0+0")
root.title("Name")
root.resizable(False, False)
root.iconbitmap(BASEPATH / "662218.ico")

frame_warnung = Frame(root)
frame_warnung.pack()
label_warn_text = Label(frame_warnung, text="Dieses Spiel wurde für eine Anzeigen-Skalierung von 125 Prozent optimiert. \nEs kann auch mit einer anderen Größen-Einstellung fortgefahren werden, jedoch können dabei möglicherweise Fehler auftreten.", font=20)
label_warn_text.place(x=100, y=300)
foto_skalierung_warn = ImageTk.PhotoImage(Image.open(BASEPATH / "Anmerkung192106.png"))
button_warn_verstanden = Button(frame_warnung, text="Verstanden", fg="green", font=20)
button_warn_verstanden.place(x=680, y=380)
label_foto_skal_warn = Label(frame_warnung, image=foto_skalierung_warn)
label_foto_skal_warn.place(x=550,y=440)

root.mainloop()

Ich erstelle also erstmal root und danach einen Frame frame_warnung. Der Frame frame_warnung basiert in root. Danach werden Buttons und Labels erstellt, welche auf frame_warnung basieren. Wenn ich das Programm jedoch ausführe, erscheint kein einziger Button oder kein einziges Label. Im Internet sind einfache Tutorial-Anwendungen über das Thema Frame() zu finden. Diese sind grundsätzlich so aufgebaut wie der Code-Ausschnitt und funktionieren auch.
Kann mir hier bitte wer weiterhelfen?

[Spedex]

Die Buttons und Labels werden mit xxx.place() gesetzt. Wenn ich sie mit xxx.pack() platziere, werden sie angezeigt. Allerdings kann ich dann keine Koordinaten angeben (zum Beispiel: x=120 Pixel, y=244 Pixel) und das ist für das Programm sehr wichtig. Gibt es eine Möglichkeit die Buttons, Labels, etc. auch mit xxx.place() sichtbar zu machen?