100+ Free PCPP1 Practice Questions

Pass your OpenEDG PCPP1 — Certified Professional in Python Programming Level 1 (PCPP-32-101) exam on the first try — instant access, no signup required.

✓ No registration✓ No credit card✓ No hidden fees✓ Start practicing immediately

~55-65% Pass Rate

100+ Questions

100% Free

1 / 10

Question 1

Score: 0/0

What does this code do? from abc import ABC, abstractmethod class Animal(ABC): @abstractmethod def speak(self): pass a = Animal()

Prints 'Animal'

Raises TypeError because Animal has abstract methods

Returns None

Creates an instance with no methods

to track

2026 Statistics

Key Facts: PCPP1 Exam

Exam Questions

OpenEDG

70%

Passing Score

OpenEDG (cumulative)

65 min

Exam Duration

OpenEDG

$295

Exam Fee

OpenEDG

~25%

Advanced OOP

Largest domain

Lifetime

Validity

Does not expire

PCPP-32-101 has 45 questions in 65 minutes with a 70% passing score. Domains: Advanced OOP (~25%), PEP 8/257 and Coding Standards (~12%), GUI Programming with tkinter (~22%), Network Programming and REST (~16%), and File Processing — XML/JSON/CSV/INI/sqlite3 (~25%). PCAP is recommended but not strictly required. Lifetime certification with no expiration. Exam fee $295 USD. Delivered online via the OpenEDG Testing Service.

Sample PCPP1 Practice Questions

Try these sample questions to test your PCPP1 exam readiness. Each question includes a detailed explanation. Start the interactive quiz above for the full 100+ question experience with AI tutoring.

1What does this code do? from abc import ABC, abstractmethod class Animal(ABC): @abstractmethod def speak(self): pass a = Animal()

A.Prints 'Animal'

B.Raises TypeError because Animal has abstract methods

C.Returns None

D.Creates an instance with no methods

Explanation: A class with at least one `@abstractmethod` cannot be instantiated directly. `Animal()` raises `TypeError: Can't instantiate abstract class Animal with abstract method speak`. Subclasses must override every abstract method to be instantiable.

2What does this code print? from abc import ABC, abstractmethod class Shape(ABC): @abstractmethod def area(self): pass class Square(Shape): def __init__(self, s): self.s = s def area(self): return self.s ** 2 print(Square(4).area())

A.TypeError

B.16

C.4

D.None

Explanation: `Square` overrides the abstract method `area`, so it can be instantiated. `Square(4).area()` returns 4 ** 2 = 16. ABCs enforce that subclasses implement required methods.

3What does this code output? class A: def f(self): return 'A' class B(A): def f(self): return 'B' class C(A): def f(self): return 'C' class D(B, C): pass print(D().f(), D.__mro__[1].__name__)

A.A B

B.B B

C.C C

D.D B

Explanation: D's MRO is D → B → C → A → object (C3 linearization, depth-first then breadth). `D().f()` finds `f` in B first, returning 'B'. `D.__mro__[1]` is B (index 0 is D itself). The diamond is resolved: B comes before C.

4What is a 'mixin' class in Python?

A.A class that mixes data types

B.A small class providing optional methods, intended only for inheritance, not instantiation

C.A class with multiple __init__ methods

D.A class with private attributes only

Explanation: A mixin is a small class designed to provide a focused capability (e.g., serialization, comparison) to other classes via multiple inheritance. Mixins are NOT meant to be instantiated alone — they 'mix in' methods to a host class. Examples: `collections.abc.Hashable`, custom `JsonSerializableMixin`.

5What does this code print? class A: def __getattr__(self, name): return f'no {name}' a = A() a.x = 5 print(a.x, a.y)

A.5 no y

B.no x no y

C.5 5

D.AttributeError

Explanation: `__getattr__` is called ONLY when normal attribute lookup FAILS. `a.x` was set, so it's found in `__dict__` (returns 5, not 'no x'). `a.y` doesn't exist, so `__getattr__` runs, returning 'no y'.

6How does `__getattribute__` differ from `__getattr__`?

A.They are identical

B.__getattribute__ is called for EVERY attribute access; __getattr__ only when normal lookup fails

C.__getattr__ is called for setting; __getattribute__ for getting

D.__getattribute__ is deprecated

Explanation: `__getattribute__` is invoked unconditionally for ALL attribute access — overriding it can easily cause infinite recursion (call `super().__getattribute__(name)`). `__getattr__` is the fallback called only when normal lookup raises AttributeError. Use `__getattr__` for default values, `__getattribute__` for total control.

7What does this code print? class Desc: def __get__(self, obj, objtype): return 'descriptor' class A: x = Desc() print(A().x)

A.'descriptor'

B.<Desc object>

C.AttributeError

D.None

Explanation: `Desc` is a DESCRIPTOR — defining `__get__` makes it intercept attribute access on instances of `A`. When you read `A().x`, Python calls `Desc.__get__(instance, A)` instead of returning the Desc object itself. `@property` is implemented as a descriptor.

8What is a metaclass in Python?

A.A class with metadata

B.The class of a class — controls class creation

C.A class that contains only @classmethod methods

D.A deprecated form of inheritance

Explanation: A metaclass is the class WHOSE INSTANCES ARE CLASSES. The default metaclass is `type`. Defining `class Meta(type):` and using `class A(metaclass=Meta):` lets you intercept class creation (e.g., for ORM-style automatic field registration).

9What does this code print? class Meta(type): def __new__(mcs, name, bases, ns): ns['marked'] = True return super().__new__(mcs, name, bases, ns) class A(metaclass=Meta): pass print(A.marked)

A.False

B.True

C.AttributeError

D.None

Explanation: The metaclass's `__new__` runs at class creation time and injects `marked = True` into the class namespace. So `A.marked` is True. Metaclasses are how Django/SQLAlchemy build ORM models from class declarations.

10In Python, what is the difference between __new__ and __init__?

A.They are the same

B.__new__ creates the instance and returns it; __init__ initializes the already-created instance

C.__init__ runs first, then __new__

D.__new__ is called only on subclasses

Explanation: `__new__(cls, ...)` is the actual constructor — it creates and returns the new instance (typically via `super().__new__(cls)`). `__init__(self, ...)` initializes the instance after creation. Override `__new__` for immutable types or singletons; override `__init__` for normal initialization.

About the PCPP1 Exam

The OpenEDG PCPP1 (PCPP-32-101) Certified Professional in Python Programming Level 1 exam validates advanced Python 3 skills: advanced object-oriented programming (ABCs, multiple inheritance, metaclasses, descriptors, design patterns), coding conventions (PEP 8 / PEP 257 / type hints), tkinter GUI programming, network programming with sockets and HTTP, and file processing using xml.etree, json, csv, configparser, sqlite3, and logging.

Questions

45 scored questions

Time Limit

65 min

Passing Score

70%

Exam Fee

$295 (OpenEDG / OpenEDG Testing Service)

PCPP1 Exam Content Outline

~25%

Advanced Object-Oriented Programming

Abstract base classes (abc.ABC, @abstractmethod), multiple inheritance and the diamond problem, mixins, attribute access (__getattr__, __getattribute__, __setattr__, __delattr__), descriptors, metaclasses (type, __new__ vs __init__), advanced exceptions (raise from, exception chaining, contextlib.suppress), classic design patterns (Singleton, Factory, Observer, Strategy, Decorator, Adapter)

~12%

Coding Conventions, Best Practices, and Standardization

PEP 8 (naming conventions, indentation, line length, import order), PEP 257 (docstring conventions), PEP 20 (Zen of Python), PEP 484 (type hints), virtual environments (venv, pip, requirements.txt), package distribution (setup.py vs pyproject.toml, wheels, PyPI basics), unittest / pytest fundamentals

~22%

GUI Programming with tkinter

Tk root window and mainloop, widgets (Label, Button, Entry, Text, Canvas, Listbox, Spinbox, Scale, Checkbutton, Radiobutton), geometry managers (pack, grid, place), event binding, ttk themed widgets, dialogs, after() scheduling, MVC patterns

~16%

Network Programming and REST

socket module (AF_INET / AF_INET6, SOCK_STREAM / SOCK_DGRAM, bind / listen / accept / connect / send / recv), TCP vs UDP, errno handling, HTTP fundamentals, urllib.request, requests library at intro level, REST principles (GET/POST/PUT/DELETE, status codes, JSON payloads)

~25%

File Processing and Communicating with the Environment

xml.etree.ElementTree (parse, find, iter, write), json module (dumps / loads / dump / load), csv module (reader, writer, DictReader, DictWriter), configparser for INI files, sqlite3 (connect, cursor, execute, commit, parameterized queries), logging module (levels, handlers, formatters)

How to Pass the PCPP1 Exam

What You Need to Know

Passing score: 70%
Exam length: 45 questions
Time limit: 65 min
Exam fee: $295

Keys to Passing

Complete 500+ practice questions
Score 80%+ consistently before scheduling
Focus on highest-weighted sections
Use our AI tutor for tough concepts

PCPP1 Study Tips from Top Performers

1Memorize PEP 8 essentials: 4-space indents, max line 79 (or 88 for Black), import order stdlib > third-party > local, snake_case for functions/variables, PascalCase for classes

2Abstract methods raise TypeError on instantiation only if the subclass does not override every @abstractmethod

3Metaclass = a class whose instances are classes; type is the default metaclass; class Meta(type) lets you intercept class creation

4Descriptors: __get__, __set__, __delete__ — @property is the most common descriptor in everyday code

5tkinter geometry managers don't mix in the same parent — pick pack OR grid OR place per container

6Socket flow server: socket > bind > listen > accept > recv > send > close; client: socket > connect > send > recv > close

7xml.etree.ElementTree: parse() returns ElementTree, getroot() returns Element, find/findall use XPath-like paths

8json.dumps(obj) serializes to string; json.dump(obj, file) writes to a file handle — easy to confuse

9sqlite3 always use parameterized queries (? placeholders) — never f-string SQL (injection risk)

10Use the free Python Professional 1 courses on edube.org — they are the official PCPP1 prep material

Frequently Asked Questions

What is the PCPP-32-101 exam?

PCPP-32-101 is the OpenEDG Certified Professional in Python Programming Level 1 (PCPP1) exam administered by the OpenEDG Python Institute. It validates advanced Python 3 skills including ABCs, metaclasses, descriptors, design patterns, PEP 8 / 257, type hints, tkinter GUI programming, socket and REST network programming, and file processing with XML, JSON, CSV, sqlite3, and logging.

How many questions are on the PCPP1 exam?

PCPP-32-101 has 45 questions in 65 minutes. Item types include single-select, multiple-select, drag-and-drop, gap-fill, code insert, and code order. The passing score is a cumulative 70%. Many questions present advanced Python 3 code (e.g., metaclass machinery, tkinter event handlers, socket flow, ElementTree parsing) and ask you to predict output, identify the bug, or complete the design.

Is PCAP required before PCPP1?

PCAP is recommended but not strictly required to register for PCPP-32-101. However, PCPP1 assumes mastery of everything PCAP covers (OOP fundamentals, modules, generators, file I/O, exceptions hierarchy) and goes much deeper. Most PCPP1 candidates have either passed PCAP or have 1-2+ years of professional Python experience.

What is the largest domain on the PCPP1 exam?

Advanced Object-Oriented Programming and File Processing are tied as the largest domains at ~25% each. For OOP, you must master ABCs, multiple inheritance with MRO, metaclasses, descriptors, attribute access protocol (__getattr__, __getattribute__), and classic design patterns. For File Processing, you must master xml.etree, json, csv, configparser, sqlite3, and logging.

How should I prepare for the PCPP1 exam?

Plan for 100-150 hours of study over 10-16 weeks. Use the free Python Professional 1 (PCPP1) courses on Edube Interactive — modules cover advanced OOP, PEP 8, GUI, network, and file processing. Build at least one tkinter application that talks to a REST API and persists data to sqlite3. Complete 100+ practice questions and aim for 80%+ before scheduling.

What jobs can I get with PCPP1 certification?

PCPP1 demonstrates professional-level Python proficiency and supports senior and lead roles such as Senior Python Developer, Backend Engineer, Software Architect, Tech Lead, Senior DevOps Engineer, and Senior Data Engineer. PCPP1 (combined with experience) is one of the strongest formal Python credentials available outside of vendor-specific certifications.