PCAP – Certified Associate in Python Programming Certification: Exam Syllabus

PCAP-31-02 (PVTCs)

Exam block #1: Control and Evaluations (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
  • assignments and shortcut operators
  • accuracy of floating-point numbers
  • basic input and output: input(), print(), int(), float(), str() functions
  • formatting print() output with 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

Exam Block #2: Data Aggregates (25%)

Objectives covered by the block (10 exam items)

  • strings in detail: ASCII, UNICODE, UTF-8, immutability, escaping using the \ character, quotes and apostrophes 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.) and functions (len(), chr(), ord()), escape characters
  • lists in detail: indexing, slicing, basic methods (append(), insert(), index()) and functions (len(), sorted(), etc.), del instruction, iterating lists with the for loop, initializing, in and not in operators, list comprehension, copying and cloning
  • 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, indexing, adding and removing keys, iterating through dictionaries as well as their keys and values, checking key existence, keys(), items() and values() methods

Exam block #3: Functions and Modules (25%)

Objectives covered by the block (10 exam items)

  • defining and invoking your own functions and generators
  • 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
  • map(), filter(), reduce(), reversed(), sorted() functions and the sort() method
  • the if operator
  • import directives, qualifying entities with module names, initializing modules
  • writing and using modules, the __name__ variable
  • pyc file creation and usage
  • 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

Exam block #4: Classes, Objects, and Exceptions (25%)

Objectives covered by the block (10 exam items)

  • defining your own 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, 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: __dict__, __name__, __module__, __bases__ properties, examining class/object structure
  • writing and using constructors
  • hasattr(), type(), issubclass(), isinstance(), super() functions
  • using predefined exceptions and defining your own ones
  • 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 your own exceptions to an existing hierarchy
  • assertions
  • the anatomy of an exception object
  • input/output basics: opening files with the open() function, stream objects, binary vs. text files, newline character translation, reading and writing files, bytearray objects
  • read(), readinto(), readline(), write(), close() methods

Last updated: April 11, 2020
Aligned with PCAP-31-01, PCAP-31-02 (Pearson VUE),
and PCAP-NP-31-02 (OpenEDG Testing Service)

 

Courses aligned:

PCAP-31-03 (PVTCs, OnVUE)

Exam block #1: Modules and Packages (12%)

Objectives covered by the block (6 items)

  • import variants; advanced qualifiying for nested modules
  • dir(); sys.path variable
  • math: ceil(), floor(), trunc(), factorial(), hypot(), sqrt(); random: random(), seed(), choice(), sample()
  • platform: platform(), machine(), processor(), system(), version(), python_implementation(), python_version_tuple()
  • idea, __pycache__, __name__, public variables, __init__.py
  • searching for modules/packages; nested packages vs directory tree

 

Exam block #2: Exceptions (14%)

Objectives covered by the block (5 items)

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

 

Exam block #3: Strings (18%)

Objectives covered by the block (8 items)

  • ASCII, UNICODE, UTF-8, codepoints, escape sequences
  • ord(), chr(), literals
  • indexing, slicing, immutability
  • iterating through,
  • concatenating, multiplying, comparing (against strings and numbers)
  • in, not in
  • .isxxx(), .join(), .split()
  • .sort(), sorted(), .index(), .find(), .rfind()

 

Exam block #4: Object-Oriented Programming (34%)

Objectives covered by the block (12 items)

  • ideas: class, object, property, method, encapsulation, inheritance, grammar vs class, superclass, subclass
  • instance vs class variables: declaring, initializing
  • __dict__ property (objects vs classes)
  • private components (instance vs classes), name mangling
  • methods: declaring, using, self parameter
  • instrospection: hasattr() (objects vs classes), __name__, __module__, __bases__ properties
  • inheritance: single, multiple, isinstance(), overriding, not is and is operators
  • inheritance: single, multiple, isinstance(), overriding, not is and is operators
  • constructors: declaring and invoking
  • polymorphism
  • __name__, __module__, __bases__ properties, __str__() method
  • multiple inheritance, diamonds

 

Exam block #5: Miscellaneous (List Comprehensions, Lambdas, Closures, and I/O Operations) (22%)

Objectives covered by the block (9 items)

  • list comprehension: if operator, using list comprehensions
  • lambdas: defining and using lambdas, self-defined functions taking lambda as as arguments; map(), filter();
  • closures: meaning, defining, and using closures
  • I/O Operations: I/O modes, predefined streams, handles; text/binary modes
    open(), errno and its values; close()
    .read(), .write(), .readline(); readlines() (along with bytearray())

 

Last updated: September 17, 2020
Aligned with PCAP-31-03 (Pearson VUE/OnVUE Online Proctoring from Pearson VUE)

 

Courses aligned: