Why Study with PlanetCert?
The Latest Questions
Practice questions and exam topics aligned with the current exam objectives.
Detailed Explanations
Go beyond the answer. Master the material with comprehensive learning and professional explanations for every concept.

AI-Powered Insights
Personalized preparation guidance that adapts to your performance and identifies weak spots automatically.
Exam Information
Official specifications published by Python Institute
Exam Format
Registration
Validity
Skills this practice test covers
- Model a real problem with is-a inheritance and has-a composition, and trace its MRO.
- Write function and class decorators, including decorators with arguments and stacked decorators.
- Lay out code to PEP 8 and document it with PEP 257 docstrings.
- Build a tkinter window from widgets, geometry managers and event callbacks.
- Send requests over a socket and build a REST client that uses GET, POST, PUT and DELETE.
- Read and write SQLite, XML, CSV and .ini data with Standard Library modules.
Explore related topics
PCPP-32-101 exam content
5 domains · 23 topics · 210 of 218 questions sorted by domain
Advanced Object-Oriented Programming35%76 questions
The largest domain goes deep into classes and objects. It covers magic methods, inheritance and composition, decorators, class and static methods, abstract classes, encapsulation, exceptions, copying, serialization and metaclasses.
Skills tested
- Implement magic methods such as __eq__, __getitem__ and __str__ so a class supports core syntax.
- Trace the Method Resolution Order (MRO) through a hierarchy with multiple inheritance.
- Write decorators that take arguments and forward *args and **kwargs to the wrapped function.
- Chain exceptions and read their __context__, __cause__ and __traceback__ attributes.
- Persist objects with pickle and shelve, and create classes with the type metaclass.
Questions by topic
- Inheritance, polymorphism, and composition11
- Extended function argument syntax and decorators6
- Advanced exception handling5
- Python core syntax operations8
- (De)serialization of Python objects5
- Metaprogramming7
- Shallow and deep copy operations8
- Basic terms and programming concepts in OOP7
- Subclassing built-in classes5
- Static and class methods5
- Attribute encapsulation5
- Abstract classes and methods4
Coding Conventions, Best Practices, and Standardization12%26 questions
This domain is about writing Python the way the community expects. Candidates explain what Python Enhancement Proposals (PEPs) are, apply PEP 8 to code layout and naming, and write docstrings that follow PEP 257.
Skills tested
- Explain the purpose of PEP 1, PEP 8, PEP 20 and PEP 257.
- Apply PEP 8 rules for indentation, line length, line breaks, blank lines and naming.
- Write one-line and multi-line docstrings, and tell them apart from comments.
- Add type hints as PEP 484 describes.
Questions by topic
- PEP 8 Guidelines12
- Python Enhancement Proposals and Python philosophy7
- PEP 257 Documentation7
GUI Programming20%41 questions
Candidates build simple desktop applications with tkinter. The domain moves from GUI terms and event-driven programming to widgets, geometry managers, event handlers and checks on user input.
Skills tested
- Create a main window with Tk(), give it a title and start mainloop().
- Place Button, Entry and Radiobutton widgets with the grid and place managers.
- Bind events with bind() and write the callbacks that handle them.
- Draw on a Canvas and set widget colors in RGB or HEX.
- Attach observers to observable variables so the window reacts to changes.
Questions by topic
- GUI toolkits and layout management17
- Using widgets and handling events24
Network Programming18%37 questions
This domain covers clients and servers. Candidates use the socket module, exchange data as JSON or XML, and build a simple REST client with HTTP methods and response status codes.
Skills tested
- Create a socket, connect it to an HTTP server, send() a request and recv() the response.
- Explain the difference between connection-oriented and connectionless communication.
- Serialize Python data to JSON with the json module, and turn JSON back into Python objects.
- Add, fetch, update and delete records on a server with GET, POST, PUT and DELETE.
Questions by topic
- REST Client Development13
- Working with sockets in Python11
- Data Transfer Mechanisms8
- Network Programming Concepts5
File Processing and Communicating with a Program's Environment15%30 questions
The last domain works with data outside the program through the Standard Library. Candidates program an SQLite database, process XML and CSV files, log events, and read and write configuration files.
Skills tested
- Run SQL through sqlite3 cursor methods such as execute, executemany, fetchone and fetchall.
- Search XML with find and findall, and build it with Element and SubElement.
- Read and write CSV data with reader, writer, DictReader and DictWriter.
- Format log messages from LogRecord attributes with custom handlers and formatters.
- Parse and create .ini files with ConfigParser, including interpolated values.
Questions by topic
- File Format Processing21
- Database programming in Python9
Requirements
- Prerequisite: the Python Institute lists PCAP – Certified Associate in Python Programming for PCPP1.
- Recommended: solid experience with object-oriented Python and the Python Standard Library.
- Recommended: working knowledge of Python 3, the version that the exam is written for.
About the PCPP-32-101 exam
PCPP-32-101 is the exam for PCPP1 – Certified Professional Python Programmer Level 1. PCPP1 is the first of two professional levels in the Python Institute's General-Purpose Programming track. The exam checks advanced object-oriented programming, coding conventions from PEP 8 and PEP 257, GUI programming with tkinter, network programming with sockets and REST, and file processing with Standard Library modules. The Python Institute names PCAP as the prerequisite, and PCPP1 does not expire.
Advanced Object-Oriented Programming has the largest weight on the exam and the most PlanetCert practice questions, from magic methods to metaclasses. The explanations help most where Python's behavior surprises, such as the Method Resolution Order, shallow and deep copies, or chained exceptions. Study Mode suits the tkinter and socket topics, which are worth retrying in a Python shell. Brainy AI Assistant can explain when a decorator runs, or what a socket's recv() call returns.
How to earn the certification
- Earns
- PCPP1 – Certified Professional Python Programmer Level 1Professional
PCPP1 is a lifetime certification and does not expire.
- Before
- PCAP PCAP – Certified Associate in Python Programming
The associate exam that the Python Institute lists as the prerequisite for PCPP1.
- PCEP-30-02 PCEP – Certified Entry-Level Python Programmer
The entry-level exam at the start of the same track, before PCAP.
- PCAP PCAP – Certified Associate in Python Programming
How to prepare for PCPP-32-101
- 1
Take Python Advanced 1 to 5
The Python Institute aligns its Python Advanced 1 to 5 courses on Edube Interactive with the five exam sections. Work through them in order, from advanced OOP to file processing.
- 2
Rebuild the OOP topics in small scripts
Advanced Object-Oriented Programming carries the most weight. Write short classes that use magic methods, multiple inheritance, decorators and a metaclass, and print each class's MRO to check the result.
- 3
Build one tkinter form end to end
Make a form with Entry, Radiobutton and Button widgets, lay it out with grid, and bind events to callbacks. Then redo the layout with place to see how the two managers differ.
- 4
Call a local REST test server
Run a small test server, then add, fetch, update and delete records with GET, POST, PUT and DELETE. Check the status code of every response, and send one raw request through a socket.
- 5
Close with timed practice
Take the PCPP-32-101 practice test in Timed Mode. Retry the idea behind every missed question in a Python shell, and ask Brainy AI Assistant about any result that still looks wrong.
Start a timed PCPP-32-101run
The Python Institute aligns its Python Advanced 1 to 5 courses on Edube Interactive with this exam, one course for each section: Advanced OOP, Best Practices and Standardization, GUI Programming, Network Programming, and File Processing and Communicating with a Program's Environment.
Who PCPP-32-101 is for
- Developers who already work at PCAP level and want to show professional Python skills.
- Software developers, network programmers and testers in junior or middle-level roles.
- Data analysts who build their own Python tools and want to go beyond simple scripts.
- Team leaders and product or project managers who want to follow their developers' work closely.
Typical job titles: Python developer · Software developer · Network programmer · Test automation engineer · Data analyst
PCPP-32-101 glossary
18 terms from the exam objectives and the vendor's official material, each defined in a sentence.
- Abstract classes
- Classes that declare abstract methods and cannot be instantiated until a subclass implements all of those methods.
- Closures
- Inner functions that keep access to variables of the enclosing function after that function has returned.
- Composition
- Giving a class its features through objects that it contains (a has-a relation) rather than through inheritance.
- ConfigParser
- The class in the configparser module that reads and writes .ini configuration files.
- CRUD
- Create, read, update and delete: the four basic data operations that a REST client performs with HTTP methods.
- Decorator stacking
- Applying more than one decorator to a function. The decorator closest to the function is applied first.
- Deep copy
- A copy of an object and of every object inside it, so that changes to the copy never reach the original.
- Duck typing
- Using an object because it has the methods and attributes that the code needs, whatever its type.
- Event-driven programming
- A style in which the program waits for events, such as clicks or key presses, and runs a handler for each one.
- Geometry managers
- The tkinter tools, such as grid and place, that decide where each widget sits in a window.
- Magic methods
- Methods with double underscores, such as __eq__ or __getitem__, that Python calls for operators and built-in functions.
- Metaclasses
- Classes whose instances are classes. The type metaclass is the default, and a custom metaclass changes how classes are built.
- Method Resolution Order (MRO)
- The order in which Python searches a class and its parents for a method or attribute. It matters most with multiple inheritance.
- Network sockets
- Endpoints for sending and receiving data over a network. Python creates them with the socket module.
- PEP 257
- The Python Enhancement Proposal that sets the conventions for writing docstrings.
- PEP 8
- The style guide for Python code, with rules for layout, whitespace, naming and comments.
- pickle
- The Standard Library module that turns Python objects into a byte stream and restores them from it.
- shelve
- A Standard Library module that stores pickled objects in a file and reads them back by key, like a dictionary.