Free Practice Questions for the Python Institute PCPP1 PCPP-32-101 Exam (2026 Updated)

The correct answers are  A. An attribute owned by every exception object  and  D. An attribute that holds interesting information that is particularly useful when the programmer wants to store exception details in other objects . A traceback is an attribute of an exception object that contains a stack trace representing the call stack at the point where the exception was raised. The traceback attribute holds information about the sequence of function calls that led to the exception, which can be useful for debugging and error reporting.

The provided code snippet defines a function  f1  that accepts variable-length arguments using the  *args  and  **kwargs  syntax. The  *args  parameter allows for an arbitrary number of unnamed arguments to be passed to the function as a tuple, while the  **kwargs  parameter allows for an arbitrary number of named arguments to be passed to the function as a dictionary.

Therefore, the correct statement that best describes the code is:

B. The  *args  parameter holds a list of unnamed parameters, while the  **kwargs  parameter holds a dictionary of named parameters.

Option A is true because PEP 8 recommends avoiding extraneous whitespace immediately inside parentheses, brackets or braces  1 .

Option C is true because PEP 8 recommends avoiding extraneous whitespace between a trailing comma and a following close parenthesis  1 .

The issue is method resolution order, commonly called MRO. In Python multiple inheritance, the interpreter must build a consistent linear inheritance path for the class. Here, B already inherits from A, meaning B must appear before A in the resolution order. However, class C(A, B) asks Python to resolve A before B. These two requirements conflict, so Python cannot create a valid MRO for class C. This results in a TypeError related to inconsistent method resolution order. The absence of an __init__() method is not a problem because Python supplies a default initializer. Also, C can inherit run() if the inheritance order is valid.

The correct answer is A because { 1 } is not valid JSON syntax. In JSON, curly braces represent an object, but an object must contain name-value pairs. Property names must be strings enclosed in double quotation marks, followed by a colon and a value, such as {"id": 1}. The expression { 1 } contains a numeric value inside braces without a property name or colon, so it cannot be parsed as a JSON object. It is also not an array, because JSON arrays use square brackets, such as [1]. It is not an integer either, because the braces change the syntax. Therefore, this JSON string is erroneous.

In the given code snippet, the  repeat  function is a decorator that takes an argument  num_times  specifying the number of times the decorated function should be called. The  repeat  function returns an inner function  wrapper_repeat  that takes a function  func  as an argument and returns another inner function  wrapper  that calls  func   num_times  times.

The provided code snippet represents an example of a decorator that accepts its own arguments. The  @decorator_function  syntax is used to apply the  decorator_function  to the  some_function  function. The  decorator_function  takes an argument  arg1  and defines an inner function  wrapper_function  that takes the original function  func  as its argument. The  wrapper_function  then returns the result of calling  func , along with the  arg1  argument passed to the  decorator_function .

Here is an example of how to use this decorator with  some_function :

@ decorator_function ( "argument 1" )

def some_function ():

return "Hello world"

When  some_function  is called, it will first be passed as an argument to the  decorator_function . The  decorator_function  then adds the string  "argument 1"  to the result of calling  some_function()  and returns the resulting string. In this case, the final output would be  "Hello world argument 1" .

If you do not define the quoting argument in the writer method provided by the csv module, the default quoting behavior is set to QUOTE_MINIMAL. This means that fields containing special characters such as the delimiter or newline character will be quoted, while fields that do not contain special characters will not be quoted.

ConfigParser is a built-in library in Python that allows you to read and write configuration files. The read method is used to read the configuration file which can be in any of the supported file formats, such as INI, YAML, and JSON. The read_dict method is used to read the configuration from a Python dictionary. The read_conf and read_str options are not valid methods in the ConfigParser module.

Therefore, the correct options to load a configuration using ConfigParser are A. read and D. read_string.

The correct answer is B. The ConfigParser.sections() method returns a list of section names, but it does not include the special DEFAULT section. Therefore, even though config['DEFAULT'] = {} is present, DEFAULT is excluded from the printed result. The code then creates three regular sections: mysql, postgresql, and redis. Assigning config['redis'] = config['postgresql'] creates or updates a separate section named redis using the values from the postgresql section; it does not duplicate the section name postgresql in the section list. Therefore, the output contains only the normal section names: ['mysql', 'postgresql', 'redis'] .

The correct answer is == because this operator compares object values, not object identity. In Python, == calls the equality comparison mechanism, usually through the __eq__() special method, to determine whether two objects are equivalent in value. For example, two different lists [1, 2, 3] and [1, 2, 3] are separate objects in memory, but list1 == list2 returns True because their contents match. The is operator checks whether two variables refer to the exact same object in memory, which is a different question. The id() function returns an object identity number, while isinstance() checks type membership. Therefore, for value equality, == is the correct operator.

Option B is true because the  unbind()  method is invoked from within a widget’s object  1 .

Option D is true because the  unbind()  method needs the event name as an argument  1 .

The  unbind()  method in Tkinter is used to remove a binding between an event and a function. It can be invoked from within a widget's object when a binding is no longer needed. The method requires the event name as an argument to remove the binding for that specific event. For example:

button = tk.Button(root, text="Click me")

button.bind(" < Button-1 > ", callback_function) # bind left mouse click event to callback_function

button.unbind(" < Button-1 > ") # remove the binding for the left mouse click event

The correct answer is A. In Tkinter event handling, an event object contains information about the event that occurred. One of its useful attributes is widget, which refers to the actual widget object that caused or received the event. This is not merely the widget’s name as text; it is a reference to the widget instance itself. That means the event handler can inspect or manipulate the widget directly, for example by reading its configuration or changing its displayed value. Option B and option D are incorrect because they describe a name, not an object reference. Option C is unrelated, since run() is not part of Tkinter event object semantics.

In the given code snippet, an instance of  OwnMath  exception is raised with an explicitly specified  __cause__  attribute that refers to the original exception ( ZeroDivisionError ). This is an example of explicitly chaining exceptions in Python.

In the JSON processing context, the term serialization: A. names a process in which Python data is turned into a JSON string.

Serialization refers to the process of converting a data object, such as a Python object, into a format that can be easily transferred over a network or stored in a file. In the case of JSON, serialization refers to converting Python data into a string representation using the JSON format. This string can be sent over a network or stored as a file, and later deserialized back into the original Python data object.

The correct answers are B and C. In Python, exception objects have a __traceback__ attribute that stores traceback information connected with the point where the exception was raised. This makes option C true. The traceback object can be processed using functions from the traceback module, including traceback.format_tb(), which formats traceback entries into readable strings, so option B is also true. Option A is wrong because __traceback__ is not a special method and is not “delivered” by the traceback module; it is an exception attribute. Option D is also incorrect because the attribute is not limited only to exceptions in an explicit or implicit exception chain.

The given code snippet demonstrates the concept of encapsulation in object-oriented programming. Encapsulation refers to the practice of keeping the internal state and behavior of an object hidden from the outside world and providing a public interface for interacting with the object. In the given code snippet, the  __init__  and  get_balance  methods provide a public interface for interacting with instances of the  BankAccount  class, while the  __balance  attribute is kept hidden from the outside world by using a double underscore prefix.

The correct answer is D. Tkinter widgets support many configuration options, and options such as width, underline, and highlightthickness are valid properties for relevant widgets. For example, width can define widget size, underline can specify which character should be underlined in text-based widgets, and highlightthickness controls the thickness of the focus highlight border. The option depth, however, is not a standard Tkinter widget configuration property. Tkinter widget options are specific names understood by the underlying Tk system, and unsupported names normally produce configuration errors when used. Therefore, among the listed options, depth is the one that does not belong as a Tkinter widget property.