Python me OOP (Object-Oriented Programming) kya hai?

OOP ek programming style hai jisme hum real-world cheezein ko code me represent karte hain. Jaise real life me ek "Car" ka concept hota hai — har car ke kuch properties hote hain (color, speed) aur kuch kaam hote hain (start, stop). OOP me isi tarah hum Classes aur Objects banate hain.

OOP ke 4 main pillars hain :-

Encapsulation — data aur methods ek saath band karna
Inheritance — ek class se doosri class banana
Polymorphism — same method alag alag kaam kare
Abstraction — implementation chhupaana, sirf zaroori dikhana

Is page me yeh sab sikhenge :-

1. Class aur Object
2. __init__() Constructor
3. Instance Variables aur Methods
4. Class Variables aur Class Methods
5. Inheritance
6. Method Overriding
7. super()
8. Encapsulation — Private Variables
9. Polymorphism
10. Special (Dunder) Methods

1. Class aur Object

Class ek blueprint (naqsha) hai — jaise ek ghar ka naqsha. Object us naqshe se bana asli ghar hai. Class ek baar likhte hain, objects baar baar bana sakte hain.

Syntax
class ClassName: # attributes aur methods obj = ClassName() # object banana

Example 1: Pehli class banana aur object create karna

Python

In [1]:

class Dog:
    def bark(self):
        print("Woof! Woof!")

    def sit(self):
        print("Dog baith gaya.")

# Objects banana
dog1 = Dog()
dog2 = Dog()

dog1.bark()
dog2.bark()
dog1.sit()

print("dog1 ka type:", type(dog1))

Output

2. init() Constructor

__init__() ek special method hai jo object banate waqt automatically call hota hai. Isme hum object ki initial properties (attributes) set karte hain. self parameter us particular object ka reference hota hai.

Example 1: __init__() se attributes set karna

Python

In [1]:

class Student:
    def __init__(self, name, age, marks):
        self.name  = name    # instance attributes
        self.age   = age
        self.marks = marks

    def introduce(self):
        print(f"Main {self.name} hoon, {self.age} saal ka.")
        print(f"Mere marks: {self.marks}")

s1 = Student("Rahul", 20, 88)
s2 = Student("Priya", 21, 95)

s1.introduce()
print()
s2.introduce()

Output

Example 2: Attributes directly access aur modify karna

Python

In [1]:

class Car:
    def __init__(self, brand, model, year):
        self.brand = brand
        self.model = model
        self.year  = year

car1 = Car("Tata", "Nexon", 2022)

# Attributes access karo
print(car1.brand)
print(car1.model)
print(car1.year)

# Attribute modify karo
car1.year = 2024
print("Updated year:", car1.year)

# Naya attribute add karo
car1.color = "Blue"
print("Color:", car1.color)

Output

3. Instance Variables aur Methods

Instance variables har object ke apne alag hote hain. Instance methods woh functions hain jo object ki properties pe kaam karte hain — inhein hamesha self parameter milta hai.

Example 1: Bank Account — realistic example

Python

In [1]:

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner   = owner
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount
        print(f"{amount} deposit hua. Balance: {self.balance}")

    def withdraw(self, amount):
        if amount > self.balance:
            print("Insufficient balance!")
        else:
            self.balance -= amount
            print(f"{amount} withdraw hua. Balance: {self.balance}")

    def show_balance(self):
        print(f"{self.owner} ka balance: Rs.{self.balance}")

acc = BankAccount("Rahul", 1000)
acc.show_balance()
acc.deposit(5000)
acc.withdraw(2000)
acc.withdraw(10000)

Output

4. Class Variables aur Class Methods

Class variables saare objects ke beech share hoti hain — ek object badalta hai toh sabko dikhta hai. @classmethod decorator se class methods banate hain — isme cls parameter hota hai (self nahi).

Example 1: Class variable — kitne objects bane track karna

Python

In [1]:

class Employee:
    company  = "Codepth"    # Class variable — sabka shared
    headcount = 0           # Kitne employees hain

    def __init__(self, name, salary):
        self.name   = name
        self.salary = salary
        Employee.headcount += 1   # har nayi employee par increment

    @classmethod
    def show_info(cls):
        print(f"Company: {cls.company}, Total Employees: {cls.headcount}")

e1 = Employee("Rahul", 50000)
e2 = Employee("Priya", 60000)
e3 = Employee("Arjun", 55000)

Employee.show_info()
print(e1.company)       # class variable instance se bhi access ho sakta hai

Output

5. Inheritance (Virasat)

Inheritance matlab ek class doosri class ki properties aur methods inherit kar leti hai. Parent class (Base class) ki saari cheezein Child class (Derived class) ko mil jaati hain — aur wo apni nayi cheezein bhi add kar sakti hai.

Example 1: Animal → Dog, Cat — basic inheritance

Python

In [1]:

class Animal:                # Parent class
    def __init__(self, name):
        self.name = name

    def eat(self):
        print(f"{self.name} khaana kha raha hai.")

    def sleep(self):
        print(f"{self.name} so raha hai.")

class Dog(Animal):           # Dog inherits Animal
    def bark(self):
        print(f"{self.name} bolta hai: Woof!")

class Cat(Animal):           # Cat inherits Animal
    def meow(self):
        print(f"{self.name} bolti hai: Meow!")

dog = Dog("Bruno")
cat = Cat("Whiskers")

dog.eat()       # inherited from Animal
dog.bark()      # Dog ka apna method
cat.sleep()     # inherited from Animal
cat.meow()      # Cat ka apna method

Output

Example 2: Person → Student → GraduateStudent — multi-level

Python

In [1]:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age  = age
    def greet(self):
        print(f"Main {self.name} hoon, {self.age} saal ka.")

class Student(Person):
    def __init__(self, name, age, rollno):
        super().__init__(name, age)   # Parent ka __init__ call karo
        self.rollno = rollno
    def study(self):
        print(f"{self.name} (Roll: {self.rollno}) padh raha hai.")

class GraduateStudent(Student):
    def __init__(self, name, age, rollno, thesis):
        super().__init__(name, age, rollno)
        self.thesis = thesis
    def research(self):
        print(f"{self.name} ka thesis topic: {self.thesis}")

gs = GraduateStudent("Arjun", 24, "PG001", "AI in Healthcare")
gs.greet()      # Person se
gs.study()      # Student se
gs.research()   # GraduateStudent ka apna

Output

6. Method Overriding

Jab child class me parent class ka same naam ka method likhte hain toh child ka method parent wale ko override kar deta hai — yaani child ka method chal jaata hai.

Example 1: Shape → Circle, Rectangle — area method override

Python

In [1]:

class Shape:
    def area(self):
        print("Shape ka area pata nahi.")

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    def area(self):                     # Override kiya!
        a = 3.14 * self.radius ** 2
        print(f"Circle ka area: {a:.2f}")

class Rectangle(Shape):
    def __init__(self, length, width):
        self.length = length
        self.width  = width
    def area(self):                     # Override kiya!
        print(f"Rectangle ka area: {self.length * self.width}")

s = Shape()
c = Circle(7)
r = Rectangle(5, 8)

s.area()   # Parent ka
c.area()   # Circle ka (overridden)
r.area()   # Rectangle ka (overridden)

Output

7. super() Function

super() se child class, parent class ke methods aur __init__ ko call kar sakti hai. Yeh tab useful hota hai jab child class me kuch extra karna ho parent ke upar se.

Example 1: super() se parent ka __init__ extend karna

Python

In [1]:

class Vehicle:
    def __init__(self, brand, speed):
        self.brand = brand
        self.speed = speed
    def describe(self):
        print(f"Brand: {self.brand}, Max Speed: {self.speed} km/h")

class ElectricCar(Vehicle):
    def __init__(self, brand, speed, battery):
        super().__init__(brand, speed)   # Parent ka __init__
        self.battery = battery           # Extra attribute
    def describe(self):
        super().describe()               # Parent ka describe call karo
        print(f"Battery: {self.battery} kWh (Electric)")

v = Vehicle("Honda", 180)
e = ElectricCar("Tesla", 250, 100)

print("--- Vehicle ---")
v.describe()
print("\n--- Electric Car ---")
e.describe()

Output

8. Encapsulation — Private Variables

Encapsulation matlab data ko bahar se direct access hone se rokna. Python me double underscore (__) se variable ko private banate hain. Private variables sirf class ke andar se access ho sakte hain.

Example 1: Private variables — __ (double underscore)

Python

In [1]:

class SecureAccount:
    def __init__(self, owner, pin, balance):
        self.owner    = owner       # public
        self.__pin    = pin         # private — __ se
        self.__balance = balance    # private

    def check_balance(self, pin):
        if pin == self.__pin:
            print(f"Balance: Rs.{self.__balance}")
        else:
            print("Galat PIN!")

    def deposit(self, amount, pin):
        if pin == self.__pin:
            self.__balance += amount
            print(f"Deposit successful! New balance: Rs.{self.__balance}")
        else:
            print("Galat PIN! Transaction failed.")

acc = SecureAccount("Rahul", 1234, 5000)
acc.check_balance(1234)    # sahi PIN
acc.check_balance(9999)    # galat PIN
acc.deposit(2000, 1234)

# Direct access nahi hoga
try:
    print(acc.__balance)
except AttributeError as e:
    print("Error:", e)

Output

9. Polymorphism

Polymorphism matlab "same naam, alag kaam". Alag alag classes ke objects par same method call karo — har class apne hisaab se kaam karegi.

Example 1: speak() method — alag animals alag awaaz

Python

In [1]:

class Dog:
    def speak(self):
        return "Woof!"

class Cat:
    def speak(self):
        return "Meow!"

class Cow:
    def speak(self):
        return "Moo!"

# Same function — alag alag objects pass karo
def make_sound(animal):
    print(f"{animal.__class__.__name__} kehta hai: {animal.speak()}")

animals = [Dog(), Cat(), Cow()]
for a in animals:
    make_sound(a)

Output

Example 2: len() — built-in polymorphism

Python

In [1]:

# len() ek polymorphic function hai — alag types pe kaam karta hai
print(len("Python"))          # string me characters
print(len([1, 2, 3, 4, 5]))  # list me elements
print(len({"a": 1, "b": 2})) # dict me keys
print(len((10, 20, 30)))      # tuple me items

# + operator bhi polymorphic hai
print(10 + 20)                # numbers add karta hai
print("Hello" + " World")

Output

10. Special (Dunder) Methods

Python me kuch special methods hote hain jo double underscore (__) se shuru aur khatam hote hain — inhe Dunder methods kehte hain. Yeh methods Python ke built-in operations ko customize karne ke kaam aate hain.

Example 1: __str__, __len__ aur __add__

Python

In [1]:

class Book:
    def __init__(self, title, author, pages):
        self.title  = title
        self.author = author
        self.pages  = pages

    def __str__(self):
        # print(obj) pe yeh chalega
        return f"'{self.title}' by {self.author}"

    def __len__(self):
        # len(obj) pe yeh chalega
        return self.pages

    def __add__(self, other):
        # obj1 + obj2 pe yeh chalega
        total = self.pages + other.pages
        return f"Combined pages: {total}"

b1 = Book("Python Basics", "Rahul", 350)
b2 = Book("Advanced Python", "Priya", 500)

print(b1)            # __str__ call hoga
print(len(b1))       # __len__ call hoga
print(b1 + b2)       # __add__ call hoga

Output

Example 2: __eq__ aur __gt__ — comparison operators customize karna

Python

In [1]:

class Student:
    def __init__(self, name, marks):
        self.name  = name
        self.marks = marks

    def __str__(self):
        return f"{self.name} ({self.marks})"

    def __eq__(self, other):
        return self.marks == other.marks   # == operator

    def __gt__(self, other):
        return self.marks > other.marks    # > operator

s1 = Student("Rahul", 85)
s2 = Student("Priya", 92)
s3 = Student("Arjun", 85)

print(s1, "==", s3, "?", s1 == s3)   # same marks
print(s1, "==", s2, "?", s1 == s2)   # alag marks
print(s2, ">",  s1, "?", s2 > s1)    # Priya ke zyada marks

Output

Quick Summary — OOP ek nazar me

Concept	Kaam	Example
class	Blueprint banana	class Dog:
object	Class ka instance	d = Dog()
__init__	Constructor — attributes set	def __init__(self, name):
self	Current object ka reference	self.name = name
Instance var	Har object ka apna	self.age = 20
Class var	Sabka shared	count = 0
@classmethod	Class method	def f(cls):
Inheritance	Parent se properties milna	class Cat(Animal):
super()	Parent class call karna	super().__init__()
Override	Parent method rewrite karna	def area(self): ...
Encapsulation	Private variables	self.__balance
Polymorphism	Same naam, alag kaam	obj.speak()
__str__	print() ke liye string	def __str__(self):
__len__	len() ke liye	def __len__(self):

Previous Next

Python me OOP (Object-Oriented Programming) kya hai?

1. Class aur Object

2. __init__() Constructor

3. Instance Variables aur Methods

4. Class Variables aur Class Methods

5. Inheritance (Virasat)

6. Method Overriding

7. super() Function

8. Encapsulation — Private Variables

9. Polymorphism

10. Special (Dunder) Methods

Quick Summary — OOP ek nazar me

2. init() Constructor