Add files via upload

Author: Fahd-Bin-Ashfaq

week_11/Abstraction.md

@@ -0,0 +1,63 @@
+### Abstraction 
+
+Abstraction is the concept of hiding complex implementation details and showing only the necessary features of an object. It simplifies interactions by focusing on what an object does rather than how it does it.
+
+For example, when you use a smartphone, you don’t need to understand the internal circuits and software. You simply use the phone's interface to make calls, send messages, or browse the internet. The intricate details are hidden, allowing you to focus on the phone’s features.
+
+### Two Ways of Abstraction
+
+1. **Abstract Class**:
+   - An abstract class is a class that cannot be instantiated on its own and is meant to be subclassed. It can include abstract methods (methods without implementation) that must be implemented by subclasses.
+   - **Python Example**:
+
+     ```python
+     from abc import ABC, abstractmethod
+
+     class Vehicle(ABC):
+         @abstractmethod
+         def start(self):
+             pass
+         
+         @abstractmethod
+         def stop(self):
+             pass
+
+     class Car(Vehicle):
+         def start(self):
+             print("Car is starting")
+
+         def stop(self):
+             print("Car is stopping")
+
+     my_car = Car()
+     my_car.start()  # Output: Car is starting
+     my_car.stop()   # Output: Car is stopping
+     ```
+
+2. **Abstract Method**:
+   - An abstract method is a method defined in an abstract class without an implementation. Subclasses that inherit from the abstract class must provide their own implementation of these methods.
+   - **Python Example**:
+
+     ```python
+     from abc import ABC, abstractmethod
+
+     class Shape(ABC):
+         @abstractmethod
+         def area(self):
+             pass
+
+     class Rectangle(Shape):
+         def __init__(self, width, height):
+             self.width = width
+             self.height = height
+
+         def area(self):
+             return self.width * self.height
+
+     my_rectangle = Rectangle(4, 5)
+     print(my_rectangle.area())  # Output: 20
+     ```
+
+In these examples:
+- The **abstract class** `Vehicle` defines methods `start` and `stop` without implementing them. The subclass `Car` must provide implementations for these methods.
+- The **abstract method** `area` in the `Shape` class is implemented by the `Rectangle` subclass, which provides the specific logic for calculating the area of a rectangle.

week_11/Class & Object.md

@@ -0,0 +1,31 @@
+### Class and Object in Simple Words
+
+- **Class  ** & ** Object**: 
+A class is just like a blueprint group of attributes and methods,
+
+Attributes represented by variables that represent data
+Methods perform an action or task similar like function
+
+
+#### Example
+
+Imagine a class called `Car`:
+
+```python
+class Car:
+    name="hello World" #atribute
+    age=22             #atribute
+
+    def show(self):     #method
+        print(self.name,seld.age)
+
+
+#creating an object of class
+obj=Car()
+obj.show()
+print(obj.name)
+print(car.age)
+```
+The code defines a class named `Car` with two attributes, `name` set to `"hello World"` and `age` set to `22`, and a method `show` that prints these attributes. To use this class, an object `obj` is created from it using `obj = Car()`. This object now has access to all the attributes and methods defined in the class. When `obj.show()` is called, it prints the `name` and `age` of the `obj`, outputting `"hello World 22"`. Additionally, the attributes of the object can be accessed directly using `print(obj.name)` and `print(obj.age)`, which will print `"hello World"` and `22`, respectively. Note that there’s a typo in the original code snippet where `print(car.age)` should be `print(obj.age)` to correctly reference the created object.
+
+

week_11/Constructor.md

@@ -0,0 +1,28 @@
+### Constructor 
+
+A constructor is a special method in a class that is automatically called when an object is created. It is used to initialize the object's attributes with specific values when the object is created.
+
+#### Example Program
+
+Here's a simple example of a class with a constructor in Python:
+
+```python
+class Person:
+    def __init__(self, name, age):
+        self.name = name  # Initialize the name attribute
+        self.age = age    # Initialize the age attribute
+
+    def display(self):
+        print(f"Name: {self.name}, Age: {self.age}")
+
+# Creating an object of the Person class
+person1 = Person("Alice", 30)
+
+# Using the object's method
+person1.display()  # Output: Name: Alice, Age: 30
+```
+`__init__` is the constructor method. It takes `self` (which represents the object itself) and two other parameters, `name` and `age`. 
+
+When `person1 = Person("Alice", 30)` is executed, the constructor initializes `person1`'s `name` and `age` attributes with `"Alice"` and `30`, respectively. 
+
+`person1.display()` then prints the values of `name` and `age` for the `person1` object.

week_11/Encapsulation.md

@@ -0,0 +1,39 @@
+### Encapsulation 
+
+Encapsulation is a principle that involves bundling the data (attributes) and methods (functions) into a single unit, which is a class. It also involves restricting access to some of the object's components, which helps to protect the internal state of the object and control how it can be accessed or modified.
+
+For example, think of a class as a box that contains both data and the operations that can be performed on that data. You only interact with the data through well-defined methods, which ensures that the data is used correctly and safely.
+
+### Example of Encapsulation
+
+Here's a simple Python example demonstrating encapsulation:
+
+```python
+class BankAccount:
+    def __init__(self, account_number, balance):
+        self.__account_number = account_number  # Private attribute
+        self.__balance = balance                # Private attribute
+
+    def deposit(self, amount):
+        if amount > 0:
+            self.__balance += amount
+            print(f"Deposited {amount}. New balance: {self.__balance}")
+
+    def withdraw(self, amount):
+        if 0 < amount <= self.__balance:
+            self.__balance -= amount
+            print(f"Withdrew {amount}. New balance: {self.__balance}")
+        else:
+            print("Insufficient funds or invalid amount")
+
+    def get_balance(self):
+        return self.__balance
+
+# Using the BankAccount class
+account = BankAccount("123456", 1000)
+account.deposit(500)
+account.withdraw(200)
+print(account.get_balance())  # Output: 1300
+
+# Attempting to access private attributes directly (not recommended)
+print(account.__balance)  # This will raise an AttributeError

week_11/OOP.md

@@ -0,0 +1,24 @@
+**Object-Oriented Programming (OOP)** Object-oriented programming (OOP) in Python is a programming approach based on class and object
+
+OOP is a programing methodology focusing on real world entity
+
+
+### Pillars of OOP:
+- **Class & Object**: Fundamental building blocks of OOP. A class defines a blueprint for objects, and an object is an instance of a class.
+- **Encapsulation**: Bundling the data and methods that operate on the data within a single unit, restricting access to some of the object's components.
+- **Inheritance**: Allows a new class to inherit properties and methods from an existing class, promoting code reuse.
+- **Polymorphism**: Enables one action to behave differently based on the object it is acting upon, allowing for flexibility in code.
+- **Abstraction**: Hiding the complex implementation details and showing only the essential features of an object.
+
+### Programming Paradigms
+
+There are several programming paradigms or styles that provide different ways of thinking about and structuring code. Here are the most common ones:
+
+- **Procedural Programming**: 
+  - This is one of the simplest and oldest ways of programming. It focuses on a sequence of instructions or procedures to be executed.
+
+- **Object-Oriented Programming (OOP)**: 
+  - Focuses on creating objects that represent real-world entities.
+
+- **Functional Programming**: 
+  - focuse on  the useing of functions and avoids dublication in the code

week_11/Polymorephism.md

@@ -0,0 +1,31 @@
+### Polymorphism 
+
+The word "polymorphism" means "many forms." In programming, polymorphism refers to the ability of methods, functions, or operators with the same name to operate on different types of objects or classes. It allows a single interface to be used for different underlying data types.
+
+### Example of Polymorphism
+
+Here's a simple Python example demonstrating polymorphism:
+
+```python
+class Animal:
+    def speak(self):
+        print("Some generic animal sound")
+
+class Dog(Animal):
+    def speak(self):
+        print("Woof!")
+
+class Cat(Animal):
+    def speak(self):
+        print("Meow!")
+
+# Function that uses polymorphism
+def make_animal_speak(animal):
+    animal.speak()
+
+# Using polymorphism
+dog = Dog()
+cat = Cat()
+
+make_animal_speak(dog)  # Output: Woof!
+make_animal_speak(cat)  # Output: Meow!

week_11/inheritance.md

@@ -0,0 +1,34 @@
+### Inheritance 
+
+Inheritance allows a class to inherit attributes and methods from another class. This helps in reusing code and creating a hierarchy of classes, making it easier to manage and extend code.
+
+#### Example
+
+Here's a simple example of inheritance in Python:
+
+```python
+# Parent class
+class Animal:
+    def __init__(self, name):
+        self.name = name
+
+    def speak(self):
+        print("Some generic animal sound")
+
+# Child class inheriting from Animal
+class Dog(Animal):
+    def speak(self):
+        print("Woof!")
+
+# Creating an object of the Dog class
+my_dog = Dog("Buddy")
+
+# Using methods from both the parent and child classes
+print(my_dog.name)  # Output: Buddy
+my_dog.speak()     # Output: Woof!
+```
+In this example:
+
+- **`Animal`** is the parent class with an attribute `name` and a method `speak`.
+- **`Dog`** is a child class that inherits from `Animal`. It overrides the `speak` method to provide a specific sound for dogs.
+- When `my_dog = Dog("Buddy")` is created, it inherits the `name` attribute from `Animal` and uses its own `speak` method to print `"Woof!"`.