Python: Tkinter: Pourquoi est-il de la racine.mainloop() et pas d'application.mainloop()

Je suis un nouveau membre à un Débordement de Pile.
J'ai trouvé ce fil de discussion, mais n'a pas été autorisé à faire des commentaires ou poser des questions sur elle, donc je pensais que je venais de référence ici: Comment puis-je faire un dans la liste interactive en Python Tkinter, complète avec des boutons qui peuvent modifier ces annonces?

from tkinter import *
import os
import easygui as eg

class App:

    def __init__(self, master):
        frame = Frame(master)
        frame.pack()

        # character box
        Label(frame, text = "Characters Editor").grid(row = 0, column = 0, rowspan = 1, columnspan = 2)
        charbox = Listbox(frame)
        for chars in []:
            charbox.insert(END, chars)
        charbox.grid(row = 1, column = 0, rowspan = 5)
        charadd = Button(frame, text = "   Add   ", command = self.addchar).grid(row = 1, column = 1)
        charremove = Button(frame, text = "Remove", command = self.removechar).grid(row = 2, column = 1)
        charedit = Button(frame, text = "    Edit    ", command = self.editchar).grid(row = 3, column = 1)

    def addchar(self):
        print("not implemented yet")
    def removechar(self):
        print("not implemented yet")
    def editchar(self):
        print("not implemented yet")


root = Tk()
root.wm_title("IA Development Kit")
app = App(root)
root.mainloop()

Quelqu'un pourrait m'expliquer pourquoi la dernière ligne est la racine.mainloop()?
Étant un novice en Python, et venant du fond que de procédure orientée sans objet-orient expérience, j'aurais pensé qu'il aurait été d'application.mainloop().

En fait app = App(racine) , l'app est jamais utilisé dans le reste du code! Je vais avoir du mal à comprendre pourquoi la racine.mainloop() fonctionne toujours.

  • Ainsi, lorsque vous initialisez votre App classe avec root, le __init__ fonction est exécutée, dans lequel tous les composants d'interface graphique sont chargés. mainloop est une méthode de Tk qui commence la boucle d'événements de la fenêtre. Nous n'avons donc pas besoin de re-référence de l' class (même si, techniquement, nous n'avons, à l'intérieur de la class lui-même) parce que tout ce dont nous avons besoin se fait que lorsque nous initialisons que class.
InformationsquelleAutor Nuuk | 2014-03-27
  1. 5

    Je ne sais pas si vous allez trouver cette réponse satisfaisante, mais vous appelez root.mainloop() parce que root est l'objet qui a le mainloop méthode. Dans le code que vous avez donné, App n'a pas de mainloop fonction.

    En termes plus simples, c'est juste la façon dont tkinter fonctionne -- vous toujours à la fin de votre script en appelant le mainloop méthode de la fenêtre racine. Lorsque cette méthode retourne, votre programme va fermer.

    Commençons par le début. Le plus simple, non-OO Tkinter programme va ressembler à l'exemple suivant. Notez que c'est un python 2.x exemple, et je ne suis pas d'utiliser une approche globale de l'importation car je pense que les importations mondiales sont mauvais. 

    import Tkinter as tk
root = tk.Tk()
<your widgets go here>
root.mainloop()

    Beaucoup de gens trouvent qu'un pur style procédural n'est pas un moyen efficace d'écrire du code, de sorte qu'ils pourraient choisir d'écrire dans un style orienté objets. Il est naturel de penser à "l'app" comme un objet singleton. Il y a beaucoup de façons de le faire-les dans votre question est, malheureusement, pas un seul de le plus clair de façons de le faire.

    Une manière légèrement meilleure, OMI, est de structurer le code comme ceci:

    class App(tk.Tk):
    def __init__(self, *args, **kwargs):
        tk.Tk.__init__(self, *args, **kwargs)
        <your widgets go here>
app = App()
app.mainloop()

    Dans ce cas, mainloop est toujours appelé, même si maintenant c'est une méthode de App depuis App hérite de Tk. Il est conceptuellement le même que root.mainloop() puisque dans ce cas, app est la fenêtre racine même si c'est par un nom différent.

    Donc, dans les deux cas, mainloop est une méthode qui appartient à la racine de la fenêtre. Et dans les deux cas, il doit être appelé pour l'interface graphique pour fonctionner correctement.

    Il y a une troisième variante, qui est ce que le code que vous avez choisi est à l'aide. Et avec cette variation, il y a plusieurs façons de la mettre en œuvre. La variation est à votre question utilise une classe pour définir l'interface graphique, mais ne pas hériter de Tk. C'est parfaitement bien, mais vous devez toujours appeler mainloop à un certain point. Puisque vous n'avez pas de créer (ou d'en hériter) un mainloop fonction de votre classe, vous devez appeler l'un associé à la fenêtre racine. Les variations dont je parle sont les comment et où l'instance de App est ajouté à la fenêtre racine, et comment mainloop est finalement appelé.

    Personnellement, je préfère que App hérite de Frame, et que vous emballez l'application à l'extérieur la définition de l'application. Le modèle j'utilise ressemble à ceci:

    class App(tk.Frame):
    def __init__(self, *args, **kwargs):
        tk.Frame.__init__(self, *args, **kwargs)
        <your widgets go here>

if __name__ == "__main__":
    root = tk.Tk()
    app = App(root)
    app.pack(fill="both", expand=True)
    root.mainloop()

    Dans ce dernier exemple, app et root sont deux totalement différents objets. app représente une image qui existe à l'intérieur de la fenêtre racine. Les cadres sont couramment utilisés de cette façon, comme un conteneur pour les groupes d'autres widgets.

    Donc, dans tous les cas, mainloop doit être appelée. où il est appelé, et comment, dépend un peu de votre style de codage. Certaines personnes préfèrent pour hériter de la fenêtre racine, certains ne le font pas. Dans les deux cas, vous devez appeler la mainloop fonction de la fenêtre racine.

    • (Excusez-moi parce que je suis potentiellement va boucher l'utilisation de la terminologie.) Cette réponse est assez satisfaisant. Je crois que je suis vraiment fauché par la, c'est quand tout est dit et fait, est d'application et de la racine de l'un et la même instance d'un objet? Venant d'un contexte procédural, si l'application et la racine sont des instances DIFFÉRENTES, tous les widgets sont emballés dans de l'instance de l'application. Donc, si j'ai appelé racine.mainloop() je ne m'attends pas à voir la nouvelle paniers widgets. Mais si j'ai appelé app.mainloop(), intuitivement, il fait sens pour moi de voir tous les paniers des widgets. Mais je suis présumant que l'application et de la racine de la même instance.
    • Et parce que l'app et de la racine de la même instance, tout emballé dans de l'app est également visible dans la racine, de sorte que dans la fin, de la racine.mainloop() affichera tous les widgets qui ont été mis en application.
    • dans le dernier exemple, l'application et la racine sont deux différentes objets. la racine est la racine de la fenêtre dans laquelle tous les autres widgets aller. Il est une instance de la classe Savoirs traditionnels, et tous les tkinter, l'application doit avoir exactement une instance de cette classe. app est une instance de la classe de l'App, qui est une sous-classe de la Trame. Un cadre est généralement utilisé comme un conteneur pour d'autres widgets, dans ce cas, les widgets qui composent l'application (à l'exception de la fenêtre racine). Ce cadre est emballé à l'intérieur de la fenêtre racine. application et la racine sont deux choses complètement différentes. racine est un conteneur pour l'application.
    • Wow, merci beaucoup pour cette élégante explication. Qui fait toute la différence. Maintenant, je sais que Cadre et les Savoirs traditionnels sont deux choses complètement différentes classes. Tout est en train de faire plus de sens. Je pense que ce est la prochaine étape pour moi est d'apprendre le langage Python les classes, comment les sous-classes de travail, de l'héritage, etc. Je crois que c'est là que la confusion se pose. Vous voyez, quand j'ai vu app = App(root), je pensais que cela signifiait que l'application était une sous-classe de la racine, et la racine est une instance de la classe Savoirs traditionnels. Mais vous avez répondu à ma question très élégamment, et relevé le vrai problème: j'ai tout simplement besoin d'apprendre le langage Python classes.
    InformationsquelleAutor Bryan Oakley
  2. 1

    J'ai testé les deux, comme vous voyez:

    Est écrite avec "application". + ".pack()" et que l'on appelle "mainframe". + ".grille()"

     #-*- coding: utf-8 -*-
#THIS IS THE "MAINFRAME." - PART
from Tkinter import *
import ttk

def show():
    p = password.get() #get password from entry
    print(p)


root = Tk()
root.title("Ingos first program")

mainframe = ttk.Frame(root, padding="30 30 60 12")
mainframe.grid(column=0, row=0, sticky=(N, W, E, S))
mainframe.columnconfigure(0, weight=1)
mainframe.rowconfigure(0, weight=1)


password = StringVar() #Password variable
passEntry = Entry(mainframe, textvariable=password, show='*').grid(column=3, row=3, sticky=S)
submit = Button(mainframe, text='Show Console',command=show).grid(column=3, row=4, sticky=S)

root.mainloop()
def show():
    p = password.get() #get password from entry
    print(p)

#THIS IS THE "APP."-PART. BOTH WORKS FINE.
app = Tk()
app.title("Ingos first program")
password = StringVar() #Password variable
passEntry = Entry(app, textvariable=password, show='#').pack()
submit = Button(app, text='Show Console',command=show).pack()

app.mainloop()

    Cette instance fonctionne très bien avec python 2.7. Dans ce test de la même application. peut gérer "mainloop()"
    Ce script ouvre 2 fenêtres, l'une après l'autre (si vous fermez le premier) et le premier programme est mis en forme, n'a pas essayé d'écrire la chronique=3... des trucs dans le pack() serre.

    J'ai encore commencé la Tkinter, afin de ne pas me battre, juste d'essayer.. j'Espère que je pourrais aider à répondre à votre question.
    Tous les meilleurs, Ingo

    InformationsquelleAutor III
  3. 0

    La App objet est juste votre code d'application, et la raison pour laquelle vous appelez App(root) est de créer une instance de votre classe, qui dispose alors d'un accès à la racine de votre fenêtre.

    Il reçoit cette référence dans le __init__ méthode:

    def __init__(self, master):
    # master refers to the root window now
    ...

    Vous pouvez voir l'ensemble de définition de la App objet (donné par le bloc de début avec class App:), et il n'a même pas un mainloop méthode, afin de commencer le principal Tkinter, boucle, vous devez appeler la fenêtre racine.

    Dans le exemple dans la documentation Python2, ils ne appelez ça comme vous le soupçonnée devrait être fait, mais notez que l'exemple de leur classe en sous-classes les Savoirs traditionnels objet Frame. Dans votre exemple de code, App est un vieux de la classe de style qui n'est pas hériter de quoi que ce soit.

    • Je ne pense pas que les mots utilisés sont un peu floues. La raison pour laquelle vous appelez App(root) n'est pas "pour enregistrer une référence", mais plutôt pour créer l'application. La seule chose qui sauve la référence, c'est quand vous attribuer le résultat à la variable app. Donc, encore une fois, vous n'avez pas appel pour enregistrer la référence, vous l'affecter à une variable pour enregistrer la référence.
    • Je voulais dire la raison pour laquelle vous appelez App avec root comme paramètre, mais je crois que je vois ce que tu veux dire.
    • Vous êtes toujours de se tromper. Vous ne l'appelez pas avec la racine en tant que paramètre pour enregistrer une référence. Vous l'appelez, avec la racine en tant que paramètre, car l'Application classe exige de vous dire ce que la fenêtre est créée.
    • Je pense toujours que nous sommes juste de parler devant les uns des autres, mais j'ai modifié le libellé. L'Application les besoins de la classe de la fenêtre passé en tant qu'il peut l'utiliser (pour lui dire ce qu'fenêtre, il est créé et peut-être d'autres utilisations en fonction de la fonctionnalité de l'app) est le point que j'essaie de faire.
    • Comme vous pouvez le voir, mon orientée objet de la connaissance est encore limitée. Ma compréhension est root.mainloop() est l'interface graphique principale de la fenêtre qui s'affiche. Puis app = App(root) est l'endroit où nous créons une instance de la classe App, mais l'application n'est jamais utilisée n'importe où ailleurs dans le code. Pourtant, par la création de l'instance de la classe App, tout dans la def __init__(self, master): de l'application est tout à coup visible sur l'interface graphique principale de la fenêtre (de la racine.mainloop()). Si c'est le mauvais endroit pour demander (parce que je sais vraiment zéro de la programmation orientée objet), je serai heureux d'être redirigé vers d'autres discussions qui peuvent l'expliquer.
    InformationsquelleAutor Two-Bit Alchemist