Python me Exception Handling kya hai?

Program chalate waqt kabhi kabhi kuch galat ho jaata hai — jaise zero se divide karna, galat type ki value dena, ya koi file na milna. Aise situations me Python ek Exception (error) raise karta hai aur program band ho jaata hai. Exception Handling se hum in errors ko gracefully handle kar sakte hain aur program ko crash hone se bacha sakte hain.

Is page me yeh sab sikhenge :-

1. Common Exceptions — Python ke built-in errors
2. try-except — basic error handling
3. Multiple except blocks
4. else aur finally
5. raise — khud error uthana
6. Custom Exceptions — apni class se error banana
7. Nested try-except

1. Common Exceptions — Python ke Built-in Errors

Python me bahut saare built-in exceptions hain. Inhe jaanna zaroori hai taaki sahi jagah handle kar sakein.

Exception	Kab aata hai	Example
ZeroDivisionError	Zero se divide karo	10 / 0
TypeError	Galat type ka operation	"5" + 5
ValueError	Sahi type, galat value	int("abc")
NameError	Variable exist nahi karta	print(xyz)
IndexError	List index out of range	lst[10]
KeyError	Dict me key nahi	d["missing"]
AttributeError	Object me attribute nahi	"hi".push()
FileNotFoundError	File nahi mili	open("xyz.txt")
RecursionError	Recursion limit exceed	infinite recursion
OverflowError	Number bahut bada	float overflow

Example 1: Different errors naturally trigger karna

Python

In [1]:

print("=== Common Exceptions Demo ===")

errors = [
    ("ZeroDivisionError", lambda: 10 / 0),
    ("TypeError",         lambda: "5" + 5),
    ("ValueError",        lambda: int("abc")),
    ("IndexError",        lambda: [1,2,3][10]),
    ("KeyError",          lambda: {"a":1}["b"]),
    ("AttributeError",    lambda: (42).upper()),
]

for name, action in errors:
    try:
        action()
    except Exception as e:
        print(f"{name}: {e}")

Output

2. try-except — Basic Error Handling

try block me woh code likhte hain jo error de sakta hai. except block me woh code likhte hain jo error aane par chalega. Error aane par program crash nahi hoga — except block chal jaayega.

Syntax
try: # code jo error de sakta hai except ExceptionType as e: # error aane par yeh chalega print(e) # error message

Example 1: try-except — bina handle kiye vs handle karke

Python

In [1]:

# BINA handle kiye — program crash ho jaata
# print(10 / 0)   # ZeroDivisionError: division by zero

# try-except se HANDLE karna
try:
    result = 10 / 0
    print("Result:", result)
except ZeroDivisionError as e:
    print("Error pakda gaya:", e)
    print("Zero se divide nahi kar sakte!")

print("Program continue kar raha hai...")

Output

Example 2: Division function — safe divide

Python

In [1]:

def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return "Error: Zero se divide nahi kar sakte!"
    except TypeError:
        return "Error: Sirf numbers dena!"

print(safe_divide(10, 2))
print(safe_divide(10, 0))
print(safe_divide("ten", 2))

Output

3. Multiple except Blocks

Ek try block me alag alag exceptions ke liye alag except likh sakte hain. Python upar se neeche check karta hai aur jo pehle match ho use chalata hai. Sabse broad exception Exception — isko hamesha sabse aakhir me likhein.

Example 1: Multiple exceptions — alag alag handle karna

Python

In [1]:

def process(data, index):
    try:
        num = int(data)        # ValueError if data not number
        result = 100 / num     # ZeroDivisionError if num = 0
        item = [1,2,3][index]  # IndexError if index out of range
        print(f"Sab theek! result={result}, item={item}")
    except ValueError:
        print("ValueError: data number nahi hai!")
    except ZeroDivisionError:
        print("ZeroDivisionError: Zero se divide nahi kar sakte!")
    except IndexError:
        print("IndexError: Index out of range!")
    except Exception as e:
        print(f"Unknown error: {e}")

process("5",  1)    # sab theek
process("abc", 0)   # ValueError
process("0",  0)    # ZeroDivisionError
process("5",  10)   # IndexError

Output

Example 2: Ek except me multiple exceptions — tuple me likhna

Python

In [1]:

inputs = ["10", "abc", "0", "5"]

for val in inputs:
    try:
        result = 100 / int(val)
        print(f"100 / {val} = {result:.1f}")
    except (ValueError, ZeroDivisionError) as e:
        # Dono errors ek saath handle karna
        print(f"Error for '{val}': {e}")

Output

4. else aur finally

else — sirf tab chalta hai jab try me koi error nahi aata.
finally — hamesha chalta hai — error aaye ya na aaye. Yeh cleanup kaam ke liye use hota hai (jaise file band karna).

Full Syntax
try: # code except ErrorType: # error par chalta hai else: # koi error nahi toh chalta hai finally: # HAMESHA chalta hai

Example 1: else aur finally ka flow samjhna

Python

In [1]:

def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("  except: Zero se divide nahi kar sakte!")
    else:
        print(f"  else  : Koi error nahi! Result = {result}")
    finally:
        print("  finally: Yeh HAMESHA chalta hai.\n")

print("--- Test 1: Normal division ---")
divide(10, 2)

print("--- Test 2: Division by zero ---")
divide(10, 0)

Output

Example 2: finally — cleanup ka real example (file close)

Python

In [1]:

def connect_db(db_name):
    print(f"DB '{db_name}' se connect ho raha hai...")
    try:
        if db_name == "bad_db":
            raise ConnectionError("DB nahi mili!")
        print("Connection successful!")
        print("Data fetch kar raha hai...")
        # kuch kaam karo...
        return "data ready"
    except ConnectionError as e:
        print(f"Error: {e}")
        return None
    finally:
        # HAMESHA connection band karo — chahe error aaye ya na aaye
        print("DB connection band kiya.\n")

connect_db("main_db")
connect_db("bad_db")

Output

5. raise — Khud Error Uthana

raise keyword se hum khud intentionally ek exception raise kar sakte hain — jab koi invalid input mile ya koi condition fail ho.

Example 1: raise — invalid input pe error uthana

Python

In [1]:

def set_age(age):
    if not isinstance(age, int):
        raise TypeError("Age sirf integer hona chahiye!")
    if age < 0:
        raise ValueError("Age negative nahi ho sakti!")
    if age > 150:
        raise ValueError("Age 150 se zyada nahi ho sakti!")
    print(f"Age set: {age}")

# Valid
set_age(25)

# Invalid — raise hoga
try:
    set_age(-5)
except ValueError as e:
    print("ValueError:", e)

try:
    set_age("bees")
except TypeError as e:
    print("TypeError:", e)

Output

Example 2: raise — error ko re-raise karna

Python

In [1]:

def validate_marks(marks):
    try:
        marks = int(marks)
        if marks < 0 or marks > 100:
            raise ValueError(f"Marks {marks} invalid! 0-100 ke beech hone chahiye.")
        return marks
    except ValueError as e:
        print(f"Validation failed: {e}")
        raise   # same error aage pass karo

try:
    m = validate_marks("150")
except ValueError:
    print("Upar se pakda gaya bhi!")

Output

6. Custom Exceptions — Apni Class Se Error Banana

Python me hum apni custom exception classes bana sakte hain — sirf Exception class se inherit karo. Yeh tab useful hota hai jab built-in errors se zyada specific error message chahiye ho.

Example 1: Simple custom exception

Python

In [1]:

# Custom exception class banana
class InvalidAgeError(Exception):
    pass

class NegativeBalanceError(Exception):
    def __init__(self, amount):
        self.amount = amount
        super().__init__(f"Balance negative nahi ho sakta! Amount: {amount}")

# Use karna
def check_age(age):
    if age < 0 or age > 120:
        raise InvalidAgeError(f"Age {age} invalid hai!")
    return f"Valid age: {age}"

def withdraw(balance, amount):
    if balance - amount < 0:
        raise NegativeBalanceError(balance - amount)
    return balance - amount

try:
    print(check_age(25))
    print(check_age(-5))
except InvalidAgeError as e:
    print("InvalidAgeError:", e)

try:
    print("New balance:", withdraw(100, 500))
except NegativeBalanceError as e:
    print("NegativeBalanceError:", e)

Output

Example 2: Exception hierarchy — custom exceptions ka group

Python

In [1]:

# Bank ke liye exception hierarchy
class BankError(Exception):          # Parent custom exception
    pass

class InsufficientFundsError(BankError):
    def __init__(self, needed, available):
        super().__init__(f"Chahiye: {needed}, Available: {available}")

class AccountLockedError(BankError):
    def __init__(self, acc_no):
        super().__init__(f"Account {acc_no} locked hai!")

def do_transaction(acc_no, balance, amount, locked=False):
    if locked:
        raise AccountLockedError(acc_no)
    if amount > balance:
        raise InsufficientFundsError(amount, balance)
    return balance - amount

# Test
transactions = [
    ("ACC001", 5000, 2000, False),
    ("ACC002", 1000, 3000, False),
    ("ACC003", 2000, 500,  True),
]

for acc, bal, amt, locked in transactions:
    try:
        new_bal = do_transaction(acc, bal, amt, locked)
        print(f"{acc}: Rs.{new_bal} bacha")
    except BankError as e:   # Dono child errors yahan pakde jayenge
        print(f"{acc} Error: {e}")

Output

7. Nested try-except

Ek try block ke andar doosra try block — ise Nested try-except kehte hain. Jab ek operation me kaafi saari alag alag jagah errors aa sakti hain tab yeh useful hota hai.

Example 1: Nested try — student data process karna

Python

In [1]:

records = [
    {"name": "Rahul",  "marks": "88"},
    {"name": "Priya"},                 # marks key nahi
    {"name": "Arjun",  "marks": "abc"},# marks number nahi
    {"name": "Neha",   "marks": "95"},
]

for record in records:
    try:
        name = record["name"]
        try:
            marks = int(record["marks"])   # KeyError ya ValueError
            grade = "A" if marks >= 90 else "B" if marks >= 75 else "C"
            print(f"{name}: {marks} — Grade {grade}")
        except KeyError:
            print(f"{name}: marks ka data missing hai!")
        except ValueError:
            print(f"{name}: marks valid number nahi hai!")
    except KeyError:
        print("Record me naam nahi hai!")

Output

Example 2: Poora example — try, except, else, finally, raise saath

Python

In [1]:

class LoginError(Exception):
    pass

def login(username, password):
    USERS = {"admin": "pass123", "user1": "hello"}

    print(f"\nLogging in as '{username}'...")

    try:
        if username not in USERS:
            raise LoginError(f"User '{username}' exist nahi karta!")

        if USERS[username] != password:
            raise LoginError("Galat password!")

        score = 100 / len(password)   # Password length se score

    except LoginError as e:
        print(f"  Login Failed: {e}")
        return False
    except ZeroDivisionError:
        print("  Error: Empty password!")
        return False
    else:
        print(f"  Login Successful! Score: {score:.1f}")
        return True
    finally:
        print("  Login attempt logged.")

login("admin", "pass123")   # success
login("admin", "wrong")     # wrong password
login("ghost", "pass")      # user not found

Output

Quick Summary — Exception Handling ek nazar me

Concept	Kaam	Example
try	Risky code yahan likhna	try: x = 1/0
except	Error pakadna	except ZeroDivisionError:
except as e	Error message lena	except ValueError as e: print(e)
Multiple except	Alag errors alag handle	except (TypeError, ValueError):
else	Koi error nahi toh	else: print("success")
finally	Hamesha chalega	finally: conn.close()
raise	Khud error uthana	raise ValueError("bad!")
Custom Exception	Apna error class	class MyError(Exception):
Exception	Sabse broad — base class	except Exception as e:

Previous Next