Python Exception Handling

Why Exceptions Exist — The Fire Alarm in Your Program 🚨Exceptions क्यों हैं — आपके Program का Fire Alarm 🚨为什么要有异常 — 程序里的火警 🚨

In Python, an exception is an object that describes an error. When something goes wrong, Python raises an exception. If no code catches it, the program stops and prints a traceback. Exception handling is how you say: "I know this can fail — here is what should happen when it does."

Python में exception एक object है जो किसी error का वर्णन करता है। जब कुछ ग़लत होता है, Python एक exception raise करता है। अगर कोई code उसे नहीं पकड़ता, तो program रुक जाता है और एक traceback छापता है। Exception handling यह कहने का तरीका है: "मुझे पता है यह fail हो सकता है — fail होने पर यह होना चाहिए।"

在 Python 中，异常 是一个描述错误的对象。出问题时，Python 会 抛出（raise） 一个异常。如果没有代码捕获它，程序就会停止并打印 traceback。异常处理就是在说："我知道这里可能失败 — 失败时应该这样做。"

The Exception Hierarchy — A Family Tree of Errors 🌳Exception Hierarchy — Errors का Family Tree 🌳异常层次结构 — 错误的家族树 🌳

Every exception in Python is an object, and every exception class comes from one common ancestor: BaseException. This tree is not trivia. It is the tool that lets one except clause catch a whole group of related errors.

Python में हर exception एक object है, और हर exception class एक ही पूर्वज से आती है: BaseException। यह tree सिर्फ़ जानकारी नहीं है। यही वह औज़ार है जिससे एक except clause संबंधित errors का पूरा समूह पकड़ लेता है।

Python 中每个异常都是对象，每个异常类都来自同一个祖先：BaseException。这棵树不是冷知识，它是让一个 except 子句就能捕获一整组相关错误的工具。

BaseException
 ├── SystemExit                    # raised by sys.exit()
 ├── KeyboardInterrupt             # Ctrl+C
 ├── GeneratorExit                 # generator .close()
 ├── BaseExceptionGroup            # several errors at once (3.11+)
 └── Exception                     # <-- catch things HERE and below
      ├── ArithmeticError
      │    ├── ZeroDivisionError
      │    ├── OverflowError
      │    └── FloatingPointError
      ├── LookupError
      │    ├── IndexError          # my_list[999]
      │    └── KeyError            # my_dict['missing']
      ├── OSError                  # file/OS problems
      │    ├── FileNotFoundError
      │    ├── PermissionError
      │    ├── IsADirectoryError
      │    ├── ConnectionError
      │    │    ├── ConnectionRefusedError
      │    │    ├── ConnectionResetError
      │    │    └── ConnectionAbortedError
      │    └── TimeoutError
      ├── ValueError               # int('abc')
      │    └── UnicodeError
      │         ├── UnicodeDecodeError
      │         └── UnicodeEncodeError
      ├── TypeError                # wrong type
      ├── AttributeError           # obj.missing_attr
      ├── NameError                # undefined variable
      │    └── UnboundLocalError
      ├── ImportError
      │    └── ModuleNotFoundError
      ├── RuntimeError
      │    ├── RecursionError
      │    └── NotImplementedError
      ├── StopIteration            # end of an iterator
      ├── AssertionError           # failed assert
      └── ExceptionGroup           # also a BaseExceptionGroup (3.11+)

This is a selection — Python has about 70 built-in exceptions. See them all with help("builtins") or the "Exception hierarchy" page of the Python docs.

यह एक चुनाव है — Python में लगभग 70 built-in exceptions हैं। सभी देखने के लिए help("builtins") या Python docs का "Exception hierarchy" page देखें।

这里只是一部分 — Python 有大约 70 个内置异常。可以用 help("builtins") 或 Python 文档的 "Exception hierarchy" 页面查看全部。

Try It — Hierarchy Explorerकरके देखें — Hierarchy Explorer动手试试 — 层次结构探索器

Pick the exception that is raised (click any name in the tree) and the class your except names. Python catches it only if the except class is on the raised exception's family line — the orange path up to the root.

जो exception raise होता है उसे चुनें (tree में किसी भी नाम पर click करें) और वह class चुनें जो आपका except लिखता है। Python उसे तभी पकड़ता है जब except वाली class raise हुए exception की परिवार line पर हो — root तक जाने वाला नारंगी रास्ता।

选择被 抛出 的异常（点击树中任意名字），再选择你的 except 写的类。只有当 except 的类位于被抛出异常的家族链上 — 也就是通往根的橙色路径 — Python 才会捕获它。

The Classes That Matter Most — What Each One Catches 🎯सबसे ज़रूरी Classes — हर एक क्या पकड़ती है 🎯最重要的几个类 — 各自捕获什么 🎯

There are dozens of built-in exceptions, but you will name only a few of them in your except clauses. Here they are, from the root down.

Built-in exceptions दर्जनों हैं, पर अपने except clauses में आप उनमें से कुछ ही लिखेंगे। ये रहीं, root से नीचे की ओर।

内置异常有几十个，但你在 except 子句里只会写其中几个。下面从根往下逐个介绍。

The try / except Statement — Basic Anatomy 🧪try / except Statement — बुनियादी बनावट 🧪try / except 语句 — 基本结构 🧪

The simplest handler has two parts: a try block that holds the risky code, and an except block that runs only if a matching exception is raised inside try.

सबसे सरल handler के दो हिस्से हैं: एक try block जिसमें जोखिम वाला code है, और एक except block जो तभी चलता है जब try के अंदर match करता exception raise हो।

最简单的处理器有两部分：放风险代码的 try 块，以及只有当 try 内抛出匹配异常时才运行的 except 块。

for text in ["25", "twenty"]:          # pretend the user typed these
    try:
        # The "maybe this will fail" code
        age = int(text)
        print(f"You are {age} years old.")
    except ValueError:
        # Runs only if a ValueError was raised inside try
        print(f"{text!r} is not a valid number.")

The loop feeds two pretend answers instead of calling input(), so you can see both paths in one run.

Loop input() बुलाने की जगह दो नक़ली जवाब देता है, ताकि एक ही run में दोनों रास्ते दिखें।

这个循环用两个假装的输入代替 input()，让你一次运行就能看到两条路径。

What Actually Happensअसल में क्या होता है实际发生了什么

Try It — Propagation Simulatorकरके देखें — Propagation Simulator动手试试 — 传播模拟器

Three functions call each other. The second item in the order is broken, so price_of() raises an exception. Choose where to put a try/except, which class it catches, and which bug happens. Then step through and watch the 🔥 bubble up the call stack. The output at the end is from real Python.

तीन functions एक-दूसरे को बुलाते हैं। Order का दूसरा item टूटा है, इसलिए price_of() exception raise करता है। चुनें कि try/except कहाँ रखना है, वह कौन-सी class पकड़ता है, और कौन-सा bug होता है। फिर कदम-दर-कदम चलें और 🔥 को call stack में ऊपर जाते देखें। आख़िर का output असली Python का है।

三个函数互相调用。订单的第二个商品有问题，所以 price_of() 抛出异常。选择把 try/except 放在 哪里、它捕获 哪个类、发生 哪种 bug。然后逐步执行，看 🔥 沿调用栈向上冒。最后的输出来自真实 Python。

Multiple except Blocks — Different Handling for Different Errors 🔀कई except Blocks — अलग Errors के लिए अलग Handling 🔀多个 except 块 — 不同错误不同处理 🔀

One try can be followed by many except blocks. Python checks them top to bottom and runs the first one that matches — like an if / elif chain for errors.

एक try के बाद कई except blocks हो सकते हैं। Python उन्हें ऊपर से नीचे जाँचता है और पहला match करने वाला चलाता है — errors के लिए if / elif chain जैसा।

一个 try 后面可以跟多个 except 块。Python 从上到下检查，运行 第一个 匹配的 — 就像错误版的 if / elif 链。

def get_user(users, index):
    try:
        user = users[index]
        return user["name"].upper()
    except IndexError:
        return "No user at that position"
    except KeyError:
        return "User has no name field"
    except AttributeError:
        return "Name is not a string"

users = [
    {"name": "Aarav"},
    {"email": "p@ex.com"},        # missing 'name'
    {"name": 42},                 # not a string
]

print(get_user(users, 0))         # happy path
print(get_user(users, 1))         # KeyError
print(get_user(users, 2))         # AttributeError
print(get_user(users, 99))        # IndexError

Catching Several Types in One Blockएक Block में कई Types पकड़ना一个块捕获多种类型

If several exceptions deserve the same treatment, list them in a tuple. as e gives you the exception object so you can print its type and message:

अगर कई exceptions को एक जैसा इलाज चाहिए, तो उन्हें tuple में लिखें। as e आपको exception object देता है ताकि आप उसका type और संदेश print कर सकें:

如果几种异常需要同样的处理，就把它们写成元组。as e 给你异常对象，可以打印它的类型和信息：

def parse_price(record):
    try:
        return float(record["price"]) * record["qty"]
    except (ValueError, TypeError, KeyError) as e:
        print(f"Input problem -> {type(e).__name__}: {e}")
        return 0.0

print(parse_price({"price": "9.5", "qty": 2}))
print(parse_price({"price": "abc", "qty": 2}))     # ValueError
print(parse_price({"price": None, "qty": 2}))      # TypeError
print(parse_price({"qty": 2}))                     # KeyError

Order Matters — Specific Before General 🪜क्रम मायने रखता है — ख़ास पहले, आम बाद में 🪜顺序很重要 — 先具体后宽泛 🪜

# The correct ordering: narrow to broad
try:
    with open("data.txt", encoding="utf-8") as f:
        content = f.read()
except FileNotFoundError:
    print("File does not exist - starting with empty content")
    content = ""
except PermissionError:
    print("No permission - ask the user for another location")
    raise
except OSError as e:
    print(f"Some other I/O problem: {e}")
    raise
print(repr(content))

The Full Statement — try / except / else / finally 🧩पूरा Statement — try / except / else / finally 🧩完整语句 — try / except / else / finally 🧩

Python's full exception statement has four clauses. Most code uses only try and except, but else and finally each solve a real problem.

Python के पूरे exception statement में चार clauses हैं। ज़्यादातर code सिर्फ़ try और except इस्तेमाल करता है, पर else और finally दोनों एक असली समस्या हल करते हैं।

Python 完整的异常语句有四个子句。大多数代码只用 try 和 except，但 else 和 finally 各自解决一个实际问题。

All Four Clauses in Actionचारों Clauses काम करते हुए四个子句的实际运行

def read_config(path):
    f = None
    try:
        print("1. try: opening", path)
        f = open(path, encoding="utf-8")
        content = f.read()
    except FileNotFoundError:
        print("2. except: file missing")
        return None
    else:
        print("2. else: parsing content")
        return content.strip().splitlines()
    finally:
        print("3. finally: cleanup")
        if f is not None:
            f.close()

print("--- success case ---")
print(read_config("settings.txt"))

print("--- failure case ---")
print(read_config("missing.txt"))

Try It — Flow Stepperकरके देखें — Flow Stepper动手试试 — 流程步进器

Type any value for text (or tap a chip) and step through. Watch which clauses light up, which are skipped, and how finally runs every single time — even when the error is not caught.

text के लिए कोई भी value लिखें (या chip दबाएँ) और कदम-दर-कदम चलें। देखें कौन-से clauses जलते हैं, कौन-से छूटते हैं, और finally कैसे हर बार चलता है — तब भी जब error पकड़ा न जाए।

为 text 输入任意值（或点一个按钮），然后逐步执行。观察哪些子句亮起、哪些被跳过，以及 finally 如何每一次都运行 — 即使错误没有被捕获。

A Trap: return Inside finallyएक जाल: finally के अंदर return一个陷阱：finally 里的 return

def risky():
    try:
        return 1 / 0
    finally:
        return "finally wins"      # swallows the ZeroDivisionError!

print(risky())

Raising Exceptions — Setting Off Your Own Alarms 📣Exceptions Raise करना — अपने Alarm बजाना 📣抛出异常 — 拉响你自己的警报 📣

You don't only catch exceptions — you raise them too. When your function finds a problem it cannot fix, it should raise a clear, specific exception so the caller can decide what to do.

आप सिर्फ़ exceptions पकड़ते नहीं — raise भी करते हैं। जब आपके function को ऐसी समस्या मिले जिसे वह ठीक न कर सके, तो उसे एक साफ़, ख़ास exception raise करना चाहिए ताकि caller तय कर सके कि क्या करना है।

你不仅捕获异常 — 也会抛出异常。当函数发现自己无法解决的问题时，应该抛出一个清晰、具体的异常，让调用者决定怎么办。

def set_age(age):
    if not isinstance(age, int):
        raise TypeError(f"age must be int, got {type(age).__name__}")
    if age < 0 or age > 150:
        raise ValueError(f"age must be in 0..150, got {age}")
    return age

# Callers can choose to catch - or let the error bubble up
for value in [30, 200, "30"]:
    try:
        print("ok:", set_age(value))
    except ValueError as e:
        print(f"Invalid value: {e}")
    except TypeError as e:
        print(f"Wrong type: {e}")

Re-raising — Catch, Log, RethrowRe-raise — पकड़ो, Log करो, फिर फेंको重新抛出 — 捕获、记录、再抛出

Sometimes you want to note that an error happened but still let it travel on. A bare raise inside an except block re-raises the current exception unchanged.

कभी आप दर्ज करना चाहते हैं कि error हुआ, पर उसे आगे भी जाने देना चाहते हैं। except block के अंदर खाली raise मौजूदा exception को बिना बदले फिर से raise करता है।

有时你想 记下 错误发生了，但仍让它继续传递。在 except 块中写一个单独的 raise，就会原样重新抛出当前异常。

import logging, sys
logging.basicConfig(stream=sys.stdout, format="%(levelname)s %(message)s")
logger = logging.getLogger("app")

def fetch():
    raise ConnectionError("server did not answer")

def load_data():
    try:
        return fetch()
    except ConnectionError as e:
        logger.warning(f"Connection failed: {e} - will retry higher up")
        raise                      # same exception continues bubbling

try:
    load_data()
except ConnectionError as e:
    print("caller got it too:", repr(e))

Exception Chaining — raise X from Y ⛓️Exception Chaining — raise X from Y ⛓️异常链 — raise X from Y ⛓️

When a low-level error causes a higher-level one, keep the whole chain so debugging shows the full story. raise ... from ... makes the link explicit. This program is meant to crash, so you can see the traceback:

जब कोई निचले स्तर का error ऊँचे स्तर का error पैदा करे, तो पूरी chain रखें ताकि debugging में पूरी कहानी दिखे। raise ... from ... यह कड़ी साफ़ करता है। यह program जान-बूझकर crash होता है, ताकि आप traceback देख सकें:

当底层错误引发上层错误时，要保留整条链，让调试时能看到完整经过。raise ... from ... 让这种关联一目了然。这个程序是 故意 崩溃的，好让你看到 traceback：

class ConfigError(Exception):
    """Raised when configuration cannot be loaded."""

def load_config(path):
    try:
        with open(path, encoding="utf-8") as f:
            return f.read()
    except FileNotFoundError as e:
        # Chain: keep the original in the traceback
        raise ConfigError(f"Config not available at {path}") from e

load_config("/etc/app.conf")

Proof: the three forms store the original in different attributes.

सबूत: तीनों रूप मूल error को अलग-अलग attributes में रखते हैं।

证明：三种写法把原始错误存在不同的属性里。

def convert(text):
    try:
        return int(text)
    except ValueError as e:
        if variant == "plain":
            raise RuntimeError("bad input")
        if variant == "from e":
            raise RuntimeError("bad input") from e
        raise RuntimeError("bad input") from None

for variant in ["plain", "from e", "from None"]:
    try:
        convert("abc")
    except RuntimeError as err:
        print(f"{variant:9} | __cause__={err.__cause__!r}")
        print(f"{'':9} | __context__={err.__context__!r}")
        print(f"{'':9} | __suppress_context__={err.__suppress_context__}")

Tracebacks — Following the Trail Back to the Real Error 🕵️Tracebacks — असली Error तक पीछे का रास्ता 🕵️Traceback — 顺着线索找到真正的错误 🕵️

Anatomy of a Traceback — Read It Bottom-UpTraceback की बनावट — नीचे से ऊपर पढ़ेंTraceback 的结构 — 从下往上读

Traceback (most recent call last):            <- header
  File "demo.py", line 11, in <module>        | 1. where it all started
    print("Total:", total(cart))
                    ~~~~~^^^^^^
  File "demo.py", line 7, in total            | 2. next call down
    s += price_of(item)
         ~~~~~~~~^^^^^^
  File "demo.py", line 2, in price_of         | 3. THE CRIME SCENE
    return item["cost"] * item["qty"]
           ~~~~^^^^^^^^                       |    the part that failed
KeyError: 'cost'                              <- WHAT went wrong

Try It — Traceback Readerकरके देखें — Traceback Reader动手试试 — Traceback 阅读器

Three real programs, three real crashes. Press the steps in order and watch the traceback and the code light up together.

तीन असली programs, तीन असली crashes। कदम क्रम से दबाएँ और traceback व code को एक साथ जलते देखें।

三个真实程序，三次真实崩溃。按顺序点击步骤，看 traceback 和代码一起亮起。

The Problem — Catching Hides the Tracebackसमस्या — पकड़ने से Traceback छिप जाता है问题 — 捕获会隐藏 traceback

Once you catch an exception, its traceback no longer appears in the terminal — handling it is now your job. But that is often exactly when you want to see it:

एक बार आप exception पकड़ लें, तो उसका traceback terminal में नहीं दिखता — उसे संभालना अब आपका काम है। पर अक्सर ठीक तभी आप उसे देखना चाहते हैं:

一旦捕获了异常，它的 traceback 就不会再出现在终端里 — 处理它成了你的事。但往往正是这时你 想 看到它：

def price_of(item):
    return item["cost"] * item["qty"]

def total(order):
    return sum(price_of(item) for item in order)

def process(order):
    try:
        return total(order)
    except Exception as e:
        print(f"something failed: {e}")      # USELESS - just the message
        return None

process([{"cost": 10, "qty": 2}, {"qty": 3}])

The traceback Module — Seeing the Real Error 🔬traceback Module — असली Error देखना 🔬traceback 模块 — 看清真正的错误 🔬

The built-in traceback module prints or captures the full traceback even after you have caught the exception. It is the difference between a useless "something failed" and a pointer to the exact line.

Built-in traceback module exception पकड़ने के बाद भी पूरा traceback छाप या सहेज सकता है। यही फ़र्क़ है बेकार "something failed" और ठीक उस line की ओर इशारे में।

内置的 traceback 模块即使在捕获异常之后，也能打印或保存完整的 traceback。这就是毫无用处的 "something failed" 与精确指向出错行之间的区别。

Example — print_exc(): See What You Caughtउदाहरण — print_exc(): जो पकड़ा वह देखें示例 — print_exc()：看清你捕获了什么

import traceback

def price_of(item):
    return item["cost"] * item["qty"]

def total(order):
    return sum(price_of(item) for item in order)

order = [{"cost": 10, "qty": 2}, {"qty": 3}]   # second item missing 'cost'

try:
    print("Total:", total(order))
except Exception:
    print("--- caught, but let me show you the real error ---")
    traceback.print_exc()
    print("--- carrying on ---")

Example — format_exc(): Send It to a Fileउदाहरण — format_exc(): File में भेजें示例 — format_exc()：写入文件

print_exc() writes to the terminal, which is useless for a server nobody is watching. format_exc() returns the same traceback as a string — perfect for a log file.

print_exc() terminal पर लिखता है, जो ऐसे server के लिए बेकार है जिसे कोई देख नहीं रहा। format_exc() वही traceback string के रूप में लौटाता है — log file के लिए बिल्कुल सही।

print_exc() 写到终端，对没人盯着的服务器毫无用处。format_exc() 以字符串返回同样的 traceback — 非常适合写进日志文件。

import traceback, datetime
from pathlib import Path

def safe_run(func, *args):
    try:
        return func(*args)
    except Exception:
        tb_text = traceback.format_exc()          # full traceback as a string
        now = datetime.datetime.now().isoformat(timespec="seconds")
        with open("errors.log", "a", encoding="utf-8") as f:
            f.write(f"===== {now} =====\n")
            f.write(tb_text)
        print("An error occurred. Details written to errors.log")
        return None

def average(nums):
    return sum(nums) / len(nums)

print(safe_run(average, [4, 8]))
print(safe_run(average, []))                      # ZeroDivisionError
print(Path("errors.log").read_text(encoding="utf-8"), end="")

(The timestamp is from the moment this page was built, in UTC.)

(Timestamp उस समय का है जब यह page बना, UTC में।)

（时间戳是本页面构建时的 UTC 时间。）

The Production Pattern — logging.exception() 📝Production का तरीका — logging.exception() 📝生产环境的做法 — logging.exception() 📝

Real applications rarely call traceback.print_exc(). They use the logging module, which has a method made exactly for this: logger.exception() logs your message at ERROR level plus the full traceback.

असली applications शायद ही traceback.print_exc() बुलाते हैं। वे logging module इस्तेमाल करते हैं, जिसमें ठीक इसी काम का method है: logger.exception() आपका संदेश ERROR level पर और पूरा traceback log करता है।

真实应用很少直接调用 traceback.print_exc()。它们使用 logging 模块，其中有专为此设计的方法：logger.exception() 以 ERROR 级别记录你的信息，外加 完整的 traceback。

import logging, sys

logging.basicConfig(stream=sys.stdout, level=logging.INFO,
                    format="%(levelname)s %(message)s")
logger = logging.getLogger(__name__)

def price_of(item):
    return item["cost"] * item["qty"]

def total(order):
    return sum(price_of(item) for item in order)

def process(order):
    try:
        return total(order)
    except Exception:
        logger.exception("failed to process order")      # msg + traceback
        return None

process([{"cost": 10, "qty": 2}, {"qty": 3}])

Looking Inside an Exception ObjectException Object के अंदर झाँकना查看异常对象内部

Every caught exception carries its details: args, its type, and __traceback__ — the traceback object, which you can pass to traceback.print_tb() or keep for later.

हर पकड़ा गया exception अपनी जानकारी साथ रखता है: args, उसका type, और __traceback__ — traceback object, जिसे आप traceback.print_tb() को दे सकते हैं या बाद के लिए रख सकते हैं।

每个被捕获的异常都带着它的细节：args、类型，以及 __traceback__ — traceback 对象，你可以把它传给 traceback.print_tb() 或留着以后用。

import traceback

def price_of(item):
    return item["cost"] * item["qty"]

try:
    price_of({"qty": 3})
except Exception as e:
    print("class   :", type(e).__name__)
    print("message :", e)
    print("args    :", e.args)
    print("tb obj  :", type(e.__traceback__).__name__, "- line", e.__traceback__.tb_lineno)
    print("--- frames only (print_tb) ---")
    traceback.print_tb(e.__traceback__)

Custom Exceptions — Your Own Alarm Classes 🏷️Custom Exceptions — आपकी अपनी Alarm Classes 🏷️自定义异常 — 你自己的警报类 🏷️

Built-in exceptions cover general problems. Problems specific to your program deserve their own classes. A custom exception is just a class that inherits from Exception (or one of its children).

Built-in exceptions आम समस्याएँ संभालती हैं। आपके program की ख़ास समस्याओं को अपनी classes मिलनी चाहिए। Custom exception बस एक class है जो Exception (या उसके किसी child) से inherit करती है।

内置异常覆盖的是通用问题。你程序特有的问题值得拥有自己的类。自定义异常就是一个继承 Exception（或其子类）的类。

# A small hierarchy for a payment library
class PaymentError(Exception):
    """Base class for all payment-related failures."""

class InsufficientFundsError(PaymentError):
    def __init__(self, balance, amount):
        super().__init__(f"Need {amount}, only {balance} available")
        self.balance = balance
        self.amount = amount

class CardDeclinedError(PaymentError):
    def __init__(self, reason):
        super().__init__(f"Card declined: {reason}")
        self.reason = reason

def charge(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(balance, amount)
    if amount > 10000:
        raise CardDeclinedError("amount exceeds daily limit")
    return balance - amount

# Callers can catch broad or narrow
for balance, amount in [(500, 1200), (50000, 20000), (900, 100)]:
    try:
        print("new balance:", charge(balance, amount))
    except InsufficientFundsError as e:
        print(f"Top up needed: short by {e.amount - e.balance}")
    except PaymentError as e:
        print(f"Some other payment issue: {e}")

Modern Tools — Notes, Exception Groups and EAFP 🧰आधुनिक औज़ार — Notes, Exception Groups और EAFP 🧰现代工具 — 注释、异常组与 EAFP 🧰

Python 3.11 added two useful tools. add_note() attaches extra context to an exception without changing its type. ExceptionGroup raises several errors at once, and except* handles each kind separately — handy for form validation or many tasks running together.

Python 3.11 ने दो काम के औज़ार जोड़े। add_note() exception का type बदले बिना उसमें अतिरिक्त संदर्भ जोड़ता है। ExceptionGroup एक साथ कई errors raise करता है, और except* हर तरह को अलग-अलग संभालता है — form validation या साथ चल रहे कई tasks के लिए उपयोगी।

Python 3.11 新增了两个实用工具。add_note() 在不改变异常类型的情况下附加额外上下文。ExceptionGroup 一次抛出 多个 错误，except* 分别处理每一类 — 适合表单校验或同时运行的多个任务。

# Python 3.11+: add context to an error with add_note()
def load_row(n, row):
    try:
        return int(row)
    except ValueError as e:
        e.add_note(f"while reading row {n} of marks.csv")
        raise

try:
    load_row(7, "ninety")
except ValueError as e:
    print(e)
    print(e.__notes__)

# Python 3.11+: report SEVERAL errors at once with ExceptionGroup
def validate(form):
    errors = []
    if not form.get("name"):
        errors.append(ValueError("name is empty"))
    if "@" not in form.get("email", ""):
        errors.append(ValueError("email has no @"))
    if not isinstance(form.get("age"), int):
        errors.append(TypeError("age must be a number"))
    if errors:
        raise ExceptionGroup("form is invalid", errors)

try:
    validate({"name": "", "email": "aarav.example.com", "age": "20"})
except* ValueError as group:
    for err in group.exceptions:
        print("value problem:", err)
except* TypeError as group:
    for err in group.exceptions:
        print("type problem: ", err)

When a note is attached and the error is not caught, the note is printed under the last line of the traceback — so whoever reads it knows which row of the file was bad.

जब note जुड़ा हो और error पकड़ा न जाए, तो note traceback की आख़िरी line के नीचे छपता है — ताकि पढ़ने वाले को पता चले कि file की कौन-सी row ख़राब थी।

附加了注释的错误如果没被捕获，注释会打印在 traceback 最后一行下面 — 读的人就知道文件的哪一行有问题。

EAFP vs LBYL — Two StylesEAFP बनाम LBYL — दो तरीकेEAFP 与 LBYL — 两种风格

Python programmers often prefer EAFP — "Easier to Ask Forgiveness than Permission": just try it and handle the exception. The other style, LBYL — "Look Before You Leap" — checks first. Both are fine; for a normal, expected case, a tool like dict.get() is often clearer than either.

Python programmers अक्सर EAFP पसंद करते हैं — "Permission से माफ़ी माँगना आसान": बस कोशिश करो और exception संभालो। दूसरा तरीका, LBYL — "कूदने से पहले देखो" — पहले जाँचता है। दोनों ठीक हैं; सामान्य, उम्मीद वाले मामले में dict.get() जैसा औज़ार अक्सर दोनों से साफ़ होता है।

Python 程序员常偏爱 EAFP —"请求原谅比请求许可更容易"：直接尝试，再处理异常。另一种风格 LBYL —"三思而后行"— 先检查。两者都可以；对于正常、预料之中的情况，像 dict.get() 这样的工具往往比两者都清晰。

prices = {"apple": 30, "banana": 10}

# LBYL - "Look Before You Leap": check first
if "mango" in prices:
    print(prices["mango"])
else:
    print("LBYL: no mango")

# EAFP - "Easier to Ask Forgiveness than Permission": try, then handle
try:
    print(prices["mango"])
except KeyError:
    print("EAFP: no mango")

# For a missing key that is NORMAL, the simplest tool is often neither:
print("get():", prices.get("mango", "no mango"))

Common Pitfalls — Anti-Patterns Every Codebase Has 🕳️आम गड्ढे — हर Codebase की बुरी आदतें 🕳️常见陷阱 — 每个代码库都有的反模式 🕳️

A Complete Real-World Example — A Robust API Client 🌐पूरा असली उदाहरण — एक मज़बूत API Client 🌐完整实战示例 — 健壮的 API 客户端 🌐

This function fetches a user from a server, parses the JSON and saves it to disk. It uses almost everything in this tutorial: specific catches, a custom exception family, chaining with from e, else for the success path and finally for cleanup. A tiny fake server makes it runnable, so the output below is real — four users, four different paths.

यह function server से एक user लाता है, JSON parse करता है और उसे disk पर save करता है। इसमें इस tutorial की लगभग हर चीज़ है: ख़ास catches, custom exception परिवार, from e से chaining, सफलता के लिए else और cleanup के लिए finally। एक छोटा नक़ली server इसे चलने लायक बनाता है, इसलिए नीचे का output असली है — चार users, चार अलग रास्ते।

这个函数从服务器获取用户、解析 JSON 并保存到磁盘。它用到了本教程几乎所有内容：具体的捕获、自定义异常家族、用 from e 链接、用 else 走成功路径、用 finally 做清理。一个小小的假服务器让它可以运行，所以下面的输出是真实的 — 四个用户，四条不同路径。

import json, logging, sys
from pathlib import Path

logging.basicConfig(stream=sys.stdout, format="%(levelname)s %(message)s")
logger = logging.getLogger("client")

class ApiClientError(Exception):
    """Base for all API client errors."""

class UserNotFound(ApiClientError):
    """The requested user does not exist."""

class MalformedResponse(ApiClientError):
    """Server returned something we cannot parse."""

# A fake server so this example runs anywhere
SERVER = {"/users/1": '{"name": "Aarav", "city": "Baddi"}', "/users/2": "{oops"}

class Connection:
    def fetch(self, url):
        if url == "/users/9":
            raise ConnectionError("network unreachable")
        return SERVER.get(url)
    def close(self):
        print("   (connection closed)")

def save_user_profile(user_id, out_path):
    conn = None
    try:
        conn = Connection()
        raw = conn.fetch(f"/users/{user_id}")
        if raw is None:
            raise UserNotFound(f"No user with id {user_id}")
        try:
            data = json.loads(raw)
        except json.JSONDecodeError as e:
            raise MalformedResponse("bad JSON from server") from e
    except ConnectionError as e:
        logger.error(f"network problem: {e}")   # expected: short message
        return False
    except UserNotFound as e:
        logger.warning(str(e))                   # expected, no traceback needed
        return False
    else:
        # Runs only if the try block succeeded
        try:
            Path(out_path).write_text(json.dumps(data, indent=2), encoding="utf-8")
        except OSError as e:
            raise ApiClientError(f"could not save profile: {e}") from e
        print(f"   saved profile to {out_path}")
        return True
    finally:
        # Always release the connection, success or failure
        if conn is not None:
            conn.close()

for uid in [1, 3, 9, 2]:
    print(f"user {uid}:")
    try:
        print("   result:", save_user_profile(uid, f"user{uid}.json"))
    except ApiClientError as e:
        print(f"   ApiClientError: {e} (caused by {type(e.__cause__).__name__})")

Golden Rules and Quick Quiz 🏆सुनहरे नियम और छोटा Quiz 🏆黄金法则与小测验 🏆

Quick Quiz — 8 Questionsछोटा Quiz — 8 सवाल小测验 — 8 道题