PCPP-32-101 PCPP1 – Certified Professional in Python Programming 1 Question and Answers

A socket object is usually created using the socket() constructor provided by the socket module in Python. The correct invocation is  socket.socket(socket_domain, socket_type) . This creates a new socket object with the specified socket domain and type.

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 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.

The correct answer is  C. Excalibur is the value passed to an instance variable . In the given code snippet,  self.name  is an instance variable of the  Sword  class. When an instance of the  Sword  class is created with  varl = Sword('Excalibur') , the value  'Excalibur'  is passed as an argument to the  __init__  method and assigned to the  name  instance variable of the  varl  object.

The code defines a class called  Sword  with an  __init__  method that takes one parameter  name . When a new instance of the  Sword  class is created with  varl = Sword('Excalibur') , the value of the  'Excalibur'  string is passed as an argument to the  __init__  method, and assigned to the  self.name  instance variable of the  varl  object.

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.

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 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.

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 C. The code creates an XML root element named data and then adds two child elements named car. Each car element receives a brand attribute, one with the value Audi and the other with the value Volkswagen. The statement tree.write('cars.xml', 'UTF-8', True) writes the XML document using UTF-8 encoding and explicitly enables the XML declaration through the third argument. Because the XML declaration is enabled, the output begins with < ?xml version='1.0' encoding='UTF-8'? > . The generated XML body then contains the data element with two self-closing car child elements. Options without the encoding declaration are therefore incomplete.

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 .

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 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 answers are B and D. In Tkinter’s Canvas widget, there is no built-in method named create_shape() or create_triangle_shape(). A triangle can be drawn either with create_line() by connecting three line segments between three coordinate points, or with create_polygon() by providing three vertices. create_polygon() is the more direct method because a triangle is a polygon with three sides, and Tkinter can render it as a filled or outlined shape. create_line() is also valid when the programmer manually draws the three sides and closes the shape. Therefore, the valid Canvas methods for producing a triangle are create_line() and create_polygon().

The true statement related to PEP 257 is  Option B . According to PEP 257, string literals occurring elsewhere in Python code may also act as documentation. They are not recognized by the Python bytecode compiler and are not accessible as runtime object attributes (i.e. not assigned to  doc ), but two types of extra docstrings may be extracted by software tools: String literals occurring immediately after a simple assignment at the top level of a module, class, or  init  method are called “attribute docstrings”.  String literals occurring immediately after another docstring are called “additional docstrings” 1 .

If the main window is too small to fit all its widgets,  some widgets may be invisible . So, the correct answer is  Option A .

When a window is not large enough to display all of its content, some widgets may be partially or completely hidden. The window will not automatically expand to fit all of its content, and no exception will be raised. The widgets will not be automatically scaled down to fit the window’s size.

If the main window is too small to fit all its widgets, some of the widgets may not be visible or may be partially visible. This is because the main window has a fixed size, and if there are more widgets than can fit within that size, some of them will be outside the visible area of the window.

To avoid this issue, you can use layout managers such as  grid ,  pack , or  place  to dynamically adjust the size and position of the widgets as the window changes size. This will ensure that all the widgets remain visible and properly arranged regardless of the size of the main window.

The socket.gaierror exception is raised when an address-related error caused by the getaddrinfo() and getnameinfo() functions occurs. These functions are used to translate hostnames to IP addresses and vice versa, and the gaierror exception is raised if they fail to perform this translation.

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" .