week 3

---

Week 3: Object-Oriented Programming & Monkey Patching

1. Classes, Objects, and Constructors

1. Basic Class and Object

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

    def greet(self):
        return f"Hello, my name is {self.name} and I am {self.age} years old."

p1 = Person("Alice", 25)
print(p1.greet())

2. Default Constructor

class Car:
    def __init__(self, brand="Toyota"):
        self.brand = brand

c1 = Car()
print(c1.brand)  # Output: Toyota

3. Class with Class Variable

class Dog:
    species = "Canine"  # Class variable

    def __init__(self, name):
        self.name = name

d1 = Dog("Buddy")
print(d1.name, d1.species)  # Output: Buddy Canine

4. Modifying Instance Variables

class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade

s1 = Student("John", "A")
s1.grade = "B"  # Modify instance variable
print(s1.grade)  # Output: B

---

2. Inheritance, Polymorphism, Encapsulation

5. Single Inheritance

class Animal:
    def speak(self):
        return "Animal speaks"

class Dog(Animal):
    def speak(self):
        return "Bark!"

d = Dog()
print(d.speak())  # Output: Bark!

6. Multiple Inheritance

class Parent1:
    def method1(self):
        return "Method from Parent1"

class Parent2:
    def method2(self):
        return "Method from Parent2"

class Child(Parent1, Parent2):
    pass

c = Child()
print(c.method1(), c.method2())  

7. Encapsulation (Private Variables)

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # Private variable

    def get_balance(self):
        return self.__balance

account = BankAccount(1000)
print(account.get_balance())  # Output: 1000

8. Polymorphism (Method Overriding)

class Shape:
    def area(self):
        pass

class Square(Shape):
    def __init__(self, side):
        self.side = side

    def area(self):
        return self.side ** 2

s = Square(4)
print(s.area())  # Output: 16

---

3. Magic Methods (__str__, __repr__, __call__)

9. __str__ Method

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

    def __str__(self):
        return f"{self.title} by {self.author}"

b = Book("Python Basics", "John Doe")
print(b)  # Output: Python Basics by John Doe

10. __repr__ Method

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

    def __repr__(self):
        return f"Book({self.title}, {self.author})"

b = Book("Python Basics", "John Doe")
print(repr(b))  # Output: Book(Python Basics, John Doe)

11. __call__ Method

class Multiplier:
    def __init__(self, factor):
        self.factor = factor

    def __call__(self, value):
        return value * self.factor

double = Multiplier(2)
print(double(5))  # Output: 10

---

4. Monkey Patching

12. Monkey Patching a Method

class Person:
    def greet(self):
        return "Hello!"

def new_greet(self):
    return "Hi there!"

Person.greet = new_greet  # Monkey patching
p = Person()
print(p.greet())  # Output: Hi there!

13. Monkey Patching an Instance Method

class Car:
    def speed(self):
        return "100 km/h"

def new_speed(self):
    return "200 km/h"

c = Car()
c.speed = new_speed.__get__(c, Car)  # Patch for a single instance
print(c.speed())  # Output: 200 km/h

14. Adding a New Method Dynamically

class Dog:
    pass

def bark(self):
    return "Woof!"

Dog.bark = bark
d = Dog()
print(d.bark())  # Output: Woof!

15. Monkey Patching a Function in a Module

import math

def new_sqrt(x):
    return f"Square root of {x} is {x ** 0.5}"

math.sqrt = new_sqrt  # Patching math module
print(math.sqrt(25))  # Output: Square root of 25 is 5.0

16. Patching print Function

import builtins

def custom_print(*args, **kwargs):
    builtins.print("Custom Print:", *args, **kwargs)

builtins.print = custom_print
print("Hello, World!")  # Output: Custom Print: Hello, World!

---

5. More Advanced OOP Concepts

17. Static Methods

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

print(MathUtils.add(3, 5))  # Output: 8

18. Class Methods

class Counter:
    count = 0

    @classmethod
    def increment(cls):
        cls.count += 1

Counter.increment()
print(Counter.count)  # Output: 1

19. Property Decorator (@property)

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius

    @property
    def fahrenheit(self):
        return (self._celsius * 9/5) + 32

temp = Temperature(25)
print(temp.fahrenheit)  # Output: 77.0

20. Abstract Classes

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "Bark!"

d = Dog()
print(d.make_sound())  # Output: Bark!

---