PCAP™ - Python Developer Certification in Netherlands

Fundamental 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

Comments

The print() function

The input() function

Numeral systems (binary, octal, decimal, hexadecimal)

Numeric operators: ** * / % // + –

String operators: * +

Assignments and shortcut operator

Objectives covered by the block (6 exam items)

Operators: unary and binary, priorities and binding

Bitwise operators: ~ & ^ | << >>

Boolean operators: not, and, or

Boolean expressions

Relational operators (== != > >= < <=), building complex Boolean expressions

Accuracy of floating-point numbers

Basic input and output operations using the input(), print(), int(), float(), str(), len() functions

Formatting print() output with end= and sep= arguments

Typecasting

Basic calculations

Simple strings: constructing, assigning, indexing, immutability

Conditional statements: if, if-else, if-elif, if-elif-else

Multiple conditional statements

The pass instruction

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

Simple lists: constructing vectors, indexing, and slicing, the len() function

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

Strings in detail: escaping using the \ character, quotes, and apostrophes inside strings, multi-line strings, and basic string functions

Defining and invoking your own functions and generators

Return and Yield keywords

Returning results

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

Import variants; advanced qualifying 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

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

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

Instance vs class variables: declaring, initializing

__dict__ property (objects vs classes)

Private components (instance vs classes)

Name mangling

Methods: declaring, using, self parameter

Introspection: 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

List comprehension: if operator, using list comprehensions

Lambdas: defining and using lambdas, self-defined functions taking lambda 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())

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 inheritances

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