week 4

Week 4: Functional Programming & System Modules

---

1. Decorators (Function Wrappers)

1. Basic Decorator

def decorator(func):
    def wrapper():
        print("Before function call")
        func()
        print("After function call")
    return wrapper

@decorator
def say_hello():
    print("Hello, World!")

say_hello()

2. Decorator with Arguments

def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def greet():
    print("Hi!")

greet()

3. Logging Decorator

def log_function_call(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with arguments {args} {kwargs}")
        return func(*args, **kwargs)
    return wrapper

@log_function_call
def add(a, b):
    return a + b

print(add(5, 3))

4. Timer Decorator

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"Execution time: {end - start:.4f} seconds")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(2)
    print("Done")

slow_function()

---

2. Generators & Iterators

5. Basic Generator

def count_up(n):
    for i in range(n):
        yield i

for num in count_up(5):
    print(num)

6. Generator for Fibonacci Series

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

print(list(fibonacci(10)))

7. Infinite Generator

def infinite_counter():
    num = 0
    while True:
        yield num
        num += 1

counter = infinite_counter()
print(next(counter))  # 0
print(next(counter))  # 1

8. Custom Iterator

class Reverse:
    def __init__(self, data):
        self.data = data
        self.index = len(data)

    def __iter__(self):
        return self

    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index -= 1
        return self.data[self.index]

rev = Reverse("Python")
for char in rev:
    print(char, end=" ")  # Output: n o h t y P

---

3. Threading & Multiprocessing

9. Basic Threading

import threading

def print_numbers():
    for i in range(5):
        print(i)

t = threading.Thread(target=print_numbers)
t.start()
t.join()

10. Threading with Delay

import threading
import time

def delayed_print(msg):
    time.sleep(2)
    print(msg)

t = threading.Thread(target=delayed_print, args=("Hello, after delay!",))
t.start()

11. Multiprocessing Example

import multiprocessing

def worker(num):
    print(f"Worker {num}")

processes = []
for i in range(5):
    p = multiprocessing.Process(target=worker, args=(i,))
    processes.append(p)
    p.start()

for p in processes:
    p.join()

12. Shared Memory (Multiprocessing Manager)

from multiprocessing import Manager, Process

def worker(shared_list):
    shared_list.append(1)

if __name__ == "__main__":
    with Manager() as manager:
        shared_list = manager.list()
        p = Process(target=worker, args=(shared_list,))
        p.start()
        p.join()
        print(shared_list)  # Output: [1]

---

4. Design Patterns

Singleton Pattern

13. Singleton Class

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

s1 = Singleton()
s2 = Singleton()
print(s1 is s2)  # Output: True

---

Factory Pattern

14. Factory Method

class Dog:
    def speak(self):
        return "Woof!"

class Cat:
    def speak(self):
        return "Meow!"

def get_pet(pet="dog"):
    pets = {"dog": Dog(), "cat": Cat()}
    return pets.get(pet, Dog())

pet = get_pet("cat")
print(pet.speak())  # Output: Meow!

---

Observer Pattern

15. Observer Implementation

class Observer:
    def update(self, message):
        raise NotImplementedError

class Subscriber(Observer):
    def update(self, message):
        print(f"Received message: {message}")

class Publisher:
    def __init__(self):
        self.subscribers = []

    def subscribe(self, observer):
        self.subscribers.append(observer)

    def notify(self, message):
        for observer in self.subscribers:
            observer.update(message)

pub = Publisher()
sub1 = Subscriber()
sub2 = Subscriber()

pub.subscribe(sub1)
pub.subscribe(sub2)

pub.notify("New Update Available!")

---

5. Useful Python Tricks

16. Swapping Variables in One Line

a, b = 5, 10
a, b = b, a
print(a, b)  # Output: 10 5

17. Dictionary Comprehension

squares = {x: x*x for x in range(5)}
print(squares)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

18. Merging Two Dictionaries

dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4}
merged_dict = {**dict1, **dict2}
print(merged_dict)

19. Finding Most Frequent Element in a List

from collections import Counter

nums = [1, 2, 2, 3, 3, 3, 4]
most_common = Counter(nums).most_common(1)
print(most_common)  # Output: [(3, 3)]

20. Lambda Function with map

nums = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, nums))
print(squared)  # Output: [1, 4, 9, 16]

---

Summary of Week 4 Topics

1. Decorators - Function wrappers, logging, timing.

2. Generators & Iterators - Lazy evaluation, custom iterators.

3. Threading & Multiprocessing - Parallel processing.

4. Design Patterns - Singleton, Factory, Observer.

5. Python Tricks - Dictionary merging, swapping, lambda.

---