Concepts·Certified Entry-Level Python Programmer

PCEP and PCAP Exam Format and Objectives

PCEP and PCAP are sold as a ladder, and most study plans treat them as one exam split across two sittings. They are not. PCEP is 30 questions on syntax, control flow, four collection types and the shape of a function; PCAP is 40 questions of which more than a third are object-oriented programming, a subject PCEP never raises. This is what each one publishes, what each section is worth, and why the question format matters as much as the content.

Start Here Guide 1 of 26 Beginner

OSUbuntu 26.04 LTS
Python3.14.4
pip25.1.1
TimeAbout 12 min

The current exams are PCEP-30-02 and PCAP-31-03. Both are examined on Python 3, and neither pins a minor release - which is exactly the problem guide 3 deals with, because the interpreter has moved on since the blueprints were written.

One machine, and nothing on it but an interpreter. Both exams test the language, so there is no cluster, no service and no second host anywhere in this path.
Server Name	IP Address	OS	Roles	CPU	RAM	HDD
RUNNER01	192.168.0.27	Ubuntu 26.04 LTS	Python 3.14.4 - the only machine this path needs	2 Core	4 GB	50 GB

This guide includes

Use this before booking either exam. This matters because PCEP and PCAP are sold as a ladder and most plans treat them as one syllabus - the blueprints overlap heavily, and the three real differences are what should decide your revision.

reading both exams in numbers, side by side
finding where PCEP's marks actually sit across its four blocks
finding the PCAP section that is a third of the exam on its own
identifying the overlap, and the three real differences
seeing what both exams do with slicing, and how this path is ordered

Before you start

No prior Python is assumed.
Nothing in this guide changes anything - it is orientation.

The two exams in numbers
PCEP-30-02 PCAP-31-03
Questions 30 40
Time 40 min (+5 NDA/tutorial) 65 min (+5 NDA/tutorial)
Pass mark 70% 70%
Sections 4 5
Objectives 15 21
Prerequisite none none

Neither exam requires the other. PCAP is *not* gated on holding PCEP, and you may sit it first - the ladder is a recommendation, not a rule.

Percentages are easy to feel relaxed about, so here is what 70% costs in answers you actually have to get right. This is also the first code in the path, and it uses the pattern every later sample uses: write a file, run the file.
bash Example session
```
$cat > ~/py/passmark.py <<'PY'for total in (30, 40):    need = -(-total * 70 // 100)    print(total, "questions:", need, "correct to pass,", total - need, "wrong allowed")PY$python3 ~/py/passmark.py30 questions: 21 correct to pass, 9 wrong allowed40 questions: 28 correct to pass, 12 wrong allowed
```
Note
Nine wrong across the whole of PCEP, twelve across PCAP. Both are tight enough that a single weak section sinks the attempt, which is why the weights in the next two steps are worth reading before you pick a starting point. The -(-total * 70 // 100) in that script is a ceiling division - the standard Python idiom for rounding *up* with integers, and a genuine PCEP objective 1.4 trick worth recognising.

Expected result21 of 30 on PCEP, 28 of 40 on PCAP.

Success conditionYou know what passing costs in raw answers rather than in percentages.

	PCEP-30-02	PCAP-31-03
Questions	30	40
Time	40 min (+5 NDA/tutorial)	65 min (+5 NDA/tutorial)
Pass mark	70%	70%
Sections	4	5
Objectives	15	21
Prerequisite	none	none

PCEP: four blocks, and where the marks are

Block	Weight	Objectives
1. Computer Programming and Python Fundamentals	18%	5
2. Control Flow - Conditional Blocks and Loops	29%	2
3. Data Collections - Tuples, Dictionaries, Lists and Strings	25%	4
4. Functions and Exceptions	28%	4

Read the objective counts against the weights and one thing jumps out: block 2 is 29% of the exam across just two objectives. Those two are if and "perform different types of iterations", which means roughly nine questions of a 30-question exam come out of if/elif/else, while, for, break, continue and the loop else. It is the single densest area in either blueprint.

Block 1 looks like the easy one and is where careless marks go: numeral systems, operator precedence and integer-versus-float division are all in there, and all three are asked as "what does this print?".

Here is one, in the exact shape PCEP uses it. Work out your answer before you play the terminal.

bash Example session

$cat > ~/py/q1.py <<'PY'x = -7print(x // 2)print(x % 2)print(x / 2)PY$python3 ~/py/q1.py-41-3.5

Expected result-4, then 1, then -3.5.

Success conditionIf -7 // 2 surprised you, block 1 is not the free section.

PCAP: five sections, and one of them is a third of the exam
Section Weight Objectives
1. Modules and Packages 12% 5
2. Exceptions 14% 2
3. Strings 18% 3
4. Object-Oriented Programming 34% 6
5. Miscellaneous - List Comprehensions, Lambdas, Closures, I/O 22% 5

Section 4 is 34% on its own - about fourteen of the forty questions - and PCEP does not contain the word "class" anywhere in its blueprint. That is the real gap between the two exams, and it is why this path gives OOP seven guides rather than one.

Section 5 is the other thing PCEP never touches: comprehensions, lambdas, closures and file I/O, 22% between them.

A section 4 question, in its usual disguise. Again: decide your answer first.
bash Example session
```
$cat > ~/py/q3.py <<'PY'class A:    tally = []     def add(self, v):        self.tally.append(v) a = A()b = A()a.add(1)b.add(2)print(a.tally, b.tally, A.tally)PY$python3 ~/py/q3.py[1, 2] [1, 2] [1, 2]
```
Note
tally is a class variable, not an instance variable. self.tally.append(v) does not create anything on the instance - it finds the class attribute through the instance and mutates it in place, so both objects and the class itself see the same list. This is objective 4.2 and it is asked in some form on almost every attempt. guide 15 is the guide for it.

Expected result[1, 2] [1, 2] [1, 2] - one list, shared by every instance.

Success conditionYou have seen the class-variable trap that PCAP's largest section is built on.

Section	Weight	Objectives
1. Modules and Packages	12%	5
2. Exceptions	14%	2
3. Strings	18%	3
4. Object-Oriented Programming	34%	6
5. Miscellaneous - List Comprehensions, Lambdas, Closures, I/O	22%	5

The overlap, and the three real differences

The two blueprints share more than the section titles suggest. Both cover exceptions; both cover strings. What differs is depth.

Subject	PCEP	PCAP
Exceptions	the built-in hierarchy, `try`/`except` ordering	plus `raise`, `assert`, `finally`, exception objects, and your own subclasses
Strings	indexing, slicing, immutability, basic methods	plus code points, encodings, `ord`/`chr`, and a named method list
Functions	defining, calling, parameters, scope, recursion	plus lambdas, closures and comprehensions
Classes	not examined	34% of the exam
Modules	not examined	12%, including writing your own package
File I/O	not examined	part of the 22% miscellaneous section

The three sections in that table PCEP never examines add up to a number worth seeing rather than estimating:

bash Example session

$cat > ~/py/gap.py <<'PY'pcap = {"modules": 12, "exceptions": 14, "strings": 18, "oop": 34, "misc": 22}absent_from_pcep = ("modules", "oop", "misc")print("total:", sum(pcap.values()), "percent")print("never examined by PCEP:", sum(pcap[k] for k in absent_from_pcep), "percent")PY$python3 ~/py/gap.pytotal: 100 percentnever examined by PCEP: 68 percent

Expected resultThe five weights total 100, and the three PCEP never touches total 68.

Success conditionYou can state exactly how much of PCAP is new material.

What both exams do to slicing
One more shared subject, because it is asked on both and the answers are counter-intuitive in the same way -7 // 2 is. PCEP objective 3.4 and PCAP section 3 both live here.

Three slices of the same six-character string. One of them prints nothing at all, and it is not an error.
bash Example session
```
$cat > ~/py/q2.py <<'PY's = "abcdef"print(s[::-2])print(s[1:4])print(s[4:1])PY$python3 ~/py/q2.pyfdbbcd
```
Note
s[::-2] starts at the end and steps back two, so abcdef gives f, d, b. s[4:1] asks for a forward slice from a higher index to a lower one, which is not an error - it is an empty string, printed as a blank line. Slicing never raises IndexError; only single-element indexing does. Both facts are examinable and both are usually got wrong the first time. guide 13 is where the rules are set out properly.

Expected resultfdb, then bcd, then an empty line.

Success conditionA negative step and a backwards range both behaved, and neither raised.

How this path is ordered

The tracks follow a reader's arc rather than the blueprint order, because the blueprints are not teachable in the sequence they are published in - PCAP section 1 (modules) needs functions, which is a PCEP subject.

Track	Serves	Why here
Start Here	both	this track
Language Fundamentals	PCEP	block 1, plus the operator rules PCAP assumes
Control Flow	PCEP	block 2 - the densest 29% in either exam
Data Collections	PCEP	block 3, and the foundation of PCAP's strings section
Functions and Scope	PCEP	block 4, and a prerequisite for every PCAP section
Exceptions	both	PCEP block 4 then PCAP section 2, in one arc
Modules and Packages	PCAP	section 1
Strings in Depth	PCAP	section 3
Object-Oriented Python	PCAP	section 4, the 34%
Comprehensions and Lambdas	PCAP	section 5 - comprehensions, lambdas, closures
Files and Streams	PCAP	the rest of section 5
Exam Craft	both	question formats and the traps both exams set
Command Cheat Sheets	both	one page per exam, for the last week

If you are sitting PCEP only, the first five tracks plus Exam Craft are the whole syllabus. If you are sitting PCAP, everything from Exceptions onwards is new material and the first five tracks are the assumed background - skim them, do not skip them, because PCAP asks about operator precedence and slicing too.

guide 2 is next, and it is short: there is one machine and nothing to install on it.

bash Example session

$python3 --versionPython 3.14.4$cat /etc/os-release | head -2PRETTY_NAME="Ubuntu 26.04 LTS"NAME="Ubuntu"

Expected resultPython 3.14.4 on Ubuntu 26.04 - the interpreter every output in this path came from.

Success conditionYou know which track you start on and what runs the code.

Troubleshooting

Studying one set of notes for both exams.

Why: PCEP and PCAP are marketed as a ladder, so the material reads as continuous.

Fix:68% of PCAP - classes, modules and file I/O - is absent from PCEP entirely, and the shared 32% is examined more deeply. Treat them as two syllabi that overlap, not one split in half.
Practising by writing programs, and still failing questions.

Why: Neither exam asks you to write code. Every question is code you read.

Fix:Practise predicting output before running it. Every code sample in this path is presented that way for exactly this reason - decide the answer, then play the terminal.
Planning to eliminate wrong answers on hard questions.

Why: Assuming multiple choice throughout.

Fix:Both exams use drag-and-drop, gap fill and code insertion as well. There is nothing to eliminate in those. See guide 25.
Told you must hold PCEP before booking PCAP.

Why: The certification ladder is presented as a sequence on the vendor's site.

Fix:There is no prerequisite. PCAP can be sat first. The recommendation is pedagogical, not a booking restriction.

Official sources

← All PCEP guides

PCEP and PCAP Exam Format and Objectives

This guide includes

Before you start

The two exams in numbers

PCEP: four blocks, and where the marks are

PCAP: five sections, and one of them is a third of the exam

The overlap, and the three real differences

What both exams do to slicing

How this path is ordered

Troubleshooting

Official sources