NCERT Notes Class 12 Computer Science Chapter 1 Exception Handling

These Notes for Class 12 Computer Science Chapter 1 Exception Handling in Python give you a fast, concept-first revision of the whole chapter, built on the latest 2026-27 CBSE syllabus. They cover the difference between a syntax error and an exception, the common built-in exceptions, and how try, except, raise, assert, else and finally keep a Python program from crashing.

• Every keyword explained with a one-line meaning, a short Python code block, and the exact line that triggers each error.
• Full coverage of ValueError, ZeroDivisionError, NameError, ImportError and the try-except-else-finally flow that the CBSE board paper tests directly.
• Notes aligned with the 2026-27 CBSE Class 12 Computer Science syllabus and useful for JEE and CUET programming questions; no NEET references because Computer Science is not a medical subject.

These Collegedunia revision notes are curated by Computer Science subject experts, mapped to the 2026-27 NCERT textbook, and refined against the last five years of CBSE Class 12 Computer Science board papers.

What the Notes for Class 12 Computer Science Chapter 1 Exception Handling in Python Cover

This chapter answers one question: how does a Python program deal with run-time errors without crashing? These notes keep the NCERT order but compress it into revision-ready blocks, so you can read the whole chapter in one sitting and recall it fast in the exam.

• Syntax error vs exception: a syntax error is caught while Python reads the code; an exception happens while a correct program runs.
• Built-in exceptions: ValueError, ZeroDivisionError, NameError, ImportError and IOError, each tied to the exact line that triggers it.
• The try-except block: risky code goes in try, handlers go in except, and the program continues instead of stopping.
• raise, assert, else and finally: throwing an error on demand, testing a condition, running code only on success, and running clean-up code in every case.

Errors and Exceptions: The Big Picture for Class 12 Computer Science

Before the keywords, fix the vocabulary. An error is anything that stops a program from doing its job. Python sorts errors into a few groups, and only one group can be caught and handled at run time. Getting these labels right is what the first two exam questions reward.

The word exception means an exceptional event that breaks the normal flow of a running program. Python represents every exception as an object of a class, and all of those classes descend from BaseException. This class idea is the thread that ties the whole chapter together, so keep it in mind as you read on.

Syntax Error vs Exception in Python

A syntax error is an error Python finds while it reads (parses) your code, before the program runs. It breaks the grammar of the language, for example a missing colon or an unmatched bracket. An exception is an error that happens while a syntactically correct program is running, such as dividing by zero or using a name that was never defined.

• Detection time: a syntax error is caught before any line runs; an exception surfaces only during execution.
• Class tree: in Python every error type is a class. SyntaxError is a subclass of Exception, so a syntax error is itself a kind of exception.
• One-way rule: every syntax error is an exception, but most exceptions (like ZeroDivisionError) are not syntax errors.

A syntax error stops parsing, so Python refuses to run the file at all. A run-time exception, by contrast, happens in grammatically correct code. The two short blocks below show the split clearly:

if x > 5      # missing colon, breaks grammar
    print(x)

SyntaxError: expected ':'

Common Built-in Exceptions in Class 12 Computer Science

A built-in exception is an error class that Python already provides and raises automatically when a specific bad situation happens at run time. The class name describes the problem, so naming the right exception in the exam is mostly about reading the trigger line carefully.

Two modern aliases earn full marks. Since Python 3.6 a missing module raises ModuleNotFoundError, a subclass of ImportError. Since Python 3.3 IOError is an alias of OSError, and a missing file raises FileNotFoundError. Writing except IOError still works because the alias catches the same family. The class hierarchy below is why a parent name can stand in for its children.

BaseException
 └── Exception
      ├── ArithmeticError
      │    └── ZeroDivisionError
      ├── ImportError
      │    └── ModuleNotFoundError
      ├── NameError
      ├── OSError  (alias: IOError)
      │    └── FileNotFoundError
      └── ValueError

The try-except Block: Catching Exceptions in Python

The try-except block is Python's main tool for catching exceptions. Risky code goes inside try. If a statement raises an exception, Python leaves the try block at that point and checks each except clause in order. The first clause whose type matches runs, then the program continues. If nothing fails, the except blocks are skipped.

try:
    a = int(input("Enter a number: "))
    b = int(input("Enter another number: "))
    print("Result =", a / b)
except ValueError:
    print("Please enter only whole numbers")
except ZeroDivisionError:
    print("The second number must not be zero")

Matching is by class, so an except that names a parent class also catches its children. Because except Exception catches almost everything, a broad handler must come last, after the specific ones, or it will swallow exceptions the specific handlers were meant to catch.

raise and assert: Throwing Errors on Purpose

Sometimes you want to signal an error yourself instead of waiting for Python. Two keywords do this, but in different ways, so keep their rules separate.

The raise statement

The raise statement throws an exception on demand. The form is raise ExceptionName("message"). It is most useful for a rule Python does not know about, such as refusing a negative denominator. Once raised, control jumps to the nearest matching except block.

num2 = int(input("Enter the denominator: "))
if num2 == 0:
    raise ZeroDivisionError("Denominator cannot be zero")

Writing except ZeroDivisionError as e stores the exception object in e, so print(e) shows the exact message you passed to raise. A clear message like "Denominator cannot be zero" beats the generic "division by zero" Python prints on its own.

The assert statement

The assert statement checks that a condition is true. The form is assert condition, message. If the condition is true, the program continues silently; if it is false, Python raises an AssertionError with the message. It is a development-time check.

• assert num2 != 0, "Denominator cannot be zero" tests the division before it runs.
• Assertions can be switched off with the -O (optimise) flag, so never rely on assert for real user-input validation in a shipped program.

Tip: Use assert for sanity checks during development and raise (or a plain if) for permanent input validation, because only raise cannot be disabled by the optimise flag.

else and finally: Success-Only and Always-Run Blocks

Two extra blocks attach to try, and mixing them up is the single most common error students make in this chapter. Map each one to exactly when it runs.

• else: runs only when the try block finishes with no exception. It is conditional on success.
• finally: runs on every exit path, whether an exception was raised, caught, or is about to propagate. It is unconditional.

try:
    quotient = num1 / num2
except ZeroDivisionError:
    print("Number 2 should not be zero")
else:
    print("Great, you are a good programmer")   # only on success
finally:
    print("JOB OVER, GO GET SOME REST")         # always runs

With valid input the try body runs, then else, then finally: three messages print. With a zero denominator the except handler runs, else is skipped, and finally still runs: two messages print. So the "JOB OVER" line from finally appears in both runs, while the "Great" line from else appears only in the clean run.

One-Glance Revision Strip and Common Exam Traps

This is the strip to read in the last five minutes before the exam. It lines up every keyword with its one-line role, then lists the traps that cost students marks every year.

How to Use the Exception Handling Notes PDF for Board Revision

The Exception Handling chapter is short but definition-heavy and trap-heavy. The best approach is two passes: one for the vocabulary and the keyword roles, one for tracing the small programs by hand.

First pass: vocabulary and keywords

Read these notes and note the syntax-error-versus-exception split, the five common built-in exceptions, and the role of each keyword: try, except, raise, assert, else, finally. Say one line of meaning aloud for each so the words stick before you start tracing code.

Second pass: trace the programs

Take the try-except-else-finally block above and trace it twice on paper: once with a valid denominator and once with a zero. Write the exact lines that print in each run. That single exercise covers the most common 3-mark board question on this chapter.

JEE and CUET angle

For students preparing competitive exams, exception handling appears in Python-based programming rounds and in CUET Computer Science. The try-except flow and the difference between value errors and type errors are exactly the kind of concept questions those papers reuse, so this revision doubles as competitive prep.

Previous Year Question Trends from the Exception Handling Chapter

The Exception Handling chapter is tested in CBSE board papers mainly through definition and output questions, with a program question on raising or catching an exception. The table below maps the asked question types across recent board papers, so your revision can target the high-frequency areas.

Also Check: The full set of CBSE board paper questions for this chapter, with step-by-step answers, is included in the downloadable PDF above, updated for the 2026-27 cycle.

Other Resources for Class 12 Computer Science Chapter 1 Exception Handling in Python

Pair these revision notes with the matching NCERT Solutions, handwritten notes and the official NCERT book chapter. All resources for Class 12 Computer Science Chapter 1 Exception Handling in Python are linked below.

Notes for Class 12 Computer Science: All Chapters

Related Links: Use the table below to open the revision notes for the other chapters of Class 12 Computer Science. Every chapter ships with the same concept-first notes style, full PDF download, and revision FAQ.