Python Object Oriented Programming

Object-Oriented Programming (OOP) in Python is a programming paradigm that organizes code by bundling related properties and behaviors into objects. Python's OOP includes fundamental concepts like classes, objects, inheritance, polymorphism, encapsulation, and abstraction. We will explore each of these from basics to advanced examples.

Benefits of OOP

1. Basics of Classes and Objects

# Defining a basic class
class Dog:
    # Class initializer (constructor) with attributes
    def __init__(self, name, age):
        self.name = name  # Attribute (instance variable)
        self.age = age

    # Method
    def bark(self):
        return f"{self.name} says Woof!"

# Creating objects from the class
dog1 = Dog("Buddy", 3)
dog2 = Dog("Lucy", 5)

print(dog1.bark())  # Calling method
print(dog2.bark())

Output:
Buddy says Woof!
Lucy says Woof!

2. Encapsulation: Bundling Attributes and Methods

class Person:
    def __init__(self, name, age):
        self.name = name       # Public attribute
        self._age = age         # Protected attribute
        self.__ssn = "123-45-6789"  # Private attribute

    def get_ssn(self):
        return self.__ssn  # Access private attribute

person = Person("Alice", 30)
print(person.name)        # Public access
print(person.get_ssn())   # Access private attribute through method

Output:
Alice
123-45-6789

3. Inheritance: Reusing Code by Extending Classes

# Base class
class Animal:
    def __init__(self, species):
        self.species = species

    def sound(self):
        return "Some generic sound"

# Derived class
class Dog(Animal):
    def __init__(self, name, age):
        super().__init__("Dog")  # Call base class constructor
        self.name = name
        self.age = age

    def sound(self):
        return "Woof!"

dog = Dog("Buddy", 3)
print(dog.species)
print(dog.sound())

Output:
Dog
Woof!

4. Polymorphism: Unified Interface for Different Data Types

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

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

# Function that works with any object implementing sound()
def animal_sound(animal):
    print(animal.sound())

dog = Dog()
cat = Cat()

animal_sound(dog)  # Dog's sound method
animal_sound(cat)  # Cat's sound method

Output:
Woof!
Meow!

5. Abstraction: Hiding Complexity

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def sound(self):
        pass  # Abstract method

class Dog(Animal):
    def sound(self):
        return "Woof!"

class Cat(Animal):
    def sound(self):
        return "Meow!"

dog = Dog()
print(dog.sound())

Output:
Woof!

6. Advanced: Class and Static Methods

class Circle:
    pi = 3.14159  # Class variable

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

    @classmethod
    def from_diameter(cls, diameter):
        return cls(diameter / 2)

    @staticmethod
    def circumference(radius):
        return 2 * Circle.pi * radius

circle = Circle.from_diameter(10)
print("Radius from diameter:", circle.radius)
print("Circumference:", Circle.circumference(circle.radius))

Output:
Radius from diameter: 5.0
Circumference: 31.4159

7. Magic Methods and Operator Overloading

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

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __str__(self):
        return f"({self.x}, {self.y})"

v1 = Vector(2, 3)
v2 = Vector(4, 5)
print("Vector Sum:", v1 + v2)

Output:
Vector Sum: (6, 8)

8. Property Decorators: Controlling Attribute Access

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

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

    @fahrenheit.setter
    def fahrenheit(self, value):
        self._celsius = (value - 32) * 5/9

temp = Temperature(0)
print("Fahrenheit:", temp.fahrenheit)
temp.fahrenheit = 100
print("Celsius:", temp._celsius)

Output:
Fahrenheit: 32.0
Celsius: 37.77777777777778

Summary