You have learned functions and modules. Your code is organized and reusable. But as programs grow larger and more complex, a new challenge emerges. How do you model real world things like bank accounts, employees, or cars? How do you group both data and actions together? The answer is object oriented programming. This python oop guide will transform how you think about code. Instead of seeing functions and variables as separate, you will learn to bundle them into objects. This approach models the real world naturally. The excellent news is that Python implements object oriented programming beautifully. Everything in Python is an object including numbers, strings, lists, and even functions. Understanding python oop guide concepts will unlock your ability to build large systems, contribute to open source projects, and understand frameworks like Django. Let me share a fascinating fact from history of python . Guido van Rossum created Python in 1991 with object oriented features built in from the start. This was a bold decision. Many languages added OOP as an afterthought. Python made it central.
What Is Object Oriented Programming (1960s – Present)
Object oriented programming (OOP) is a paradigm that organizes code around objects rather than actions. An object contains both state and behavior . State means data stored in attributes. Behavior means actions defined as methods. Think of a real car. The car has state like color, model, and speed. The car has behavior like accelerate, brake, and turn. In procedural programming you write functions that operate on separate data. In OOP you define a Car class that bundles the data and functions together. This approach follows the object oriented design principles that emerged in the 1960s with languages like Simula. Alan Kay coined the term “object oriented” in the 1970s. Today, OOP dominates software development. This python oop guide covers the four pillars. Encapsulation bundles data and methods. Inheritance creates hierarchies. Polymorphism enables flexible interfaces. Abstraction hides complexity. Python supports all four pillars elegantly.
Classes The Blueprint
A blueprint is the perfect metaphor for a class. A class defines the structure and behavior that all objects of that type will have. The class itself is not an object. It is the plan. You create actual objects from the class. Think of a house blueprint. The blueprint is not a house. You cannot live in it. But you can build many houses from that same blueprint. Each house has the same rooms and layout but different paint colors and furniture. In Python, you define a class using the class keyword. Here is a simple class:
class Dog:
pass
This empty class does nothing yet. Let me add attributes and methods. Attributes are variables that belong to an object. Methods are functions that belong to an object. Here is a more complete class:
class Dog:
def __init__(self, name, breed):
self.name = name
self.breed = breed
def bark(self):
return f"{self.name} says Woof!"
The __init__ method is the constructor . It runs automatically when you create a new object. The self parameter refers to the specific instance being created. I explain self parameter in detail shortly.
Objects Instances of Classes
An object is a specific instance of a class. Creating an object is called instantiation. You use the class name followed by parentheses. Here is how to create Dog objects:
my_dog = Dog("Buddy", "Golden Retriever")
your_dog = Dog("Max", "German Shepherd")
print(my_dog.name) # Buddy
print(your_dog.breed) # German Shepherd
print(my_dog.bark()) # Buddy says Woof!
my_dog and your_dog are two separate objects. Each has its own name and breed attributes. Each can call the bark method. The blueprint metaphor holds. The Dog class defines what all dogs have. Each dog object has specific values. This python oop guide emphasizes that objects combine data and behavior in one package. The data is name and breed. The behavior is bark(). This bundling is called encapsulation.
The Init Method and Self Parameter
The init method is the constructor in Python. The name __init__ has double underscores before and after. These are called dunder methods or dunder methods (magic methods) . Python uses them for special functionality. The __init__ method runs as soon as you create an object. It sets up the initial state. The self parameter is the most confusing concept for beginners. Here is the truth. self is a reference to the current object. When you call my_dog.bark(), Python automatically passes my_dog as the self argument. You do not pass it manually. The name self is a convention, not a keyword. You could name it this or me. But always use self because every Python developer expects it. Here is a class showing self clearly:
class Car:
def __init__(self, make, model):
self.make = make
self.model = model
self.speed = 0
def accelerate(self, amount):
self.speed += amount
return f"{self.make} {self.model} now going {self.speed} mph"
Every method in a class must include self as the first parameter. The exception is class methods and static methods which I cover later. Understanding self parameter is the key to unlocking python oop guide mastery.
Instance vs Class Variables
Variables in classes come in two flavors. Instance vs class variables is a critical distinction. Instance variables are unique to each object. They are defined inside methods using self. In the Dog class, name and breed are instance variables. Each dog has its own name. Class variables are shared across all objects of that class. They are defined directly inside the class, not inside any method. Here is an example:
class Student:
school_name = "Lincoln High" # Class variable shared by all students
def __init__(self, name):
self.name = name # Instance variable unique to each student
student1 = Student("Alice")
student2 = Student("Bob")
print(student1.school_name) # Lincoln High
print(student2.school_name) # Lincoln High
print(student1.name) # Alice
print(student2.name) # Bob
Student.school_name = "Jefferson High" # Changes for all students
Class variables are useful for constants, counters, and shared configuration. Instance variables store object specific data. This python oop guide recommends using instance variables for most cases. Use class variables only when the value truly should be identical across all instances.
Python Class Inheritance
Python class inheritance is one of the most powerful features of OOP. Inheritance allows a class to inherit attributes and methods from another class. The original class is called the parent or base class. The new class is called the child or derived class. The child class automatically gets everything from the parent. You can then add new attributes or override existing ones. Here is a simple example:
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
return "Some sound"
class Dog(Animal):
def speak(self): # Method overriding
return f"{self.name} says Woof!"
class Cat(Animal):
def speak(self):
return f"{self.name} says Meow!"
animals = [Dog("Buddy"), Cat("Whiskers")]
for animal in animals:
print(animal.speak())
The class Dog(Animal): syntax shows inheritance. Dog is the child, Animal is the parent. Dog inherits the __init__ method and the name attribute. Dog overrides the speak method with its own version. This class hierarchy mirrors the real world. All animals have a name and can speak. Dogs and cats are specific types of animals. Inheritance promotes code reusability . You write common code once in the parent class. Children inherit and customize.
Method Overriding and the Super Function
Method overriding occurs when a child class defines a method that already exists in the parent class. The child’s version replaces the parent’s version. Sometimes you want to call the parent’s method in addition to adding new behavior. The super() function gives you access to the parent class. Here is an example:
class Employee:
def __init__(self, name, salary):
self.name = name
self.salary = salary
def get_info(self):
return f"Name: {self.name}, Salary: ${self.salary}"
class Manager(Employee):
def __init__(self, name, salary, department):
super().__init__(name, salary) # Call parent constructor
self.department = department
def get_info(self): # Override parent method
parent_info = super().get_info() # Call parent method
return f"{parent_info}, Department: {self.department}"
mgr = Manager("Alice", 80000, "Engineering")
print(mgr.get_info()) # Name: Alice, Salary: $80000, Department: Engineering
The super() function is essential when you extend parent functionality. Without it, you would need to manually duplicate parent code. That violates the DRY principle (Don’t Repeat Yourself) . Always use super() to call parent methods from child classes. This python oop guide emphasizes that super() works even with multiple inheritance, though multiple inheritance is advanced.
Polymorphism in Python
Polymorphism in python means “many forms.” It allows objects of different classes to respond to the same method call in their own way. You have already seen polymorphism. The speak method worked differently for Dog and Cat objects. The same method name produced different behaviors. Polymorphism enables flexible code. You can write functions that work with any object as long as that object provides certain methods. This is called duck typing. “If it walks like a duck and quacks like a duck, it is a duck.” Python does not care about an object’s class. It only cares that the object has the required method. Here is an example:
def make_animal_speak(animal):
print(animal.speak())
make_animal_speak(Dog("Buddy")) # Buddy says Woof!
make_animal_speak(Cat("Whiskers")) # Whiskers says Meow!
make_animal_speak(Animal("Generic")) # Some sound
The make_animal_speak function works with any object that has a speak method. It does not check types. This flexibility is powerful. You can create new animal classes later, and the existing function works immediately. Polymorphism is the secret to writing extensible, maintainable code.
Encapsulation and Access Modifiers
Encapsulation bundles data and methods into a single unit (the object). It also controls access to internal data. Python does not have strict access modifiers like private or protected in Java. Instead, Python uses naming conventions. A single underscore _variable suggests internal use. Do not access it directly. A double underscore __variable triggers name mangling. Python renames it internally to make accidental access harder. Here is an example:
class BankAccount:
def __init__(self, owner, balance):
self.owner = owner
self._balance = balance # Protected by convention
self.__account_number = "12345" # Name mangled
def deposit(self, amount):
if amount > 0:
self._balance += amount
def withdraw(self, amount):
if 0 < amount <= self._balance:
self._balance -= amount
return amount
return None
def get_balance(self):
return self._balance
account = BankAccount("Alice", 1000)
account.deposit(500)
account.withdraw(200)
print(account.get_balance()) # 1300
print(account._balance) # Works but you should not do this
The underscore _balance warns other developers not to access it directly. They should use the deposit, withdraw, and get_balance methods. This access modifiers convention protects internal state. The double underscore __account_number is even harder to access accidentally. Encapsulation gives you control over how your objects are used. You can change internal implementation without breaking code that uses your class.
Abstract Base Classes
Sometimes you want a class that cannot be instantiated. It exists only to be inherited. This is called an abstract base class. Python provides the abc module for this. Abstract base classes define methods that child classes must implement. Here is an example:
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
pass
@abstractmethod
def perimeter(self):
pass
class Rectangle(Shape):
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)
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.14159 * self.radius ** 2
def perimeter(self):
return 2 * 3.14159 * self.radius
# shape = Shape() # TypeError: Can't instantiate abstract class Shape
rect = Rectangle(5, 3)
print(rect.area()) # 15
Abstract base classes enforce a contract. Any child of Shape must implement area and perimeter. This is powerful for designing frameworks. The python oop guide uses abstract base classes to define interfaces that other developers must follow.
Dunder Methods Making Your Classes Pythonic
Dunder methods (magic methods) are special methods with double underscores. They allow your objects to work with Python’s built in features. The most common dunder method is __init__. Here are others you should know:
__str__ returns a readable string for end users__repr__ returns a detailed string for developers__len__ returns the length of your object__add__ defines what + does with your object__eq__ defines what == does with your object
Here is an example implementing these methods:
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}"
def __repr__(self):
return f"Book('{self.title}', '{self.author}', {self.pages})"
def __len__(self):
return self.pages
def __eq__(self, other):
if isinstance(other, Book):
return self.title == other.title and self.author == other.author
return False
book1 = Book("1984", "George Orwell", 328)
book2 = Book("1984", "George Orwell", 328)
print(str(book1)) # 1984 by George Orwell
print(repr(book1)) # Book('1984', 'George Orwell', 328)
print(len(book1)) # 328
print(book1 == book2) # True
Dunder methods make your classes feel like native Python types. Implementing __len__ means you can use len(my_object). Implementing __add__ means you can use my_object + another_object. This is what makes Python elegant.
Multiple Inheritance and Method Resolution Order
Python supports multiple inheritance . A class can inherit from multiple parent classes. This is powerful but complex. Here is an example:
class Flyer:
def move(self):
return "Flying"
class Swimmer:
def move(self):
return "Swimming"
class Duck(Flyer, Swimmer):
pass
duck = Duck()
print(duck.move()) # Flying (uses first parent's method)
When two parents have the same method, Python uses the method resolution order (MRO). The MRO is depth first, left to right. You can view the MRO using Duck.__mro__. Avoid multiple inheritance when possible. It creates confusion. Use composition instead. Composition means one class contains instances of other classes rather than inheriting from them. This python oop guide recommends simple inheritance hierarchies. One parent class is usually enough.
Real World Example Building a Library System
Let me combine all OOP concepts into a realistic example. A library system with books and members:
class LibraryItem:
def __init__(self, title, item_id):
self.title = title
self.item_id = item_id
self.checked_out = False
def check_out(self):
if not self.checked_out:
self.checked_out = True
return True
return False
def return_item(self):
self.checked_out = False
def __str__(self):
status = "Checked Out" if self.checked_out else "Available"
return f"{self.title} ({self.item_id}) - {status}"
class Book(LibraryItem):
def __init__(self, title, item_id, author, pages):
super().__init__(title, item_id)
self.author = author
self.pages = pages
def __len__(self):
return self.pages
class DVD(LibraryItem):
def __init__(self, title, item_id, director, duration):
super().__init__(title, item_id)
self.director = director
self.duration = duration
def __len__(self):
return self.duration
class LibraryMember:
def __init__(self, name, member_id):
self.name = name
self.member_id = member_id
self.checked_out_items = []
def check_out_item(self, item):
if item.check_out():
self.checked_out_items.append(item)
print(f"{self.name} checked out {item.title}")
else:
print(f"{item.title} is already checked out")
def return_item(self, item):
if item in self.checked_out_items:
item.return_item()
self.checked_out_items.remove(item)
print(f"{self.name} returned {item.title}")
book = Book("1984", "B001", "George Orwell", 328)
dvd = DVD("Inception", "D001", "Christopher Nolan", 148)
member = LibraryMember("Alice", "M001")
member.check_out_item(book) # Alice checked out 1984
member.check_out_item(book) # 1984 is already checked out
member.check_out_item(dvd) # Alice checked out Inception
print(len(book)) # 328 pages
member.return_item(book) # Alice returned 1984
This example demonstrates encapsulation (items manage their own state), inheritance (Book and DVD inherit from LibraryItem), polymorphism (len works differently for Book and DVD), and composition (LibraryMember contains checked_out_items).
Frequently Asked Questions (FAQs)
Q1: What is the difference between a class and an object in python oop guide?
A class is a blueprint. An object is an instance created from that blueprint.
Q2: Why do I need the self parameter in every method?
Self refers to the current instance. It allows methods to access instance attributes.
Q3: What is python class inheritance and why use it?
Inheritance lets a child class reuse code from a parent class. It reduces duplication.
Q4: How does polymorphism in python work?
Different classes implement the same method name. The correct method runs based on the object.
Q5: What are dunder methods (magic methods) used for?
They allow your objects to work with Python’s built in functions like len(), str(), and +.
Conclusion
You have completed this python oop guide . You now understand classes and objects, the init method and self parameter , instance vs class variables , python class inheritance , method overriding with the super() function , polymorphism in python , encapsulation with access modifiers , abstract base classes , dunder methods (magic methods) , and multiple inheritance. These concepts transform you from a script writer into a software designer. Object oriented programming is the foundation of large scale systems. Frameworks like Django, Flask, and TensorFlow are built on OOP principles. The history of programming languages shows that OOP revolutionized software development starting in the 1960s. Guido van Rossum embraced OOP fully in Python. Now you have that same power. Go build classes that model your domain. Create objects that represent real things. Write elegant, maintainable, scalable code. The world needs your object oriented creations.
