PCPP1 Best Practices And Coding Conventions Practice Test 4 — 15 Questions

Question 1

Which THREE of the following are recommended in PEP 8 for class definitions?

Accepted Answer

Put two blank lines between top-level classes.. Option A is correct because PEP 8's blank-lines rule requires two blank lines around top-level function and class definitions, so separating top-level classes with two blank lines is the recommended style. Option D is correct because PEP 8 prescribes the CapWords (CamelCase) convention for class names, e.g., class MyClass. Option E is correct because PEP 8 states that docstrings should be written for all public modules, functions, classes, and methods, so a class should include a docstring. Option B is not recommended: imports must be placed at the top of the file, after module docstrings and before module-level code, never inside a class body. Option C is not recommended: PEP 8 calls for docstrings on all public classes, and omitting them for private classes is not a PEP 8 rule.

Answer

Place imports inside the class definition.

Answer

Omit docstrings for private classes.

Question 2

A code reviewer notices that a Python module defines a class named `dataProcessor` and a function named `processData`. The team follows PEP 8. Which naming convention should be applied to the class name?

Accepted Answer

Rename the class to `DataProcessor` using CapWords (PascalCase).. PEP 8 recommends CapWords (PascalCase) for class names, so `DataProcessor` is the correct choice. Snake_case, camelCase, and all-uppercase with underscores are used for other purposes: functions/variables, non-standard style, and constants respectively. Adhering to this convention ensures consistency and readability in Python projects.

Answer

Rename the class to `data_processor` using snake_case.

Answer

Keep the class name as `dataProcessor` (camelCase).

Answer

Rename the class to `DATA_PROCESSOR` using all uppercase with underscores.

Question 3

A developer is writing a function that computes the average of a list of numbers. The function should not modify the input list. Which annotation best communicates this intent and aligns with PEP 484 best practices?

Accepted Answer

def average(numbers: Sequence[float]) -> float:. Using Sequence[float] from the typing module communicates that the function accepts any read-only sequence of floats, preserving flexibility while indicating no mutation. This follows PEP 484 guidance to prefer abstract types for parameters. List and Tuple are more specific and imply mutability or a concrete type, which is unnecessarily limiting.

Answer

def average(numbers: List[float]) -> float:

Answer

def average(numbers: Tuple[float, ...]) -> float:

Answer

def average(numbers: list) -> float:

Question 4

A developer is writing a Python function that accepts a mutable default argument, such as `def add_item(item, items=[])`. A code reviewer flags this as a potential bug. Which statement best explains the issue and the recommended fix according to best practices?

Accepted Answer

The default list is shared across all calls, so use `None` as the default and create a new list inside the function.. Mutable default arguments are evaluated once at definition time, causing shared state across calls. The correct practice is to use `None` as a default and create a new mutable object inside the function. This avoids bugs where data unexpectedly persists. Other options either misdiagnose the problem or propose ineffective solutions.

Answer

The default list is copied for each call, so the only issue is performance; use a tuple for efficiency.

Answer

The default list is immutable, so it cannot be modified; use a tuple instead.

Answer

The default argument is re-evaluated on each call, so the code is safe; no change is needed.

Question 5

A developer is adding a new public function `calculate_discount` to an existing Python module. The module currently uses four spaces per indentation level, and the function spans several nested `if` blocks. Which PEP 8 indentation practice should the developer follow?

Accepted Answer

Use four spaces per indentation level throughout the function and avoid mixing tabs with spaces.. PEP 8 recommends four spaces per indentation level and spaces over tabs. Because the existing module already uses four spaces, the new function should match that convention to keep the file internally consistent and avoid tab/space mixing, which Python 3 can reject with `TabError`. Consistency within a module matters more than personal preference.

Answer

Use one tab per indentation level because tabs render consistently in every IDE.

Answer

Use two spaces per indentation level to keep deeply nested blocks from drifting too far right.

Answer

Use a mix of tabs for the outer blocks and spaces for the inner blocks to visually separate nesting levels.

Question 6

You are designing a Python class that manages a database connection. The class has a method `_execute_query` that should only be used internally. According to Python best practices and PEP 8, how should you indicate that this method is for internal use only?

Accepted Answer

Prefix the method name with a single underscore: `_execute_query`.. PEP 8 specifies that a single leading underscore should be used to indicate that an attribute or method is intended for internal use. This is a widely recognized convention in Python. Double underscores are for name mangling, comments are not a convention, and there is no standard `@internal` decorator.

Answer

Prefix the method name with two underscores: `__execute_query`.

Answer

Use the `@internal` decorator from the `typing` module.

Answer

Add a comment above the method: `# Internal use only`.

Question 7

A team is reviewing code and notices that a function uses a mutable default argument: def append_to(element, target=[]):. Which change best adheres to Python best practices and avoids unexpected behavior?

Accepted Answer

def append_to(element, target=None): if target is None: target = []. Mutable default arguments are evaluated once at function definition, so using a list as a default causes state to persist across calls. The best practice is to use None as the default and create a new list inside the function. This ensures each call without an explicit target gets a fresh list, preventing unintended side effects.

Answer

def append_to(element, target=[]): target.append(element); return target

Answer

def append_to(element, target=list()): target.append(element); return target

Answer

def append_to(element, target=()): target.append(element); return target

Question 8

A team is reviewing a module where a helper function `_normalize_path` is prefixed with a single underscore. A new developer asks which statement best describes the intent of that naming choice according to common Python conventions.

Accepted Answer

The single underscore signals that the function is intended for internal use and is not part of the module's public API.. A leading single underscore is a convention that marks a name as internal, signaling that it is not part of the public API and may change without notice. It provides no runtime enforcement, so callers can still use it, but doing so is discouraged. This convention helps communicate intent in `_normalize_path` without altering behavior.

Answer

The single underscore marks the function as deprecated and scheduled for removal in a future release.

Answer

The single underscore makes the function inaccessible from outside the module at runtime.

Answer

The single underscore indicates that the function is a special method recognized by the Python interpreter.

Question 9

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 10

A developer is writing a Python script and wants to ensure that the code adheres to PEP 8's recommendations for blank lines. According to PEP 8, how many blank lines should surround a top-level function definition?

Accepted Answer

Two blank lines before and after the function definition.. PEP 8 recommends two blank lines before and after top-level function and class definitions. This provides clear visual separation and improves readability. One blank line is used for methods inside classes, and no blank lines would make the code cramped. Three blank lines are excessive. The correct choice is two blank lines.

Answer

No blank lines are required; the function can be adjacent to other code.

Answer

One blank line before and after the function definition.

Answer

Three blank lines before and after the function definition.

Question 11

A Python developer is writing a function that reads a configuration file and returns a dictionary. They want to follow PEP 8 and best practices for function design and documentation. Which two of the following should they do? (Choose two.)

Accepted Answer

Include a docstring that describes the function's purpose, parameters, and return value.. Following PEP 8 and best practices, function names should be descriptive and use lowercase with underscores, and public functions should have docstrings that explain their purpose, parameters, and return values. These practices enhance code readability and maintainability. The other options either use unclear parameter names, raise overly broad exceptions, or misplace the function relative to imports, all of which violate established conventions.

Answer

Place the function at the top of the file, before any imports, to make it easily accessible.

Answer

Raise a generic `Exception` if the file cannot be read, to keep error handling simple.

Answer

Use a single-letter parameter name like `f` for the file path to keep the signature short.

Question 12

A developer is writing a Python module and wants to follow best practices for documenting functions. Which TWO of the following are recommended by PEP 257 for docstrings? (Choose two.)

Accepted Answer

The docstring should be enclosed in triple double quotes (""").. PEP 257 recommends using triple double quotes for docstrings and that they should describe the function's purpose and parameters. It also advises that a one-line docstring should end with a period, but does not require all docstrings to be single-line. No blank line should precede the docstring, and there is no rule about uppercase.

Answer

The docstring should be a single line that ends with a period.

Answer

The docstring should be separated from the function definition by a blank line.

Answer

The docstring should be written in all uppercase letters.

Question 13

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 14

A developer is writing a Python module and wants to follow PEP 8's recommendations for imports. The module currently has the following imports: `import os`, `import sys`, `import requests`, `from collections import defaultdict`. According to PEP 8, how should these imports be grouped and ordered?

Accepted Answer

Standard library imports first, then third-party imports, each group separated by a blank line.. PEP 8 specifies that imports should be grouped in the order: standard library, third-party, and local application/library specific. Each group should be separated by a blank line. In the given scenario, `os`, `sys`, and `collections` are standard library, while `requests` is third-party. Therefore, standard library imports should come first, followed by a blank line, then third-party imports.

Answer

All imports should be sorted alphabetically regardless of origin.

Answer

Imports should be placed on separate lines, and no blank lines are needed between groups.

Answer

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

Question 15

A Python developer is reviewing code and notices that a function has a default argument value set to an empty list: `def append_to(element, target=[]):`. According to best practices, what is the recommended way to handle mutable default arguments?

Accepted Answer

Use `None` as the default and create a new list inside the function if needed.. Mutable default arguments are evaluated once at function definition, leading to shared state. The recommended practice is to use None as the default and create a new mutable object inside the function when needed. This ensures each call gets a fresh object unless one is explicitly passed.

Answer

Keep the empty list as the default; Python handles it safely.

Answer

Use a tuple instead of a list as the default value.

Answer

Define the default argument inside the function body instead.