Meilleur moyen de structurer une application tkinter?

Ce qui suit est la structure générale de mon programme tkinter python typique.

def funA():
    def funA1():
        def funA12():
            # stuff

    def funA2():
        # stuff

def funB():
    def funB1():
        # stuff

    def funB2():
        # stuff

def funC():
    def funC1():
        # stuff

    def funC2():
        # stuff


root = tk.Tk()

button1 = tk.Button(root, command=funA)
button1.pack()
button2 = tk.Button(root, command=funB)
button2.pack()
button3 = tk.Button(root, command=funC)
button3.pack()

funA funBet funCfera apparaître une autre Toplevelfenêtre avec des widgets lorsque l'utilisateur cliquera sur le bouton 1, 2, 3.

Je me demande si c'est la bonne façon d'écrire un programme python tkinter? Bien sûr, cela fonctionnera même si j'écris de cette façon, mais est-ce le meilleur moyen? Cela semble stupide mais quand je vois les codes écrits par d'autres personnes, leur code n'est pas foiré avec un tas de fonctions et la plupart ont des classes.

Y a-t-il une structure spécifique que nous devrions suivre comme bonne pratique? Comment dois-je planifier avant de commencer à écrire un programme python?

Je sais qu'il n'existe pas de meilleure pratique en matière de programmation et je ne la demande pas non plus. Je veux juste quelques conseils et explications pour me garder dans la bonne direction alors que j'apprends Python par moi-même.

Je préconise une approche orientée objet. Voici le modèle avec lequel je commence:

# 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 choses importantes à noter sont:

• Je n'utilise pas d'importation générique. J'importe le package en tant que "tk", ce qui nécessite que je préfixe toutes les commandes avec tk.. Cela évite la pollution globale des espaces de noms, et rend le code complètement évident lorsque vous utilisez des classes Tkinter, des classes ttk ou certaines des vôtres.

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

Si votre application a des fenêtres de niveau supérieur supplémentaires, je vous recommande de faire de chacune de celles-ci une classe distincte, héritant de tk.Toplevel. Cela vous donne tous les mêmes avantages mentionnés ci-dessus - les fenêtres sont atomiques, elles ont leur propre espace de noms et le code est bien organisé. De plus, il est facile de mettre chacun dans son propre module une fois que le code commence à devenir volumineux.

Enfin, vous voudrez peut-être envisager d'utiliser des classes pour chaque partie majeure de votre interface. Par exemple, si vous créez une application avec une barre d'outils, un volet de navigation, une barre d'état et une zone principale, vous pouvez créer 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)

Puisque toutes ces instances partagent un parent commun, le parent devient effectivement la partie «contrôleur» d'une architecture modèle-vue-contrôleur. Ainsi, par exemple, la fenêtre principale pourrait placer 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, contribuant à maintenir le couplage à un minimum.

Le fait de placer chacune de vos fenêtres de niveau supérieur dans sa propre classe distincte vous permet de réutiliser le code et d'une meilleure organisation du code. Tous les boutons et méthodes pertinentes présents dans la fenêtre doivent être définis dans cette classe. Voici un exemple (tiré d' ici ):

import tkinter as tk

class Demo1:
    def __init__(self, master):
        self.master = master
        self.frame = tk.Frame(self.master)
        self.button1 = tk.Button(self.frame, text = 'New Window', width = 25, command = self.new_window)
        self.button1.pack()
        self.frame.pack()
    def new_window(self):
        self.newWindow = tk.Toplevel(self.master)
        self.app = Demo2(self.newWindow)

class Demo2:
    def __init__(self, master):
        self.master = master
        self.frame = tk.Frame(self.master)
        self.quitButton = tk.Button(self.frame, text = 'Quit', width = 25, command = self.close_windows)
        self.quitButton.pack()
        self.frame.pack()
    def close_windows(self):
        self.master.destroy()

def main(): 
    root = tk.Tk()
    app = Demo1(root)
    root.mainloop()

if __name__ == '__main__':
    main()

Regarde aussi:

• simple bonjour le monde de tkinter docs
• Exemple de code Tkinter pour plusieurs fenêtres, pourquoi les boutons ne se chargent-ils pas correctement?
• Tkinter: Comment afficher / masquer une fenêtre

J'espère que cela pourra aider.

Ce n'est pas une mauvaise structure; cela fonctionnera très bien. Cependant, vous devez avoir des fonctions dans une fonction pour exécuter des commandes lorsque quelqu'un clique sur un bouton ou quelque chose

Donc, ce que vous pouvez faire est d'écrire des classes pour ceux-ci, puis d'avoir des méthodes dans la classe qui gèrent les commandes pour les clics de bouton et autres.

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()

Habituellement, les programmes tk avec plusieurs fenêtres sont de plusieurs grandes classes et dans le __init__ toutes les entrées, les étiquettes, etc. sont créées, puis chaque méthode consiste à gérer les événements de clic de bouton

Il n'y a pas vraiment de bonne façon de le faire, tout ce qui fonctionne pour vous et fait le travail du moment qu'il est lisible et vous pouvez facilement l'expliquer car si vous ne pouvez pas facilement expliquer votre programme, il y a probablement une meilleure façon de le faire .

Jetez un œil à Penser à Tkinter .

La POO doit être l'approche et framedoit être une variable de classe au lieu d' une variable d' instance .

from Tkinter import *
class App:
  def __init__(self, master):
    frame = Frame(master)
    frame.pack()
    self.button = Button(frame, 
                         text="QUIT", fg="red",
                         command=frame.quit)
    self.button.pack(side=LEFT)
    self.slogan = Button(frame,
                         text="Hello",
                         command=self.write_slogan)
    self.slogan.pack(side=LEFT)
  def write_slogan(self):
    print "Tkinter is easy to use!"

root = Tk()
app = App(root)
root.mainloop()

Référence: http://www.python-course.eu/tkinter_buttons.php

L'organisation de votre application à l'aide de la classe facilite le débogage des problèmes et l'amélioration de l'application pour vous et les autres personnes qui travaillent avec vous.

Vous pouvez facilement organiser votre application comme ceci:

class hello(Tk):
    def __init__(self):
        super(hello, self).__init__()
        self.btn = Button(text = "Click me", command=close)
        self.btn.pack()
    def close():
        self.destroy()

app = hello()
app.mainloop()

La meilleure façon d'apprendre à structurer votre programme est probablement de lire le code d'autres personnes, surtout s'il s'agit d'un grand programme auquel de nombreuses personnes ont contribué. Après avoir examiné le code de nombreux projets, vous devriez avoir une idée de ce que devrait être le style de consensus.

Python, en tant que langage, est spécial en ce sens qu'il existe des directives strictes sur la façon dont vous devez formater votre code. Le premier est le soi-disant "Zen of Python":

• Beau est mieux que laid.
• L'explicite vaut mieux que l'implicite.
• Le simple vaut mieux que le complexe.
• Complexe vaut mieux que compliqué.
• Plat vaut mieux que niché.
• Clairsemé vaut mieux que dense.
• La lisibilité compte.
• Les cas spéciaux ne sont pas assez spéciaux pour enfreindre les règles.
• Bien que l'aspect pratique l'emporte sur la pureté.
• Les erreurs ne devraient jamais passer silencieusement.
• À moins d'être explicitement réduit au silence.
• Face à l'ambiguïté, refusez la tentation de deviner.
• Il devrait y avoir une - et de préférence une seule - façon évidente de le faire.
• Bien que cette manière ne soit pas évidente au début, sauf si vous êtes néerlandais.
• C'est mieux que jamais.
• Bien que jamais ne soit souvent mieux que bien maintenant.
• Si l'implémentation est difficile à expliquer, c'est une mauvaise idée.
• Si la mise en œuvre est facile à expliquer, cela peut être une bonne idée.
• Les espaces de noms sont une excellente idée - faisons-en plus!

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

Dans cet esprit, je dirais que votre style de code ne convient pas vraiment, en particulier les fonctions imbriquées. Trouvez un moyen de les aplatir, soit en utilisant des classes, soit en les déplaçant dans des modules séparés. Cela rendra la structure de votre programme beaucoup plus facile à comprendre.

Personnellement, je n'utilise pas l'approche orientée objet, principalement parce qu'elle a) ne fait que gêner; b) vous ne réutiliserez jamais cela en tant que module.

mais quelque chose qui n'est pas discuté ici, c'est que vous devez utiliser le threading ou le multiprocessing. Toujours. sinon votre application sera horrible.

faites simplement un test simple: lancez une fenêtre, puis récupérez une URL ou autre chose. les modifications sont que votre interface utilisateur ne sera pas mise à jour pendant la demande réseau. Cela signifie que la fenêtre de votre application sera cassée. dépend du système d'exploitation sur lequel vous vous trouvez, mais la plupart du temps, il ne sera pas redessiné, tout ce que vous faites glisser sur la fenêtre sera collé dessus, jusqu'à ce que le processus revienne à la boucle principale TK.