PCEP and PCAP Exam Format and Objectives

Start Here / Guide 1 of 26 / Beginner

• Python3.14.4
• OSUbuntu 26.04 LTS
• pip25.1.1
• TimeAbout 12 min
• Reviewed23 August 2026

Written against the versions above. 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:python-314-versus-the-syllabus}} deals with, because the interpreter has moved on since the blueprints were written.

Before you start

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

1. 1

   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.

   $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

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

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

2. 2

   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.

   $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.

3. 3

   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.

   $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]

   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.

4. 4

   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:

   $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.

5. 5

   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.

   $cat > ~/py/q2.py <<'PY's = "abcdef"print(s[::-2])print(s[1:4])print(s[4:1])PY$python3 ~/py/q2.pyfdbbcd

   Expected resultfdb, then bcd, then an empty line.

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

6. 6

   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.

   $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

• Python Institute - PCEP-30-02 exam and syllabus
• Python Institute - PCAP-31-03 exam and syllabus
• Python documentation - The Python Tutorial