Python PCEP Certification: Complete Study Guide for 2026

When we built the Dragonfly Python PCEP practice set, we went through the official Python Institute exam syllabus question by question and compared it to what most Python tutorials cover. The gap is significant: most beginner Python tutorials teach you to write scripts and solve problems, but the PCEP exam tests your ability to predict exactly what a specific piece of code will do — including edge cases, error conditions, and operator precedence that most tutorials gloss over. This guide focuses on what the exam actually tests.

What the PCEP exam covers

The PCEP-30-02 exam covers five exam blocks. Block 1 — Computer Programming and Python Fundamentals (18%): how Python works as an interpreted language, the role of variables and literals, Python keywords, and basic input/output operations. Block 2 — Control Flow (29%): Boolean expressions, comparison and logical operators, if/elif/else statements, while loops, for loops, break and continue, range(), and nested loops. Block 3 — Data Collections (25%): lists (indexing, slicing, methods), tuples, dictionaries (keys and values, methods), strings (immutability, methods, formatting). Block 4 — Functions and Exceptions (28%): defining functions, parameters vs arguments, return values, variable scope, recursion, and exception handling with try/except.

Notice that control flow, functions, and data collections together account for over 80% of the exam. Number theory, complex algorithms, and object-oriented programming are mostly absent — the PCEP is a foundational certification focused on core Python language behaviour.

The skill the exam actually tests: code prediction

PCEP questions are almost always code-reading questions, not code-writing questions. You are shown a Python snippet and asked: what will this code output? What error will this produce? What is the value of this variable after this code runs? This requires a very specific mental skill: the ability to execute code in your head, step by step, following Python's exact rules.

The areas where this skill is most tested and where most candidates make errors: operator precedence (what order does Python evaluate 2 + 3 * 4 - 1?), integer division and modulo (7 // 2 = 3, 7 % 2 = 1), string immutability (you cannot change individual characters), list mutability and reference behaviour (two variables pointing to the same list both change when one is modified), and variable scope (local vs global vs enclosing scope in nested functions).

Operator precedence: learn it precisely

Python's operator precedence from highest to lowest (simplified for PCEP): parentheses first, then exponentiation (**), then unary operators (-, +, ~), then multiplication/division/floor division/modulo (* / // %), then addition/subtraction (+ -), then comparison operators (< > <= >= == !=), then not, then and, then or. The PCEP regularly tests whether candidates know that 2 + 3 * 4 evaluates to 14 (not 20), or that not True or False evaluates to False (not True).

For PCEP preparation, practise evaluating complex expressions step by step on paper before running them in Python. The exam does not allow a computer — you must trace the code mentally. Write out the evaluation steps for any expression involving mixed operators, and verify by running the code in Python afterwards.

Lists and strings: the most-tested data types

Lists are mutable ordered sequences. Key operations: indexing (my_list[0] is the first element, my_list[-1] is the last), slicing (my_list[1:4] returns elements at index 1, 2, 3 — not 4), length (len(my_list)), append vs extend vs insert, remove vs pop vs del, and list comprehensions. The most common PCEP trap: modifying a list while iterating over it — this produces unexpected behaviour that is directly tested.

Strings are immutable ordered sequences of characters. Key operations: indexing and slicing (same syntax as lists), concatenation (+), repetition (*), in operator for membership testing, upper/lower/strip/replace/split methods, and string formatting (f-strings: f'Hello {name}' and the format() method). The immutability of strings means that my_string[0] = 'A' raises a TypeError — this is tested.

Exception handling: try, except, else, finally

Exception handling is Block 4 content and carries significant marks. The basic structure: try (code that might raise an exception), except (code that runs if an exception occurs — can specify exception type), else (code that runs if no exception occurred), finally (code that always runs, exception or not). Common exception types tested: TypeError (wrong data type), ValueError (right type, wrong value), ZeroDivisionError, IndexError (list index out of range), KeyError (dictionary key not found), and NameError (variable not defined).

The PCEP tests whether you know the difference between catching a general exception (except Exception:), catching a specific exception (except ValueError:), and what happens when an exception type that is not caught occurs (the program crashes with a traceback). Also tested: raising exceptions manually with raise, and the order of except clauses (more specific exceptions must come before more general ones).