Refactor docs, removed redundancy

Author: Sarmad426

7-OOP/2-Abstraction/Readme.md

@@ -5,127 +5,3 @@ Abstraction is one of the key principles in Object-Oriented Programming (OOP). I
 ## Abstraction in Python
 
 In Python, abstraction can be achieved through the use of classes and methods. By defining classes with methods that represent the behaviors of objects, we can abstract away the implementation details from the users of those objects.
-
-### Code Samples
-
-Here are four different code samples in Python to demonstrate abstraction:
-
-#### 1. Abstract Base Class (ABC) with Abstract Method
-
-```python
-from abc import ABC, abstractmethod
-
-class Shape(ABC):
-    """Abstract base class representing a shape."""
-    
-    @abstractmethod
-    def area(self) -> float:
-        """Calculate the area of the shape."""
-        pass
-
-class Square(Shape):
-    """Class representing a square."""
-    
-    def __init__(self, side_length: float) -> None:
-        self.side_length = side_length
-    
-    def area(self) -> float:
-        """Calculate the area of the square."""
-        return self.side_length ** 2
-
-square = Square(5)
-print("Area of the square:", square.area())
-```
-
-#### 2. Abstract Property
-
-```python
-from abc import ABC, abstractproperty
-
-class Vehicle(ABC):
-    """Abstract base class representing a vehicle."""
-    
-    @abstractproperty
-    def max_speed(self) -> float:
-        """Maximum speed of the vehicle."""
-        pass
-
-class Car(Vehicle):
-    """Class representing a car."""
-    
-    def __init__(self, max_speed: float) -> None:
-        self._max_speed = max_speed
-    
-    @property
-    def max_speed(self) -> float:
-        return self._max_speed
-
-my_car = Car(200)
-print("Max speed of the car:", my_car.max_speed)
-```
-
-#### 3. Abstract Class with Concrete Methods
-
-```python
-from abc import ABC, abstractmethod
-
-class Animal(ABC):
-    """Abstract base class representing an animal."""
-    
-    @abstractmethod
-    def sound(self) -> str:
-        """Produce the sound of the animal."""
-        pass
-    
-    def move(self) -> str:
-        """Describe how the animal moves."""
-        return "The animal moves."
-
-class Dog(Animal):
-    """Class representing a dog."""
-    
-    def sound(self) -> str:
-        return "Woof!"
-
-dog = Dog()
-print(dog.sound())
-print(dog.move())
-```
-
-#### 4. Interface Abstraction
-
-```python
-from abc import ABC, abstractmethod
-
-class PaymentGateway(ABC):
-    """Interface for payment gateways."""
-    
-    @abstractmethod
-    def process_payment(self, amount: float) -> bool:
-        """Process a payment."""
-        pass
-
-class PayPal(PaymentGateway):
-    """Class representing the PayPal payment gateway."""
-    
-    def process_payment(self, amount: float) -> bool:
-        """Process a payment using PayPal."""
-        print(f"Processing payment of ${amount} via PayPal.")
-        return True
-
-class Stripe(PaymentGateway):
-    """Class representing the Stripe payment gateway."""
-    
-    def process_payment(self, amount: float) -> bool:
-        """Process a payment using Stripe."""
-        print(f"Processing payment of ${amount} via Stripe.")
-        return True
-
-paypal_gateway = PayPal()
-stripe_gateway = Stripe()
-
-print(paypal_gateway.process_payment(100))
-print(stripe_gateway.process_payment(150))
-```
-
-These examples demonstrate how abstraction allows us to define interfaces and hide implementation details, providing a clear separation between what an object does and how it does it.

7-OOP/3B-Encapsulation/Readme.md

@@ -5,41 +5,3 @@ Encapsulation is another fundamental principle in Object-Oriented Programming (O
 ## Encapsulation in Python
 
 In Python, encapsulation is typically implemented using classes. By defining attributes as private (prefixed with double underscores `__`) and providing public methods to access or modify these attributes, encapsulation can be achieved. This ensures that the internal state of an object remains hidden from the outside world and can only be accessed or modified through well-defined interfaces.
-
-### Code Example
-
-#### Private Attributes with Getter and Setter Methods
-
-```python
-class Person:
-    """Class representing a person."""
-    
-    def __init__(self, name: str, age: int) -> None:
-        self.__name = name
-        self.__age = age
-    
-    def get_name(self) -> str:
-        """Get the name of the person."""
-        return self.__name
-    
-    def set_name(self, name: str) -> None:
-        """Set the name of the person."""
-        self.__name = name
-    
-    def get_age(self) -> int:
-        """Get the age of the person."""
-        return self.__age
-    
-    def set_age(self, age: int) -> None:
-        """Set the age of the person."""
-        self.__age = age
-
-person = Person("Alice", 30)
-print("Name:", person.get_name())
-print("Age:", person.get_age())
-
-person.set_name("Bob")
-person.set_age(25)
-print("Updated Name:", person.get_name())
-print("Updated Age:", person.get_age())
-```

7-OOP/5-Polymorphism/Readme.md

@@ -5,74 +5,3 @@ Polymorphism is a key concept in Object-Oriented Programming (OOP) that allows o
 ## Polymorphism in Python
 
 In Python, polymorphism is achieved through method overriding and method overloading. Method overriding occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. Method overloading, however, is not directly supported in Python as it is in languages like Java or C++, but Python offers a flexible way to achieve similar functionality through default arguments or variable-length arguments.
-
-### Code Samples
-
-Here are two code samples in Python to demonstrate polymorphism:
-
-#### 1. Method Overriding
-
-```python
-class Animal:
-    """Class representing an animal."""
-    
-    def sound(self) -> str:
-        """Produce the sound of the animal."""
-        return "Some generic animal sound."
-
-class Dog(Animal):
-    """Class representing a dog."""
-    
-    def sound(self) -> str:
-        """Produce the sound of the dog."""
-        return "Woof!"
-
-class Cat(Animal):
-    """Class representing a cat."""
-    
-    def sound(self) -> str:
-        """Produce the sound of the cat."""
-        return "Meow!"
-
-def make_sound(animal: Animal) -> None:
-    """Make the given animal sound."""
-    print(animal.sound())
-
-# Polymorphic behavior based on object types
-dog = Dog()
-cat = Cat()
-
-make_sound(dog)  # Output: Woof!
-make_sound(cat)  # Output: Meow!
-```
-
-#### 2. Duck Typing
-
-```python
-class Bird:
-    """Class representing a bird."""
-    
-    def fly(self) -> str:
-        """Fly like a bird."""
-        return "Flying high."
-
-class Airplane:
-    """Class representing an airplane."""
-    
-    def fly(self) -> str:
-        """Fly like an airplane."""
-        return "Soaring through the sky."
-
-def lift_off(entity):
-    """Make the given entity fly."""
-    return entity.fly()
-
-# Polymorphic behavior based on methods
-bird = Bird()
-airplane = Airplane()
-
-print(lift_off(bird))      # Output: Flying high.
-print(lift_off(airplane))  # Output: Soaring through the sky.
-```
-
-These examples demonstrate how polymorphism allows different objects to be treated uniformly through a common interface, enabling code reuse, flexibility, and extensibility in software design.