PCPP1 Practice Test 17 — 15 Questions

Question 1

In a team environment, which PEP 8 guideline should be applied to maintain consistent indentation when mixing spaces and tabs?

Accepted Answer

Use spaces exclusively for indentation.. PEP 8 explicitly recommends using spaces exclusively for indentation, with four spaces per indentation level. This avoids the ambiguity and inconsistency that arises when tabs and spaces are mixed, which can lead to Python interpreting indentation differently across editors and causing IndentationError or TabError. Using spaces ensures that code looks the same regardless of editor tab width settings.

Answer

Use tabs exclusively, as they are more efficient for file size.

Answer

Always use a combination of tabs and spaces to allow personal editor configuration.

Answer

Default to the indentation used by the first author of the module.

Question 2

A developer is writing a Python script that contains a class named `DataProcessor`. According to PEP 8, which naming convention should be used for the class's methods and attributes?

Accepted Answer

Methods and attributes should use `lowercase_with_underscores`.. PEP 8 recommends that method names and instance variables use lowercase with underscores (snake_case). This convention distinguishes them from class names, which use CapWords. Following this guideline ensures consistency and readability across Python codebases. The other options suggest styles that are either not recommended (camelCase, CapWords) or misapply the constant convention to attributes.

Answer

Methods and attributes should use `CapWords` to be consistent with the class name.

Answer

Methods and attributes should use `camelCase` to match the class name style.

Answer

Methods should use `lowercase_with_underscores`, but attributes should use `UPPERCASE`.

Question 3

You are implementing a custom context manager using a class. Which methods must be implemented to support the 'with' statement?

Accepted Answer

__enter__ and __exit__.. A context manager requires `__enter__` to set up the resource and `__exit__` to handle cleanup.

Answer

__setup__ and __teardown__.

Answer

__open__ and __close__.

Answer

__init__ and __del__.

Question 4

Which TWO of these are valid PEP 8 recommendations for whitespace?

Accepted Answer

Avoid trailing whitespace.. Option C is correct because PEP 8 explicitly states that trailing whitespace should be avoided anywhere in code, since it is invisible, can cause spurious diffs, and may trigger errors in some tools. Option E is correct because PEP 8 recommends a single space after a comma in expressions and argument lists (e.g., function calls and tuples), which improves readability. Option A is wrong because PEP 8 mandates four spaces per indentation level, not two. Option B is wrong because PEP 8 advises using blank lines sparingly—typically two blank lines around top-level functions and classes—not large blocks of whitespace. Option D is wrong because PEP 8 recommends spaces over tabs for indentation, and mixing tabs and spaces is explicitly discouraged.

Answer

Use two spaces for every level of indentation.

Answer

Use large blocks of whitespace between functions.

Answer

Use tabs for all indentation.

Question 5

A developer is documenting a function `fetch_records` that accepts a database connection, a table name, and an optional limit. The team follows Google Style Python Docstrings. Which approach correctly documents the parameters and their types?

Accepted Answer

List each parameter under an `Args:` section with the parameter name, a colon, and a description that includes the expected type.. Google Style Python Docstrings document parameters in an `Args:` section using the pattern `name (type): description`. This structured format is parsed by documentation tools and keeps type information alongside the parameter name. Other styles, such as Sphinx field lists or unstructured summaries, do not match the convention the team has adopted, so consistency requires the `Args:` form.

Answer

Use a `Parameters:` section modeled on reStructuredText field lists with `:param name:` and `:type name:` entries.

Answer

Describe parameters only in inline `#` comments next to each function call in the calling code.

Answer

Embed the parameter details directly in the first summary line so readers see them immediately.

Question 6

You are preparing a Python module for PyPI. Your project layout is:

project_root/
├── setup.py
├── src/
│   └── mypackage/
│       ├── __init__.py
│       └── core.py
└── tests/
    └── test_core.py

You want to write a test that imports mypackage.core and verifies the function add(a, b). Which import statement should you use at the top of tests/test_core.py to follow best practices for a src-layout project after installing the package in editable mode?

Accepted Answer

from mypackage import core. In a src-layout project, the package is installed into the environment (e.g., editable install) before tests are run, so tests should import the package by its top-level name, not via the src directory. Using 'from mypackage import core' ensures the test exercises the installed code, matches how users will import it, and avoids fragile sys.path assumptions. This aligns with packaging best practices for test isolation.

Answer

from src.mypackage import core

Answer

import core

Answer

import src.mypackage.core as core

Question 7

Which module provides a high-level API for working with URLs, such as parsing and unparsing them?

Accepted Answer

urllib.parse. The 'urllib.parse' module is designed for splitting and joining URL components.

Answer

requests

Answer

socket

Answer

http.client

Question 8

Which TWO of the following exceptions might be raised during socket operations?

Accepted Answer

TimeoutError. TimeoutError (option C) is correct because socket operations that use a timeout (e.g., after calling socket.settimeout() or when a connect/recv/send exceeds the configured timeout) raise socket.timeout, which is an alias/subclass of TimeoutError in Python 3.10+. ConnectionRefusedError (option E) is correct because when a client attempts to connect to a host/port where no process is listening, the TCP RST response causes the OS to report ECONNREFUSED, which Python surfaces as ConnectionRefusedError (a subclass of OSError). The other options do not belong: ImportError (A) relates to module import failures, ValueError (B) is a generic value/argument error not specific to socket I/O, and KeyError (D) arises from missing dictionary keys, none of which are raised by socket operations themselves.

Answer

ImportError

Answer

ValueError

Answer

KeyError

Question 9

Which of the following describes the purpose of the __slots__ attribute in a class?

Accepted Answer

To improve performance and reduce memory usage.. __slots__ restricts the creation of new instance attributes and reduces memory footprint by preventing the creation of a per-instance __dict__.

Answer

To allow private attribute access.

Answer

To define the method resolution order.

Answer

To prevent inheritance.

Question 10

A developer defines a class `Temperature` that stores a Celsius value in `self._celsius` and exposes a `celsius` property with a setter that validates the value is not below absolute zero. After instantiating `t = Temperature(20)`, the developer runs `t.celsius = -300`. What happens?

Accepted Answer

The setter runs, detects the invalid value, and raises a ValueError; `t._celsius` remains 20.. The property setter is invoked on assignment to `t.celsius`, and its validation logic rejects -300. Because the exception is raised before `self._celsius` is updated, the original value remains intact. This demonstrates how properties enforce encapsulation and invariants without changing the public attribute name.

Answer

A TypeError is raised because `t.celsius` is read-only once the property is defined without a deleter.

Answer

The assignment silently succeeds and `t.celsius` returns -300 because properties only intercept reads, not writes.

Answer

Python bypasses the setter because `_celsius` is a private attribute and assigns -300 directly to `t._celsius`.

Question 11

You are implementing a custom Tkinter widget that must validate user input in an Entry field and prevent non-numeric characters from being entered. Which mechanism should you use to intercept and optionally reject each keystroke before it modifies the Entry contents?

Accepted Answer

Register a validation function with entry.config(validate='key', validatecommand=(vcmd, '%P')) and return True or False from it.. Tkinter's built-in validation support is designed for exactly this purpose. Configuring validate='key' with a validatecommand that receives the %P substitution lets the callback inspect the prospective Entry value and return True to accept or False to reject the edit. This intercepts input before it is applied, which is more reliable than post-hoc key bindings that must undo changes.

Answer

Use entry.config(state='readonly') and toggle it in a '<FocusIn>' handler.

Answer

Bind '<Key>' to a handler that deletes the last character if it is not a digit.

Answer

Bind '<KeyRelease>' to a handler that checks the Entry contents and calls entry.delete(0, tk.END) if invalid.

Question 12

Which TWO of the following represent common data formats used for REST API request/response payloads?

Accepted Answer

XML. XML (A) is correct because REST APIs commonly use it as a structured, self-describing payload format, typically with the Content-Type application/xml or text/xml, and many frameworks support XML serialization/deserialization. JSON (D) is correct because it is the most widely used REST payload format, with Content-Type application/json, offering lightweight key-value and array structures that map easily to objects in most languages. The unmarked options do not belong: plain text only (B) is not a structured data format for typical REST payloads, SQL queries (C) are database commands rather than a payload serialization format, and binary-encoded images (E) are media content, not a common structured data format for REST request/response bodies.

Answer

Plain text only

Answer

SQL queries

Answer

Binary-encoded images

Question 13

A Tkinter application has a modal dialog implemented as a Toplevel that collects a numeric discount. The dialog's OK button command calls a validator that may raise ValueError, and you want the dialog to stay open with an inline error label rather than crashing the mainloop. The dialog is opened from the main window with dialog.grab_set() followed by main_window.wait_window(dialog). Which approach correctly keeps the error visible and prevents the exception from propagating out of the Tkinter callback?

Accepted Answer

Wrap the validation logic in try/except ValueError inside the OK button's command, update an error Label's text, and return normally so the callback ends without raising.. Inline validation in a modal Toplevel requires the callback to handle its own exceptions and update widget state instead of letting the error escape into Tkinter's global handler. Catching ValueError, writing to the error Label, and returning normally keeps the dialog alive and interactive, which is exactly what the scenario demands. Threading, nested wait_window, and protocol overrides all miss that central point.

Answer

Move the validation into a separate thread and call dialog.destroy() from that thread when validation fails.

Answer

Call dialog.wait_window(dialog) again inside the OK button command so the dialog blocks until validation succeeds.

Answer

Set dialog.protocol('WM_DELETE_WINDOW', lambda: None) so the dialog cannot be closed while validation is pending.

Question 14

When using the place() geometry manager, what is the purpose of 'relx' and 'rely'?

Accepted Answer

Relative position as a float from 0 to 1.. In Tkinter's place() geometry manager, relx and rely specify the widget's position as a fraction of the parent's width and height, expressed as a float between 0.0 and 1.0. For example, relx=0.5 centers the widget horizontally regardless of the window's actual pixel size. This makes layouts resolution-independent, unlike absolute x/y coordinates.

Answer

Relative font size.

Answer

Relative pixel coordinates.

Answer

Relative Z-index for layering.

Question 15

You are writing a client that must upload a binary file to a REST endpoint using requests.put(). The file is several hundred megabytes, and you want to avoid loading it entirely into memory while still letting the server know the total size. Which approach meets both goals?

Accepted Answer

Open the file in binary mode and pass the file object as the data argument, optionally setting the Content-Length header explicitly.. Supplying an open binary file object as data lets requests stream the body in chunks, avoiding a full in-memory copy, and an explicit Content-Length header communicates the total size. Reading bytes, passing a path string, or base64-encoding into JSON all either consume large memory or send the wrong payload format.

Answer

Read the file with open(path, 'rb').read() and pass the resulting bytes to the data argument.

Answer

Encode the file with base64 and pass the result as a JSON string in the json argument.

Answer

Pass the file path string directly as the data argument so requests opens it on your behalf.