วิธีที่ดีที่สุดในการจัดโครงสร้างแอปพลิเคชัน tkinter? [ปิด]

ต่อไปนี้เป็นโครงสร้างโดยรวมของโปรแกรม python tkinter ทั่วไปของฉัน

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 funBและfunCจะแสดงToplevelหน้าต่างอื่นพร้อมวิดเจ็ตเมื่อผู้ใช้คลิกที่ปุ่ม 1, 2, 3

ฉันสงสัยว่านี่เป็นวิธีที่ถูกต้องในการเขียนโปรแกรม python tkinter หรือไม่? แน่นอนว่ามันจะใช้งานได้แม้ว่าฉันจะเขียนแบบนี้ แต่มันเป็นวิธีที่ดีที่สุดหรือไม่? มันฟังดูโง่ แต่เมื่อฉันเห็นรหัสที่คนอื่นเขียนโค้ดของพวกเขาก็ไม่ยุ่งกับฟังก์ชันมากมายและส่วนใหญ่จะมีคลาส

มีโครงสร้างเฉพาะใดบ้างที่เราควรปฏิบัติตามแนวทางปฏิบัติที่ดี? ฉันควรวางแผนอย่างไรก่อนเริ่มเขียนโปรแกรม python?

ฉันรู้ว่าไม่มีแนวทางปฏิบัติที่ดีที่สุดในการเขียนโปรแกรมและฉันก็ไม่ได้ขอเช่นกัน ฉันแค่ต้องการคำแนะนำและคำอธิบายเพื่อให้ฉันไปในทิศทางที่ถูกต้องในขณะที่ฉันเรียนรู้ Python ด้วยตัวเอง

ฉันสนับสนุนแนวทางเชิงวัตถุ นี่คือเทมเพลตที่ฉันเริ่มต้นด้วย:

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

สิ่งสำคัญที่ควรสังเกตคือ:

• ฉันไม่ใช้การนำเข้าสัญลักษณ์แทน ฉันนำเข้าแพ็คเกจเป็น "tk" ซึ่งต้องการให้ฉันนำหน้าคำสั่งทั้งหมดด้วยtk.. สิ่งนี้จะป้องกันไม่ให้เกิดมลพิษเนมสเปซทั่วโลกรวมทั้งทำให้รหัสชัดเจนอย่างสมบูรณ์เมื่อคุณใช้คลาส Tkinter คลาส ttk หรือบางส่วนของคุณเอง

• การประยุกต์ใช้หลักคือชั้นเรียน สิ่งนี้ช่วยให้คุณมีเนมสเปซส่วนตัวสำหรับการเรียกกลับและฟังก์ชันส่วนตัวทั้งหมดของคุณและโดยทั่วไปทำให้การจัดระเบียบโค้ดของคุณง่ายขึ้น ในรูปแบบขั้นตอนคุณต้องเขียนโค้ดจากบนลงล่างกำหนดฟังก์ชันก่อนใช้งาน ฯลฯ ด้วยวิธีนี้คุณจะไม่ทำเนื่องจากคุณไม่ได้สร้างหน้าต่างหลักจนกระทั่งถึงขั้นตอนสุดท้าย ฉันชอบที่จะสืบทอดจากtk.Frameเพียงเพราะฉันมักจะเริ่มต้นด้วยการสร้างเฟรม แต่ก็ไม่จำเป็น

ถ้า app tk.Toplevelของคุณมีหน้าต่างระดับบนสุดเพิ่มเติมผมขอแนะนำให้ทำแต่ละคนแยกชั้นสืบทอดจาก สิ่งนี้ทำให้คุณได้เปรียบทั้งหมดที่กล่าวมาข้างต้น - หน้าต่างเป็นแบบปรมาณูมีเนมสเปซของตัวเองและโค้ดได้รับการจัดระเบียบอย่างดี นอกจากนี้ยังทำให้ง่ายต่อการใส่แต่ละโมดูลลงในโมดูลของตัวเองเมื่อโค้ดเริ่มมีขนาดใหญ่

สุดท้ายคุณอาจต้องการพิจารณาใช้คลาสสำหรับทุกส่วนหลักของอินเทอร์เฟซของคุณ ตัวอย่างเช่นหากคุณกำลังสร้างแอปที่มีแถบเครื่องมือบานหน้าต่างนำทางแถบสถานะและพื้นที่หลักคุณสามารถสร้างแต่ละคลาสเหล่านั้นได้ สิ่งนี้ทำให้โค้ดหลักของคุณค่อนข้างเล็กและเข้าใจง่าย:

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)

เนื่องจากอินสแตนซ์ทั้งหมดเหล่านั้นใช้พาเรนต์ร่วมกันพาเรนต์จึงกลายเป็นส่วน "คอนโทรลเลอร์" ของสถาปัตยกรรม model-view-controller ได้อย่างมีประสิทธิภาพ self.parent.statusbar.set("Hello, world")ดังนั้นสำหรับตัวอย่างเช่นหน้าต่างหลักสามารถวางบางสิ่งบางอย่างเกี่ยวกับสถานะโดยการเรียก สิ่งนี้ช่วยให้คุณกำหนดอินเทอร์เฟซที่เรียบง่ายระหว่างส่วนประกอบช่วยให้การเชื่อมต่อกับ minimun

การใส่หน้าต่างระดับบนสุดแต่ละหน้าต่างลงในคลาสแยกต่างหากจะช่วยให้คุณใช้โค้ดซ้ำและจัดระเบียบโค้ดได้ดีขึ้น ปุ่มและวิธีการที่เกี่ยวข้องใด ๆ ที่มีอยู่ในหน้าต่างควรกำหนดไว้ในคลาสนี้ นี่คือตัวอย่าง (นำมาจากที่นี่ ):

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

ดูเพิ่มเติมที่:

• สวัสดีชาวโลกง่ายๆจาก tkinter docs
• โค้ดตัวอย่าง Tkinter สำหรับหลาย ๆ หน้าต่างทำไมปุ่มไม่โหลดอย่างถูกต้อง
• Tkinter: วิธีแสดง / ซ่อนหน้าต่าง

หวังว่าจะช่วยได้

นี่ไม่ใช่โครงสร้างที่ไม่ดี มันจะทำงานได้ดี อย่างไรก็ตามคุณต้องมีฟังก์ชันในฟังก์ชันเพื่อทำคำสั่งเมื่อมีคนคลิกที่ปุ่มหรือบางสิ่งบางอย่าง

ดังนั้นสิ่งที่คุณทำได้คือเขียนคลาสสำหรับสิ่งเหล่านี้แล้วมีเมธอดในคลาสที่จัดการคำสั่งสำหรับการคลิกปุ่มและอื่น ๆ

นี่คือตัวอย่าง:

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

โดยปกติโปรแกรม tk ที่มีหลายหน้าต่างจะมีคลาสขนาดใหญ่หลายคลาสและใน__init__ทุกรายการจะมีการสร้างป้ายกำกับและอื่น ๆ จากนั้นแต่ละวิธีจะจัดการเหตุการณ์การคลิกปุ่ม

ไม่มีวิธีที่ถูกต้องจริงๆไม่ว่าจะเป็นวิธีใดก็ตามที่เหมาะกับคุณและทำให้งานเสร็จได้ตราบเท่าที่อ่านได้และคุณสามารถอธิบายได้อย่างง่ายดายเพราะถ้าคุณไม่สามารถอธิบายโปรแกรมของคุณได้อย่างง่ายดายอาจมีวิธีที่ดีกว่า .

ลองดูที่ความคิดใน Tkinter

OOP ควรจะเป็นวิธีการและframeควรจะเป็นตัวแปรระดับแทนตัวแปรเช่น

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

อ้างอิง: http://www.python-course.eu/tkinter_buttons.php

การจัดระเบียบแอปพลิเคชันของคุณโดยใช้ชั้นเรียนทำให้คุณและคนอื่น ๆ ที่ทำงานร่วมกับคุณสามารถแก้ไขปัญหาและปรับปรุงแอปได้อย่างง่ายดาย

คุณสามารถจัดระเบียบแอปพลิเคชันของคุณได้อย่างง่ายดายดังนี้:

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

อาจเป็นวิธีที่ดีที่สุดในการเรียนรู้วิธีจัดโครงสร้างโปรแกรมของคุณคือการอ่านโค้ดของผู้อื่นโดยเฉพาะอย่างยิ่งหากเป็นโปรแกรมขนาดใหญ่ที่มีคนจำนวนมากมีส่วนร่วม หลังจากดูรหัสของโครงการต่างๆแล้วคุณควรเข้าใจว่ารูปแบบฉันทามติควรเป็นอย่างไร

Python เป็นภาษาที่มีความพิเศษตรงที่มีแนวทางที่ชัดเจนเกี่ยวกับวิธีที่คุณควรจัดรูปแบบโค้ดของคุณ อย่างแรกคือสิ่งที่เรียกว่า "Zen of Python":

• สวยดีกว่าน่าเกลียด
• Explicit ดีกว่าโดยปริยาย
• ง่ายดีกว่าซับซ้อน
• ซับซ้อนดีกว่าซับซ้อน
• แบนดีกว่าซ้อน
• เบาบางดีกว่าหนาแน่น
• จำนวนการอ่าน
• กรณีพิเศษไม่พิเศษพอที่จะทำลายกฎ
• แม้ว่าการปฏิบัติจริงจะเอาชนะความบริสุทธิ์
• ข้อผิดพลาดไม่ควรผ่านไปอย่างเงียบ ๆ
• เว้นแต่จะปิดเสียงไว้อย่างชัดเจน
• เมื่อเผชิญกับความคลุมเครือให้ปฏิเสธสิ่งล่อใจที่จะคาดเดา
• ควรมีวิธีเดียวและควรมีเพียงวิธีเดียวที่จะทำได้
• แม้ว่าวิธีดังกล่าวอาจไม่ชัดเจนในตอนแรกเว้นแต่คุณเป็นชาวดัตช์
• ตอนนี้ดีกว่าไม่เคย
• แม้ว่าจะไม่เคยเป็นมักจะดีกว่าขวาในขณะนี้
• หากการนำไปใช้นั้นยากที่จะอธิบายก็เป็นความคิดที่ไม่ดี
• หากการใช้งานง่ายต่อการอธิบายก็อาจเป็นความคิดที่ดี
• เนมสเปซเป็นแนวคิดที่ยอดเยี่ยมอย่างหนึ่ง - มาทำสิ่งเหล่านั้นให้มากขึ้น!

ในระดับที่ใช้งานได้จริงมีPEP8ซึ่งเป็นคู่มือสไตล์สำหรับ Python

เมื่อคำนึงถึงสิ่งเหล่านี้แล้วฉันจะบอกว่ารูปแบบโค้ดของคุณไม่เหมาะสมจริงๆโดยเฉพาะฟังก์ชันที่ซ้อนกัน หาวิธีแบนสิ่งเหล่านั้นออกโดยใช้คลาสหรือย้ายไปไว้ในโมดูลแยกต่างหาก สิ่งนี้จะทำให้เข้าใจโครงสร้างของโปรแกรมได้ง่ายขึ้นมาก

โดยส่วนตัวฉันไม่ได้ใช้วิธีการเชิงคัดค้านส่วนใหญ่เป็นเพราะก) เข้ามาขวางเท่านั้น b) คุณจะไม่นำสิ่งนั้นกลับมาใช้ใหม่เป็นโมดูล

แต่สิ่งที่ไม่ได้กล่าวถึงในที่นี้คือคุณต้องใช้เธรดหรือการประมวลผลหลายขั้นตอน เสมอ. มิฉะนั้นแอปพลิเคชันของคุณจะแย่มาก

เพียงทำการทดสอบง่ายๆ: เริ่มหน้าต่างจากนั้นเรียก URL หรือสิ่งอื่นใด การเปลี่ยนแปลงคือ UI ของคุณจะไม่ได้รับการอัปเดตในขณะที่คำขอเครือข่ายกำลังเกิดขึ้น หมายความว่าหน้าต่างแอปพลิเคชันของคุณจะเสีย ขึ้นอยู่กับระบบปฏิบัติการที่คุณใช้งานอยู่ แต่โดยส่วนใหญ่แล้วระบบจะไม่วาดใหม่สิ่งที่คุณลากผ่านหน้าต่างจะถูกฉาบไว้จนกว่ากระบวนการจะกลับไปที่ TK mainloop