The PCAP-31-03 exam is built from five weighted sections, with Object-Oriented Programming alone worth more raw score than the other four sections combined except one. That single detail changes how most candidates should study: a lot of people preparing for PCAP still study it like an extension of the Official beginner-level PCEP exam, loading up on syntax basics while under-preparing for inheritance, polymorphism, and exception class hierarchies. This practice test is built around the actual scoring weight of each section, not a generic "cover everything equally" approach.
The exam is organized into five sections: Modules and Packages, Exceptions, Strings, Object-Oriented Programming, and Miscellaneous. Here's what each one covers in practice, not just in name:
Modules and Packages. Import syntax variants (import, from...import, import as, import *), the dir() function, sys.path, and how to build your own modules and packages. This section also tests the exact function names and behavior inside the math and random standard library modules, and the platform module's introspection functions like platform(), machine(), and python_version_tuple().
Exceptions. Python's built-in exception hierarchy (where ArithmeticError and LookupError sit relative to Exception and BaseException), raising and handling exceptions with try/except/else/finally, and writing your own exception classes by inheriting from built-in ones.
Strings. String immutability, indexing and slicing edge cases, the full set of built-in string methods (split(), join(), strip(), replace(), find(), and others), and string formatting.
Object-Oriented Programming. Classes, constructors, instance vs. class variables, inheritance and method overriding, super(), polymorphism, encapsulation conventions, and Python's dunder (magic) methods. This is the largest single section on the exam and the one candidates most consistently under-study.
Miscellaneous. A mix that includes generators, closures, lambda functions, list comprehensions, and file I/O, covering modes, predefined streams, and the difference between text and binary handling.
PCAP is not a first Python certification for most candidates. It assumes you can already write a working script, use loops and functions, and read basic error messages. The typical candidate has usually completed the entry-level PCEP certification or an equivalent introductory course (often through the Python Institute's own free "Python Essentials 1 & 2" courses, which are also distributed through Cisco's Networking Academy) and is now trying to prove they can structure multi-module, object-oriented programs rather than just write scripts. This makes PCAP a common target for self-taught developers applying for junior developer roles, computer science students supplementing coursework with an industry credential, and career changers moving into Python from another language who need to demonstrate OOP competence specifically, since that's where the exam concentrates its weight.
PCAP-31-03 is a 65-minute exam made up of 40 questions, with a passing score of 70 percent, delivered through Pearson VUE. A few format specifics catch candidates off guard:
There is no code editor or interpreter available during the exam. Every "predict the output" question has to be worked out by hand, on paper or in your head, which is a very different skill from debugging in an IDE where you can just run the code and see.
Some items are single-choice, some are multiple-choice with more than one correct answer, and some are gap-fill or ordering items rather than plain multiple choice. Missing that a question wants more than one selected answer is a common, avoidable point loss.
Section 4 (Object-Oriented Programming) carries 12 of the 40 items and Section 3 (Strings) carries 8, so time pressure tends to hit hardest on the string-slicing and OOP-tracing questions, which typically take longer to work through by hand than a straightforward "what does this import statement do" question.
Don't run through the practice questions in exam order and call it done. Instead, sort your attempts by section and track your accuracy on OOP and Miscellaneous separately from the rest, since together those two sections determine more than half your raw score. If you're consistently missing OOP questions on inheritance chains or dunder methods, that's worth more remediation time than another pass through import syntax you already know cold. Also time yourself in blocks: since there's no compiler during the exam, practice predicting output on paper first, then check your answer, rather than defaulting to running the code mentally against a REPL you won't have on test day.
The most frequent mistake is treating PCAP like a slightly harder version of PCEP and spreading study time evenly across all five sections. Given the actual scoring weight, that leaves people under-prepared for the section that decides the outcome. The second most common mistake is memorizing that Python has an exception hierarchy without actually knowing which built-in exceptions inherit from which, which shows up directly in questions about except clause ordering. Third, candidates frequently misjudge string slicing behavior at boundary conditions, negative indices, and step values, an area that's easy to think you understand until you're tested on an edge case rather than the textbook example. Finally, a lot of people lose points simply by not reading whether a question is asking for one answer or several, since PCAP mixes single-select and multi-select items without always flagging which is which as clearly as candidates expect. Want to practice for another exam? Try our free CCSP practice exam test.
Build a written reference of Python's built-in exception class tree before you start heavy practice; it comes up repeatedly and is pure recall, not something you can reason out on the fly. Go through the math, random, and platform module documentation and write out the exact function names and what they return, since these are tested as recall items rather than conceptual ones. For OOP, don't just read about inheritance, write small class hierarchies yourself with overridden methods and super() calls, then trace through what happens when you instantiate and call methods on them, since that's the actual skill the exam is testing. For strings, deliberately practice slicing with negative indices and unusual step values until the behavior is automatic rather than something you have to work out each time.
Start with the full practice test below, sectioned to match the PCAP-31-03 syllabus weighting, and review every explanation, not just the questions you got wrong. Since Object-Oriented Programming and Miscellaneous together make up more than half the exam, if your accuracy in those two sections lags behind Modules, Exceptions, and Strings, that's where your remaining prep time should go before you book the exam.
Last updated on Oct, 9 2026
