Cara terbaik untuk menyusun aplikasi tkinter?

Berikut ini adalah struktur keseluruhan dari program tkinter python tipikal saya.

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 funBdan funCakan memunculkan Topleveljendela lain dengan widget ketika pengguna mengklik tombol 1, 2, 3.

Saya bertanya-tanya apakah ini cara yang tepat untuk menulis program python tkinter? Tentu, ini akan berhasil walaupun saya menulis dengan cara ini, tetapi apakah ini cara terbaik? Kedengarannya bodoh tetapi ketika saya melihat kode yang ditulis orang lain, kode mereka tidak kacau dengan banyak fungsi dan sebagian besar mereka memiliki kelas.

Apakah ada struktur khusus yang harus kita ikuti sebagai praktik yang baik? Bagaimana saya harus merencanakan sebelum mulai menulis program python?

Saya tahu tidak ada yang namanya praktik terbaik dalam pemrograman dan saya juga tidak memintanya. Saya hanya ingin beberapa saran dan penjelasan agar saya tetap berada di arah yang benar karena saya belajar Python sendiri.

Saya menganjurkan pendekatan berorientasi objek. Ini adalah template yang saya mulai dengan:

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

Hal-hal penting yang perlu diperhatikan adalah:

• Saya tidak menggunakan impor wildcard. Saya mengimpor paket sebagai "tk", yang mengharuskan saya mengawali semua perintah tk.. Ini mencegah pencemaran namespace global, ditambah lagi membuat kode itu sangat jelas ketika Anda menggunakan kelas Tkinter, kelas ttk, atau sebagian dari Anda sendiri.

• Aplikasi utama adalah kelas . Ini memberi Anda ruang nama pribadi untuk semua panggilan balik dan fungsi pribadi Anda, dan secara umum membuatnya lebih mudah untuk mengatur kode Anda. Dalam gaya prosedural Anda harus kode top-down, mendefinisikan fungsi sebelum menggunakannya, dll. Dengan metode ini Anda tidak melakukannya karena Anda tidak benar-benar membuat jendela utama sampai langkah terakhir. Saya lebih suka mewarisi dari tk.Framehanya karena saya biasanya mulai dengan membuat bingkai, tetapi itu sama sekali tidak perlu.

Jika aplikasi Anda memiliki jendela tingkat atas tambahan, saya sarankan untuk membuat masing-masing dari mereka menjadi kelas terpisah, diwarisi dari tk.Toplevel. Ini memberi Anda semua keuntungan yang sama yang disebutkan di atas - jendela adalah atom, mereka memiliki ruang nama sendiri, dan kode terorganisir dengan baik. Plus, membuatnya mudah untuk menempatkan masing-masing ke dalam modulnya sendiri setelah kode mulai menjadi besar.

Terakhir, Anda mungkin ingin mempertimbangkan menggunakan kelas untuk setiap bagian utama antarmuka Anda. Misalnya, jika Anda membuat aplikasi dengan bilah alat, panel navigasi, bilah status, dan area utama, Anda dapat membuat masing-masing kelas tersebut. Ini membuat kode utama Anda cukup kecil dan mudah dimengerti:

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)

Karena semua instans tersebut memiliki induk yang sama, induk tersebut secara efektif menjadi bagian "pengontrol" dari arsitektur model-view-controller. Jadi, misalnya, jendela utama dapat meletakkan sesuatu di bilah status dengan memanggil self.parent.statusbar.set("Hello, world"). Ini memungkinkan Anda untuk mendefinisikan antarmuka sederhana antara komponen, membantu menjaga kopling ke minimun.

Menempatkan setiap jendela tingkat atas Anda ke dalam kelas terpisah itu sendiri memberi Anda penggunaan kembali kode dan organisasi kode yang lebih baik. Setiap tombol dan metode yang relevan yang ada di jendela harus didefinisikan di dalam kelas ini. Ini sebuah contoh (diambil dari sini ):

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

Lihat juga:

• dunia halo sederhana dari tkinter docs
• Contoh kode Tkinter untuk banyak windows, mengapa tombol tidak dimuat dengan benar?
• Tkinter: Cara Menampilkan / Menyembunyikan Jendela

Semoga itu bisa membantu.

Ini bukan struktur yang buruk; itu akan bekerja dengan baik. Namun, Anda harus memiliki fungsi dalam fungsi untuk melakukan perintah ketika seseorang mengklik tombol atau sesuatu

Jadi yang dapat Anda lakukan adalah menulis kelas untuk ini kemudian memiliki metode di kelas yang menangani perintah untuk klik tombol dan semacamnya.

Ini sebuah contoh:

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

Biasanya program tk dengan banyak jendela adalah beberapa kelas besar dan dalam __init__semua entri, label dll dibuat dan kemudian masing-masing metode adalah untuk menangani peristiwa klik tombol

Sebenarnya tidak ada cara yang tepat untuk melakukannya, apa pun yang bekerja untuk Anda dan menyelesaikan pekerjaan selama dapat dibaca dan Anda dapat dengan mudah menjelaskannya karena jika Anda tidak dapat dengan mudah menjelaskan program Anda, mungkin ada cara yang lebih baik untuk melakukannya .

Lihatlah Thinking in Tkinter .

OOP harus menjadi pendekatan dan frameharus menjadi variabel kelas dan bukan variabel instan .

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

Referensi: http://www.python-course.eu/tkinter_buttons.php

Pengorganisasian aplikasi Anda menggunakan kelas memudahkan Anda dan orang lain yang bekerja dengan Anda untuk men-debug masalah dan meningkatkan aplikasi dengan mudah.

Anda dapat dengan mudah mengatur aplikasi Anda seperti ini:

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

Mungkin cara terbaik untuk mempelajari bagaimana menyusun program Anda adalah dengan membaca kode orang lain, terutama jika itu adalah program besar yang telah dikontribusikan banyak orang. Setelah melihat kode banyak proyek, Anda harus mendapatkan ide tentang gaya konsensus yang seharusnya.

Python, sebagai bahasa, adalah spesial karena ada beberapa panduan kuat tentang bagaimana Anda harus memformat kode Anda. Yang pertama adalah apa yang disebut "Zen Python":

• Cantik lebih baik dari yang jelek.
• Eksplisit lebih baik daripada implisit.
• Sederhana lebih baik daripada kompleks.
• Kompleks lebih baik daripada rumit.
• Flat lebih baik daripada bersarang.
• Jarang lebih baik daripada padat.
• Jumlah keterbacaan diperhitungkan.
• Kasus khusus tidak cukup istimewa untuk melanggar aturan.
• Meskipun kepraktisan mengalahkan kemurnian.
• Kesalahan tidak boleh terjadi secara diam-diam.
• Kecuali secara eksplisit dibungkam.
• Dalam menghadapi ambiguitas, tolak godaan untuk menebak.
• Harus ada satu - dan lebih disukai hanya satu - cara yang jelas untuk melakukannya.
• Meskipun demikian mungkin tidak jelas pada awalnya kecuali Anda orang Belanda.
• Sekarang lebih baik daripada tidak sama sekali.
• Meskipun tidak pernah sering lebih baik daripada yang tepat sekarang.
• Jika implementasinya sulit dijelaskan, itu ide yang buruk.
• Jika implementasinya mudah dijelaskan, mungkin itu ide yang bagus.
• Namespaces adalah salah satu ide bagus - mari kita lakukan lebih dari itu!

Pada tingkat yang lebih praktis, ada PEP8 , panduan gaya untuk Python.

Dengan semua itu dalam pikiran, saya akan mengatakan bahwa gaya kode Anda tidak benar-benar cocok, terutama fungsi bersarang. Temukan cara untuk meratakannya, baik dengan menggunakan kelas atau memindahkannya ke modul terpisah. Ini akan membuat struktur program Anda lebih mudah dipahami.

Saya pribadi tidak menggunakan pendekatan yang berorientasi pada keberatan, sebagian besar karena itu a) hanya menghalangi; b) Anda tidak akan pernah menggunakannya kembali sebagai modul.

tetapi sesuatu yang tidak dibahas di sini, adalah Anda harus menggunakan threading atau multiprocessing. Selalu. jika tidak aplikasi Anda akan mengerikan.

lakukan saja tes sederhana: mulai jendela, lalu ambil beberapa URL atau apa pun. perubahan adalah UI Anda tidak akan diperbarui saat permintaan jaringan sedang terjadi. Artinya, jendela aplikasi Anda akan rusak. tergantung pada OS yang Anda gunakan, tetapi sebagian besar waktu, itu tidak akan redraw, apa pun yang Anda seret jendela akan terpampang di atasnya, sampai proses kembali ke mainlo TK.