Python OOP Introduction
In this page:
What is OOP?
Object-Oriented Programming organizes code around objects that bundle data and behavior together, rather than passing data between standalone functions -- this mirrors how real-world things work (a car has both properties like color and actions like drive()) and keeps related logic in one place as programs grow.
Example: What is OOP?
class Car:
color = "red" # attribute shared by every instance
def drive(self):
print("Driving")
Car().drive() # create an object and call its methodObjects and Classes
A class is the blueprint -- it defines what attributes and methods every object of that type will have -- while an object is one concrete instance built from that blueprint, holding its own actual values (two Car objects share the class definition but have different colors).
Example: Objects and Classes
class Car:
def __init__(self, color):
self.color = color # each instance stores its own color
car1 = Car("red")
car2 = Car("blue")
print(car1.color, car2.color) # same class, different attribute valuesEncapsulation
Encapsulation keeps an object's internal data bundled with the methods that operate on it and limits direct outside access -- in Python this is a convention rather than an enforced rule, signaled by prefixing attribute names with an underscore or double underscore.
Example: Encapsulation
class Account:
def __init__(self, balance):
self._balance = balance # underscore signals "internal use"
print(Account(100)._balance)Abstraction
Abstraction means exposing only what a user of your class needs to know (like a .drive() method) while hiding the messy implementation details behind it (engine RPM calculations, gear ratios) -- it lets you change the internals later without breaking code that uses the class.
Example: Abstraction
class Car:
def drive(self):
print("Engine details are hidden from the caller") # implementation is hidden behind the method
Car().drive()Benefits of OOP
Because classes can be extended and reused across a codebase instead of copy-pasted, OOP tends to produce more modular code -- fixing a bug or adding a feature in one base class automatically benefits every class that inherits from it.
Example: Benefits of OOP
class Animal:
def eat(self):
print("Eating")
class Dog(Animal):
pass
Dog().eat() # inherited automatically- Thinking a class and an object are the same thing, when the class is the blueprint and each object is one instance created from it.
- Writing many loose functions and global variables that share data, instead of grouping the data and behaviour in one class.
- Using classes for everything, even a tiny task that one function would handle more simply.
Chapter Quiz — Complete all 11 topics to unlock
0/11 topics done
Complete these topics first: