PCAP™ – Certified Associate in Python Programming (Exam PCAP-31-0x) – EXAM SYLLABUS

Certificate holder's profile: the test candidate who has passed the PCAP-31-0x exam demonstrates the following proficiency in Python programming:

  • an ability to design, develop and improve multi-module computer applications coded in Python
  • an ability to analyze and model real-life problems in OOP categories
  • experience allowing her/him to take a job as a junior developer
  • sufficient skills to create and develop her/his own programming portfolio
  • the potential to use Python in everyday life applications including DIY activities

PCAP-31-03 Exam Syllabus


PCAP-31-03 badge

The exam consists of five sections:

  • Section 1 → 6 items, Max Raw Score: 12 (12%)
  • Section 2 → 5 items, Max Raw Score: 14 (14%)
  • Section 3 → 8 items, Max Raw Score: 18 (18%)
  • Section 4 → 12 items, Max Raw Score: 34 (34%)
  • Section 5 → 9 items, Max Raw Score: 22 (22%)

Objectives covered by the block (6 exam items)

PCAP-31-03 1.1 – Import and use modules and packages

  • import variants: import, from import, import as, 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

Objectives covered by the block (5 exam items)

PCAP-31-03 2.1 – Handle errors using Python-defined exceptions

  • except, except:-except, except:-else:, except (e1, e2)
  • the hierarchy of exceptions
  • raise, raise ex
  • assert
  • event classes
  • except E as e
  • the arg property

PCAP-31-02 2.2 – Extend the Python exceptions hierarchy with self-defined exceptions

  • self-defined exceptions
  • defining and using self-defined exceptions

Objectives covered by the block (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
  • iterating through strings, concatenating, multiplying, comparing (against strings and numbers)
  • operators: in, not in

PCAP-31-03 3.3 – Employ built-in string methods

  • methods: .isxxx(), .join(), .split(), .sort(), sorted(), .index(), .find(), .rfind()

Objectives covered by the block (12 exam items)

PCAP-31-03 4.1 – Understand the Object-Oriented approach

  • ideas and notions: class, object, property, method, encapsulation, inheritance, superclass, subclass, identifying class components

PCEP-31-03 4.2 – Employ class and object properties

  • instance vs. class variables: declarations and initializations
  • the __dict__ property (objects vs. classes)
  • private components (instances vs. classes)
  • 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 the hasattr() function (objects vs classes)
  • properties: __name__, __module__ , __bases__

PCAP-31-03 4.5 – Build a class hierarchy using inheritance

  • single and multiple inheritance
  • the isinstance() function
  • overriding
  • operators:
  • not is
  • , is
  • polymorphism
  • overriding the __str__() method
  • diamonds

PCAP-31-03 4.6 – Construct and initialize objects

  • declaring and invoking constructors

Scope: List Comprehensions, Lambdas, Closures, and I/O Operations

Objectives covered by the block (9 exam items)

PCAP-31-03 5.1 – Build complex lists using list comprehension

  • list comprehensions: the if operator, nested comprehensions

PCAP-31-03 5.2 – Embed lambda functions into the code

  • lambdas: defining and using lambdas
  • self-defined functions taking lambdas as arguments
  • functions: map(), filter()

PCAP-31-03 5.3 – Define and use closures

  • 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

  • the open() function
  • the errno variable and its values
  • functions: close(), .read(), .write(), .readline(), readlines()
  • using bytearray as input/output buffer

Last updated: March 7, 2022
Aligned with Exam PCAP-31-03

PCAP-31-02 Exam Syllabus

Status: RETIRED (December 31, 2021)

PCAP-31-02 badge

The exam consists of four sections:

  • Section 1 → 10 items, Max Raw Score: 25 (25%)
  • Section 2 → 10 items, Max Raw Score: 25 (25%)
  • Section 3 → 10 items, Max Raw Score: 25 (25%)
  • Section 4 → 10 items, Max Raw Score: 25 (25%)

Objectives covered by the block (10 exam items)

  • basic concepts: interpreting and the interpreter, compilation and the compiler, language elements, lexis, syntax and semantics, Python keywords, instructions, indenting
  • literals: Boolean, integer, floating-point numbers, scientific notation, strings
  • operators: unary and binary, priorities and binding
  • numeric operators: **, *, /, %, //, +,
  • bitwise operators: ~, &, ^, |, <<, >>
  • string operators: *, +
  • Boolean operators: not, and, or
  • relational operators: ==, != >, >=, <, <=
  • building complex Boolean expressions
  • assignment and shortcut operators
  • accuracy of floating-point numbers
  • basic input and output: input(), print(), int(), float(), str() functions
  • formatting the print() output with the end= and sep= arguments
  • conditional statements: if, if-else, if-elif, if-elif-else
  • the pass instruction
  • simple lists: constructing vectors, indexing and slicing, the len() function
  • simple strings: constructing, assigning, indexing, slicing comparing, immutability
  • building loops: while, for, range(), in, iterating through sequences
  • expanding loops: while-else, for-else, nesting loops and conditional statements
  • controlling loop execution: break, continue

Objectives covered by the block (10 exam items)

  • strings in detail: ASCII, UNICODE, UTF-8, immutability, escape characters and escaping using the \ character, single and double quotes inside strings, multiline strings, copying vs. cloning, advanced slicing, string vs. string, string vs. non-string
  • basic string methods: upper(), lower(), isxxx(), capitalize(), split(), join(), etc.
  • basic string functions: len(), chr(), ord()
  • lists in detail: indexing, slicing, the del instruction, iterating lists with the for loop, initializing lists, the in and not in operators, list comprehensions, copying and cloning lists
  • basic list methods: append(), insert(), index(), etc.
  • basic list functions: len(), sorted(), etc.
  • lists in lists: matrices and cubes
  • tuples: indexing, slicing, building, immutability
  • tuples vs. lists: similarities and differences, lists inside tuples and tuples inside lists
  • dictionaries: building and indexing dictionaries, adding and removing keys, iterating through dictionaries as well as their keys and values, checking a key's existence
  • basic dictionary methods: keys(), items(), values(), etc.

Objectives covered by the block (10 exam items)

  • defining and invoking user-created functions
  • generators
  • the return and yield keywords, returning results, the None keyword, recursion
  • parameters vs. arguments, positional keyword and mixed argument passing, default parameter values
  • converting generator objects into lists using the list() function
  • name scopes, name hiding (shadowing), the global keyword
  • lambda functions, defining and using lambdas
  • functions: map(), filter(), reduce(), reversed(), sorted()
  • methods: sort()
  • the if operator
  • import directives, qualifying entities with module names, initializing modules
  • writing and using modules, the __name__ variable
  • creating and using pyc files
  • constructing and distributing packages, packages vs. directories, the role of the __init__.py file
  • hiding module entities
  • Python hashbangs, using multiline strings as module documentation

Objectives covered by the block (10 exam items)

  • defining user-created classes, superclasses, subclasses, inheritance, searching for missing class components, creating objects
  • class attributes: class variables and instance variables, defining, adding and removing attributes, explicit constructor invocation
  • class methods: defining and using class methods, the self parameter: meaning and usage
  • inheritance and overriding, finding class/object components
  • single inheritance vs. multiple inheritance
  • name mangling
  • invoking methods, passing and using the self argument/parameter
  • the __init__ method
  • the role of the __str__ method
  • introspection – properties: __dict__, __name__, __module__, __bases__, examining class/object structure
  • writing and using constructors
  • functions: hasattr(), type(), issubclass(), isinstance(), super()
  • using predefined exceptions and defining user-created exceptions
  • the try-except-else-finally block, the raise statement, the except-as variant
  • exceptions hierarchy, assigning more than one exception to one except branch
  • adding user-created exceptions to an existing hierarchy
  • assertions
  • the anatomy of exception objects
  • input/output essentials: opening files with the open() function, stream objects, binary vs. text files, newline character translation, reading and writing files, bytearray objects
  • methods: read(), readinto(), readline(), write(), close()

Last updated: September 17, 2020
Aligned with Exam PCAP-31-02