PCPP-32-101 Python Institute PCPP1 – Certified Professional in Python Programming 1 Free Practice Exam Questions (2026 Updated)

C. w.resizable()

The  resizable()  method takes two Boolean arguments,  width  and  height , that specify whether the main window can be resized in the corresponding directions. Passing  False  to both arguments makes the main window non-resizable, whereas passing  True  to both arguments (or omitting them) makes the window resizable.

Here is an example that sets the dimensions of the main window to 500x400 pixels and makes it non-resizable:

import tkinter as tk

root = tk. Tk ()

root. geometry ( "500x400" )

root. resizable (False, False)

root. mainloop ()

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.

Composition is an object-oriented design concept that models a  has-a relationship . In composition, a class known as  composite  contains an object of another class known as  component .  In other words, a composite class has a component of another class 1 .

B. Composition allows a class to be projected as a container of different classes.

Composition is a concept in Python that allows for building complex objects out of simpler objects, by aggregating one or more objects of another class as attributes. The objects that are aggregated are generally considered to be parts of the whole object, and the containing object is often viewed as a container for the smaller objects.

In composition, objects are combined in a way that allows for greater flexibility and modifiability than what inheritance can offer. With composition, it is possible to create new objects by combining existing objects, by using a container object to host other objects. By contrast, with inheritance, new objects extend the behavior of their parent classes, and are limited by that inheritance hierarchy.

The correct answer is  B. The getNumberofCrosswords() method should be decorated with @classmethod . In the given code snippet, the  getNumberofCrosswords  method is intended to be a class method that returns the value of the  numberofcrosswords  class variable. However, the method is not decorated with the  @classmethod  decorator and does not take a  cls  parameter representing the class itself. To make  getNumberofCrosswords  a proper class method, it should be decorated with  @classmethod  and take a  cls  parameter as its first argument.

B. The  getNumberofCrosswords()  method should be decorated with  @classmethod .

This is because the  getNumberofCrosswords()  method is intended to access the class-level variable  numberofcrosswords , but it is defined as an instance method, which requires an instance of the class to be created before it can be called. To make it work as a class-level method, you can define it as a class method by adding the  @classmethod  decorator to the function.

Here's an example of how to define  getNumberofCrosswords()  as a class method:

class Crossword :

numberofcrosswords = 0

def __init__(self, author, title):

self.author = author

self.title = title

Crossword.numberofcrosswords += 1

@classmethod

def getNumberofCrosswords (cls):

return cls.numberofcrosswords

In this example,  getNumberofCrosswords()  is defined as a class method using the  @classmethod  decorator, and the  cls  parameter is used to access the class-level variable  numberofcrosswords .

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.

The correct answers are A and C. Option A uses a concise one-line docstring that explains the function’s purpose in a useful way. It follows the common Python documentation style by describing what the function returns rather than repeating implementation mechanics. Option C is also useful because the inline comment explains why the value is being adjusted, not merely what the code already shows. Option B is poor because it restates the obvious operation n = n - 1; such comments add noise instead of clarity. Option D is weaker because the docstring describes internal mechanics and argument handling rather than the function’s intended result. Good Python comments should clarify intent, purpose, or non-obvious reasoning.

 The true statement about the  __name__  attribute is  D. name is a special attribute, which is inherent for classes, and it contains the name of a class . The  __name__  attribute is a special attribute of classes that contains the name of the class as a string.

The  __name__  attribute is a special attribute in Python that is available for all classes, and it contains the name of the class as a string. The  __name__  attribute can be accessed from both the class and its instances using the dot notation.

The snippet raises a NameError because the variable height is referenced inside the constructor but is never defined. The __init__() method accepts only weight and sex as parameters, apart from self. When kitty = Cat(1, 'male') is executed, Python enters the constructor and evaluates self.height = height. Since there is no local variable, parameter, global variable, or built-in name called height, Python raises a NameError before the object is fully initialized. Because object construction fails, kitty.say() is never reached. The code does not print meows, and it does not raise ValueError, because the problem is not an invalid value but an undefined name.

To test whether two variables refer to the same object in memory, you should use the  is  operator. The  is  operator returns  True  if the two variables point to the same object in memory, and  False  otherwise.

For example:

a = [1, 2, 3]

b = a

c = [1, 2, 3]

print(a is b) # True

print(a is c) # False

In this example,  a  and  b  refer to the same list object in memory, so  a is b  returns  True . On the other hand,  a  and  c  refer to two separate list objects with the same values, so  a is c  returns  False .

The cget() method in Python is used to read the configuration options of a widget in Tkinter. It retrieves the value of a specified configuration option for a Tkinter widget. Hence, option A is the correct answer.

The correct answers are C and D. PEP 8 recommends that module names should be short and entirely lower-case; underscores may be used only when they improve readability. This keeps imports clean and predictable. PEP 8 also warns against using the single-character variable names l, O, or I because they can be visually confused with 1 and 0 in many fonts. Option A is incorrect because Python class names should normally use the CapWords convention, not mixedCase. Option B is incorrect because exception names are class names and should follow class naming conventions; if the exception represents an error, the name should usually end with Error.

A. It addresses a service deployed at localhost (the host where the code is run).

This statement is true because localhost is a special hostname that refers to the local machine or the current host where the code is run. It is equivalent to using the IP address 127.0.0.1, which is the loopback address of the network interface. By using localhost as the hostname, the invocation addresses a service that is deployed on the same machine as the client.

D. It addresses a service listening at port 3000.

This statement is true because port 3000 is the part of the URL that follows the colon after the hostname. It specifies the port number where the service is listening for incoming requests. A port number is a 16-bit integer that identifies a specific process or application on a host. By using port 3000, the invocation addresses a service that is listening at that port.

B. It addresses a service whose timeout is set to 3000 ms.

This statement is false because timeout is not a part of the URL, but a parameter that can be passed to the requests.get () function in Python. Timeout specifies how long to wait for the server to send data before giving up. It is measured in seconds, not milliseconds. By using timeout=3, the invocation sets the timeout to 3 seconds, not 3000 ms.

C. It addresses a service located at the following address local.host.com.

This statement is false because local.host.com is not the same as localhost. Local.host.com is a fully qualified domain name (FQDN) that consists of three parts: local, host, and com. It requires DNS resolution to map it to an IP address. Localhost, on the other hand, is a special hostname that does not require DNS resolution and always maps to 127.0.0.1. By using localhost as the hostname, the invocation does not address a service located at local.host.com.

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 B because Python’s pickle module can serialize many built-in data types, including integers, floating-point numbers, complex numbers, strings, bytes, bytearrays, booleans, and None. However, it does not serialize the actual implementation or definition body of functions and classes. Top-level functions and classes may sometimes be pickled by reference using their fully qualified names, but their code definitions are not stored inside the pickle byte stream. This distinction matters: pickle records enough information to locate an object again during unpickling, but it does not preserve source code, nested definitions, lambda functions, or dynamically created definitions in a portable way. Therefore, “function and class definitions” is the option that cannot truly be pickled as definitions.

Option A is true because PEP 8 recommends that function and variable names should be lowercase, with words separated by underscores .

Option D is true because PEP 8 recommends that constants should be written in all capital letters with words separated by underscores .

PEP 8 is the official style guide for Python code. It provides guidelines for how to write readable code that follows consistent naming conventions. The aim of PEP 8 is to improve the readability of Python code and make it easier to understand and maintain.

According to PEP 8, variable and function names should be written in all lower-case letters with words separated by underscores, as stated in A. Constants, which are variables whose value is expected to remain constant throughout the code, should be written in all upper-case letters with words separated by underscores, as stated in D.

The json.dumps() function is used to convert a Python object into a JSON string  1 . It takes Python data as its argument, such as a dictionary or a list, and returns a JSON string.

The correct answers are  B. Option B  and  D. Option D . Both options B and D are compliant with PEP 8 recommendations for line breaks and indentation. PEP 8 recommends using 4 spaces per indentation level and breaking lines before binary operators. In option B, the arguments to the  print  function are aligned with the opening delimiter, which is another acceptable way to format long lines according to PEP 8. In option D, the second line is indented by 4 spaces to distinguish it from the next logical line.

The correct answers are A and B. Option A uses a clean multi-line dictionary layout, placing each key-value pair on its own line and aligning the closing brace clearly. This is readable and consistent with PEP 8’s preference for clear continuation formatting. Option B is also compliant because continuation lines are aligned with the opening delimiter of the function call, which is an accepted PEP 8 style. Option C is not compliant because the function call is split awkwardly, making the call structure unclear and damaging readability. Option D uses unnecessary spaces inside braces and around dictionary colons; PEP 8 discourages extraneous whitespace in expressions and dictionary displays.