PCAP™ – Certified Associate in Python Programming: EXAM SYLLABUS
Exam: PCAP-31-03
Status: ACTIVE
The PCAP-31-03 exam consists of single-select, multiple-select, coding, scenario-based, and interactive items that assess a candidate’s ability to design, write, and debug multi-module Python programs and apply core object-oriented programming techniques. The exam evaluates practical knowledge of modules and packages, exceptions, string processing, OOP, list comprehensions, lambdas, closures, and file I/O.
Each item is worth a maximum of 40 points. After completion, the candidate’s raw score is normalized and presented as a percentage.
The exam is divided into five sections, each reflecting key areas of Python programming. The weight of each section indicates its importance in the overall exam.
The table below summarizes the distribution of exam items and their corresponding weight within the total exam.
| Section | Section Name | Number of Items | Weight |
|---|---|---|---|
| 1 | Modules and Packages | 6 | 12% |
| 2 | Exceptions | 5 | 14% |
| 3 | Strings | 8 | 18% |
| 4 | Object-Oriented Programming | 12 | 34% |
| 5 | Miscellaneous (List Comprehensions, Lambdas, Closures, I/O) | 9 | 22% |
| 40 | 100% |
Exam Syllabus
Last updated: March 7, 2022
Aligned with Exam PCAP-31-03
Exam Syllabus Contents
- Section 1: Modules and Packages
- Section 2: Exceptions
- Section 3: Strings
- Section 4: Object-Oriented Programming
- Section 5: Miscellaneous (List Comprehensions, Lambdas, Closures, I/O)
Section 1: Modules and Packages
Objectives covered by the section → 6 exam items
PCAP-31-03 1.1 – Import and use modules and packages
- import variants: import, from … import, import as, from … import *
- advanced qualifying for nested modules
- the dir() function
- the sys.path variable
PCAP-31-03 1.2 – Perform evaluations using the math module
- functions: ceil(), floor(), trunc(), factorial(), hypot(), sqrt()
PCAP-31-03 1.3 – Generate random values using the random module
- functions: random(), seed(), choice(), sample()
PCAP-31-03 1.4 – Discover host platform properties using the platform module
- functions: platform(), machine(), processor(), system(), version(), python_implementation(), python_version_tuple()
PCAP-31-03 1.5 – Create and use user-defined modules and packages
- idea and rationale
- the __pycache__ directory
- the __name__ variable
- public and private variables
- the __init__.py file
- searching for/through modules/packages
- nested packages vs. directory trees
Section 2: Exceptions
Objectives covered by the section → 5 exam items
PCAP-31-03 2.1 – Handle errors using Python-defined exceptions
- try / except, ordering except branches, except … as, grouped exceptions
- the hierarchy of exceptions
- raise, raise ex; assert
- exception classes and the args property
- else and finally in exception handling
PCAP-31-03 2.2 – Extend the exceptions hierarchy with self-defined exceptions
- defining custom exceptions
- using and integrating custom exceptions into existing hierarchies
Section 3: Strings
Objectives covered by the section → 8 exam items
PCAP-31-03 3.1 – Understand machine representation of characters
- encoding standards: ASCII, Unicode, UTF-8; code points; escape sequences
PCAP-31-03 3.2 – Operate on strings
- functions: ord(), chr()
- indexing, slicing, immutability
- iteration, concatenation, repetition, comparisons
- membership operators: in, not in
PCAP-31-03 3.3 – Employ built-in string methods
- methods: .isxxx(), .join(), .split(), .strip(), .index(), .find(), .rfind()
- functions: sorted() (ordering strings)
Section 4: Object-Oriented Programming
Objectives covered by the section → 12 exam items
PCAP-31-03 4.1 – Understand the object-oriented approach
- class, object, property, method, encapsulation, inheritance, superclass/subclass
- identifying class components
PCAP-31-03 4.2 – Employ class and object properties
- instance vs. class variables (declaration/initialization)
- the __dict__ property (objects vs. classes)
- private components (instances vs. classes) and name mangling
PCAP-31-03 4.3 – Equip a class with methods
- declaring and using methods
- the self parameter
PCAP-31-03 4.4 – Discover the class structure
- introspection and hasattr() (objects vs. classes)
- properties: __name__, __module__, __bases__
PCAP-31-03 4.5 – Build a class hierarchy using inheritance
- single and multiple inheritance
- functions/operators: isinstance(), overriding, is / is not
- polymorphism, overriding __str__(), diamond problems
PCAP-31-03 4.6 – Construct and initialize objects
- declaring and invoking constructors
Section 5: Miscellaneous (List Comprehensions, Lambdas, Closures, I/O)
Objectives covered by the section → 9 exam items
PCAP-31-03 5.1 – Build complex lists using list comprehensions
- conditions with if; nested comprehensions
PCAP-31-03 5.2 – Embed lambda functions into code
- defining and using lambdas
- user-defined functions taking lambdas as arguments
- functions: map(), filter()
PCAP-31-03 5.3 – Define and use closures
- meaning and rationale; defining and using closures
PCAP-31-03 5.4 – Understand basic input/output terminology
- I/O modes; predefined streams; handles vs. streams; text vs. binary modes
PCAP-31-03 5.5 – Perform input/output operations
- open(); errno and its values
- functions/methods: close(), .read(), .write(), .readline(), readlines()
- using bytearray as an input/output buffer
Download PCAP-31-03 Exam Syllabus in PDF
MQC Profile
The Minimally Qualified Candidate (MQC) for the PCAP™ certification can design, develop, and improve multi-module Python applications; analyze and model real-life problems in object-oriented categories; and apply Python’s modules, exceptions, strings, and file I/O to implement correct and maintainable solutions. They can structure programs into packages and modules, use standard libraries effectively, write and test classes with appropriate use of properties and methods, and handle exceptions to ensure robust behavior.
Section 1: Modules and Packages
The MQC can import, qualify, and organize code into reusable modules and packages; configure search paths; and use standard-library modules such as math, random, and platform.
Section 2: Exceptions
The MQC understands the built-in exception hierarchy, can handle, raise, and propagate exceptions appropriately, and can define simple custom exceptions to model domain-specific error conditions.
Section 3: Strings
The MQC can represent, transform, and analyze text using slicing, iteration, membership, and key string methods (.split(), .join(), .strip(), .find(), etc.).
Section 4: Object-Oriented Programming
The MQC can define classes, create objects, use instance and class variables, implement methods (including constructors), apply inheritance and polymorphism, and leverage introspection where appropriate.
Section 5: Miscellaneous
The MQC can employ list comprehensions, lambdas, and closures to write concise code, and can perform basic file I/O in text and binary modes, including buffered operations with bytearray.
Passing Requirement
To pass the PCAP exam, a candidate must achieve a cumulative average score of at least 70% across all exam blocks.