TBYs Coding Academy Logo

Home > Programs > PCAP Certification

PCAP Certification

Course Description

Prepare for the PCAP™ – Certified Associate Python Programmer certification (Exam PCAP-31-0x) with our specialized course designed to advance your Python programming skills. This certification focuses on the Object-Oriented Programming (OOP) approach in Python, covering advanced topics such as modules, packages, exception handling, string operations, list comprehensions, lambdas, generators, closures, and file processing.

  • Learn the essentials of object-oriented programming in Python, covering classes, objects, inheritance, and polymorphism
  • Gain proficiency in handling modules, packages, and using PIP for package management.
  • Learn advanced techniques for effectively manipulating and processing strings in Python.
  • Explore and apply the power of list comprehensions, lambdas, generators, and closures in Python programming.
  • Develop skills in working with files, file streams, and performing various file processing tasks using Python.
  • Understand how to effectively manage the hierarchy of exceptions, exception classes, and objects within Python.
  • Utilize selected Python Standard Library modules in practical, real-world applications to enhance your programming capabilities.
  • PCAP™ certification validates your intermediate-level proficiency in Python programming, equipping you with the skills to design, develop, debug, execute, and refactor multi-module Python programs. This credential enhances your confidence in Python programming, distinguishes you in the competitive job market, and serves as a stepping stone to professional-level Python development.

  • Completion of PCEP™ – Certified Entry-Level Python Programmer certification course.
  • Proficiency in Intermediate Python programming concepts, including modules, packages, strings, exceptions, object-oriented programming (OOP)principles, file handling, and standard library modules.

Course Module

Course Material

Course Details

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

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

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

  • 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: innot in

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

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

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 isis
  • polymorphism
  • overriding the __str__() method
  • diamonds

PCAP-31-03 4.6 – Construct and initialize objects

  • declaring and invoking constructors

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