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.

PCAP-31-03 badge

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

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.