Python Institute · Associate-Level Certification

PCAP™ – Certified Associate Python Programmer: Exam Syllabus

The assessment scope for PCAP-31-04. Explore six weighted sections, from Python modules and packages to object-oriented programming, testing, collaboration, and AI-assisted development.

PCAP-31-04 General-Purpose-Programming Revised November 2, 2026
View Exam Syllabus About PCAP Certification

Looking for PCAP-31-03? Explore the PCAP-31-03 exam syllabus.

PCAP certification badge PCAP™ Certification Associate-level Python programming
PCAP-31-04 Exam code
Associate Certification level
42 Questions
65 min Exam duration
72% Passing score
5 years Validity
About the exam

About PCAP-31-04

The PCAP™ – Certified Associate Python Programmer certification assesses the knowledge and practical skills needed to organize, create, analyze, test, debug, and maintain intermediate Python programs.

The examination builds on entry-level Python programming knowledge and focuses on modules and packages, exception handling, string processing, object-oriented programming, advanced language constructs, file and filesystem operations, testing, debugging, collaborative workflows, and responsible use of AI-assisted programming tools.

There are 42 questions across six sections. The exam emphasizes practical code analysis and application of Python programming techniques.

Exam structure

Exam Sections and Weighting

The table shows the planned distribution of questions and the relative importance of each section.

Section Section name Questions Weight
01 Modules and Packages 5
12%
02 Exceptions 5
12%
03 Strings 4
9.5%
04 Object-Oriented Programming 12
28.5%
05 Advanced Python Constructs and I/O 10
24%
06 Testing, Debugging, Collaborative Development, and AI Assistance 6
14%
Total 42 100%
Full exam syllabus

PCAP-31-04 Exam Syllabus

Blueprint version 1.5 · Last revised November 2, 2026 · 42 objectives across six sections

View the complete PCAP-31-04 syllabus Expand to see all six sections and their assessment requirements
Section 01

Modules and Packages

12% 5 questions · 5 objectives

1.1 Import and Use Modules and Packages

Objective 1.1.1 Apply module import statements and namespace rules (1 item)
  1. Use the import statement to load a module.
  2. Use from ... import to import selected objects from a module.
  3. Create aliases using import ... as and from ... import ... as.
  4. Explain the effects and risks of wildcard imports using from ... import *.
  5. Distinguish between module names, imported object names, and aliases in the current namespace.
  6. Use fully qualified names to access objects stored in nested modules and packages.
  7. Recognize name collisions caused by importing objects with identical names from different modules.
Objective 1.1.2 Inspect module contents and resolve module search paths (1 item)
  1. Use the dir() function to inspect names available in a module or other object.
  2. Interpret the list of attributes, functions, classes, and other names returned by dir().
  3. Explain how Python searches for a module during an import operation.
  4. Inspect the module search path using the sys.path variable.
  5. Explain how the current directory, standard library, installed packages, and configured paths affect module discovery.
  6. Modify sys.path for the current process when a valid use case requires an additional module location.
  7. Recognize import failures caused by incorrect module names, package structures, or search paths.

1.2 User-Defined Modules and Packages

Objective 1.2.1 Create and use user-defined modules (1 item)
  1. Create reusable modules containing functions, classes, constants, and other objects.
  2. Import and use objects defined in a user-created module.
  3. Use __name__ and the if __name__ == "__main__": pattern appropriately.
  4. Explain the purpose of the __pycache__ directory and compiled bytecode files.
  5. Recognize basic module naming conflicts and circular import problems.
Objective 1.2.2 Create and organize Python packages (1 item)
  1. Explain why related modules are grouped into packages.
  2. Create regular and nested packages using an appropriate directory structure.
  3. Explain the role of the __init__.py file.
  4. Import modules and objects from packages using qualified names.
  5. Recognize package import errors caused by incorrect structure or qualification.

1.3 External Package Management

Objective 1.3.1 Manage external packages and project dependencies (1 item)
  1. Explain the purpose of PyPI and distinguish external packages from standard-library and local modules.
  2. Install, list, and remove packages using pip and python -m pip.
  3. Record dependencies and version requirements in requirements.txt.
  4. Install project dependencies from a requirements file and explain how this supports reproducible environments.
Back to syllabus contents ↑
Section 02

Exceptions

12% 5 questions · 5 objectives

2.1 Advanced Exception Handling

Objective 2.1.1 Handle exception types and inspect exception objects (1 item)
  1. Order except branches from more specific to more general exception classes.
  2. Handle multiple exception types in a single except branch using a tuple.
  3. Capture an exception object using except ... as.
  4. Access information provided by a captured exception object.
  5. Analyze which except branch handles a given exception.
Objective 2.1.2 Control exception-handling flow with else and finally (1 item)
  1. Use else to execute code when the try block completes successfully.
  2. Use finally to execute code regardless of whether an exception occurs.
  3. Distinguish between the roles of try, except, else, and finally.
  4. Combine try, except, else, and finally in a structured exception-handling statement.
  5. Trace exception-handling flow for handled and unhandled exceptions.
Objective 2.1.3 Analyze Python’s exception hierarchy and exception objects (1 item)
  1. Explain how exception classes are organized through inheritance.
  2. Distinguish between BaseException, Exception, and selected subclasses.
  3. Explain how superclass handlers can catch subclass exceptions.
  4. Inspect exception information using the args property.
Objective 2.1.4 Raise and propagate exceptions (1 item)
  1. Raise an exception explicitly using raise.
  2. Re-raise the currently handled exception using a bare raise statement.
  3. Distinguish between re-raising an exception and explicitly raising a captured exception.
  4. Explain how unhandled exceptions propagate through function calls.
  5. Trace exception propagation across multiple function boundaries.

2.2 User-Defined Exceptions

Objective 2.2.1 Define and integrate custom exception classes (1 item)
  1. Define custom exceptions by inheriting from Exception or another appropriate class.
  2. Raise and handle custom exceptions for application-specific conditions.
  3. Initialize custom exceptions with useful explanatory information.
  4. Organize related custom exceptions into an inheritance hierarchy.
Back to syllabus contents ↑
Section 03

Strings

9.5% 4 questions · 4 objectives

3.1 Character Encoding and Text Representation

Objective 3.1.1 Work with character encoding and Unicode code points (1 item)
  1. Describe the purpose and limitations of ASCII, the role of Unicode, and how UTF-8 represents code points using a variable number of bytes.
  2. Distinguish between Python str objects and binary data represented by bytes.
  3. Use ord() and chr() to convert between characters and Unicode code points.

3.2 String Analysis, Validation, and Search

Objective 3.2.1 Analyze string immutability and comparison behavior (1 item)
  1. Explain how string immutability affects assignment, slicing, concatenation, repetition, and method calls.
  2. Trace expressions that create new string objects from existing string values.
  3. Compare strings using equality and relational operators.
  4. Explain how Unicode code points and letter case affect string equality and lexicographical ordering.
  5. Analyze the results of combined string operations and comparisons.
Objective 3.2.2 Classify and validate string contents using is...() methods (1 item)
  1. Distinguish between decimal, digit, numeric, alphabetic, alphanumeric, whitespace, and case-related checks.
  2. Use methods such as isalnum(), isalpha(), isdigit(), islower(), isspace(), and isupper().
  3. Combine multiple classification checks in Boolean expressions.
Objective 3.2.3 Analyze string search and ordering behavior (1 item)
  1. Locate substrings using index(), find(), rindex(), and rfind().
  2. Compare the return values and exceptions produced when a searched substring is absent.
  3. Use optional start and stop arguments to limit string searches.
  4. Use count(), startswith(), and endswith() to analyze occurrences and boundary patterns.
  5. Use sorted() to order string characters.
Back to syllabus contents ↑
Section 04

Object-Oriented Programming

28.5% 12 questions · 12 objectives

4.1 Object-Oriented Foundations

Objective 4.1.1 Explain the fundamental principles of object-oriented programming (1 item)
  1. Explain the four pillars of OOP: abstraction, encapsulation, inheritance, and polymorphism.
  2. Explain how abstraction hides unnecessary implementation details.
  3. Explain how encapsulation organizes and protects related data and behavior.
  4. Explain how inheritance supports specialization and code reuse.
  5. Explain how polymorphism allows different objects to provide different implementations of the same behavior.
  6. Explain how object-oriented design supports reuse, specialization, and maintainability.
Objective 4.1.2 Identify class components and object relationships in Python code (1 item)
  1. Define classes, objects, attributes, methods, state, and behavior.
  2. Distinguish between a class and an instance of that class.
  3. Distinguish between references to classes and references to objects.
  4. Distinguish between class attributes and instance attributes.
  5. Trace relationships between classes, instances, superclasses, and subclasses.

4.2 Class and Object Properties

Objective 4.2.1 Create and use instance and class variables (1 item)
  1. Declare class variables and initialize instance variables.
  2. Distinguish between shared class data and instance-specific data.
  3. Access and update class and instance variables appropriately.
  4. Explain how instance attributes can hide class attributes with the same name.
  5. Trace values across multiple instances of the same class.
Objective 4.2.2 Inspect namespaces and apply name mangling (1 item)
  1. Inspect class and instance namespaces using the __dict__ property.
  2. Use double-leading-underscore names to trigger name mangling.
  3. Explain how name mangling helps prevent accidental naming collisions.
  4. Recognize that name mangling does not provide strict private access.

4.3 Methods

Objective 4.3.1 Define and invoke instance methods (1 item)
  1. Declare instance methods using self as the conventional name for the first parameter referring to the instance.
  2. Access and modify object state through self.
  3. Pass additional arguments to methods.
  4. Invoke methods through objects and trace how Python supplies the instance reference.
  5. Override __str__() to provide a human-readable object representation.
  6. Recognize errors caused by incorrect method signatures.

4.4 Class Introspection

Objective 4.4.1 Inspect objects and classes using introspection (1 item)
  1. Explain the purpose of introspection.
  2. Use hasattr() with an attribute name provided as a string to determine whether an object or class provides that attribute.
  3. Use getattr() with an attribute name provided as a string to retrieve selected attributes where appropriate.
  4. Trace attribute lookup across an object and its class hierarchy.
Objective 4.4.2 Discover class metadata and inheritance information (1 item)
  1. Use __name__ to retrieve the definition names of functions, classes, and modules.
  2. Use __module__ to identify the module in which a class was defined.
  3. Use __bases__ to inspect direct base classes.
  4. Interpret class metadata when analyzing class relationships.

4.5 Inheritance and Polymorphism

Objective 4.5.1 Build class hierarchies using single inheritance (1 item)
  1. Define subclasses that inherit from a superclass.
  2. Access and specialize inherited attributes and methods.
  3. Override inherited methods.
  4. Invoke superclass behavior using super().
  5. Trace method calls across a superclass-subclass relationship.
Objective 4.5.2 Apply multiple inheritance and resolve diamond-shaped hierarchies (1 item)
  1. Define classes that inherit from multiple base classes.
  2. Explain how method resolution order (MRO) determines attribute and method lookup.
  3. Recognize diamond-shaped inheritance hierarchies.
  4. Trace which method implementation is selected according to the MRO when multiple parent classes define methods with the same name.
  5. Use super() appropriately in cooperative multiple-inheritance designs.
Objective 4.5.3 Use type and identity checks in polymorphic code (1 item)
  1. Use isinstance() to test whether an object belongs to a class or subclass.
  2. Distinguish between object identity and value equality using is and is not.
  3. Explain polymorphism through compatible behavior across different object types.

4.6 Object Initialization

Objective 4.6.1 Construct and initialize class instances (1 item)
  1. Define initializers using __init__().
  2. Accept initialization arguments and assign them to instance attributes.
  3. Provide default values for optional initialization data.
  4. Invoke superclass initializers using super().__init__().
  5. Trace initialization through a simple inheritance hierarchy.
Objective 4.6.2 Use flexible and safe initialization patterns (1 item)
  1. Use keyword arguments to make initialization calls clearer and less error-prone.
  2. Provide sensible default values to allow partial initialization.
  3. Validate initialization arguments inside __init__() and raise appropriate exceptions.
  4. Explain why mutable default arguments (e.g., lists, dicts) should not be passed as initializer parameters.
Back to syllabus contents ↑
Section 05

Advanced Python Constructs and I/O

24% 10 questions · 10 objectives

5.1 Comprehensions

Objective 5.1.1 Build and filter data structures using comprehensions (1 item)
  1. Construct list, set, and dictionary comprehensions.
  2. Transform source values using expressions.
  3. Filter source values using if clauses.
  4. Use conditional expressions within comprehensions.
Objective 5.1.2 Construct and interpret nested comprehensions (1 item)
  1. Use multiple for clauses within a comprehension.
  2. Process nested and multidimensional collections.
  3. Create nested or flattened results using comprehensions.
  4. Trace the order of iteration and filtering in nested comprehensions.
  5. Explain how to flatten a list of lists using the unpacking feature.

5.2 Advanced Control Flow Constructs

Objective 5.2.1 Perform structural pattern matching with match-case (1 item)
  1. Use a match statement to compare a value against multiple patterns.
  2. Define individual alternatives using case clauses.
  3. Use a default case to handle unmatched values.
  4. Explain how match-case differs from an if-elif-else structure
Objective 5.2.2 Use else clauses with loops (1 item)
  1. Use a while-else structure.
  2. Use a for-else structure.
  3. Explain when a loop’s else block is executed.
  4. Select appropriate use cases for loop else clauses

5.3 Lambda Functions and Closures

Objective 5.3.1 Define and use lambda functions (1 item)
  1. Define lambda functions using a single expression.
  2. Pass arguments to lambdas and use their implicitly returned results.
  3. Store, invoke, and pass lambda functions as objects.
  4. Recognize when a named function is clearer than a lambda.
Objective 5.3.2 Transform and filter iterable data using map() and filter() (1 item)
  1. Use map() with named functions or lambdas to transform iterable data.
  2. Use filter() with named functions or lambdas to select values.
  3. Explain that map() and filter() return iterators in Python 3.
  4. Convert iterator results into collections when required.
Objective 5.3.3 Define and use closures (1 item)
  1. Define functions inside other functions.
  2. Return inner functions from enclosing functions.
  3. Explain how closures retain access to names from enclosing scopes.
  4. Create simple function factories using captured values.
  5. Recognize practical uses of closures for configuration and specialized behavior.

5.4 File I/O and Filesystem Operations

Objective 5.4.1 Explain Python input/output terminology and modes (1 item)
  1. Define streams, file handles, input, and output.
  2. Identify sys.stdin, sys.stdout, and sys.stderr.
  3. Distinguish between text and binary modes.
  4. Recognize common file modes, including r, w, a, x, b, t, and +.
  5. Select appropriate access modes for stated file operations.
Objective 5.4.2 Perform text and binary file operations safely (1 item)
  1. Open files using appropriate modes and manage them safely using with.
  2. Read file data using read(), readline(), and readlines().
  3. Write text or binary data using write().
  4. Create and use bytearray objects as mutable binary buffers.
  5. Handle common file-related exceptions.
Objective 5.4.3 Navigate and manipulate the filesystem using pathlib (1 item)
  1. Create and combine Path objects representing files and directories.
  2. Distinguish between relative and absolute paths.
  3. Navigate directory contents using iterdir().
  4. Read and write text using read_text() and write_text().
  5. Read and write binary data using read_bytes() and write_bytes().
Back to syllabus contents ↑
Section 06

Testing, Debugging, Collaborative Development, and AI Assistance

14% 6 questions · 6 objectives

6.1 Testing and Debugging

Objective 6.1.1 Apply unit testing concepts using test cases and assertions (1 item)
  1. Explain the purpose of unit testing and define terms such as unit test, test case, test suite, expected result, and actual result.
  2. Design repeatable test cases for individual functions or classes using typical, boundary, and invalid input values.
  3. Use assert statements to compare actual results with expected results and verify internal program invariants.
  4. Explain the importance of test isolation and recognize that one unit test should focus on a specific behavior.
  5. Interpret passed and failed tests, and rerun relevant tests after code changes to detect regressions.
Objective 6.1.2 Debug Python programs and identify the causes of defects (1 item)
  1. Distinguish between syntax errors, runtime errors, and logic errors.
  2. Read error messages and tracebacks to identify the location and likely cause of a problem.
  3. Use diagnostic output and step-by-step tracing to follow program execution.
  4. Inspect variable values, expressions, function calls, and control flow while debugging.
  5. Correct the underlying defect and rerun relevant test cases to verify the solution.

6.2 Teamwork and Collaboration

Objective 6.2.1 Coordinate development work using shared repositories and version control (1 item)
  1. Explain how shared repositories support collaborative Python development.
  2. Use branches to isolate changes and support parallel development.
  3. Use commits and clear commit messages to record meaningful development changes.
  4. Use pull or merge requests to propose and integrate changes into shared branches.
  5. Recognize common causes of merge conflicts and coordinate changes to shared code.
  6. Resolve or prevent conflicts by reviewing concurrent changes and communicating with other contributors.
Objective 6.2.2 Communicate, review, and validate changes in collaborative development workflows (1 item)
  1. Use issue descriptions, task records, and project documentation to communicate requirements, defects, progress, and development decisions.
  2. Participate in code reviews by examining proposed changes and providing specific, constructive feedback.
  3. Respond to review feedback by clarifying decisions, revising code where appropriate, and documenting resolutions.
  4. Explain how automated tests help validate changes made by multiple contributors.
  5. Explain how continuous integration provides consistent automated checks for shared code.
  6. Use review results and automated test feedback to decide whether a change is ready to be merged.

6.3 AI-Assisted Development

Objective 6.3.1 Use AI-assisted tools to generate and improve Python code (1 item)
  1. Provide clear requirements, relevant context, examples, and constraints when requesting AI assistance.
  2. Use AI-assisted tools to draft, explain, complete, refactor, document, and test Python code.
  3. Evaluate AI-generated suggestions against the stated task and development requirements.
  4. Refine prompts or provide additional context when generated output is incomplete, incorrect, or unsuitable.
  5. Use AI assistance to explore alternative implementations and improve code readability and maintainability.
Objective 6.3.2 Validate and use AI-generated Python code responsibly (1 item)
  1. Apply a human-in-the-loop (HITL) approach by reviewing, validating, and approving AI-generated outputs before use.
  2. Review generated code for correctness, readability, maintainability, security, and compliance with requirements.
  3. Execute and test generated code before incorporating it into a project.
  4. Verify that referenced modules, functions, methods, APIs, and other technical claims actually exist and behave as expected.
  5. Protect passwords, credentials, personal data, proprietary code, and other sensitive information when using AI-assisted tools.
  6. Retain human responsibility for approving the final implementation and for the consequences of using AI-generated code.
Back to syllabus contents ↑
Candidate expectations

Minimally Qualified Candidate (MQC) Profile

A minimally qualified PCAP-31-04 candidate has reliable knowledge of Python fundamentals and can apply associate-level techniques to build, analyze, test, and maintain intermediate Python programs.

Modules and packages

Can work with import forms, namespaces, search paths, reusable packages, and external dependencies.

Exceptions

Can use advanced exception-handling flow, understand the exception hierarchy, raise and propagate errors, and define basic custom exceptions.

Strings

Can interpret Unicode code points, evaluate immutable strings, and use string classification, comparison, and search methods.

Object-oriented programming

Can define classes, manage class and instance data, use introspection, initialize objects, and apply single and multiple inheritance.

Advanced Python constructs and I/O

Can use comprehensions, pattern matching, loop else, lambdas, closures, text and binary streams, and pathlib.

Testing, collaboration, and AI assistance

Can write and analyze basic unit tests, debug programs, participate in code reviews, and verify AI-generated code independently.

Passing requirement

Pass the PCAP-31-04 Exam

The passing score is 72%. The certification's passing standard is finalized based on psychometric analysis, item performance, exam-form difficulty, and minimum competency requirements.

72% Passing score

Ready to advance your Python skills?

Explore the associate-level certification requirements and prepare for PCAP-31-04.

Explore PCAP Certification