Object-Oriented & GUI Programming

Classes, Objects & The `__init__` Constructor

पाइथनमा सबै कुरा (even integers, functions, and modules) वस्तु (Object) हुन्। Class भनेको कुनै पनि Object सिर्जना गर्ने लजिकल ब्लुप्रिन्ट (Blueprint) हो, र Object भनेको उक्त ब्लुप्रिन्टको मेमोरीमा अवस्थित वास्तविक उदाहरण (Instance) हो।

१. `__init__` Constructor र `self` को भूमिका

जब कुनै क्लासबाट नयाँ अब्जेक्ट बनाइन्छ (उदा. s1 = Student("Aayush", 24)), पाइथनले आन्तरिक रूपमा दुईवटा काम गर्छ:

1. `__new__(cls)`: Memory को Heap Area मा नयाँ object को लागि space reserve गर्छ (Object Creation)।
2. `__init__(self, ...)`: भर्खरै बनेको object का attributes initialize गर्छ (Object Initialization)।
3. `self` Parameter: यो कुनै keyword होइन तर conventional first argument हो जसले current object को Memory Address (Current Instance Reference) लाई point गर्छ। जब तपाईं s1.display() call गर्नुहुन्छ, Python ले internally त्यसलाई Student.display(s1) मा bind गर्छ।

+-----------------------------------------------------------------------------------+
|  CLASS BLUEPRINT (Code Segment / Type Object)                                     |
|  class Student:                                                                   |
|      college = "TU IOST"  <--- [Class Attribute: Shared across all instances]    |
|      def __init__(self, name, roll):                                              |
|          self.name = name                                                         |
|          self.roll = roll                                                         |
|      def display(self): ...                                                       |
+-----------------------------------------------------------------------------------+
             |
             | Instantiation: s1 = Student("Bikash", 101)
             |                s2 = Student("Sarita", 102)
             v
+------------------------------------+      +------------------------------------+
| HEAP OBJECT 1: (id: 0x7fa12)       |      | HEAP OBJECT 2: (id: 0x7fa99)       |
| s1.__dict__ = {                    |      | s2.__dict__ = {                    |
|   "name": "Bikash",                |      |   "name": "Sarita",                |
|   "roll": 101                      |      |   "roll": 102                      |
| }                                  |      | }                                  |
| [self resolves to 0x7fa12]         |      | [self resolves to 0x7fa99]         |
+------------------------------------+      +------------------------------------+

२. Instance Variables vs Class Variables

TU परीक्षामा पटक-पटक सोधिने प्रश्न हो: "Differentiate between class variables and instance variables with code."

class Student:
    # 1. Class Variable: Class भित्र तर कुनै method बाहिर परिभाषित
    # सबै instance ले यही shared memory साझा गर्छन्
    university_name = "Tribhuvan University"

    def __init__(self, student_name, roll_no):
        # 2. Instance Variables: self मार्फत बाँधिएका
        # प्रत्येक object को आफ्नै छुट्टै प्रतिलिपि हुन्छ
        self.name = student_name
        self.roll = roll_no

s1 = Student("Sunil", 1)
s2 = Student("Alina", 2)

print(s1.name, "|", s1.university_name) # Sunil | Tribhuvan University
print(s2.name, "|", s2.university_name) # Alina | Tribhuvan University

# Class variable परिवर्तन गर्दा सबैमा असर पर्छ:
Student.university_name = "TU Institute of Science"
print(s1.university_name) # TU Institute of Science

Inheritance, `super()` & Method Resolution Order (MRO)

Inheritance (उत्तराधिकार) ले एउटा क्लासका गुण, विशेषता र विधिहरू अर्को क्लासमा पुनःप्रयोग (Code Reusability) गर्न अनुमति दिन्छ। पाइथनले निम्न ५ प्रकारका इनहेरिटेन्स समर्थन गर्छ:

The Diamond Problem & C3 Linearization (MRO)

जब कुनै चाइल्ड क्लासले दुईवटा त्यस्ता प्यारेन्ट क्लासहरूबाट इनहेरिट गर्छ जसको साझा मूल (Common Ancestor) हुन्छ, त्यसलाई Diamond Problem भनिन्छ। पाइथनले यो अस्पष्टता समाधान गर्न C3 Linearization Algorithm प्रयोग गर्दछ, जसलाई Method Resolution Order (MRO) भनिन्छ।

                        +-------------------+
                        |      class A      |
                        |    def info():    |
                        +-------------------+
                               /     \
                              /       \
                             /         \
             +-------------------+   +-------------------+
             |      class B(A)   |   |      class C(A)   |
             |    def info():    |   |    def info():    |
             +-------------------+   +-------------------+
                             \         /
                              \       /
                               \     /
                        +-------------------+
                        |   class D(B, C)   |
                        +-------------------+

C3 Linearization Search Order for d = D():
1. D (Current Class)
2. B (First Parent listed in class definition)
3. C (Second Parent listed in class definition)
4. A (Common Ancestor Base)
5. object (Python root object)

Python Expression: D.mro() or D.__mro__

`super()` को प्रयोग सहितको कोड उदाहरण

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        return f"I am {self.name}, aged {self.age}."

class Student(Person):
    def __init__(self, name, age, roll_no, semester):
        # super() ले Parent class को __init__ लाई कल गर्छ
        super().__init__(name, age)
        self.roll = roll_no
        self.semester = semester

    def introduce(self):
        # Method Overriding: Parent को method विस्तार गरिएको
        parent_msg = super().introduce()
        return f"{parent_msg} Roll: {self.roll}, Sem: {self.semester}"

std = Student("Pooja Sharma", 23, "MCA-05", "3rd Sem")
print(std.introduce())
# Output: I am Pooja Sharma, aged 23. Roll: MCA-05, Sem: 3rd Sem

Abstraction (ABC) & Polymorphism

Abstraction (अमूर्तीकरण): आवश्यक फिचरहरू मात्र बाहिर देखाउने र आन्तरिक जटिलताहरू लुकाउने विधि हो। पाइथनमा Abstraction लागू गर्न abc (Abstract Base Classes) मोड्युल र @abstractmethod डेकोरेटर प्रयोग गरिन्छ।

from abc import ABC, abstractmethod
import math

class Shape(ABC):
    @abstractmethod
    def area(self):
        """सबै चाइल्ड क्लासले area() विधि परिभाषित गर्नै पर्छ"""
        pass

    @abstractmethod
    def perimeter(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return math.pi * (self.radius ** 2)

    def perimeter(self):
        return 2 * math.pi * self.radius

# c = Shape()  # TypeError: Can't instantiate abstract class Shape
c = Circle(7)
print(f"Area: {c.area():.2f}") # Area: 153.94

Polymorphism: Duck Typing & Magic Methods (Dunder)

Polymorphism (बहुरूपता): एउटै नाम भएको विधि (Method) वा अपरेटरले परिस्थिति अनुसार फरक-फरक व्यवहार गर्नु हो। पाइथनमा यसका दुई मुख्य स्वरूप छन्:

1. Duck Typing: "If it walks like a duck and quacks like a duck, it is a duck." पाइथनले कुनै अब्जेक्ट कुन क्लासको हो भनी कडा टाइप चेकिङ गर्दैन, बरु उक्त अब्जेक्टसँग आवश्यक विधि छ कि छैन मात्र हेर्छ।
2. Operator Overloading (Magic Methods): अपरेटरहरू (जस्तै +, -, ==) लाई हाम्रा आफ्नै क्लास अनुसार काम गराउन dunder methods (__add__, __sub__, __eq__, __str__) ओभरलोड गरिन्छ।

class Point2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # + अपरेटर ओभरलोड गर्न __add__ विधि
    def __add__(self, other):
        return Point2D(self.x + other.x, self.y + other.y)

    # print() गर्दा सुन्दर फर्म्याट दिन __str__
    def __str__(self):
        return f"Point({self.x}, {self.y})"

p1 = Point2D(3, 4)
p2 = Point2D(5, 7)
p3 = p1 + p2  # आन्तरिक रूपमा Point2D.__add__(p1, p2) कल हुन्छ
print(p3)     # Point(8, 11)

Custom Exception Classes

पाइथनमा सबै Built-in Exceptions हरू (जस्तै ValueError, KeyError, TypeError) BaseException वा Exception क्लासका सन्तान हुन्। आफ्नो प्रोग्रामको आवश्यकता अनुसार नयाँ अपवाद बनाउन Exception क्लासलाई इनहेरिट गरिन्छ र raise किवर्डबाट फाल्न सकिन्छ।

# १. Custom Exception Class बनाउने
class InsufficientBalanceError(Exception):
    def __init__(self, balance, amount):
        super().__init__(f"रकम अपुग भयो! ब्यालेन्स रु {balance} मात्र छ, तर रु {amount} झिक्न खोजियो।")
        self.balance = balance
        self.amount = amount

# २. बिजनेस लजिकमा प्रयोग गर्ने
class BankAccount:
    def __init__(self, initial_balance):
        self.balance = initial_balance

    def withdraw(self, amount):
        if amount > self.balance:
            raise InsufficientBalanceError(self.balance, amount)
        self.balance -= amount
        return self.balance

# ३. try-except ब्लकले सुरक्षित रूपमा ह्यान्डल गर्ने
account = BankAccount(1000)
try:
    account.withdraw(2500)
except InsufficientBalanceError as err:
    print(f"[त्रुटि समातियो]: {err}")
finally:
    print("खाता विवरण सुरक्षित बन्द गरियो।")

Iterators & Generators (`yield` Paradigm)

TU MCA504 परीक्षाको सबैभन्दा लोकप्रिय प्रश्नमध्ये एक हो: "What is an Iterator? How does a Generator differ from an Iterator? Explain the yield statement."

१. Iterator Protocol (`__iter__` र `__next__`)

पाइथनमा कुनै पनि वस्तुलाई लुप गर्न सकिने बनाउन Iterator Protocol पूरा गर्नुपर्छ:

• __iter__(): यसले स्वयं Iterator अब्जेक्ट फिर्ता (return) गर्छ।
• __next__(): यसले क्रमैसँग अर्को मान दिन्छ। यदि अब कुनै मान बाँकी छैन भने यसले StopIteration एक्सेप्सन उठाउँछ (जसलाई for लुपले चुपचाप समातेर लुप अन्त्य गर्छ)।

STANDARD FUNCTION (return):
Call func() --------> Executes logic --------> return val (Stack frame destroyed!)

GENERATOR FUNCTION (yield):
Call gen()  --------> Returns Generator Object (NO code runs yet!)
next(gen)   --------> Runs until 'yield val 1' ---> Pauses & freezes local variables
next(gen)   --------> Resumes from freeze point --> Runs until 'yield val 2'
next(gen)   --------> No more yields -----------> Raises StopIteration

MEMORY FOOTPRINT COMPARISON (10 Million Integers):
List:      [x for x in range(10_000_000)]  ===> ~85.2 Megabytes RAM (Immediate)
Generator: (x for x in range(10_000_000))  ===> ~112 Bytes RAM     (Lazy on-demand)

कस्टम Iterator र Generator को कोड तुलना

# १. CUSTOM ITERATOR CLASS (Class-based Approach)
class CountdownIterator:
    def __init__(self, start):
        self.current = start

    def __iter__(self):
        return self

    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        val = self.current
        self.current -= 1
        return val

# २. GENERATOR FUNCTION WITH YIELD (Function-based Approach)
def countdown_generator(start):
    while start > 0:
        yield start
        start -= 1

# दुवैको नतिजा समान हुन्छ तर Generator धेरै छरितो र सफा हुन्छ:
for n in countdown_generator(3):
    print(n, end=" ")  # Output: 3 2 1

Decorators & Closures

Decorator भनेको कुनै पनि फङ्सनको मूल कोड (Source Code) मा परिमार्जन नगरी त्यसको कार्यक्षमता (Behavior) थप्ने वा विस्तार गर्ने उच्च-स्तरीय फङ्सन (Higher-Order Function) हो। यो Closure को सिद्धान्तमा आधारित हुन्छ।

सिन्ट्याक्सको रूपमा लेखिने @my_decorator वास्तवमा निम्न कोडको संक्षिप्त रूप (Syntactic Sugar) मात्र हो:

say_hello = my_decorator(say_hello)

Caller calls: greet("Ram")
      |
      v
+-----------------------------------------------------------------+
| WRAPPER FUNCTION (Outer Enclosing Scope Closure)                |
| 1. Execute PRE-HOOK: Check authentication or start timer        |
| 2. Call ORIGINAL: func(*args, **kwargs) ---> executes greet()   |
| 3. Execute POST-HOOK: Log audit or calculate execution elapsed  |
| 4. Return result                                                |
+-----------------------------------------------------------------+
      |
      v
Result returned to caller

परीक्षामुखी Decorator कोड उदाहरण (Execution Timer)

import time
import functools

def calculate_time(original_func):
    """कुनै पनि function कति सेकेन्ड चल्यो भनी नाप्ने डेकोरेटर"""
    @functools.wraps(original_func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        # मूल फङ्सन चलाउने
        result = original_func(*args, **kwargs)
        end_time = time.time()
        print(f"[{original_func.__name__}] ले {end_time - start_time:.6f} सेकेन्ड लियो।")
        return result
    return wrapper

@calculate_time
def compute_heavy_sum(n):
    return sum(i * i for i in range(n))

val = compute_heavy_sum(500000)
# Output: [compute_heavy_sum] ले 0.038412 सेकेन्ड लियो।

GUI Programming & Tkinter Architecture

पाइथनमा डेस्कटप एप्लिकेसन निर्माणका लागि विभिन्न लाइब्रेरीहरू छन्:

• Tkinter: पाइथनको आधिकारिक स्ट्यान्डर्ड लाइब्रेरी (Tcl/Tk को बन्धन)। MCA504 को मूल पाठ्यक्रम यही हो किनकि यो कुनै अतिरिक्त इन्स्टलेसन बिना तुरुन्त चल्छ।
• PyQt / PySide: Qt फ्रेमवर्कमा आधारित शक्तिशाली व्यावसायिक GUI टुलकिट।
• wxPython & Kivy: नेटिभ कम्पोनेन्ट र मोबाइल/मल्टी-टच स्क्रिनका लागि उपयोगी।

Tkinter का ३ आधार स्तम्भहरू (Core Concepts)

1. The Root Window (`tk.Tk()`): सबै विजेटहरू अट्ने मुख्य कन्टेनर विन्डो।
2. Geometry Managers (Layout):
   • pack(): विजेटहरूलाई ठाडो (Vertical) वा तेर्सो (Horizontal) ब्लकको रूपमा लहरै राख्छ।
   • grid(row=r, column=c): तालिका (Table/Matrix) जस्तै पङ्क्ति र स्तम्भमा व्यवस्थित गर्छ (फारम डिजाइनका लागि सर्वोत्तम)।
   • place(x=..., y=...): पिक्सेलको यकिन स्थान (Absolute Coordinates) मा राख्छ।
3. The Event Loop (`root.mainloop()`): यो विन्डोलाई प्रयोगकर्ताका इभेन्टहरू (Button Click, Keypress, Mouse move) कुर्न अनन्त लुपमा सञ्चालन गरिरहने इन्जिन हो।

+-------------------------------------------------------------------------+
| OS EVENT QUEUE (Mouse Clicks, Keystrokes, Window Resize)               |
+-------------------------------------------------------------------------+
                                   |
                                   v
+-------------------------------------------------------------------------+
| ROOT WINDOW: root = tk.Tk()                                             |
| Starts root.mainloop() (Infinite Non-blocking Event Dispatcher)        |
|                                                                         |
|   +-------------------------- Frame: main_frame --------------------+   |
|   |  Label(main_frame, text="Username:")                            |   |
|   |  Entry(main_frame)                                              |   |
|   |  Button(main_frame, text="Submit", command=handle_click) ------+   |
|   +-----------------------------------------------------------------+   |
+-------------------------------------------------------------------------+
                                                                     |
                                  Event Triggered: <Button-1>        |
                                                                     v
                                                    +---------------------+
                                                    | Callback Function:  |
                                                    | def handle_click()  |
                                                    +---------------------+

Complete Tkinter Widget Showcase

TU पाठ्यक्रममा तोकिएका सबै विजेटहरू (Widgets) को भूमिका, सिन्ट्याक्स र परीक्षामा सोधिने कोड:

lbl = tk.Label(root, text="स्वागतम!", font=("Arial", 12), fg="gold", bg="#111")
lbl.pack(pady=5)

def on_click():
    lbl.config(text="बटन थिचियो!")

btn = tk.Button(root, text="Click Me", command=on_click, relief="raised")
btn.pack(pady=5)

# Single-line Entry
ent = tk.Entry(root, width=30)
ent.pack()
entered_text = ent.get()  # भित्रको टेक्स्ट निकाल्ने

# Multi-line Text
txt = tk.Text(root, height=4, width=30)
txt.pack()
txt_content = txt.get("1.0", tk.END)  # पङ्क्ति १ क्यारेक्टर ० देखि अन्त्यसम्म

top_frame = tk.Frame(root, padx=10, pady=10, relief="groove", borderwidth=2)
top_frame.pack(fill="x")

# अब विजेटहरू सिधै root मा होइन, top_frame भित्र राखिन्छन्:
lbl_inside = tk.Label(top_frame, text="Frame भित्रको लेबल")
lbl_inside.pack()

# Checkbutton (स्वतन्त्र छनोट)
agree_var = tk.BooleanVar()
chk = tk.Checkbutton(root, text="सर्तहरू मञ्जुर छन्", variable=agree_var)
chk.pack()

# Radiobutton (साझा variable ले गर्दा एउटा मात्र चुनिन्छ)
gender_var = tk.StringVar(value="Male")
rb1 = tk.Radiobutton(root, text="पुरुष", variable=gender_var, value="Male")
rb2 = tk.Radiobutton(root, text="महिला", variable=gender_var, value="Female")
rb1.pack()
rb2.pack()

lb = tk.Listbox(root, selectmode="single", height=4)
lb.pack()

courses = ["Python MCA504", "Data Structures", "Web Tech", "Database Systems"]
for c in courses:
    lb.insert(tk.END, c)

def show_selected():
    selected_index = lb.curselection()
    if selected_index:
        print("चयन गरिएको विषय:", lb.get(selected_index))

menubar = tk.Menu(root)
filemenu = tk.Menu(menubar, tearoff=0) # tearoff=0 ले मेनु छुट्टिन दिँदैन
filemenu.add_command(label="New Project", command=lambda: print("New"))
filemenu.add_command(label="Save", command=lambda: print("Saved"))
filemenu.add_separator()
filemenu.add_command(label="Exit", command=root.quit)

menubar.add_cascade(label="File", menu=filemenu)
root.config(menu=menubar)

Full Model Tkinter Exam Project: Student Registration System

TU परीक्षामा प्रायः सोधिने लामो प्रयोगात्मक प्रश्न: "Write a complete Python Tkinter program to design a Student Registration Form containing Label, Entry, Radiobutton, Checkbutton, Listbox, and a Submit Button with validation."

import tkinter as tk
from tkinter import messagebox

class StudentRegistrationApp:
    def __init__(self, root):
        self.root = root
        self.root.title("TU MCA Student Registration System")
        self.root.geometry("460x540")
        self.root.resizable(False, False)

        # Main Title Header
        title = tk.Label(root, text="TU MCA Student Enrollment", font=("Helvetica", 14, "bold"), fg="#333")
        title.pack(pady=10)

        # 1. Container Form Frame
        form_frame = tk.Frame(root, padx=15, pady=10)
        form_frame.pack(fill="both", expand=True)

        # 2. Name Entry (grid layout)
        tk.Label(form_frame, text="Full Name:", font=("Arial", 10)).grid(row=0, column=0, sticky="w", pady=6)
        self.name_entry = tk.Entry(form_frame, width=28)
        self.name_entry.grid(row=0, column=1, pady=6)

        # 3. Roll Number Entry
        tk.Label(form_frame, text="Roll Number:", font=("Arial", 10)).grid(row=1, column=0, sticky="w", pady=6)
        self.roll_entry = tk.Entry(form_frame, width=28)
        self.roll_entry.grid(row=1, column=1, pady=6)

        # 4. Gender (Radiobuttons)
        tk.Label(form_frame, text="Gender:", font=("Arial", 10)).grid(row=2, column=0, sticky="w", pady=6)
        self.gender_var = tk.StringVar(value="Male")
        gender_frame = tk.Frame(form_frame)
        gender_frame.grid(row=2, column=1, sticky="w")
        tk.Radiobutton(gender_frame, text="Male", variable=self.gender_var, value="Male").pack(side="left", padx=2)
        tk.Radiobutton(gender_frame, text="Female", variable=self.gender_var, value="Female").pack(side="left", padx=2)

        # 5. Course Elective (Listbox)
        tk.Label(form_frame, text="Specialization:", font=("Arial", 10)).grid(row=3, column=0, sticky="nw", pady=6)
        self.course_listbox = tk.Listbox(form_frame, height=3, width=28, selectmode="single")
        for course in ["Data Science & ML", "Cyber Security", "Cloud Computing"]:
            self.course_listbox.insert(tk.END, course)
        self.course_listbox.selection_set(0)
        self.course_listbox.grid(row=3, column=1, pady=6)

        # 6. Terms Agreement (Checkbutton)
        self.terms_var = tk.BooleanVar()
        self.terms_chk = tk.Checkbutton(form_frame, text="I accept the TU terms and code of conduct", variable=self.terms_var)
        self.terms_chk.grid(row=4, column=0, columnspan=2, pady=10, sticky="w")

        # 7. Action Button
        self.submit_btn = tk.Button(root, text="Register Student", bg="#2e7d32", fg="white", font=("Arial", 10, "bold"), padx=10, pady=5, command=self.handle_submit)
        self.submit_btn.pack(pady=10)

    def handle_submit(self):
        name = self.name_entry.get().strip()
        roll = self.roll_entry.get().strip()
        gender = self.gender_var.get()
        terms = self.terms_var.get()

        selected_course_idx = self.course_listbox.curselection()
        course = self.course_listbox.get(selected_course_idx) if selected_course_idx else "None"

        # Validation Logic
        if not name or not roll:
            messagebox.showerror("Validation Error", "Name and Roll Number cannot be empty!")
            return

        if not terms:
            messagebox.showwarning("Terms Required", "Please accept terms and conditions.")
            return

        success_msg = f"Registration Successful!\n\nName: {name}\nRoll: {roll}\nGender: {gender}\nTrack: {course}"
        messagebox.showinfo("Success", success_msg)

if __name__ == "__main__":
    root_window = tk.Tk()
    app = StudentRegistrationApp(root_window)
    root_window.mainloop()