PCPP1™ – Certified Professional in Python Programming 1: EXAM SYLLABUS

Exam: PCPP-32-101
Status: ACTIVE


The PCPP-32-101 exam consists of single-select, multiple-select, coding, scenario-based, and interactive items that assess a candidate’s ability to apply advanced object-oriented programming, follow Python coding standards, build GUI applications, implement network communication, and process files and data formats using Python.

Each item is worth a maximum of 4 points. After completion, the candidate’s raw score is normalized and presented as a percentage.

The exam is divided into five sections, each reflecting key areas of professional Python practice. The weight of each section indicates its importance in the overall exam.

PCPP-32-101 badge

The table below summarizes the distribution of exam items and their corresponding weight within the total exam.

Section Section Name Number of Items Weight
1 Advanced Object-Oriented Programming 15 35%
2 Coding Conventions, Best Practices, and Standardization 7 12%
3 GUI Programming 8 20%
4 Network Programming 8 18%
5 File Processing and Communicating with a Program’s Environment 7 15%
45 100%

Exam Syllabus

Last updated: March 11, 2022
Aligned with Exam PCPP-32-101


Exam Syllabus Contents


Section 1: Advanced Object-Oriented Programming

Objectives covered by the section → 15 exam items

PCPP-32-101 1.1 – Understand and explain the basic terms and programming concepts used in the OOP paradigm

  • essential terminology: class, instance, object, attribute, method, type, instance and class variables, superclasses and subclasses
  • reflection: isinstance(), issubclass()
  • the __init__() method
  • creating classes, methods, and class and instance variables; calling methods; accessing class and instance variables

PCPP-32-101 1.2 – Perform Python core syntax operations

  • Python core syntax expressions – magic methods: comparison (e.g., __eq__(self, other)), numeric (e.g., __abs__(self)), type conversion (e.g., __int__(self)), intro/retrospection (e.g., __str__(self), __instancecheck__(self, object)), attribute access (e.g., __getattr__(self, attribute)), container access (e.g., __getitem__(self, key))
  • operating with special methods
  • extending class implementations to support additional core syntax operations

PCPP-32-101 1.3 – Understand and use inheritance, polymorphism, and composition

  • class hierarchies; single vs. multiple inheritance; Method Resolution Order (MRO)
  • duck typing
  • inheritance vs. composition; modeling real-life problems using “is a” and “has a” relations

PCPP-32-101 1.4 – Understand extended function argument syntax and use decorators

  • *args, **kwargs; forwarding arguments; parameter handling
  • closures; function and class decorators; decorating functions with classes
  • creating decorators: decorator patterns, decorator arguments, wrappers; decorator stacking; syntactic sugar
  • special methods: __call__, __init__

PCPP-32-101 1.5 – Design, build, and use static and class methods

  • implementing class and static methods; @classmethod vs. @staticmethod; the cls parameter
  • class methods: accessing/modifying class state, creating objects

PCPP-32-101 1.6 – Understand and use abstract classes and methods

  • defining and implementing abstract classes/methods; overriding abstract methods
  • multiple inheritance from abstract classes; delivering multiple child classes

PCPP-32-101 1.7 – Understand attribute encapsulation

  • definition, meaning, usage; operating with getter, setter, deleter methods

PCPP-32-101 1.8 – Apply subclassing of built-in classes

  • inheriting from built-ins to extend/modify features, methods, attributes

PCPP-32-101 1.9 – Advanced techniques for creating and serving exceptions

  • exceptions as objects; named attributes; chained exceptions (__context__, __cause__); implicit vs. explicit chaining
  • analyzing traceback objects (__traceback__)
  • operating with different kinds of exceptions

PCPP-32-101 1.10 – Perform shallow and deep copy operations

  • object: label vs. identity vs. value; id() and the is operator
  • using copy() and deepcopy()

PCPP-32-101 1.11 – (De)serialize Python objects

  • persistence, serialization, deserialization – meaning, purpose, usage
  • single-byte-stream serialization: the pickle module; dumps(), loads()
  • serialization dictionary via shelve: file modes, creating shelve objects

PCPP-32-101 1.12 – Explain the concept of metaprogramming

  • metaclasses: meaning, purpose, usage; the type metaclass and type()
  • special attributes: __name__, __class__, __bases__, __dict__; operating with metaclasses, class variables, and class methods

Section 2: Coding Conventions, Best Practices, and Standardization

Objectives covered by the section → 7 exam items

PCPP-32-101 2.1 – Python Enhancement Proposals and Python philosophy

  • PEP concept and selected PEPs: PEP 1, PEP 8, PEP 20, PEP 257
  • PEP 1 types, formats, purpose, guidelines
  • PEP 20 aphorisms (import this) and guiding principles

PCPP-32-101 2.2 – Employ PEP 8 guidelines, conventions, and best practices

  • PEP 8 checkers; code layout (indentation, continuation lines, max length, line breaks, blank lines)
  • default encodings; module imports
  • string quotes, whitespace, trailing commas
  • comments vs. documentation strings
  • naming conventions; programming recommendations

PCPP-32-101 2.3 – Employ PEP 257 conventions and related standards

  • docstrings: rationale, usage; comments vs. docstrings
  • PEP 484 type hints
  • creating, using, and accessing docstrings (one-line vs. multi-line); documentation standards, linters, fixers

Section 3: GUI Programming

Objectives covered by the section → 8 exam items

PCPP-32-101 3.1 – Basic concepts and terminology for GUI programming

  • GUI meaning/rationale; visual programming; widgets/controls (windows, buttons, icons, labels, etc.)
  • classical vs. event-driven programming; events – basic terms; GUI toolkits

PCPP-32-101 3.2 – Use GUI toolkits, blocks, and conventions to build simple GUIs

  • importing tkinter; Tk(), mainloop(), title
  • adding widgets: buttons, labels, frames; place(); coordinates and sizing
  • event controller: handlers, callbacks, destroy(), dialog boxes
  • validating input and handling errors; Canvas methods
  • Entry, Radiobutton, Button; layout with grid and place; binding events via bind()

PCPP-32-101 3.3 – Widgets and event handling

  • geometry managers; coloring widgets (RGB, HEX)
  • event-driven programming with events/callbacks
  • widget properties/methods; observable variables and observers
  • using clickable/non-clickable widgets; identifying/servicing events

Section 4: Network Programming

Objectives covered by the section → 8 exam items

PCPP-32-101 4.1 – Basic concepts of network programming

  • REST; sockets; domains, addresses, ports, protocols, services
  • connection-oriented vs. connectionless; clients and servers

PCPP-32-101 4.2 – Work with sockets in Python

  • the socket module: creating sockets; connecting to HTTP servers; closing connections
  • sending requests (send()); receiving responses (recv()); exception handling

PCPP-32-101 4.3 – Data transfer mechanisms

  • JSON syntax/structure/types; json module (dumps(), loads) for Python↔JSON
  • XML syntax/structure; DTD; XML as a tree; processing XML files

PCPP-32-101 4.4 – Design, develop, and improve a simple REST client

  • the requests module; test environments
  • HTTP methods: GET, POST, PUT, DELETE; CRUD operations
  • adding/updating/fetching/removing data; analyzing responses; status codes

Section 5: File Processing and Communicating with a Program’s Environment

Objectives covered by the section → 7 exam items

PCPP-32-101 5.1 – Database programming in Python

  • sqlite3 module; connect/close database connections
  • creating tables; inserting, reading, updating, deleting data
  • transaction demarcation; cursor methods: execute, executemany, fetchone, fetchall
  • basic SQL statements (SELECT, INSERT INTO, UPDATE, DELETE, etc.)

PCPP-32-101 5.2 – Process different file formats in Python

  • parsing XML: find/findall; building XML via Element and SubElement
  • reading/writing CSV via reader, writer, DictReader, DictWriter
  • logging events; logging levels; LogRecord attributes; custom handlers/formatters
  • configuration files with ConfigParser; value interpolation in .ini files

Download PCPP-32-101 Exam Syllabus in PDF

MQC Profile

The Minimally Qualified Candidate (MQC) for the PCPP1™ certification demonstrates professional-level Python skills across advanced object-oriented programming, coding standards, GUI development, network communication, and file/data processing. the MQC can design, implement, test, and troubleshoot medium-size, multi-module applications; apply Pythonic idioms and best practices; and integrate external services and data sources using the standard library and commonly used techniques.

Section 1: Advanced Object-Oriented Programming

The MQC can model real-world domains using classes, objects, inheritance, composition, and polymorphism; reason about and customize behavior through special (dunder) methods; and use introspection for debugging and design. They can:

  • design class hierarchies (single/multiple inheritance) and explain MRO implications; apply composition where appropriate.
  • implement and override special methods (e.g., __eq__, __lt__, __hash__, __str__, __repr__, __len__, __iter__, __getitem__).
  • use decorators (function/class), closures, *args/**kwargs, and callable objects (__call__) to extend behavior.
  • define and apply @classmethod and @staticmethod; manage class vs. instance state responsibly.
  • work with abstract base classes and interfaces; encapsulate attributes via properties (getter/setter/deleter).
  • subclass built-in types safely to extend functionality while preserving invariants.
  • design robust exception hierarchies; analyze tracebacks; use exception chaining (__cause__, __context__).
  • distinguish shallow vs. deep copies and choose correct strategies (copy/deepcopy).
  • persist objects via pickle and simple object stores (shelve); explain the risks and trade-offs.
  • recognize metaprogramming patterns (e.g., metaclasses, type()) and when to avoid overuse.

Section 2: Coding Conventions, Best Practices, and Standardization

The MQC writes Pythonic, maintainable code aligned with community standards. They can:

  • summarize the role of PEPs (PEP 1, PEP 8, PEP 20, PEP 257) and apply their guidance in day-to-day work.
  • enforce PEP 8 using linters/formatters; structure modules and imports; use consistent naming and whitespace.
  • author clear, accurate docstrings (PEP 257) and apply type hints (PEP 484) where beneficial.
  • set up basic quality gates (lint, formatting, simple static checks) for small projects.

Section 3: GUI Programming

The MQC can design small desktop utilities using a standard toolkit (e.g., tkinter) and event-driven patterns. They can:

  • create application windows, place/manage widgets, and bind events/callbacks.
  • validate user input, handle runtime errors gracefully, and maintain responsive UIs.
  • use common widgets (labels, buttons, entries, radio buttons, canvas) and geometry managers (grid, place).

Section 4: Network Programming

The MQC can implement simple client-side networking and data exchange workflows. They can:

  • explain core concepts (domains, ports, protocols, sockets; connection-oriented vs. connectionless).
  • use the socket module to open connections, send/receive data, and handle exceptions safely.
  • serialize/deserialize data with json; parse/process XML at a basic level.
  • build and test a straightforward REST client (e.g., with requests): perform CRUD, inspect status codes, and handle failures.

Section 5: File Processing and Communicating with a Program’s Environment

The MQC can read, write, and transform structured data; configure applications; and persist data locally. They can:

  • use sqlite3 to create tables and run basic SQL (SELECT, INSERT, UPDATE, DELETE); manage transactions and cursors.
  • process CSV files (reader/writer, DictReader/DictWriter), and build/parse XML structures.
  • log application events with appropriate levels and custom handlers/formatters.
  • manage configuration via configparser and interpolate values from .ini files.

Overall

The MQC delivers clean, well-documented, and testable Python code; selects suitable language features and libraries to solve problems efficiently; and integrates multiple subsystems (OOP, GUI, networking, storage) into cohesive, reliable applications.

Passing Requirement

To pass the PCEP-30-02 exam, a candidate must achieve a cumulative average score of at least 70% across all exam blocks.