Object Oriented Python Tutorial
Object-Oriented Programming (OOP) is one of the most important programming paradigms used in Python. It helps developers organize code into reusable and maintainable structures called classes and objects.
Python fully supports OOP and provides simple syntax for creating powerful applications. Most modern Python frameworks and libraries use object-oriented principles extensively.
In this tutorial, you'll learn everything about Object-Oriented Programming in Python, from basic concepts to advanced techniques.
What is Object-Oriented Programming?
Object-Oriented Programming (OOP) is a programming style that organizes code around objects instead of functions and logic alone.
An object contains:
- Data (Attributes)
- Behavior (Methods)
Real-world examples:
| Object | Attributes | Methods |
|---|---|---|
| Car | Color, Model, Speed | Start(), Stop() |
| Student | Name, Age, Grade | Study(), AttendClass() |
| Bank Account | Balance, Owner | Deposit(), Withdraw() |
Why Use OOP?
OOP offers several advantages:
- Code Reusability
- Better Organization
- Easy Maintenance
- Improved Security
- Scalability
- Real-World Modeling
Without OOP, large applications become difficult to manage.
Understanding Classes and Objects
Class
A class is a blueprint for creating objects.
Example:
class Student:
pass
The class itself doesn't create data.
It simply defines the structure.
Object
An object is an instance of a class.
class Student:
pass
student1 = Student()
student2 = Student()
Here:
Student → Class
student1 → Object
student2 → Object
Creating Your First Class
class Car:
brand = "Toyota"
car1 = Car()
print(car1.brand)
Output:
Toyota
The init() Constructor
The constructor automatically runs when an object is created.
class Car:
def __init__(self, brand):
self.brand = brand
car1 = Car("Toyota")
print(car1.brand)
Output:
Toyota
Understanding self
self refers to the current object.
Example:
class Student:
def __init__(self, name):
self.name = name
student = Student("John")
print(student.name)
Output:
John
Instance Variables
Variables attached to objects are called instance variables.
class Employee:
def __init__(self, name, salary):
self.name = name
self.salary = salary
emp = Employee("Alice", 5000)
print(emp.name)
print(emp.salary)
Output:
Alice
5000
Methods in Classes
Methods define object behavior.
class Dog:
def bark(self):
print("Woof!")
dog = Dog()
dog.bark()
Output:
Woof!
Accessing Object Attributes
class Person:
def __init__(self, name):
self.name = name
person = Person("David")
print(person.name)
Output:
David
Modifying Attributes
class Person:
def __init__(self, name):
self.name = name
person = Person("David")
person.name = "Michael"
print(person.name)
Output:
Michael
Class Variables
Class variables are shared among all objects.
class Employee:
company = "Tech Corp"
def __init__(self, name):
self.name = name
e1 = Employee("John")
e2 = Employee("Alice")
print(e1.company)
print(e2.company)
Output:
Tech Corp
Tech Corp
Inheritance
Inheritance allows one class to inherit properties from another.
class Animal:
def speak(self):
print("Animal Sound")
class Dog(Animal):
pass
dog = Dog()
dog.speak()
Output:
Animal Sound
Method Overriding
Child classes can replace parent methods.
class Animal:
def speak(self):
print("Animal Sound")
class Dog(Animal):
def speak(self):
print("Bark")
dog = Dog()
dog.speak()
Output:
Bark
Multiple Inheritance
Python supports multiple inheritance.
class Father:
def skill1(self):
print("Driving")
class Mother:
def skill2(self):
print("Cooking")
class Child(Father, Mother):
pass
c = Child()
c.skill1()
c.skill2()
Output:
Driving
Cooking
Encapsulation
Encapsulation protects data from direct modification.
Public Variable
class User:
def __init__(self):
self.name = "John"
Protected Variable
class User:
def __init__(self):
self._name = "John"
Private Variable
class User:
def __init__(self):
self.__password = "12345"
Private variables cannot be accessed directly.
Getter and Setter Methods
class User:
def __init__(self):
self.__age = 20
def get_age(self):
return self.__age
def set_age(self, age):
self.__age = age
u = User()
u.set_age(25)
print(u.get_age())
Output:
25
Polymorphism
Polymorphism allows different objects to use the same method name.
class Dog:
def sound(self):
print("Bark")
class Cat:
def sound(self):
print("Meow")
animals = [Dog(), Cat()]
for animal in animals:
animal.sound()
Output:
Bark
Meow
Abstraction
Abstraction hides implementation details.
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
pass
Implementing Abstract Classes
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
pass
class Rectangle(Shape):
def __init__(self, w, h):
self.w = w
self.h = h
def area(self):
return self.w * self.h
r = Rectangle(10, 5)
print(r.area())
Output:
50
Magic Methods
Python provides special methods called magic methods.
str()
class Student:
def __init__(self, name):
self.name = name
def __str__(self):
return self.name
s = Student("John")
print(s)
Output:
John
Static Methods
Static methods belong to the class.
class Math:
@staticmethod
def add(a, b):
return a + b
print(Math.add(5, 3))
Output:
8
Class Methods
class Employee:
company = "Tech Corp"
@classmethod
def get_company(cls):
return cls.company
print(Employee.get_company())
Output:
Tech Corp
Real-World Example: Bank Account
class BankAccount:
def __init__(self, owner, balance):
self.owner = owner
self.balance = balance
def deposit(self, amount):
self.balance += amount
def withdraw(self, amount):
self.balance -= amount
def show_balance(self):
print("Balance:", self.balance)
account = BankAccount("John", 1000)
account.deposit(500)
account.withdraw(200)
account.show_balance()
Output:
Balance: 1300
OOP Principles Summary
| Principle | Description |
|---|---|
| Encapsulation | Hide internal data |
| Inheritance | Reuse code from parent classes |
| Polymorphism | Same interface, different behavior |
| Abstraction | Hide implementation details |
Best Practices
Use Meaningful Class Names
class Student:
pass
Avoid:
class S:
pass
Keep Classes Focused
One class should have one responsibility.
Use Inheritance Carefully
Avoid unnecessary inheritance chains.
Protect Sensitive Data
Use encapsulation for secure data handling.
Common Applications of OOP
Object-Oriented Programming is used in:
- Web Development
- Game Development
- Desktop Applications
- Machine Learning
- Data Science
- Banking Systems
- ERP Software
- Robotics
- Artificial Intelligence
Conclusion
Object-Oriented Programming is a powerful approach that helps developers write organized, reusable, and scalable code. By understanding classes, objects, inheritance, polymorphism, encapsulation, and abstraction, you can build complex Python applications more efficiently.
Mastering OOP is essential for any Python developer because it forms the foundation of modern software development, frameworks, and enterprise applications. Start by creating simple classes and gradually explore advanced concepts to become proficient in Object-Oriented Python programming.
0 Comments