Python OOP - Complete Python Tutorial

🎯 Understanding OOP

Object-Oriented Programming (OOP) is a programming paradigm that uses "objects" to design applications and computer programs. These objects are instances of "classes," which serve as blueprints for creating objects. OOP aims to implement real-world entities like inheritance, hiding, polymorphism, etc., in programming.


# Simple class example
class Car:
    def __init__(self, brand, model):
        self.brand = brand    # Instance attribute
        self.model = model    # Instance attribute
    
    def display(self):        # Instance method
        return f"{self.brand} {self.model}"

# Creating an object
my_car = Car("Toyota", "Camry")
print(my_car.display())  # Output: Toyota Camry

4

Core Principles

Reusable

Code

Modular

Design

What is OOP?

OOP focuses on creating reusable code and organizing programs into logical, modular components. It helps manage complexity in large applications by breaking them down into smaller, manageable objects that interact with each other.

🏗️

Classes

Blueprints or templates for creating objects

📦

Objects

Instances of classes, representing real-world entities

🏷️

Attributes

Variables that belong to an object, representing its characteristics

⚙️

Methods

Functions that belong to an object, representing its behaviors

🔑 Key OOP Principles:

🔒

Encapsulation

Bundling data and methods within a single unit and restricting direct access to some components

🧬

Inheritance

A mechanism where a new class inherits properties and behaviors from an existing class

🎭

Polymorphism

The ability of an object to take on many forms, allowing methods to do different things based on the object

🎨

Abstraction

Hiding complex implementation details and showing only the necessary parts to the user

Why Use OOP?

🧩

Modularity

Objects are self-contained, making it easier to manage and debug code

♻️

Reusability

Classes can be reused to create multiple objects, and inheritance allows reusing code from parent classes

🔧

Maintainability

Changes in one part of the code are less likely to affect other parts

📈

Scalability

Easier to extend and add new features without disrupting existing code

🌍

Real-world Modeling

OOP maps well to real-world problems, making the code more intuitive and understandable

Basic Class and Object Example

Before diving deeper into each OOP concept, let's see a simple example of a class and an object.

dog_class.py

# Define a Class
class Dog:
    # Class attribute
    species = "Canis familiaris"

    # Initializer / Instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

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

# Create Objects (Instances of the Dog class)
dog1 = Dog("Buddy", 3)
dog2 = Dog("Lucy", 5)

# Access attributes
print(f"{dog1.name} is {dog1.age} years old.")
print(f"{dog2.name} is {dog2.age} years old.")

# Access class attribute
print(f"All dogs are of species: {Dog.species}")

# Call methods
print(dog1.bark())
print(dog2.bark())

Expected Output:

Buddy is 3 years old.
Lucy is 5 years old.
All dogs are of species: Canis familiaris
Buddy says Woof!
Lucy says Woof!

🏋️ Practice Exercise: Create a Simple Car Class

Define a class called Car with attributes make , model , and year . Include a method called display_info that prints the car's make, model, and year. Then, create two Car objects and call their display_info method.

car_exercise.py

# Write your code here
class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    def display_info(self):
        print(f"Car: {self.year} {self.make} {self.model}")

# Create car objects
car1 = Car("Toyota", "Camry", 2020)
car2 = Car("Honda", "Civic", 2022)

# Display car information
car1.display_info()
car2.display_info()

# Expected Output:
# Car: 2020 Toyota Camry
# Car: 2022 Honda Civic

Python OOP (Object-Oriented Programming)