PCAP™ - Python Developer Certification Training in Saudi Arabia

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, initialising
• __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 byte array())

• 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