Python PCAP exam: every syllabus topic as a checklist, weighted by exam share
The PCAP (Certified Associate Python Programmer) exam is 40 questions in 65 minutes, and you pass at 70%. The Python Institute publishes how those 40 questions split across five syllabus blocks, and the split is far from even: object-oriented programming alone is 34% of the exam, modules and packages only 12%. This article turns that published split into a study checklist: what each block is worth, what one question in it is worth, how many hours to give it, and the order to tick it off in. Figures were read from the Python Institute pages on 29 October 2026.
One date matters before you start. The current exam is PCAP-31-03, whose syllabus was last updated on 7 March 2022. The Python Institute lists PCAP-31-04 as "Pending Release", scheduled for 31 October 2026, and calls it a routine version update; on 29 October its syllabus was not yet published. Everything below is for 31-03. If your booking says 31-04, compare its objective list with the one here and edit the checklist to match.
The exam in numbers
| Fact | PCAP-31-03 |
|---|---|
| Questions | 40 (single- and multiple-select, interactive and scenario items) |
| Time | 65 minutes, plus 10 minutes for the NDA and tutorial |
| Pass mark | 70%, as a cumulative average across all blocks (no per-block minimum) |
| Price | Exam from $295; exam + retake from $345; exam + retake + practice test from $359; practice test alone $49 |
| Retake (bundle) | After a minimum 7-day wait, within 90 days of the failed attempt (TestNow voucher terms) |
| Voucher | Valid 12 months from purchase |
| Where | Pearson VUE test centres or OnVUE online, or OpenEDG TestNow |
| Credential | Valid 5 years; PCEP is recommended first but not required |
| Free course | Python Essentials 2 (Edube or Cisco Networking Academy) is aligned to the exam |
Every block, its weight and what one question is worth
The syllabus gives each block a number of items and a weight. The weights don't follow the item counts exactly: block 1 has six items but only 12% of the score, block 2 has five items and 14%. If every item inside a block counts the same (the Institute doesn't publish per-item scoring, so this is our assumption), one exceptions question is worth 2.8 points out of 100 and one modules question 2.0. An exceptions question is worth nearly as much as an OOP question.
| Block | Items | Weight | Points per item | Time if paced by items |
|---|---|---|---|---|
| 1. Modules and packages | 6 | 12% | 2.00 | 9.8 min |
| 2. Exceptions | 5 | 14% | 2.80 | 8.1 min |
| 3. Strings | 8 | 18% | 2.25 | 13.0 min |
| 4. Object-oriented programming | 12 | 34% | 2.83 | 19.5 min |
| 5. Comprehensions, lambdas, closures, I/O | 9 | 22% | 2.44 | 14.6 min |
| Total | 40 | 100% | 2.50 average | 65 min |
Pace: 65 minutes over 40 items is 97.5 seconds a question. The last column is that pace times the block's item count, which is a fair budget for a timed mock.
What happens if you skip a block
Because the pass mark is a cumulative 70, you can in theory leave a weak block for last. The table shows the best score you could reach with a block left blank, and how well you would then have to do on everything else. OOP can't be skipped at all: without it the ceiling is 66, under the pass mark. Even dropping the smallest block means getting about four in five of the rest right.
| Block left blank | Highest possible score | Needed on the other blocks to reach 70 |
|---|---|---|
| 1. Modules and packages (12) | 88 | 79.5% (70 / 88) |
| 2. Exceptions (14) | 86 | 81.4% (70 / 86) |
| 3. Strings (18) | 82 | 85.4% (70 / 82) |
| 5. Comprehensions, lambdas, closures, I/O (22) | 78 | 89.7% (70 / 78) |
| 4. Object-oriented programming (34) | 66 | not possible |
The lesson for the checklist: every block gets real hours, and OOP gets the most.
Hours to budget: a 40-hour plan
The Python Institute doesn't publish study hours for PCAP, so this is our own plan for someone who already knows basic Python (PCEP level: variables, loops, functions, lists and dicts). It sets 30 hours for the syllabus, split by exam weight (0.3 hours per point), and 10 hours for timed practice, review and booking. At 10 hours a week it is four weeks. Cut it down if you write Python every day; add a week for each block that is new to you.
| Block | Weight | Weight x 30 h | Hours in the plan |
|---|---|---|---|
| 1. Modules and packages | 12% | 3.6 h | 3.5 h |
| 2. Exceptions | 14% | 4.2 h | 4 h |
| 3. Strings | 18% | 5.4 h | 5.5 h |
| 4. Object-oriented programming | 34% | 10.2 h | 10.5 h |
| 5. Comprehensions, lambdas, closures, I/O | 22% | 6.6 h | 6.5 h |
| Version check | - | - | 1 h |
| Timed mocks, review and booking | - | - | 9 h |
| Total | 100% | 30 h | 40 h |
Week 1 (10 h): version check, block 1, block 3.
Week 2 (10.5 h): block 4.
Week 3 (10.5 h): block 2, block 5.
Week 4 (9 h): two timed mocks, review every miss, re-study the weakest block, book the exam.
Why this tick-off order and not 1 to 5
The syllabus numbers the blocks 1 to 5, but they don't build on each other in that order. We tick them off as 1, 3, 4, 2, 5:
Modules first (1): short, mostly knowing what math, random and platform give you, and it covers imports, which every later block uses.
Strings next (3): methods and slicing are mechanical, and they turn up inside OOP and I/O questions too.
OOP in the middle (4): the biggest block, while you are fresh.
Exceptions after OOP (2): objective 2.2 asks you to write your own exception classes inside the existing hierarchy, which is inheritance from block 4; exceptions are classes, and an except branch catches subclasses too.
Block 5 last: file I/O raises exceptions (errno values), so it reads better once block 2 is done; closures and lambdas are short.
The checklist: every objective, in order
This is every objective of the PCAP-31-03 syllabus with the hours from the plan. Each line is an item in our PCAP exam study plan checklist, linked to the free page in the official Python documentation that covers it.
| Tick | Objective | What the syllabus lists | Hours |
|---|---|---|---|
| 0 | Before you start | Check your exam version (31-03, or 31-04 from 31 Oct 2026) and its syllabus | 1 |
| 1.1 | Import modules and packages | import, from ... import, import as, import *, nested qualification, dir(), sys.path | 1 |
| 1.2 | Math evaluations | ceil(), floor(), trunc(), factorial(), hypot(), sqrt() | 0.5 |
| 1.3 | Random values | random(), seed(), choice(), sample() | 0.5 |
| 1.4 | Host platform | platform(), machine(), processor(), system(), version(), python_implementation(), python_version_tuple() | 0.5 |
| 1.5 | Your own modules and packages | __pycache__, __name__, public vs private names, __init__.py, search path, nested packages vs directory trees | 1 |
| 3.1 | Character representation | ASCII, Unicode, UTF-8, code points, escape sequences | 1 |
| 3.2 | String operations | ord(), chr(), indexing, slicing, immutability, iteration, concatenation, repetition, comparison, in / not in | 2 |
| 3.3 | String methods | isxxx(), join(), split(), strip(), index(), find(), rfind(), sorted() on strings | 2.5 |
| 4.1 | The OOP approach | class, object, property, method, encapsulation, inheritance, superclass, subclass | 1 |
| 4.2 | Class and object properties | instance vs class variables, __dict__ of objects and classes, private components, name mangling | 2 |
| 4.3 | Methods | declaring and using methods, the self parameter | 1 |
| 4.4 | Class structure | introspection, hasattr() on objects and classes, __name__, __module__, __bases__ | 1.5 |
| 4.5 | Inheritance | single and multiple inheritance, isinstance(), overriding, is / is not, polymorphism, __str__(), the diamond problem | 3.5 |
| 4.6 | Construction | declaring and invoking constructors | 1.5 |
| 2.1 | Python-defined exceptions | try/except and branch order, except as, grouped exceptions, the hierarchy, raise, raise ex, assert, args, else, finally | 3 |
| 2.2 | Self-defined exceptions | your own exception classes placed in the existing hierarchy | 1 |
| 5.1 | List comprehensions | if conditions, nested comprehensions | 1 |
| 5.2 | Lambdas | defining lambdas, functions that take them, map(), filter() | 1.5 |
| 5.3 | Closures | what a closure is, why, defining and using one | 1 |
| 5.4 | I/O terms | modes, predefined streams, handles vs streams, text vs binary | 1 |
| 5.5 | I/O operations | open(), errno values, close(), read(), write(), readline(), readlines(), bytearray as a buffer | 2 |
| M1 | Timed mock 1 | 40 questions in 65 minutes | 1.5 |
| M2 | Mark every miss | write the objective number next to each wrong answer | 2 |
| M3 | Re-study the weakest block | pick it by points lost (misses x points per item), not by count | 3 |
| M4 | Timed mock 2 | aim for 80% or more before you book | 1.5 |
| M5 | Book the exam | for OnVUE, run the system test on the same computer and room | 1 |
A worked M3 example: in a mock you miss 2 OOP questions and 3 strings questions. By count and by points strings lose more here: 3 x 2.25 = 6.75 against 2 x 2.83 = 5.7. Now say you miss 4 module questions and 3 exceptions questions: 4 x 2.00 = 8.0 against 3 x 2.80 = 8.4. Fewer misses, more points lost, so exceptions come first.
Is the retake bundle worth $50?
Exam only is $295; exam with one retake is $345. Without the bundle, a fail means buying another exam at $295. The extra $50 pays for itself if your chance of failing the first attempt is above 50 / 295 = 17%. If your mocks are under 80%, buy the bundle; if you score 85% or more on two timed mocks, the plain voucher is the better bet. The retake opens after at least 7 days and must be used within 90 days of the failed attempt.
Using the checklist
Open the PCAP exam study plan, press Start, and tick objectives off as you finish them. Leave out the ones you already know, add your own lines ("redo the 4.5 diamond questions"), or change hours to fit your weeks. If you study with a group or a class, add people and each person sees the same list. If you are not at PCAP level yet, our Python developer study plan goes from first script to a packaged project, also on the free docs.
Why tick at all rather than read the syllabus once? Short, specific items that get ticked are what the hospital checklist studies found worked; we went through what they measured in Do checklists work?
Start the PCAP-31-03 study plan: 21 syllabus objectives, block weights and a 40-hour budget, ready to tick and change.
Open the PCAP study checklistSources
Python Institute, PCAP – Certified Associate Python Programmer: exam information (40 items, 65 minutes, 70%, prices, PCAP-31-04 pending release on 31 October 2026), read 29 October 2026. pythoninstitute.org/pcap
Python Institute, PCAP-31-03 exam syllabus (items and weight per section, every objective; last updated 7 March 2022), read 29 October 2026. pythoninstitute.org/pcap-exam-syllabus
OpenEDG Edube store, PCAP exam + retake (TestNow) voucher terms: $345, 7-day minimum wait, retake within 90 days, voucher valid 12 months, read 29 October 2026. ums.edube.org
Python 3 documentation (links in the checklist). docs.python.org
Points per item, skip-a-block ceilings, the 40-hour split and the retake break-even are our own calculations from the figures above.