PCEP course and practice exam: Certified Entry-Level Python Programmer
This PCEP course has 24 video lessons and 93 graded labs, and its PCEP practice exam follows the official exam objectives: a 20-question sampler free with an account, the full question bank and timed mock exams with Pro.
Python fundamentals, control flow, collections, functions and exceptions
Prepares you for PCEP-30-02: computer programming and Python fundamentals, control flow, data collections, and functions and exceptions.
Beginner · 2 hours · 24 lessons · 93 labs
PCEP exam guide
The PCEP exam (PCEP – Certified Entry-Level Python Programmer, by Python Institute (OpenEDG)): 40 minutes (plus 5 minutes NDA/tutorial); questions: 30; pass mark: 70%; cost: from USD 69 (exam only); from USD 86 (exam + retake); from USD 95 (exam + retake + practice test).
- Format: Single- and multiple-select questions, drag & drop, gap fill, sort, code fill, code insertion, interactive and scenario-based items
- Duration: 40 minutes (plus 5 minutes NDA/tutorial)
- Questions: 30
- Pass mark: 70%
- Cost: From USD 69 (exam only); from USD 86 (exam + retake); from USD 95 (exam + retake + practice test)
- Valid for: 5 years
- Delivery: Online proctored via OpenEDG TestNow, or at an OpenEDG testing partner
- Prerequisites: None
Exam domains and weights
- Computer Programming and Python Fundamentals: 18%
- Control Flow – Conditional Blocks and Loops: 29%
- Data Collections – Tuples, Dictionaries, Lists, and Strings: 25%
- Functions and Exceptions: 28%
A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
10 PCEP sample questions with answers: free to read, no account needed.
Common questions
How long is the PCEP exam?
The PCEP exam lasts 40 minutes (plus 5 minutes NDA/tutorial).
How many questions are on the PCEP exam?
30.
What is the PCEP passing score?
The pass mark is 70%.
How much does the PCEP exam cost?
From USD 69 (exam only); from USD 86 (exam + retake); from USD 95 (exam + retake + practice test).
Is there a free PCEP practice test?
Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
Source: PCEP-30-0x Exam Syllabus (Python Institute) (Python Institute (OpenEDG)), checked 2026-10-03.
Who it is for
Beginner level.
For anyone who wants the PCEP entry-level Python certificate, starting from nothing. Each new piece of Python is explained in plain words, with a no-code warm-up, before a lab uses it.
What you don't need yet:
- No programming experience: you learn to read each lab before you run it
- Nothing to install: a real Python runs in your browser
- No exam experience: one lesson covers timing and pacing
- No classes or objects: those belong to the PCAP exam
No prerequisites. You can start here.
Take next:
- PCAP Certified Associate in Python Programming (PCAP-31-03) Exam Prep — Intermediate
- Hands-on Python: Complete Video Course & Book — Beginner
Learning paths:
Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.
What this exam proves, and what it doesn't
PCEP is an exam of select, code-fill, scenario and interactive items: passing shows you can read and write basic Python. It doesn't show you can build real programs; our graded labs run a real Python in your browser.
Exam objectives this course teaches
PCEP – Certified Entry-Level Python Programmer (PCEP-30-02)
- Computer Programming and Python Fundamentals (18% of the exam): Understand fundamental terms and definitions: interpreting and the interpreter, compilation and the compiler, lexis, syntax, and semantics; Understand Python's logic and structure: keywords, instructions, indentation, comments; Introduce literals and variables into code and use different numeral systems: Boolean, integers, floats, scientific notation, strings; binary, octal, decimal, and hexadecimal; variables, naming conventions, PEP-8; Choose operators and data types adequate to the problem: numeric operators (**,*,/,%,//,+,-), string operators (*,+), assignment and shortcut operators, unary and binary operators, priorities and binding, bitwise operators (~,&,^,|,<<,>>), Boolean operators (not, and, or), relational operators, floating-point accuracy, type casting; Perform Input/Output console operations: the print() and input() functions, sep= and end= keyword parameters, int() and float() functions
- Control Flow – Conditional Blocks and Loops (29% of the exam): Make decisions and branch the flow with the if instruction: conditional statements (if, if-else, if-elif, if-elif-else), multiple and nested conditional statements; Perform different types of iterations: pass instruction; while, for, range(), and in; iterating through sequences; while-else and for-else; nesting loops and conditionals; break and continue
- Data Collections – Tuples, Dictionaries, Lists, and Strings (25% of the exam): Collect and process data using lists: vectors, indexing, slicing, len(), list methods (append, insert, index, etc.), sorted(), del, for loops with lists, list comprehensions, copying/cloning, lists in lists; Collect and process data using tuples: indexing, slicing, building, immutability; tuples vs. lists; lists inside tuples and tuples inside lists; Collect and process data using dictionaries: building, indexing, adding/removing keys, iterating, checking key existence, keys(), items(), values() methods; Operate with strings: constructing strings, indexing, slicing, immutability, escaping with \, multi-line strings, basic string functions and methods
- Functions and Exceptions (28% of the exam): Decompose the code using functions: defining and invoking user-defined functions and generators, return keyword, None, recursion; Organize interaction between the function and its environment: parameters vs. arguments, positional/keyword/mixed argument passing, default parameter values, name scopes, name hiding (shadowing), and the global keyword; Python Built-In Exceptions Hierarchy: BaseException, Exception, SystemExit, KeyboardInterrupt, abstract exceptions, ArithmeticError, LookupError, IndexError, KeyError, TypeError, ValueError; Basics of Python Exception Handling: try-except / try-except Exception, ordering except branches, propagating exceptions through function boundaries, delegating responsibility for handling exceptions
Labs
93 labs, 93 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.
What is free
Start free: First module free with an account. Pro: Every course, lab, handbook, practice exam and certificate.
- Pro monthly — $29 a month. Every course, lab, handbook, practice exam and certificate
- Pro yearly — $249 a year. Every course, lab, handbook, practice exam and certificate
Course outline
Start Here
- Thirty Questions, One Sneaky Print (4 labs): You can predict the output of the classic one-line PCEP traps (power, floor division, sep, aliasing, loop else, types) and explain the rule behind each.
- Forty Minutes, Thirty Items: How PCEP Is Run (4 labs): You can describe how PCEP-30-02 is delivered and scored, pace forty minutes across thirty items with checkpoints, and trace only what an item's output needs.
Python Fundamentals
- Interpreter, Compiler, And What Counts As Syntax (6 labs): You can explain compiling versus interpreting and how CPython does both, tell lexis, syntax and semantics apart, and predict whether an error stops a program before it runs.
- Literals, Names And Four Number Bases (4 labs): You can read integer literals in binary, octal, decimal and hex, recognise float, string, Boolean and None literals, and tell legal names from illegal ones and PEP 8 style.
- Operators And Who Binds First (4 labs): You can evaluate expressions by operator priority and binding, including power, unary minus, floor division and modulo with negatives, bitwise operators, shortcut assignment, float accuracy and casts.
- Print, Input And The Casts Between (4 labs): You can predict print output with sep and end, explain why input always returns a string, and apply int, float and str conversions and their failures.
- Fundamentals Sprint (4 labs): You can answer mixed fundamentals items (terms, structure, literals, operators, input and output) at exam pace, and turn your misses into a short list of rules to practise.
Control Flow
- Branching With If, Elif And Else (4 labs): You can trace if, if-else, if-elif and if-elif-else chains, separate ifs and nested ifs, and order overlapping conditions so the right branch wins.
- Conditions The Exam Loves (4 labs): You can classify values as truthy or falsy, predict what and, or and not return, and evaluate chained comparisons and mixed-type equality.
- While, For, Range And The Loop Else (3 labs): You can predict range with one, two or three arguments, trace while and for loops with break, continue and pass, and say when a loop's else clause runs.
- Nested Loops, Traced By Hand (4 labs): You can count the passes of nested loops whose inner range depends on the outer one, sort shuffled loop lines into a working program, and trace break, continue and else in nested loops.
- Control Flow Sprint (4 labs): You can answer mixed if, while, for, range, break, continue and loop-else items at exam pace, using a shortcut for each kind of item.
Data Collections
- Lists: Slices, Methods And Aliases (4 labs): You can index and slice lists with steps, use list methods, del, sorted and comprehensions, and spot aliasing in assignments, plus equals and grids.
- Tuples, And The Comma That Makes Them (3 labs): You can build tuples (including one-item and empty ones), index and slice them, explain what immutability does and does not prevent, and pack, unpack and swap with them.
- Dictionaries: Keys, Values And Items (3 labs): You can build, read, update and delete dictionary entries, iterate over keys, values and items, check key membership, and predict duplicate and equal keys.
- Strings: Escapes, Slices And Methods (4 labs): You can write strings with quotes, escapes, raw and multi-line literals, index and slice them, explain immutability, and predict common string methods.
- Collections Sprint (3 labs): You can answer mixed list, tuple, dictionary and string items at exam pace by asking whether each name refers to the same object or a new one.
Functions And Exceptions
- Functions, Return Values And Recursion (4 labs): You can define and call functions, tell print from return and predict None, write and trace recursion with a base case, and use generator functions with yield.
- Parameters, Arguments And Scope (4 labs): You can match positional, keyword and default arguments, spot illegal headers and calls, trace local and global names, shadowing and the global keyword, and explain shared default values.
- The Exception Family Tree (5 labs): You can place BaseException, Exception, SystemExit, KeyboardInterrupt, ArithmeticError, LookupError and the common built-in exceptions in the hierarchy and say which except clause catches what.
- Try, Except, Else And Finally (3 labs): You can trace try, except, else and finally, order except clauses from specific to general, handle several exceptions in one clause, and follow an exception as it propagates through functions.
- Functions And Exceptions Sprint (3 labs): You can answer mixed function, argument, scope and exception items at exam pace by asking what each function hands back and which handler runs first.
Mock And Review
- Twelve Traps, One Shape Each (5 labs): You can recognise the twelve traps that recur across the four PCEP blocks by their shape and predict each one at exam pace.
- Mock, Review And Exam Day (3 labs): You can sit a timed mock, score it by block weight, review it by marks lost, and plan the week before the exam.