What Is OOP in Python? Concepts and Syntax Explained

In this blog, you’ll learn:

• What OOP is
   
• Core concepts of OOP in Python
   
• Syntax with simple examples
   
• Why OOP matters
   
• Common mistakes beginners should avoid
   

What Is OOP (Object-Oriented Programming)?

OOP is a programming paradigm based on the concept of “objects”—which can contain data (attributes) and code (methods). These objects are created from classes, which serve as blueprints.

Unlike procedural programming (where the focus is on functions and sequences), OOP helps manage complexity by organizing code around real-world elements.

Real-World Analogy

Imagine a car. It has properties like color, make, and model (attributes), and behaviors like drive() and brake() (methods). In OOP, you’d create a Car class, and each car you build from it would be an object or instance of that class.

Why Use OOP in Python?

Python's OOP features help:

• Encapsulate data and behavior
   
• Promote code reuse through inheritance
   
• Improve modularity and scalability
   
• Make debugging and maintenance easier
   

Four Core Principles of OOP

Let’s break down the four major pillars of Object-Oriented Programming:

1. Encapsulation

Encapsulation is the bundling of data and the methods that operate on that data into a single unit (a class). It protects the internal state of an object.

Example:

python

CopyEdit

class BankAccount:

    def __init__(self, balance):

        self.__balance = balance  # private variable

    def deposit(self, amount):

        self.__balance += amount

    def get_balance(self):

        return self.__balance

account = BankAccount(1000)

account.deposit(500)

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

Here, __balance is a private attribute—protected from external access.

2. Abstraction

Abstraction hides complex implementation details and shows only the necessary parts to the user.

Example:

python

CopyEdit

class Car:

    def start_engine(self):

        print("Engine started")

    def drive(self):

        self.start_engine()

        print("Driving")

my_car = Car()

my_car.drive()

The user doesn’t need to know how the engine starts—just that calling drive() makes the car go.

3. Inheritance

Inheritance allows a class to inherit properties and methods from another class. It promotes code reuse.

Example:

python

CopyEdit

class Animal:

    def speak(self):

        print("Animal speaks")

class Dog(Animal):

    def bark(self):

        print("Dog barks")

d = Dog()

d.speak()  # Inherited from Animal

d.bark()   # Specific to Dog

Dog inherits the speak() method from Animal.

4. Polymorphism

Polymorphism allows methods to behave differently depending on the object.

Example:

python

CopyEdit

class Bird:

    def make_sound(self):

        print("Chirp")

class Cat:

    def make_sound(self):

        print("Meow")

def sound(animal):

    animal.make_sound()

sound(Bird())  # Output: Chirp

sound(Cat())   # Output: Meow

The same function sound() works differently depending on the object passed.

Basic OOP Syntax in Python

Let’s now look at how to define and use classes and objects in Python.

Defining a Class

python

CopyEdit

class Person:

    def __init__(self, name, age):

        self.name = name

        self.age = age

    def greet(self):

        print(f"Hello, my name is {self.name} and I’m {self.age} years old.")

__init__() is a constructor method, called automatically when an object is created.


self refers to the current object instance.
 

Creating Objects

python

CopyEdit

p1 = Person("Alice", 25)

p1.greet()  # Output: Hello, my name is Alice and I’m 25 years old.

OOP Example: Student Class

Let’s create a more complete example:

python

CopyEdit

class Student:

    def __init__(self, name, student_id):

        self.name = name

        self.student_id = student_id

        self.grades = []

    def add_grade(self, grade):

        self.grades.append(grade)

    def average(self):

        return sum(self.grades) / len(self.grades)

    def show(self):

        print(f"{self.name} ({self.student_id}) has an average grade of {self.average():.2f}")

Usage:

python

CopyEdit

s1 = Student("John", "S101")

s1.add_grade(90)

s1.add_grade(85)

s1.add_grade(95)

s1.show()

This shows how attributes (name, student_id, grades) and methods (add_grade, average, show) work together.

Advanced OOP Concepts in Python

Class Methods vs Static Methods

• Instance methods work on object-level data.
   
• Class methods use @classmethod and work with class-level data.
   
• Static methods use @staticmethod and don’t access class or instance data.

Example:

python

CopyEdit

class Math:

    @staticmethod

    def add(x, y):

        return x + y

print(Math.add(10, 5))  # Output: 15

Inheritance with Constructor Overriding

python

CopyEdit

class Vehicle:

    def __init__(self, brand):

        self.brand = brand

    def show(self):

        print(f"Brand: {self.brand}")

class Bike(Vehicle):

    def __init__(self, brand, model):

        super().__init__(brand)

        self.model = model

    def show(self):

        super().show()

        print(f"Model: {self.model}")

b = Bike("Yamaha", "R15")

b.show()

When to Use OOP in Python Projects

You should consider OOP when:

• Your project involves managing entities (students, customers, vehicles).
   
• You want reusable code through inheritance.
   
• You are building scalable applications (e.g., games, GUI apps, web frameworks).
   
• You want data and behavior to stay together.

Common Beginner Mistakes in OOP

1. Forgetting the self parameter in method definitions.

2. Accessing private attributes directly.

3. Mixing procedural and OOP styles inconsistently.

4. Not using constructors properly.

5. Avoiding inheritance when it’s needed, leading to repeated code.

Benefits of OOP in Python

• Better structure and organization
   
• Improved reusability through classes
   
• Code readability and debugging made easier
   
• Makes large-scale development practical

Practice Exercises

Try implementing these:

1. Create a class Library with methods to add books and display available ones.

2. Define a base class Employee and a derived class Manager with additional salary bonus.

3. Implement a simple Bank class where you can deposit, withdraw, and check balance.

Learn OOP in Python with Uncodemy

To go beyond the basics and become a Python pro, consider enrolling in:

✅ Uncodemy’s Python Programming Course

• Beginner to advanced level OOP
   
• Hands-on project experience
   
• Live mentor support
   
• Interview and placement assistance
   

Whether you're a student, fresher, or working professional, this course is built to make you job-ready with practical programming skills.

Conclusion

Object-Oriented Programming in Python is a powerful way to structure code. By understanding classes, objects, inheritance, encapsulation, and other core principles, you’ll be able to build clean, efficient, and scalable programs.

If you're just starting out, begin small. Practice by modeling everyday objects into classes. Then gradually implement methods and build relationships between classes. Over time, OOP will become second nature and open doors to web development, game development, and even AI applications.