Object-Oriented Programming (OOP) in Python 🧠

A class defines the blueprint or concept (like "Dog").
An object (or instance) is a specific example of that concept (like "Buddy").

class Dog:                          # Step 1: Define the blueprint
    def __init__(self, name, age):  # Step 2: Setup method (runs when creating)
        self.name = name            # Step 3: Store the name
        self.age  = age             # Step 4: Store the age

    def bark(self):                 # Step 5: Define a behavior
        print(f"{self.name} says Woof!")

# Creating objects (instances)
dog1 = Dog("Buddy", 3)              # Creates a Dog named Buddy, age 3
dog2 = Dog("Max", 5)                # Creates a Dog named Max, age 5

dog1.bark()                         # Buddy barks
dog2.bark()                         # Max barks

Buddy says Woof! Max says Woof!

Each object has its own data (name, age) but shares the same class definition.

Inside a class, every method receives self as the first argument. self represents the current object, allowing access to its own data.

class Cat:
    def __init__(self, name):
        self.name = name       # self.name = "this cat's name"

    def meow(self):
        # self.name refers to THIS cat's name
        print(f"{self.name} says Meow!")

cat = Cat("Luna")
cat.meow()  # Luna says Meow!

When you call cat.meow(), Python automatically passes that instance as self.

Class Attributes

These are shared by all objects of that class.

class Dog:
    species = "Canis familiaris"   # class attribute

    def __init__(self, name):
        self.name = name           # instance attribute

dog1 = Dog("Buddy")
dog2 = Dog("Max")

print(Dog.species)  # Canis familiaris
print(dog1.species) # Canis familiaris

Change Dog.species once and it affects every dog.

Instance Attributes

Belong only to that object.

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

Each dog keeps its own name and age.

Methods are functions inside classes that act on that object's data.

class Calculator:
    def add(self, a, b):
        return a + b

    def multiply(self, a, b):
        return a * b

calc = Calculator()
print(calc.add(5, 3))
print(calc.multiply(4, 6))

8 24

Whenever you see a design that repeats logic, wrap it inside a method — it's cleaner and reusable.

The special __init__() method (called a constructor) runs automatically every time you create a new object.

class Student:
    def __init__(self, name, grade):   # Runs automatically when creating
        self.name  = name              # Store name in the object
        self.grade = grade             # Store grade in the object
        print(f"Student {self.name} created.")

s1 = Student("Boopie", "A+")  # __init__ runs here automatically!

Student Boopie created.

You can think of __init__ as the setup stage for each object.

Python classes can override built-in behavior by defining dunder (double-underscore) methods.

Example:

class Dog:
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return f"Dog named {self.name}"

dog = Dog("Buddy")
print(dog)

Dog named Buddy

Encapsulation means keeping data safe inside a class, exposing only what's needed. You hide details using private attributes (by convention, prefix with underscore).

class BankAccount:
    def __init__(self, owner, balance):
        self.owner   = owner
        self._balance = balance  # "private" - don't access directly!

    def deposit(self, amount):
        if amount > 0:           # Validation! Can't deposit negative
            self._balance += amount

    def get_balance(self):       # Safe way to check balance
        return self._balance

account = BankAccount("Brayan", 500)
account.deposit(200)
print(account.get_balance())     # ✅ Use the method
# print(account._balance)        # ❌ Works but bad practice!

This approach is standard in finance, games, and apps where data integrity matters.

Abstraction hides unnecessary details so the user focuses on what matters.

Example: You use print() without worrying about how text is sent to stdout.

You can design your own abstractions:

class CoffeeMachine:
    def brew(self):
        print("Heating water…")
        print("Grinding beans…")
        print("Pouring coffee…")
        print("Coffee ready!")

All the complex steps stay hidden inside brew().

(Full lesson follows next module, but short preview here.)

Inheritance lets one class extend another:

class Animal:                 # Parent class
    def speak(self):
        print("Some sound")

class Dog(Animal):            # Child class - inherits from Animal
    def speak(self):          # Override parent's method
        print("Woof!")

# Dog gets everything from Animal, plus its own version of speak()
dog = Dog()
dog.speak()  # Output: Woof!

Now Dog inherits everything from Animal and customizes speak().

Different objects can share method names but act differently:

class Bird:
    def make_sound(self): print("Chirp")

class Cat:
    def make_sound(self): print("Meow")

class Dog:
    def make_sound(self): print("Woof")

# All have make_sound() but each does something different!
animals = [Bird(), Cat(), Dog()]
for animal in animals:
    animal.make_sound()  # Python figures out which version to call

Chirp Meow Woof

Good Naming

Use nouns for class names (Book, Student) and verbs for methods (calculate_total, display_info).

Docstrings

Document each class and method for clarity.

class Rectangle:
    """Represents a 2D rectangle with width and height."""
    def __init__(self, w, h):
        self.width = w
        self.height = h

Class methods operate on the class itself, not instances.
Static methods don't use self or cls — they're utility functions inside a class.

class MathTools:
    @staticmethod
    def add(a, b):              # No self or cls needed
        return a + b

    @classmethod
    def identity(cls):          # cls = the class itself
        return f"This is class {cls.__name__}"

# Call without creating an object!
print(MathTools.add(3, 5))      # Output: 8
print(MathTools.identity())     # Output: This is class MathTools

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

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

book = Book("1984", "George Orwell", 328)
print(book)

'1984' by George Orwell (328 pages)

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

rect = Rectangle(5, 10)
print("Area:", rect.area())
print("Perimeter:", rect.perimeter())

class Student:
    def __init__(self, name):
        self.name = name
        self.grades = []

    def add_grade(self, grade):
        self.grades.append(grade)

    def average(self):
        return sum(self.grades) / len(self.grades)

s = Student("Boopie")
s.add_grade(95)
s.add_grade(88)
s.add_grade(92)
print("Average:", s.average())

This model mirrors real-life objects — names, attributes, behaviors.

class ShoppingCart:
    def __init__(self):
        self.items = {}

    def add_item(self, name, price, quantity=1):
        self.items[name] = self.items.get(name, 0) + price * quantity

    def remove_item(self, name):
        if name in self.items: del self.items[name]

    def total(self):
        return sum(self.items.values())

cart = ShoppingCart()
cart.add_item("Apple", 1.5, 4)
cart.add_item("Banana", 0.8, 6)
print("Total:", cart.total())

Bringing it all together:

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

class Library:
    def __init__(self):
        self.books = []

    def add_book(self, book):
        self.books.append(book)

    def borrow_book(self, title):
        for b in self.books:
            if b.title == title and not b.borrowed:
                b.borrowed = True
                print(f"You borrowed '{title}'.")
                return
        print("Book unavailable.")

library = Library()
library.add_book(Book("1984","Orwell"))
library.add_book(Book("Dune","Herbert"))
library.borrow_book("Dune")

This project demonstrates encapsulation, composition, and real-world thinking in code design.

• Your program models real-world entities (users, products, orders).
• Code needs to be reused or extended.
• You're building systems with multiple components (games, apps, APIs).

If your code is short and one-off, functions may be enough. But for any project you plan to grow, OOP keeps it organized and maintainable.

• ✔ Each class should have a single responsibility.
• ✔ Keep methods small and focused.
• ✔ Use meaningful names.
• ✔ Hide internal data with underscores.
• ✔ Favor composition over deep inheritance.
• ✔ Add docstrings for clarity.
• ✔ Test classes individually.

These habits match professional guidelines (PEP 8 and SOLID principles).

Remember that Python module names are case-sensitive on most systems.

• Learn design patterns (singleton, factory, observer).
• Use dataclasses (from dataclasses import dataclass) to auto-generate boilerplate.
• Explore typing annotations for cleaner interfaces.
• Apply inheritance in Flask, FastAPI, and Django views.
• Practice with real APIs that use OOP under the hood (Discord bots, Turtle graphics).