PySide6 ट्यूटोरियल: Python के साथ GUI एप्लिकेशन बनाना

सच कहें तो, गैर-तकनीकी हितधारक या एंड यूज़र आपके द्वारा डेटा प्रैक्टिशनर के रूप में बनाए गए Jupyter Notebooks या Python स्क्रिप्ट्स में दिलचस्पी नहीं रखते। वे समाधान के साथ इंटरैक्ट करना चाहते हैं और परिणाम खुद देखना चाहते हैं।

इसीलिए हमें अपने काम को इनसाइट रिपोर्ट्स, डैशबोर्ड्स या डेटा साइंस एप्लिकेशंस में बदलने की ज़रूरत होती है। जहाँ रिपोर्ट्स, डैशबोर्ड्स और वेब एप्लिकेशन आम हैं, वहीं एक कम-खोजा गया विकल्प डेस्कटॉप एप्लिकेशन है।

कल्पना कीजिए कि आप ऐसा ऐप डिज़ाइन कर सकें जहाँ उपयोगकर्ता बटन क्लिक करें, फॉर्म भरें और मेनू में नेविगेट करें—यह सब आपके डेस्कटॉप पर एक साफ़-सुथरे और सुखद इंटरफ़ेस के जरिए। कितना बढ़िया होगा, है ना?

इस ट्यूटोरियल में, हम PySide6 का परिचय देंगे, शुरुआती इंस्टॉलेशंस में आपकी मदद करेंगे, और आपका पहला डेस्कटॉप एप्लिकेशन बनाएंगे। हम सामान्यतः इस्तेमाल होने वाले विजेट्स का भी अन्वेषण करेंगे, लोकप्रिय डेटा साइंस लाइब्रेरीज़ से विज़ुअलाइज़ेशन शामिल करेंगे, और उपयोगी संसाधन साझा करेंगे।

PySide6 क्या है?

PySide6 एक टूलकिट है जो आपको Python प्रोग्रामिंग भाषा के साथ आकर्षक और सहज ग्राफिकल इंटरफ़ेस वाले सॉफ्टवेयर एप्लिकेशन बनाने देता है।

यह सॉफ्टवेयर के लिए इमारती ब्लॉक्स जैसा है, जो प्रोग्रामिंग में नए लोगों को भी ऐप के दृश्य और इंटरैक्टिव तत्वों को जोड़ने देता है। PySide6 के साथ, आप अपनी कल्पनाओं को वास्तविक, काम करने वाले एप्लिकेशंस में बदल सकते हैं जो Windows, Mac, Linux और यहाँ तक कि मोबाइल प्लेटफ़ॉर्म्स पर भी चलते हैं।

PySide6 सेट करना

सेटअप के लिए, हम मानते हैं कि आपके पास पहले से Python इंस्टॉल है और आपका सामान्य IDE मौजूद है। इंस्टॉलेशन सेटअप काफ़ी सीधा है।

अपना टर्मिनल खोलें और निम्न कमांड चलाएँ, और सब तैयार हो जाएगा।

pip3 install pyside6
संचालित द्वारा

अपना पहला PySide6 एप्लिकेशन बनाना

अब जब आपने लाइब्रेरी सफलतापूर्वक इंस्टॉल कर ली है, अगला कदम अपना पहला PySide6 एप्लिकेशन बनाना है। इससे हम यह भी जाँच लेते हैं कि सेटअप ठीक से काम कर रहा है, साथ ही आपको डेस्कटॉप एप्लिकेशंस का स्वाद भी मिलता है।

“main.py” नाम की एक Python फ़ाइल बनाएँ और नीचे दिया गया कोड कॉपी-पेस्ट करें।

import sys
from PySide6.QtWidgets import QApplication, QLabel
app = QApplication(sys.argv)
label = QLabel('Hello, PySide6!')
label.show()
sys.exit(app.exec_())
संचालित द्वारा

हम एक मिनट में इस कोड को समझेंगे, लेकिन पहले, टर्मिनल में Python फ़ाइल को इस तरह चलाएँ:

python3 run main.pyसंचालित द्वारा

बधाई हो, आपने अपना पहला डेस्कटॉप एप्लिकेशन बना लिया है! आपको कुछ इस तरह का दिखना चाहिए:

“Hello, PySide6” डेस्कटॉप एप्लिकेशन (छवि: लेखक)

आईए अब उस सरल PySide6 स्क्रिप्ट को तोड़कर देखें जो हमने पहले देखी थी। सबसे पहले हम आवश्यक मॉड्यूल इम्पोर्ट करते हैं:

import sys
from PySide6.QtWidgets import QApplication, QLabelसंचालित द्वारा

• sys Python की स्टैण्डर्ड लाइब्रेरी का मॉड्यूल है जो Python इंटरप्रेटर द्वारा इस्तेमाल या बनाए रखे जाने वाले कुछ वेरिएबल्स तक पहुँच देता है। PySide6 एप्लिकेशन के संदर्भ में, यह आमतौर पर कमांड-लाइन आर्ग्युमेंट्स के लिए उपयोग होता है। अधिक जानने के लिए हमारा कमांड लाइन आर्ग्युमेंट पार्सिंग ट्यूटोरियल देखें।
• QApplication और QLabel को PySide6.QtWidgets से इम्पोर्ट किया गया है। QApplication PySide6 में कोर एप्लिकेशन मैनेजमेंट क्लास है, जो किसी भी GUI एप्लिकेशन के लिए आवश्यक है। QLabel एक विजेट है जो टेक्स्ट दिखाता है, जिसका उपयोग हम एक साधारण संदेश दिखाने के लिए करते हैं।

इसके बाद, हम QApplication का एक इंस्टेंस बनाते हैं।

app = QApplication(sys.argv)
संचालित द्वारा

यह हर PySide6 एप्लिकेशन में आवश्यक है। sys.argv कमांड-लाइन आर्ग्युमेंट्स को एप्लिकेशन तक पहुँचाने के लिए उपयोग होता है। भले ही आप कमांड-लाइन आर्ग्युमेंट्स का इस्तेमाल न करें, sys.argv फिर भी आवश्यक है, क्योंकि यह QApplication को कुछ डिफ़ॉल्ट्स के साथ इनिशियलाइज़ करता है।

label = QLabel('Hello, PySide6!')संचालित द्वारा

इसके बाद, हम "Hello, PySide6!" टेक्स्ट के साथ एक QLabel विजेट बनाते हैं। यही टेक्स्ट हमारे एप्लिकेशन विंडो में दिखेगा।

label.show()संचालित द्वारा

यह लाइन label को दृश्य बनाती है। डिफ़ॉल्ट रूप से, PySide6 में विजेट्स तब तक दिखाई नहीं देते जब तक आप उन्हें स्पष्ट रूप से शो न करें।

sys.exit(app.exec_())संचालित द्वारा

अंत में, यह लाइन एप्लिकेशन के इवेंट लूप को शुरू करती है। QApplication की exec_() मेथड एप्लिकेशन के मेन लूप में प्रवेश करती है, जहाँ सभी इवेंट्स (जैसे माउस क्लिक और कीबोर्ड प्रेस) प्रोसेस होते हैं। sys.exit() कॉल एप्लिकेशन बंद होने पर साफ़-सुथरा एग्ज़िट सुनिश्चित करता है। इवेंट लूप तब तक चलता है जब तक QApplication इंस्टेंस को एग्ज़िट सिग्नल नहीं मिल जाता, जैसे कि विंडो बंद करना।

जैसा कि हमने पहले आउटपुट में देखा, हमारी स्क्रिप्ट एक मूलभूत GUI एप्लिकेशन बनाती है जिसमें एक सिंगल विंडो है जो “Hello, PySide6!” टेक्स्ट दिखाती है।

GUI एप्लिकेशन में PySide6 विजेट्स शामिल करना

PySide6 और GUI के संदर्भ में विजेट्स वे मूलभूत बिल्डिंग ब्लॉक्स हैं जिनसे किसी सॉफ्टवेयर एप्लिकेशन का यूज़र इंटरफ़ेस बनाया जाता है। विजेट्स को उन तमाम तत्वों की तरह समझें जिन्हें आप किसी भी सॉफ्टवेयर एप्लिकेशन में देखते और जिनसे इंटरैक्ट करते हैं—जैसे बटन, टेक्स्ट बॉक्स, लेबल, स्लाइडर और ड्रॉप-डाउन मेनू।

पहले PySide6 एप्लिकेशन में, हमने एक लेबल विजेट देखा था जिसका उपयोग टेक्स्ट दिखाने के लिए किया गया था। जब हम PySide6 के साथ GUI बनाते हैं, तो मूलतः हम इन विजेट्स को एक विंडो में इस तरह व्यवस्थित करते हैं कि वह हमारे एप्लिकेशन के लिए समझ में आए। हर विजेट का एक विशिष्ट उद्देश्य होता है और वह उपयोगकर्ता के साथ अलग तरह से इंटरैक्ट करता है।

विजेट्स और उनके उपयोगों की व्यापक सूची आधिकारिक दस्तावेज़ में मिल सकती है, लेकिन सबसे अधिक इस्तेमाल होने वाले हैं:

• QLabel: टेक्स्ट या इमेज दिखाने के लिए इस्तेमाल होने वाला विजेट। इसे अक्सर निर्देश, संदेश दिखाने या GUI में इमेज प्रदर्शित करने के लिए उपयोग किया जाता है।
• QPushButton: एक क्लिक करने योग्य बटन जिससे उपयोगकर्ता कुछ कार्रवाइयों को ट्रिगर कर सकते हैं। यह GUI डेवलपमेंट के सबसे बुनियादी विजेट्स में से एक है, जिसका उपयोग फॉर्म सबमिट करने, प्रक्रियाएँ शुरू करने आदि के लिए होता है।
• QLineEdit: यह विजेट उपयोगकर्ताओं को एक पंक्ति का टेक्स्ट दर्ज करने और संपादित करने देता है। इसका उपयोग आमतौर पर फॉर्म्स और सेटिंग्स में होता है जहाँ टेक्स्ट इनपुट की आवश्यकता होती है, जैसे नाम या संख्या दर्ज करना।
• QComboBox: ड्रॉपडाउन सूची और टेक्स्ट फ़ील्ड का संयोजन, जो उपयोगकर्ताओं को पूर्व-परिभाषित विकल्पों में से चुनने या अपना विकल्प टाइप करने देता है।
• QCheckBox: एक बॉक्स प्रस्तुत करता है जिसे उपयोगकर्ता चेक या अनचेक कर सकते हैं। इसे आमतौर पर फीचर्स को सक्षम/अक्षम करने या नियम व शर्तों से सहमति दर्शाने के लिए इस्तेमाल किया जाता है।
• QRadioButton: विकल्पों के एक सेट में से एक विकल्प चुनने के लिए बनाया गया, रेडियो बटन किसी समूह में एक ही चयन की अनुमति देते हैं, जैसे जेंडर, आयु रेंज, या कोई अन्य एक्सक्लूसिव चयन।
• QTextEdit: मल्टी-लाइन टेक्स्ट एडिटिंग के लिए विजेट, जो QLineEdit से अधिक कार्यक्षमता देता है, जैसे टेक्स्ट फ़ॉर्मैटिंग, कॉपी-पेस्ट और स्क्रॉलिंग।
• QSlider: स्लाइडर कंट्रोल प्रदान करता है, जो किसी रेंज के भीतर संख्यात्मक मान दर्ज करने का उपयोगी टूल है, जैसे वॉल्यूम समायोजित करना या प्राइस फ़िल्टर सेट करना।
• QSpinBox: ऐसा विजेट जो उपयोगकर्ताओं को दिए गए दायरे से एक संख्या चुनने देता है। उपयोगकर्ता छोटे ऊपर-नीचे तीरों से संख्या बढ़ा-घटा सकते हैं।
• QProgressBar: किसी कार्य की प्रगति दिखाता है। यह पूर्णता प्रतिशत को विज़ुअली दिखाता है, इसलिए फ़ाइल अपलोड/डाउनलोड जैसी प्रक्रियाओं की प्रगति ट्रैक करने में उपयोगी है।
• QTableWidget: डेटा को सारणीबद्ध रूप में दिखाने के लिए उपयोगी। यह डेटा को पंक्तियों और स्तंभों में व्यवस्थित करने देता है, जिससे संरचित डेटा प्रदर्शित और इंटरैक्ट करना आसान हो जाता है।

आइए एक ऐसा एप्लिकेशन बनाएँ जो इन सामान्य विजेट्स का उपयोग करे और उन्हें दिखाए:

import sys
from PySide6.QtWidgets import QApplication, QMainWindow, QLabel, QPushButton, QLineEdit, QComboBox, QCheckBox, QRadioButton, QTextEdit, QSlider, QSpinBox, QProgressBar, QTableWidget, QTableWidgetItem, QVBoxLayout, QHBoxLayout, QWidget

class DemoWindow(QMainWindow):
   def __init__(self):
       super().__init__()

       # Main Widget and Layout
       main_widget = QWidget()
       self.setCentralWidget(main_widget)
       main_layout = QVBoxLayout(main_widget)

       # Function to add widget with label
       def add_widget_with_label(layout, widget, label_text):
           hbox = QHBoxLayout()
           label = QLabel(label_text)
           hbox.addWidget(label)
           hbox.addWidget(widget)
           layout.addLayout(hbox)

       # QLabel
       self.label = QLabel('Hello PySide6!')
       add_widget_with_label(main_layout, self.label, 'QLabel:')

       # QPushButton
       self.button = QPushButton('Click Me')
       self.button.clicked.connect(self.on_button_clicked)
       add_widget_with_label(main_layout, self.button, 'QPushButton:')

       # QLineEdit
       self.line_edit = QLineEdit()
       add_widget_with_label(main_layout, self.line_edit, 'QLineEdit:')

       # QComboBox
       self.combo_box = QComboBox()
       self.combo_box.addItems(['Option 1', 'Option 2', 'Option 3'])
       add_widget_with_label(main_layout, self.combo_box, 'QComboBox:')

       # QCheckBox
       self.check_box = QCheckBox('Check Me')
       add_widget_with_label(main_layout, self.check_box, 'QCheckBox:')

       # QRadioButton
       self.radio_button = QRadioButton('Radio Button')
       add_widget_with_label(main_layout, self.radio_button, 'QRadioButton:')

       # QTextEdit
       self.text_edit = QTextEdit()
       add_widget_with_label(main_layout, self.text_edit, 'QTextEdit:')

       # QSlider
       self.slider = QSlider()
       add_widget_with_label(main_layout, self.slider, 'QSlider:')

       # QSpinBox
       self.spin_box = QSpinBox()
       add_widget_with_label(main_layout, self.spin_box, 'QSpinBox:')

       # QProgressBar
       self.progress_bar = QProgressBar()
       add_widget_with_label(main_layout, self.progress_bar, 'QProgressBar:')

       # QTableWidget
       self.table_widget = QTableWidget(5, 3) 
       for i in range(5):
           for j in range(3):
               item = QTableWidgetItem(f"Cell {i+1},{j+1}")
               self.table_widget.setItem(i, j, item)
       add_widget_with_label(main_layout, self.table_widget, 'QTableWidget:')

   def on_button_clicked(self):
       self.label.setText('Button Clicked!')

# Run the application
app = QApplication(sys.argv)
window = DemoWindow()
window.show()
sys.exit(app.exec_())
संचालित द्वारा

आउटपुट इस प्रकार है:

विजेट्स डेस्कटॉप एप्लिकेशन (छवि: लेखक)

हमने सफलतापूर्वक ऐसा डेस्कटॉप एप्लिकेशन बना लिया है जो सबसे सामान्य विजेट्स को शामिल करता है। समझने में आसानी के लिए, हमने प्रत्येक विजेट के साथ उसके लेबल जोड़ दिए हैं। यद्यपि यह एक सैंपल एप्लिकेशन है, अब हम इनमें से किसी लोकप्रिय विजेट को उठाकर अपने अधिक जटिल एप्लिकेशंस में इस्तेमाल कर सकते हैं।

PySide6, Matplotlib, और Seaborn के साथ एक डेटा विज़ुअलाइज़ेशन एप्लिकेशन

यह एप्लिकेशन बनाने के लिए, हम पहले एक लोकप्रिय डेटासेट लेंगे और स्टैंडअलोन विज़ुअलाइज़ेशन बनाएँगे। यह चरण उस रोज़मर्रा की एक्स्प्लोरेटरी डेटा एनालिसिस जैसा है जो हम डेटा साइंस के काम में करते हैं। फिर हम इन्हीं विज़ुअलाइज़ेशंस को एक डेस्कटॉप एप्लिकेशन में लपेटेंगे, ठीक वैसे ही जैसे हम अपनी रिपोर्ट्स और विश्लेषण को एक इंटरैक्टिव डेस्कटॉप एप्लिकेशन में बदल सकते हैं।

शुरू करने से पहले, टर्मिनल पर निम्न कमांड चलाकर सुनिश्चित करें कि हमारे पास सभी आवश्यक लाइब्रेरीज़ हैं।

pip3 install matplotlib seabornसंचालित द्वारा

कदम 1: सरल स्टैंडअलोन विज़ुअलाइज़ेशन बनाना

यहाँ, हम लोकप्रिय “iris डेटासेट” को लोड करते हैं जो Python की विज़ुअलाइज़ेशन पैकेज—Seaborn—में नैटिव रूप से उपलब्ध है। हम इसी पैकेज के साथ Matplotlib का उपयोग करके विज़ुअलाइज़ेशन बनाते हैं। Seaborn के साथ प्लॉटिंग को व्यापक रूप से समझने के लिए, आप हमारा Python Seaborn विज़ुअलाइज़ेशन गाइड देखना चाहेंगे।

import seaborn as sns
import matplotlib.pyplot as plt
# Load the Iris dataset
iris = sns.load_dataset("iris")संचालित द्वारा

इसके बाद, हम इस प्रकार विज़ुअलाइज़ेशन बनाते हैं:

plt.figure(figsize=(6, 4))
sns.scatterplot(data=iris, x="sepal_length", y="sepal_width", hue="species")
plt.title("Sepal Length vs Sepal Width")
plt.show()
संचालित द्वारा

पहला विज़ुअलाइज़ेशन एक स्कैटर प्लॉट है जो सेपल लंबाई बनाम सेपल चौड़ाई दिखाता है, प्रजाति के अनुसार रंग-कोडेड।

विज़ुअलाइज़ेशन #1: सेपल लंबाई बनाम सेपल चौड़ाई (छवि: लेखक)

दूसरा विज़ुअलाइज़ेशन पंखुड़ी की लंबाई का एक हिस्टोग्राम है, जो प्रजाति के अनुसार रंगा हुआ है।

plt.figure(figsize=(6, 4))
sns.histplot(iris, x="petal_length", hue="species", kde=True)
plt.title("Histogram of Petal Length")
plt.show()
संचालित द्वारा

और हमें आउटपुट इस तरह दिखता है:

विज़ुअलाइज़ेशन #2: पंखुड़ी की लंबाई का हिस्टोग्राम (छवि: लेखक)

अंत में, आइए एक बॉक्स प्लॉट बनाते हैं जो अलग-अलग प्रजातियों में पंखुड़ी की चौड़ाई का वितरण दिखाता है।

plt.figure(figsize=(6, 4))
sns.boxplot(x="species", y="petal_width", data=iris)
plt.title("Box Plot of Petal Width")
plt.show()
संचालित द्वारा

विज़ुअलाइज़ेशन इस प्रकार है:

ये प्लॉट्स Iris डेटासेट के बारे में अलग-अलग इनसाइट्स देते हैं, जो विभिन्न फीचर्स के आपसी संबंधों और वितरणों को प्रजातियों के पार दर्शाते हैं।

कदम 2: विज़ुअलाइज़ेशन को डेस्कटॉप एप्लिकेशन में एकीकृत करना

पहले, कोड देखें और उसे समझें।

import sys
import seaborn as sns
from PySide6.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.figure import Figure

class IrisVisualizer(QMainWindow):
   def __init__(self):
       super().__init__()
       self.setWindowTitle("Iris Dataset Visualizations")
       self.setGeometry(100, 100, 1200, 900)  # x, y, width, height
       self.initUI()

   def initUI(self):
       central_widget = QWidget(self)
       self.setCentralWidget(central_widget)
       layout = QVBoxLayout(central_widget)

       # Adding multiple plots
       self.addScatterPlot(layout)
       self.addHistogram(layout)
       self.addBoxPlot(layout)

   def addPlotCanvas(self, layout, plot_func):
       canvas = FigureCanvas(Figure(figsize=(6, 4)))
       plot_func(canvas.figure)
       layout.addWidget(canvas)

   def addScatterPlot(self, layout):
       def scatter_plot(figure):
           iris = sns.load_dataset("iris")
           ax = figure.add_subplot(111)
           sns.scatterplot(data=iris, x="sepal_length", y="sepal_width", hue="species", ax=ax)
           ax.set_title("Sepal Length vs Sepal Width")

       self.addPlotCanvas(layout, scatter_plot)

   def addHistogram(self, layout):
       def histogram(figure):
           iris = sns.load_dataset("iris")
           ax = figure.add_subplot(111)
           sns.histplot(iris, x="petal_length", hue="species", kde=True, ax=ax)
           ax.set_title("Histogram of Petal Length")

       self.addPlotCanvas(layout, histogram)

   def addBoxPlot(self, layout):
       def box_plot(figure):
           iris = sns.load_dataset("iris")
           ax = figure.add_subplot(111)
           sns.boxplot(x="species", y="petal_width", data=iris, ax=ax)
           ax.set_title("Box Plot of Petal Width")

       self.addPlotCanvas(layout, box_plot)

# Run the application
app = QApplication(sys.argv)
window = IrisVisualizer()
window.show()
sys.exit(app.exec_())
संचालित द्वारा

हमने एप्लिकेशन को IrisVisualizer क्लास के इर्द-गिर्द संरचित किया है, जो PySide6 के QMainWindow को एक्सटेंड करता है। यह क्लास मुख्य विंडो और उसके लेआउट को सेट करती है और हमारे विज़ुअलाइज़ेशंस के कंटेनर के रूप में कार्य करती है। हर प्लॉट को Matplotlib के FigureCanvasQTAgg के माध्यम से GUI में एम्बेड किया गया है, जो Matplotlib फ़िगर्स को PySide6 विजेट्स के रूप में प्रदर्शित करने देता है।

हमारे एकीकरण की कुंजी addPlotCanvas मेथड है। यह मेथड एक Matplotlib फ़िगर बनाती है, उस पर प्लॉट रेंडर करती है, और फिर उस फ़िगर को एप्लिकेशन के लेआउट में एम्बेड कर देती है। addScatterPlot, addHistogram, और addBoxPlot जैसी विशिष्ट मेथड्स व्यक्तिगत प्लॉट्स परिभाषित करती हैं, जो पहले हमारे स्टैंडअलोन प्लॉट्स थे। मुख्य विंडो का लेआउट वर्टिकल बॉक्स लेआउट (QVBoxLayout) पर सेट है, जो सभी प्लॉट्स को वर्टिकली स्टैक करता है।

आइए अपना अंतिम एप्लिकेशन देखें:

Iris डेटासेट विज़ुअलाइज़ेशन डेस्कटॉप एप्लिकेशन (छवि: लेखक)

क्या यह एप्लिकेशन Jupyter Notebook में बने एक प्लॉट से बेहतर नहीं है? बेशक, यह एक साधारण उदाहरण है, लेकिन एक बार जब हम ऐसे एप्लिकेशंस बनाने के पीछे के कॉन्सेप्ट्स समझ लेते हैं, तो हम इन्हें एक पूर्ण-फ़ledged डेटा इनसाइट्स डैशबोर्ड या डेटा साइंस एप्लिकेशन में विकसित कर सकते हैं।

निष्कर्ष

इस ट्यूटोरियल में हमने PySide6 का परिचय दिया, जो एक Python लाइब्रेरी है जो डेटा प्रैक्टिशनर्स को सबसे परिचित भाषा—Python—का उपयोग करके GUI डेस्कटॉप एप्लिकेशंस बनाने देती है। हमने PySide6 इंस्टॉल करने और अपना पहला डेस्कटॉप एप्लिकेशन बनाने से शुरुआत की।

इसके बाद, हमने डेस्कटॉप एप्लिकेशंस में इस्तेमाल होने वाले सबसे सामान्य विजेट्स को शामिल करने तक इसे विस्तृत किया।

अंततः, हमने समझा कि Seaborn और Matplotlib जैसी लोकप्रिय लाइब्रेरीज़ के विज़ुअलाइज़ेशन को सीधे अपने PySide6 एप्लिकेशंस में कैसे शामिल किया जाए।

अधिक सीखने के लिए, हम आपको आधिकारिक दस्तावेज़ देखने और अपनी जिज्ञासा के अनुसार कोई भी पसंदीदा एप्लिकेशन बनाने के लिए प्रोत्साहित करते हैं। वैकल्पिक रूप से, आप हमारा वह ट्यूटोरियल भी देख सकते हैं जो Python में GUI डेस्कटॉप एप्लिकेशन बनाता है, पर एक वैकल्पिक लाइब्रेरी Tkinter का उपयोग करते हुए।