Here's a structured example of a comprehensive educational notebook on Python Object-

Oriented Programming (OOP), following your format guidelines:

---

# Python Object-Oriented Programming (OOP)

## Introduction

Python is an incredibly versatile language, known for its simplicity and readability. However, as
applications grow in size and complexity, it becomes essential to adopt principles that help in
managing this complexity. Object-Oriented Programming (OOP) is a programming paradigm
that organizes code into reusable, modular objects, providing an intuitive approach to
structuring programs. In Python, OOP principles allow developers to create classes, define
objects, and model real-world problems with efficiency and scalability.

This notebook will walk you through the fundamentals of OOP in Python, covering core
concepts like classes and objects, advanced principles like inheritance and polymorphism, and
some of the common patterns used in OOP design. Whether you are a beginner looking to
understand how OOP can help you write better Python code or an advanced user looking to
deepen your knowledge, this guide will provide the insights you need.

---

## Core Concepts and Principles

### What is Object-Oriented Programming (OOP)?

1
Object-Oriented Programming (OOP) is a paradigm where code is organized into objects, which
are instances of classes. This style of programming emphasizes modularity and reusability by
creating "objects" that combine data and functionality.

- **Object**: A collection of data (attributes) and methods (functions) that act on the data.

- **Class**: A blueprint that defines the structure and behavior of objects. It allows creating
multiple instances of similar objects, making code modular and reusable.

### Benefits of OOP

- **Modularity**: Break down complex programs into simpler, manageable parts.

- **Reusability**: Write code that can be reused across different parts of the program.

- **Abstraction**: Simplify complex realities by modeling classes appropriate to the problem.

- **Encapsulation**: Restrict access to specific details, allowing safe modification of code.

- **Inheritance**: Create hierarchies where derived classes inherit properties of base classes.

- **Polymorphism**: Enable functions to use different types of objects in a uniform manner.

---

## OOP Fundamentals in Python

### 1. Classes and Objects

A **class** is a blueprint for creating objects. Each object is an instance of a class. Let's start by
defining a simple class:

2
```python

# Define a simple class

class Animal:

# Constructor to initialize the object

def __init__(self, name):

self.name = name

# Method to print a greeting

def greet(self):

print(f"Hello, I am {self.name}")

# Create an instance (object) of the class

cat = Animal("Cat")

cat.greet() # Output: Hello, I am Cat

```

#### Key Points

- The `__init__` method is the constructor that initializes object attributes.

- Methods are functions defined inside a class and are specific to objects created from that
class.

### 2. Attributes and Methods

Attributes and methods form the data and behavior of an object, respectively.

3
```python

class Car:

# Class attribute

wheels = 4

def __init__(self, make, model):

# Instance attributes

self.make = make

self.model = model

def drive(self):

print(f"The {self.make} {self.model} is driving.")

```

#### Example Usage

```python

# Instantiate the Car class

car1 = Car("Toyota", "Corolla")

print(car1.wheels) # Output: 4

car1.drive() # Output: The Toyota Corolla is driving.

```

---

4
## Important OOP Principles

### 1. Encapsulation

Encapsulation restricts access to certain attributes or methods of an object to protect data

integrity and prevent unintended interactions.

- Use an underscore (`_`) prefix to indicate that an attribute or method is private.

- Use double underscores (`__`) for stronger name mangling in Python.

```python

class BankAccount:

def __init__(self, balance=0):

self.__balance = balance # Private attribute

def deposit(self, amount):

if amount > 0:

self.__balance += amount

else:

print("Invalid amount")

def withdraw(self, amount):

if amount <= self.__balance:

self.__balance -= amount

else:

5
 print("Insufficient balance")

def get_balance(self):

return self.__balance

```

#### Example Usage

```python

account = BankAccount(1000)

account.deposit(500)

print(account.get_balance()) # Output: 1500

```

### 2. Inheritance

Inheritance allows a class to inherit attributes and methods from another class, promoting code
reusability.

```python

# Base class

class Animal:

def speak(self):

print("Animal speaks")

# Derived class

6
class Dog(Animal):

def bark(self):

print("Dog barks")

# Example usage

dog = Dog()

dog.speak() # Inherited method

dog.bark() # Dog-specific method

```

### 3. Polymorphism

Polymorphism allows objects to be treated as instances of their parent class, even if their
behaviors differ.

#### Example

```python

class Bird:

def sound(self):

print("Bird chirps")

class Dog:

def sound(self):

print("Dog barks")

7
def make_sound(animal):

animal.sound()

# Example usage

sparrow = Bird()

puppy = Dog()

make_sound(sparrow) # Output: Bird chirps

make_sound(puppy) # Output: Dog barks

```

---

## Advanced OOP Concepts

### 1. Abstraction

Abstraction simplifies complex reality by focusing on essential aspects, hiding irrelevant details.

```python

from abc import ABC, abstractmethod

class Shape(ABC):

@abstractmethod

8
 def area(self):

pass

class Circle(Shape):

def __init__(self, radius):

self.radius = radius

def area(self):

return 3.14 * (self.radius ** 2)

```

### 2. Composition

Composition models relationships between classes by allowing an object to contain other

objects as attributes.

```python

class Engine:

def start(self):

print("Engine starts")

class Car:

def __init__(self):

self.engine = Engine() # Car "has a" Engine

9
 def start(self):

self.engine.start()

print("Car starts")

```

---

## Summary Table: Key OOP Concepts in Python

| Concept | Description | Example |

|------------------|----------------------------------------------------|----------------|

| Class | Blueprint for objects | `class Person:` |

| Object | Instance of a class | `john = Person()` |

| Encapsulation | Restricting access to certain components | Private variables |

| Inheritance | Deriving new classes from existing ones | `class Dog(Animal):` |

| Polymorphism | Allowing functions to use objects of different types | `make_sound()` |

| Abstraction | Hiding complex details from the user | Abstract base classes |

| Composition | A class contains another class | `Car` and `Engine` |

---

## Practical Example: Building a Simple Library System

Below is a more comprehensive example that brings together the concepts of classes,
inheritance, encapsulation, and polymorphism.

10
```python

class Book:

def __init__(self, title, author):

self.title = title

self.author = author

class Library:

def __init__(self):

self.books = []

def add_book(self, book):

self.books.append(book)

def list_books(self):

for book in self.books:

print(f"{book.title} by {book.author}")

# Example usage

library = Library()

book1 = Book("To Kill a Mockingbird", "Harper Lee")

book2 = Book("1984", "George Orwell")

library.add_book(book1)

11
library.add_book(book2)

library.list_books()

```

---

## Conclusion

Object-Oriented Programming in Python is a powerful approach to writing clear, scalable, and

reusable code. By structuring data and behavior into classes, you can create programs that are
intuitive to build and easy to maintain. We covered the core concepts, principles, and advanced
aspects of OOP, enabling you to start applying these concepts effectively in your Python
projects. Practice and experimentation are key to mastering OOP, so feel free to expand on
these examples and build more complex applications.

12