PCPP1 Practice Test 22 — 15 Questions

Question 1

What is the result of applying the @staticmethod decorator to a method inside a class that also defines a metaclass?

Accepted Answer

The method is correctly bound as a static function regardless of the metaclass.. The @staticmethod decorator creates a static method object which is stored in the class dictionary; it is independent of the metaclass's __init__ logic for instance methods.

Answer

The metaclass must manually convert it back to a static method.

Answer

It raises a TypeError at class definition time.

Answer

The metaclass will treat the method as an instance method.

Question 2

You are writing a reusable module that must expose only a small public API while keeping several helper functions and constants internal. Users of the module should not import the helpers with 'from mymodule import *', but direct access such as mymodule._helper() may still be needed for tests. Which approach fits best?

Accepted Answer

Rename every helper with a leading underscore and define __all__ listing only the public names.. Marking implementation details with a leading underscore communicates that they are non-public, while __all__ explicitly defines which names a star import exports. Because __all__ only affects star imports, the underscored helpers remain directly accessible as attributes for unit tests. This pairing gives a precise, documented public API without making the internals unreachable.

Answer

Rename every helper with a leading underscore and omit __all__ entirely.

Answer

Define __all__ listing only the public names and leave helper names unchanged.

Answer

Place the helpers in a nested class and expose them as static methods of that class.

Question 3

You are writing a class `Temperature` that should support addition and comparison. You want `t1 + t2` to return a new `Temperature` object, and `t1 == t2` to compare their values. Which magic methods must you implement to achieve this?

Accepted Answer

__add__ and __eq__. To support the + operator, a class must implement __add__. For equality comparison with ==, it must implement __eq__. These two methods directly correspond to the requested operations. Other methods like __iadd__ or __radd__ serve different purposes and are not required for the basic behavior described.

Answer

__radd__ and __eq__

Answer

__add__ and __cmp__

Answer

__iadd__ and __eq__

Question 4

A desktop tool built with Tkinter needs a list of departments shown as mutually exclusive radio buttons. When the user selects a department, the underlying model object's department attribute must update immediately, and the code must read the selection later without iterating over every radio button. Which Tkinter mechanism best satisfies these requirements?

Accepted Answer

Create an IntVar or StringVar, pass it as the variable option to every Radiobutton in the group, and read or trace that variable when the model needs updating.. A shared Tkinter variable is the mechanism that ties a group of Radiobuttons together and makes their selection readable as a single value. Because the variable can be traced, the model updates the moment the user clicks, and later reads need only the variable rather than a loop over widgets. Separate variables, Listboxes, and Comboboxes all fail at least one stated requirement.

Answer

Use a ttk.Combobox and call get() on it whenever the model is saved to the database.

Answer

Give each Radiobutton its own BooleanVar and inspect all of them with cget when the model needs the current department.

Answer

Use a Listbox configured with selectmode='browse' and read its curselection() to determine the chosen department.

Question 5

You are using the datetime module to calculate the difference between two dates. You have two datetime objects, start and end, and you need to find the number of full days between them, ignoring any fractional part. Which expression correctly computes this?

Accepted Answer

(end - start).days. Subtracting two datetime objects produces a timedelta object. The .days attribute of a timedelta gives the number of full days between the two dates, as an integer, discarding any partial day. This is the correct way to get the number of whole days. Other attributes like .seconds and .microseconds represent only the respective components, not the total duration.

Answer

(end - start).microseconds / 86400000000

Answer

(end - start).total_seconds() / 86400

Answer

(end - start).seconds / 86400

Question 6

You are building a Tkinter desktop application with a menu bar. Users report two problems: keyboard shortcuts such as Ctrl+S do not trigger the Save command when focus is inside a Text widget, and mnemonic underlines on the File menu are missing. You must correct the menu configuration. Which two changes should you make? (Choose two.)

Accepted Answer

Bind the event to the save handler on the root window or on the widget that holds focus, in addition to adding the menu entry.. In Tkinter, the accelerator option only displays shortcut text and does not install a binding, so making Ctrl+S work requires an explicit binding of to the handler. Separately, mnemonic underlines come from the underline option, which names the character index to underline on the menu label. Applying those two settings fixes the reported shortcut and underline problems.

Answer

Configure the menu entry with state="normal" so keyboard traversal is enabled for the File menu.

Answer

Set tearoff=0 on the menubar so the File menu can be detached and the underline becomes visible.

Answer

Pass accelerator="Ctrl+S" to the Save menu entry so the shortcut text is displayed next to the command.

Question 7

You are creating a dialog window in a Tkinter application that must block interaction with the main window until the user closes it, and must return a value to the caller. Which approach correctly implements this behavior?

Accepted Answer

Create a Toplevel, call grab_set() on it, use wait_window() to wait until it is destroyed, then read the stored result.. A modal dialog must prevent input to other application windows and block the caller until dismissed. Creating a Toplevel, calling grab_set() to capture input, and then calling wait_window() achieves both: the grab routes events to the dialog, and wait_window() suspends the caller until the dialog is destroyed. Storing the result on the dialog instance before destruction lets the caller retrieve it after wait_window() returns.

Answer

Use the messagebox.askyesno() function, since it returns a value and is always modal.

Answer

Set the Toplevel's transient() option to True and call update() in a loop until the user closes it.

Answer

Create a Toplevel, call its mainloop(), and read a global variable after it returns.

Question 8

A `Temperature` class stores a numeric `celsius` attribute. Callers keep assigning `temp.celsius = -500`, which is physically impossible. You want any assignment below absolute zero to raise `ValueError` while keeping normal attribute access unchanged. Which construct should you implement?

Accepted Answer

A `property` named `celsius` whose setter validates the incoming value before storing it in a private attribute.. A `property` is the idiomatic way to validate a single attribute: its setter runs on every assignment and can raise `ValueError` before the value is stored, while the getter preserves ordinary read syntax. Broader hooks like `__setattr__` or `__getattribute__` affect all attributes and are harder to reason about. Slots control structure, not values, so they cannot enforce the physical limit.

Answer

Implement `__getattribute__` to compute `celsius` on demand and reject invalid reads with `ValueError`.

Answer

Define `__slots__ = ('celsius',)` so that Python enforces type and range constraints on the slot automatically.

Answer

Override `__setattr__` on the class to accept a value only when the attribute name is `celsius` and the value is valid.

Question 9

A developer is designing a `Shape` base class and wants subclasses to be forced to implement an `area()` method. Which two approaches are valid in Python for enforcing that subclasses provide `area()`? (Choose two.)

Accepted Answer

Define `area` in the base class with a body that raises `NotImplementedError`, so subclasses fail at call time if they forget to override.. Python enforces method implementation either through the `abc` module's `@abstractmethod` mechanism, which blocks instantiation until overrides exist, or through a base method that raises `NotImplementedError` at call time. The first is stricter and catches errors earlier; the second is a simpler convention that still signals missing overrides clearly.

Answer

Assign `area = None` in the base class body so calling `area()` raises TypeError automatically.

Answer

Decorate `area` with `@staticmethod` in the base class so subclasses must redefine it to avoid a TypeError.

Answer

Use `__slots__ = ('area',)` in the base class to declare `area` as a required slot that subclasses must fill.

Question 10

How do you implement the 'Strategy' pattern in Python?

Accepted Answer

By passing strategy instances into the context constructor.. By injecting different strategy objects into a context class, which then delegates operations to the injected object.

Answer

By using a large switch-case statement.

Answer

By creating a metaclass for all strategies.

Answer

By using inheritance for every strategy.

Question 11

A developer wants to ensure that a method `area` in a base class `Shape` must be overridden by any concrete subclass. The developer writes `class Shape(ABC):` and `@abstractmethod def area(self): ...`. A colleague then creates `class Circle(Shape):` without implementing `area` and tries to instantiate `Circle()`. What happens?

Accepted Answer

A `TypeError` is raised at instantiation time because `Circle` still has abstract methods.. The `ABCMeta` metaclass maintains a set of abstract method names on each class. A subclass that does not override all of them keeps a non-empty set, and instantiation raises `TypeError`. The `...` body is irrelevant because the abstract method is never invoked; enforcement happens before the object exists.

Answer

`Circle()` succeeds and `area()` returns `None` because the base method body is `...`.

Answer

`Circle()` succeeds, and calling `area()` later raises `NotImplementedError`.

Answer

A `SyntaxError` is raised when the `Circle` class definition is parsed.

Question 12

Which THREE of the following are valid methods of the xml.etree.ElementTree.Element class?

Accepted Answer

find(). The xml.etree.ElementTree.Element class provides find(), append(), and set() as valid instance methods. find(match) searches the element's direct children for the first subelement matching the tag or path and returns it (or None), which is a core Element API method. append(subelement) adds a child Element to the end of the element's list of children, and set(key, value) sets an attribute on the element, both being standard Element methods. write() is not an Element method; it belongs to the ElementTree class (ElementTree.write(file, encoding, xml_declaration, ...)), which serializes the whole tree to a file. to_string() is also not an Element method; serialization to a string is done via xml.etree.ElementTree.tostring(element) (no underscore), so option E is invalid.

Answer

write()

Answer

to_string()

Question 13

You are writing a script that downloads a large file from a REST endpoint using `requests.get(url, stream=True)`. You want to write the content to disk in chunks rather than loading it all into memory. Which approach correctly implements chunked reading?

Accepted Answer

for chunk in response.iter_content(chunk_size=8192): file.write(chunk). Streaming a large download requires reading the body incrementally. The iter_content() method yields chunks of a specified size and is the standard way to write streaming responses to disk without buffering the whole payload. Using response.content or response.raw.read() without a size loads everything into memory, while iter_lines() is intended for line-delimited text streams.

Answer

file.write(response.raw.read())

Answer

for chunk in response.iter_lines(): file.write(chunk)

Answer

file.write(response.content)

Question 14

You are creating a Tkinter application with a Canvas widget. You draw a circle using create_oval and assign it the tag 'ball'. Later, you want to move the circle 10 pixels to the right and 5 pixels down. Which Canvas method should you use?

Accepted Answer

canvas.move('ball', 10, 5). The Canvas.move method is designed to shift items by a relative offset. It accepts a tag or item ID and delta x and delta y values. The other methods either set absolute coordinates, do not exist, or are from different libraries. Thus, move is the correct choice for moving the circle by (10,5).

Answer

canvas.coords('ball', 10, 5)

Answer

canvas.translate('ball', 10, 5)

Answer

canvas.moveto('ball', 10, 5)

Question 15

A development team is refactoring a legacy Python module. They want to enforce a consistent import ordering convention across the codebase. According to PEP 8, which grouping and ordering of imports is considered best practice?

Accepted Answer

Standard library imports first, then third-party imports, then local application imports, with each group separated by a blank line.. PEP 8 recommends grouping imports into three distinct categories: standard library, third-party, and local application. Each group should be separated by a blank line. This ordering is not just stylistic; it helps developers quickly understand a module's dependencies and ensures that imports are logically organized. Alphabetical sorting within each group is also encouraged but not mandatory.

Answer

Third-party imports first, followed by standard library imports, to highlight external dependencies.

Answer

Local application imports first, then standard library and third-party imports mixed together alphabetically.

Answer

All imports in a single block, sorted alphabetically by module name, regardless of origin.