La meilleure façon de structurer un tkinter application?

Je préconise une approche orientée objet. C'est le modèle que j'ai commencer avec:

# Use Tkinter for python 2, tkinter for python 3
import tkinter as tk

class MainApplication(tk.Frame):
    def __init__(self, parent, *args, **kwargs):
        tk.Frame.__init__(self, parent, *args, **kwargs)
        self.parent = parent

        <create the rest of your GUI here>

if __name__ == "__main__":
    root = tk.Tk()
    MainApplication(root).pack(side="top", fill="both", expand=True)
    root.mainloop()

Les points importants à noter sont:

• Je ne pas utiliser un caractère générique à l'importation. J'ai importer le paquet comme "savoirs traditionnels", qui exige que je préfixe toutes les commandes avec tk.. Cela empêche espace de noms global de la pollution, et en plus il rend le code tout à fait évident quand vous êtes en utilisant Tkinter classes, ttk classes, ou une partie de votre propre.

• L'application principale est une classe. Cela vous donne un espace de noms privé pour tous vos rappels et des fonctions privées, et généralement facilite l'organisation de votre code. Dans un style procédural vous avez le code de haut en bas, de définir des fonctions avant de les utiliser, etc. Avec cette méthode, vous n'avez pas puisque vous n'avez pas réellement créer la fenêtre principale jusqu'à la dernière étape. Je préfère héritant de tk.Frame juste parce que je commence généralement par la création d'un cadre, mais il n'est pas nécessaire.

Si votre application a plus de générique de windows, je recommande de faire chaque de ces dans une classe à part, héritant de tk.Toplevel. Cela vous donne tout de même des avantages mentionnés ci-dessus, les fenêtres sont atomiques, ils ont leur propre espace de noms, et le code est bien organisé. De Plus, il le rend facile à mettre chacun dans son propre module une fois que le code commence à devenir grand.

Enfin, vous pouvez envisager d'utiliser des classes pour chaque grande partie de votre interface. Par exemple, si vous êtes en train de créer une application avec une barre d'outils, un volet de navigation, une barre de statut, et une zone principale, vous pourriez faire de chacune de ces classes. Cela rend votre code principal assez petit et facile à comprendre:

class Navbar(tk.Frame): ...
class Toolbar(tk.Frame): ...
class Statusbar(tk.Frame): ...
class Main(tk.Frame): ...

class MainApplication(tk.Frame):
    def __init__(self, parent, *args, **kwargs):
        tk.Frame.__init__(self, parent, *args, **kwargs)
        self.statusbar = Statusbar(self, ...)
        self.toolbar = Toolbar(self, ...)
        self.navbar = Navbar(self, ...)
        self.main = Main(self, ...)

        self.statusbar.pack(side="bottom", fill="x")
        self.toolbar.pack(side="top", fill="x")
        self.navbar.pack(side="left", fill="y")
        self.main.pack(side="right", fill="both", expand=True)

Depuis toutes ces instances partagent un parent, le parent devient le "contrôleur" partie d'un modèle-vue-contrôleur de l'architecture. Ainsi, par exemple, la fenêtre principale pourrait mettre quelque chose sur la barre d'état en appelant self.parent.statusbar.set("Hello, world"). Cela vous permet de définir une interface simple entre les composants, en aidant à maintenir le couplage à un minimum.

Ce n'est pas une mauvaise structure; il fonctionne très bien. Cependant, vous ne devez avoir les fonctions dans une fonction pour faire des commandes lorsque quelqu'un clique sur un bouton ou quelque chose

Donc ce que vous pourriez faire est d'écrire des classes pour ceux-ci, de disposer de méthodes dans la classe qui gèrent les commandes pour que le bouton s'enclenche et ces.

Voici un exemple:

import tkinter as tk

class Window1:
    def __init__(self, master):
        pass
        # Create labels, entries,buttons
    def button_click(self):
        pass
        # If button is clicked, run this method and open window 2


class Window2:
    def __init__(self, master):
        #create buttons,entries,etc

    def button_method(self):
        #run this when button click to close window
        self.master.destroy()

def main(): #run mianloop 
    root = tk.Tk()
    app = Window1(root)
    root.mainloop()

if __name__ == '__main__':
    main()

Généralement les savoirs traditionnels des programmes avec plusieurs fenêtres sont plusieurs grandes classes et, dans le __init__ toutes les entrées, étiquettes, etc sont créés et chaque méthode est de gérer les événements click de bouton

Il n'est pas vraiment une bonne façon de le faire, tout ce qui fonctionne pour vous et fait le travail, aussi longtemps que ses lisible et vous pouvez facilement l'expliquer parce que si vous ne pouvez pas expliquer facilement votre programme, il y a sans doute une meilleure façon de le faire.

Prendre un coup d'oeil à Penser en Tkinter.

Probablement la meilleure façon d'apprendre comment structurer votre programme est en lisant d'autres personnes de code, surtout si c'est un programme de taille importante pour laquelle de nombreuses personnes ont contribué. Après avoir regardé le code de nombreux projets, vous devriez avoir une idée de ce que le consensus de style devrait être.

Python, comme une langue, est particulier en ce qu'il y a de fortes lignes directrices sur la façon dont vous devez formater votre code. La première est la soi-disant "Zen de Python":

• Belle est mieux que laid.
• Explicite est mieux qu'implicites.
• Simple est mieux que complexe.
• Complexe est mieux que compliqué.
• Plat est meilleur que imbriqués.
• Incomplet est mieux que dense.
• Lisibilité compte.
• Cas particuliers ne sont pas assez spécial pour briser les règles.
• Bien que le côté pratique battements de pureté.
• Erreurs ne doivent jamais passer sous silence.
• Sauf s'il est explicitement fait taire.
• Dans le visage de l'ambiguïté, de refuser la tentation de le deviner.
• Il devrait y avoir un, et de préférence seulement une façon évidente de le faire.
• Bien que cette façon peut-être pas évident à première vue, sauf si vous êtes néerlandais.
• Est maintenant mieux que jamais.
• Bien que jamais est souvent mieux que droit maintenant.
• Si la mise en œuvre est difficile à expliquer, c'est une mauvaise idée.
• Si la mise en œuvre est facile à expliquer, il peut être une bonne idée.
• Les espaces de noms sont un coup de klaxon grande idée, nous allons faire plus de ceux-là!

Sur un plan plus pratique, il est PEP8, le guide de style pour Python.

Avec celles à l'esprit, je dirais que votre style de code n'a pas vraiment d'ajustement, en particulier les fonctions imbriquées. Trouver un moyen de les aplatir ceux qui, soit par l'utilisation de classes ou de les déplacer dans des modules séparés. Cela permettra à la structure de votre programme beaucoup plus facile à comprendre.