🐍 شرح Python Design Patterns

def square_positive(number: float):
    """Return square of number if number > 0, otherwise None."""
    if number <= 0:
        return None
    return number * number
def demo():
    tests = [5, 0, -3, 2.5]
    for t in tests:
        print(f"Input={t:>4} -> Output={square_positive(t)}")
if __name__ == "__main__":
    demo()

from pathlib import Path
def read_text(path: str) -> str:
    """Read all text from a file."""
    return Path(path).read_text(encoding="utf-8")
def clean_text(text: str) -> str:
    """Normalize whitespace and lowercase the text."""
    normalized = " ".join(text.split())
    return normalized.lower()
def count_words(text: str) -> int:
    """Count words in cleaned text."""
    return len(text.split())
def main():
    sample_path = "lecture1_sample.txt"
    Path(sample_path).write_text("  Hello   Python   Students!\nWelcome to   ELC 423.  ", encoding="utf-8")
    raw = read_text(sample_path)
    cleaned = clean_text(raw)
    n_words = count_words(cleaned)
    print("RAW:", raw)
    print("CLEANED:", cleaned)
    print("WORD COUNT:", n_words)
if __name__ == "__main__":
    main()

from typing import Optional
def safe_divide(a: float, b: float) -> Optional[float]:
    """Return a/b if b != 0, otherwise None."""
    if b == 0:
        return None
    return a / b
def main():
    tests = [(10, 2), (5, 0), (7.5, 2.5)]
    for a, b in tests:
        result = safe_divide(a, b)
        print(f"{a} / {b} = {result}")

def write_students(path: str, students: list[str]) -> None:
    with open(path, "w", encoding="utf-8") as f:
        for name in students:
            f.write(name + "\n")
def read_students(path: str) -> list[str]:
    with open(path, "r", encoding="utf-8") as f:
        return [line.strip() for line in f if line.strip()]
def main():
    file_path = "students.txt"
    students = ["Ahmed", "Mona", "Hany", "Sara"]
    write_students(file_path, students)
    loaded = read_students(file_path)
    print("Saved students:", students)
    print("Loaded students:", loaded)

import time
from functools import wraps
def timer(func):
    """Decorator to measure execution time."""
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        value = func(*args, **kwargs)
        end = time.perf_counter()
        print(f"[TIMER] {func.__name__} took {(end - start):.6f} seconds")
        return value
    return wrapper
@timer
def sum_to_n(n: int) -> int:
    return sum(range(1, n + 1))
def main():
    result = sum_to_n(5_000_000)
    print("Result:", result)

class StudentGrades:
    def __init__(self, student_name: str, grades: list[float]):
        self.student_name = student_name
        self.grades = grades
    def average(self) -> float:
        if not self.grades: return 0.0
        return sum(self.grades) / len(self.grades)
class ReportPrinter:
    def print_report(self, student: StudentGrades) -> None:
        avg = student.average()
        print(f"Student: {student.student_name}")
        print(f"Average: {avg:.2f}")
def main():
    student = StudentGrades("Ahmed", [90, 85, 92, 88, 95])
    printer = ReportPrinter()
    printer.print_report(student)

from abc import ABC, abstractmethod
class PaymentMethod(ABC):
    @abstractmethod
    def pay(self, amount: float) -> None: pass
class CreditCardPayment(PaymentMethod):
    def pay(self, amount: float) -> None:
        print(f"[Credit Card] Paid {amount:.2f} EGP")
class CashPayment(PaymentMethod):
    def pay(self, amount: float) -> None:
        print(f"[Cash] Paid {amount:.2f} EGP")
class BankTransferPayment(PaymentMethod):   # مضاف بدون تعديل PaymentProcessor
    def pay(self, amount: float) -> None:
        print(f"[Bank Transfer] Paid {amount:.2f} EGP")
class PaymentProcessor:
    def __init__(self, method: PaymentMethod):
        self.method = method
    def process(self, amount: float) -> None:
        self.method.pay(amount)   # Polymorphism — no if/else!
def main():
    for method in (CreditCardPayment(), CashPayment(), BankTransferPayment()):
        PaymentProcessor(method).process(250.0)

class Bird:
    def move(self) -> None:
        raise NotImplementedError
class Sparrow(Bird):
    def move(self) -> None:
        print("Sparrow flies in the sky.")
class Penguin(Bird):
    def move(self) -> None:
        print("Penguin swims in the water.")
def make_bird_move(bird: Bird) -> None:
    bird.move()   # works for ANY Bird subclass
def main():
    for b in [Sparrow(), Penguin()]:
        make_bird_move(b)

from abc import ABC, abstractmethod
class Printer(ABC):
    @abstractmethod
    def print_doc(self, text: str) -> None: pass
class Scanner(ABC):
    @abstractmethod
    def scan_doc(self) -> str: pass
class SimplePrinter(Printer):
    def print_doc(self, text: str) -> None:
        print(f"[SimplePrinter] Printing: {text}")
class MultiFunctionDevice(Printer, Scanner):
    def print_doc(self, text: str) -> None:
        print(f"[MFD] Printing: {text}")
    def scan_doc(self) -> str:
        print("[MFD] Scanning document...")
        return "Scanned document content"

from abc import ABC, abstractmethod
class Notifier(ABC):
    @abstractmethod
    def send(self, message: str) -> None: pass
class EmailNotifier(Notifier):
    def send(self, message: str) -> None:
        print(f"[EMAIL] {message}")
class SMSNotifier(Notifier):
    def send(self, message: str) -> None:
        print(f"[SMS] {message}")
class FakeNotifier(Notifier):   # For testing
    def __init__(self):
        self.sent_messages: list[str] = []
    def send(self, message: str) -> None:
        self.sent_messages.append(message)
class AlertService:
    def __init__(self, notifier: Notifier):   # Depends on abstraction!
        self.notifier = notifier
    def alert(self, level: str, details: str) -> None:
        self.notifier.send(f"ALERT [{level}]: {details}")

from abc import ABC, abstractmethod
import math
class Shape(ABC):
    @abstractmethod
    def area(self) -> float: pass
class Circle(Shape):
    def __init__(self, radius: float): self.radius = radius
    def area(self) -> float: return math.pi * self.radius ** 2
class Rectangle(Shape):
    def __init__(self, width: float, height: float):
        self.width = width; self.height = height
    def area(self) -> float: return self.width * self.height
def create_shape(shape_type: str, **kwargs) -> Shape:
    if shape_type == "circle": return Circle(radius=kwargs["radius"])
    if shape_type == "rectangle": return Rectangle(kwargs["width"], kwargs["height"])
    raise ValueError(f"Unknown shape: {shape_type}")
def main():
    s1 = create_shape("circle", radius=5)
    s2 = create_shape("rectangle", width=4, height=6)
    print("Circle area:", round(s1.area(), 3))
    print("Rectangle area:", round(s2.area(), 3))

class LightButton(Button):
    def render(self): print("[LightButton] White background")
class DarkButton(Button):
    def render(self): print("[DarkButton] Dark background")
class LightFactory(UIFactory):
    def create_button(self): return LightButton()
    def create_textbox(self): return LightTextBox()
class DarkFactory(UIFactory):
    def create_button(self): return DarkButton()
    def create_textbox(self): return DarkTextBox()
def build_screen(factory: UIFactory) -> None:
    btn = factory.create_button()
    tb  = factory.create_textbox()
    btn.render(); tb.render()
def main():
    build_screen(LightFactory())   # Light theme
    build_screen(DarkFactory())    # Dark theme

from dataclasses import dataclass
@dataclass
class Computer:
    cpu: str | None = None
    ram: str | None = None
    storage: str | None = None
    gpu: str | None = None
class ComputerBuilder:
    def __init__(self): self._computer = Computer()
    def cpu(self, cpu): self._computer.cpu = cpu; return self
    def ram(self, ram): self._computer.ram = ram; return self
    def storage(self, s): self._computer.storage = s; return self
    def gpu(self, gpu): self._computer.gpu = gpu; return self
    def build(self):
        built = self._computer
        self._computer = Computer()   # reset for next build
        return built
def main():
    builder = ComputerBuilder()
    gaming = builder.cpu("Intel i7").ram("32GB").storage("1TB SSD").gpu("RTX 4070").build()
    office = builder.cpu("Intel i5").ram("16GB").storage("512GB SSD").build()
    print("Gaming PC:", gaming)
    print("Office PC:", office)

import copy
from dataclasses import dataclass
@dataclass
class TrainingConfig:
    model_name: str
    learning_rate: float
    batch_size: int
    epochs: int
    def clone(self) -> "TrainingConfig":
        return copy.deepcopy(self)
def main():
    base = TrainingConfig("CNN", learning_rate=0.001, batch_size=32, epochs=20)
    variant_lr = base.clone(); variant_lr.learning_rate = 0.0005
    variant_bs = base.clone(); variant_bs.batch_size = 64
    print("Base      :", base)
    print("Variant LR:", variant_lr)
    print("Variant BS:", variant_bs)

class LoggerSingleton:
    """Singleton logger — use carefully."""
    _instance = None
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance._logs = []
        return cls._instance
    def log(self, message: str) -> None:
        self._logs.append(message)
    def show_logs(self) -> None:
        for i, msg in enumerate(self._logs, 1):
            print(f"{i}. {msg}")
def main():
    logger1 = LoggerSingleton()
    logger2 = LoggerSingleton()
    print("Same object?", logger1 is logger2)  # True
    logger1.log("System started")
    logger2.log("User logged in")
    logger1.show_logs()