🐍

Certified Associate in Python Programming · PCAP

One workspace for passing the Python Institute PCAP-31-03 — blueprint-weighted flashcard decks, a full practice exam, and the live in-browser Python coding track for the hands-on reps. Everything authored against the official OpenEDG syllabus.

Start in the coding track Reading guide Programming subject All paths

Time-sensitive — read this first: the current PCAP-31-03 exam is scheduled to retire August 31, 2026. It carries lifetime validity. Its successor PCAP-31-04 is in development (its objectives were not yet public as of July 2026) and will carry 7-year validity. If you want the lifetime-valid 31-03, plan to sit it before the deadline; this workspace targets the 31-03 objectives. Always confirm the current status at pythoninstitute.org before booking.

The honest read: PCAP is a knowledge exam you pass by writing Python, not a hands-on proctored lab. So the coding track is the real practice — the decks and the practice exam lock in the concepts and the output-prediction style the exam loves. OOP is a third of the score; weight your time accordingly.

Deep work · PCAP—total

or log

Certification roadmap

sequence

PCEPCertified Entry-Level Python ProgrammerOptional first

Entry · PCEP-30-0x · multiple-choice

Recommended, not required. Covers the absolute basics (data types, control flow, functions, simple data collections). Skip it if you already write Python comfortably.

PCAPCertified Associate in Python ProgrammingThe goal

Associate · PCAP-31-03 · 40 questions · 65 min · 70% to pass · $295 · lifetime validity

The target of this workspace. Tests real Python: modules/packages, exceptions, strings, OOP (a third of the exam), and comprehensions/lambdas/closures/generators/file I/O. Delivered online-proctored via Pearson VUE (OnVUE) or the OpenEDG Testing Service.

PCPP1 / PCPP2Next steps — ProfessionalAfter PCAP

Professional

PCAP is the stated stepping stone into PCPP1 (advanced OOP, GUI, network, file processing) and then PCPP2. Also a strong signal for any Python-touching SRE/DevOps/data role.

Exam domains — weight your study by these

official weights

Block	Weight	What it covers
1 · Modules & Packages	12%	import variants, the module search path (sys.path), __name__/__main__, public vs private names, packages & __init__.py, and math/random/platform basics.
2 · Exceptions	14%	try/except/else/finally, the exception hierarchy (BaseException → Exception → …), raising & re-raising, assertions, and custom exceptions.
3 · Strings	18%	immutability, ord/chr & code points, indexing/slicing, operators (+, *, in), comparison, and the essential string methods (split/join/strip/find/replace/format).
4 · Object-Oriented Programming	34%	The largest block — classes & objects, instance vs class variables, inheritance & MRO, super(), polymorphism, encapsulation & name mangling, introspection, and special methods.
5 · Miscellaneous	22%	List/dict/set comprehensions, lambdas, map/filter, closures, generators & yield, the iterator protocol, and file I/O (open modes, read/write, with).

Object-Oriented Programming (34%) + Miscellaneous (22%) = over half the exam. 40 questions, 65 minutes, 70% to pass. The decks below carry ~132 cards distributed to match these weights.

Hands-on coding — the real practice

live · do this most

Live Python coding track — 54 problems + teachingPCAP is about writing real Python, so the coding track is your hands-on practice. Write from a blank editor and run it in your browser (real CPython via Pyodide — no install, no AI, no autocomplete). Tiers 0–5 build core fluency (loops → lists → dicts → strings → sorting → parse-compute-output); Tiers 6–10 map straight to the PCAP blueprint — exceptions & custom errors, string methods, classes & OOP (special methods, inheritance, properties, operator overloading), comprehensions & lambdas, and generators, closures & the math module. Each problem has a 'how to approach this', progressive hints, and a verified reference solution. The muscle behind the Exceptions, Strings, OOP, and Miscellaneous blocks.

Flashcard decks — the recall layer

5 decks · 132 cards

Block 4 · Object-Oriented Programming (34%)32 cards — a full third of the exam. Classes vs instances, instance/class variables & shadowing, inheritance, super(), the MRO (which method wins with multiple inheritance), name mangling, isinstance/issubclass, __dict__/__bases__, and special methods. Start here; it's the biggest single scoring block.

The other four blueprint blocks

Block 1 · Modules & Packages (12%)20 cards — the three import forms, sys.path, __name__ == '__main__', __init__.py packages, __pycache__, and math/random/platform (inclusive vs exclusive ranges).Block 2 · Exceptions (14%)22 cards — the full try/except/else/finally, the exception class tree (where ValueError/IndexError/KeyError/ArithmeticError sit), raise vs bare raise, assert, and custom exceptions.Block 3 · Strings (18%)26 cards — immutability, ord/chr, negative indexing & slice steps (s[::-1]), lexicographic comparison, and find vs index / split vs join / strip / replace / the is* checks.Block 5 · Comprehensions, Lambdas, Closures & I/O (22%)32 cards — list/dict/set comprehensions (filter vs conditional expression), lambdas with map/filter/sorted, closures & nonlocal, generators/yield, the iterator protocol, and file modes/with.

Practice exam

live · 150-question pool

PCAP-31-03 — Practice ExamA fresh 40-question draw each attempt (matching the real exam) from a blueprint-weighted 150-question pool, scored at 70% (the real pass mark). Output-prediction and pick-the-true-statement MCQs with worked explanations and a per-block weak-area breakdown. Progress saves in your browser — no login.

Use it to find weak blocks, then close them in the coding track and the matching deck. Hit 70%+ three times to trip the readiness benchmark.

Skill map — where to practice each thing

the workspace

Skill	Practice with	Status
Write & reason about Python from scratch	Live Python coding track — 54 problems	ready
OOP mechanics (classes, inheritance, MRO, special methods)	OOP deck (32) + Tier 8 coding (BankAccount, Stack, __str__/__eq__/__add__, inheritance, properties)	ready
Strings & slicing under time pressure	Strings deck (26) + Tier 7 coding (reverse, anagram, snake→camel, Caesar)	ready
Comprehensions, lambdas, closures, generators	Miscellaneous deck (32) + Tier 9–10 coding (comprehensions, lambdas, fib generator, closures)	ready
Exceptions & the class hierarchy	Exceptions deck (22) + Tier 6 coding (try/except, custom exceptions)	ready
Exam-format recall & weak-area finding	PCAP-31-03 practice exam (draw 40, pass 70%)	ready

A study routine

1.Front-load OOP (34%) and Miscellaneous (22%) — together they're over half the exam. Do the OOP deck, then build a couple of small classes in the coding track to make it stick.
2.Alternate recall and reps: run a deck block, then do coding problems in the same area (strings deck → string coding tier; comprehensions deck → list/dict tier). Recall tells you what; the editor makes it reflex.
3.Learn to PREDICT output. Many PCAP items show a snippet and ask what it prints or which line errors — the practice-exam questions are written in exactly that style.
4.Drill the classic traps: inclusive vs exclusive ranges (randint vs range/slicing), instance-vs-class-variable shadowing, MRO order, generators being single-pass, and 'w' truncating a file.
5.When you can pass the practice exam at 70%+ three times in a row (the readiness benchmark), sit the real one — and mind the retirement date below.

Curated resources — free-first

verified July 2026

Everything you need to LEARN PCAP is free (the official Python Essentials courses + the docs). Only the vendor practice test and the exam voucher cost money. Every link checked live (July 2026); prices/versions shift, so treat costs as “as seen.” Full sourced list: docs/PCAP_RESOURCES.md.