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

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

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()