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

Question 1

Which comment style is preferred for block comments in Python?

Accepted Answer

Each line starting with a single '#' and a space.. Block comments should consist of paragraphs of text, each starting with a # and a single space.

Answer

Using a string literal (triple quotes) at the top level.

Answer

Using block comments inside a single line.

Answer

Using a single '#' at the end of every line.

Question 2

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 3

When is it acceptable to ignore PEP 8 guidelines?

Accepted Answer

When necessary to maintain consistency with existing code or for legacy reasons.. PEP 8 itself states that project consistency and backward compatibility may warrant exceptions to the rules.

Answer

Only when you disagree with the stylistic choice.

Answer

Never.

Answer

When you are writing a script that will only be used once.

Question 4

When creating a new project, how should you structure your imports?

Accepted Answer

Standard library imports, then third-party, then local, with blank lines between groups.. PEP 8 specifies that imports should be grouped in the order: standard library, related third-party, then local application/library imports, with a blank line between each group. Within each group, imports should be sorted alphabetically. This convention makes dependencies explicit and helps detect circular imports early.

Answer

In the order they are used in the file.

Answer

Alphabetically regardless of source.

Answer

All in a single line separated by semicolons.

Question 5

How should one handle the 'KeyboardInterrupt' exception if it must be caught for cleanup purposes?

Accepted Answer

Catch it, clean up resources, and then use 'raise'.. You should catch it, perform the cleanup, and then re-raise it so the application still shuts down gracefully.

Answer

Prevent it by setting a signal handler for SIGINT.

Answer

Use a bare 'except:' clause.

Answer

Catch it and ignore it to keep the app running.

Question 6

What is the recommended way to handle a function that requires a large number of arguments?

Accepted Answer

Group related parameters into a dataclass or object.. If a function has too many arguments, it is often a sign it should be broken down or that a configuration object should be used.

Answer

Just define the function with many arguments; it is perfectly fine.

Answer

Use a single argument dictionary.

Answer

Use *args and **kwargs for everything.

Question 7

Which TWO of the following are valid conventions for naming in Python according to PEP 8?

Accepted Answer

Classes: PascalCase. Option B is correct because PEP 8 specifies that class names should use the CapWords (PascalCase) convention, e.g., class MyClass. Option E is correct because PEP 8 states that variable names should be lowercase with words separated by underscores (snake_case), e.g., my_variable. The unmarked options are incorrect: constants should be UPPER_CASE_WITH_UNDERSCORES, not camelCase (A); modules should be short, all-lowercase names, preferably with underscores, not PascalCase (C); and functions should be lowercase with underscores (snake_case), not camelCase (D).

Answer

Constants: camelCase

Answer

Modules: PascalCase

Answer

Functions: camelCase

Question 8

Which THREE practices are recommended when handling external libraries?

Accepted Answer

Use a virtual environment for every project.. Option C is correct because creating a virtual environment (e.g., python -m venv .venv) for every project isolates its third-party packages from the system Python and other projects, preventing version conflicts and keeping the global interpreter clean. Option D is correct because documenting dependencies in a manifest file (such as requirements.txt, pyproject.toml, or package.json) records exactly which external libraries the project needs, enabling reproducible installs and easier auditing. Option E is correct because pinning dependencies in requirements.txt (e.g., requests==2.31.0) locks exact versions so builds are deterministic and a later upstream release cannot silently break the application. Option A is wrong because installing libraries globally pollutes the system interpreter, risks version clashes between projects, and often requires elevated privileges. Option B is wrong because imports should be grouped at the top of the file per PEP 8, and deferring them to the end harms readability and can cause NameError at runtime.

Answer

Install libraries globally.

Answer

Import all libraries at the very end of the file.

Question 9

Which TWO of the following are secure coding practices in Python?

Accepted Answer

Avoid using 'pickle' for untrusted data.. Option C is correct because Python's 'pickle' module is inherently unsafe for untrusted data: unpickling executes arbitrary code via the __reduce__ method, so deserializing attacker-controlled bytes can lead to remote code execution; safe alternatives include 'json' or other non-executable formats. Option D is correct because validating and sanitizing all user input (e.g., using allowlists, type checks, and parameterized queries) prevents injection flaws such as SQL injection, command injection, and XSS, forming a core secure coding practice. Option A is wrong because 'subprocess' with 'shell=True' passes the command through the shell, enabling shell metacharacter injection; the safe practice is 'shell=False' with an argument list. Option B is wrong because 'eval()' executes arbitrary Python expressions and is a classic code-injection vector; dynamic execution should use safer mechanisms like 'ast.literal_eval' for literals. Option E is wrong because hardcoded credentials in source code expose secrets and violate secure secret-management practices such as using environment variables or a secrets manager.

Answer

Use 'subprocess' with 'shell=True'.

Answer

Always use 'eval()' for dynamic execution.

Answer

Use hardcoded credentials for database connections.

Question 10

Which TWO practices help maintain clean code when using Python's 'try-except' blocks?

Accepted Answer

Keep the 'try' block as small as possible.. Option A is correct because keeping the 'try' block as small as possible limits it to only the statements that can actually raise the expected exception, which makes the source of an error obvious and prevents unrelated bugs from being accidentally caught and masked. Option D is correct because Python evaluates 'except' clauses in order, so catching the most specific exception classes first (for example 'except ValueError:' before 'except Exception:') ensures precise handling and prevents a broad handler from shadowing a more specific one. Option B is wrong because a single bare 'except:' for the whole project swallows every exception, including 'KeyboardInterrupt' and 'SystemExit', and hides real defects. Option C is wrong because silently ignoring errors in the 'except' block discards diagnostic information and lets the program continue in an invalid state. Option E is wrong because putting as much code as possible in the 'try' block widens the scope of what can be caught, making it unclear which statement raised the exception and increasing the chance of masking unrelated errors.

Answer

Use a single 'except:' clause for the whole project.

Answer

Always ignore errors in the 'except' block.

Answer

Put as much code as possible in the 'try' block.

Question 11

Which THREE features are associated with robust logging in production applications?

Accepted Answer

Log rotation to prevent disk space exhaustion.. Option A is correct because log rotation (e.g., via logrotate or size/time-based rolling appenders) caps log file growth and prevents disk space exhaustion, which is a core production reliability concern. Option C is correct because structured output (e.g., JSON formatters) makes logs machine-parseable, enabling reliable aggregation, searching, and alerting in tools like the ELK stack or Splunk. Option D is correct because using different logging levels per environment (e.g., DEBUG in development, WARN or ERROR in production) controls verbosity, reduces noise and cost, and keeps production logs actionable. Option B is not inherently a robust-logging feature: writing only to stdout can be valid in containerized setups, but 'exclusively' excludes durable file or remote sinks and is not a defining best practice. Option E is incorrect because including personal user data in logs risks privacy violations (e.g., GDPR) and security exposure, so it should be avoided or masked.

Answer

Logging to 'stdout' exclusively.

Answer

Including personal user data in logs.

Question 12

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 13

Which THREE practices improve documentation maintenance?

Accepted Answer

Updating documentation as part of the code review process.. Option A is correct because integrating documentation updates into the code review process makes doc changes a required, verifiable part of every pull request, so docs stay synchronized with code changes instead of drifting out of date. Option C is correct because following a consistent docstring format such as Google style enforces a uniform structure for parameters, returns, and raises sections, which makes documentation easier to read, review, and parse by tooling. Option E is correct because automatic documentation generation tools like Sphinx build docs directly from source docstrings, so regenerating after each change keeps published documentation current with minimal manual effort. Option B is not correct because writing docs only at the end of a project causes them to lag behind implementation and often results in incomplete or stale content. Option D is not correct because keeping documentation in a separate repository decouples it from the code, making it harder to update in the same commit or review cycle and increasing the risk of version mismatch.

Answer

Writing docs only at the end of the project.

Answer

Keeping documentation in a separate repository.

Question 14

Which TWO of these identify a potential 'code smell' in Python exception handling?

Accepted Answer

Swallowing exceptions with an empty 'except' block.. Option B is a code smell because an empty 'except:' block silently swallows every exception, hiding failures and making debugging nearly impossible; at minimum the handler should log or re-raise. Option D is a code smell because 'BaseException' includes 'SystemExit', 'KeyboardInterrupt', and 'GeneratorExit', so catching it can prevent normal interpreter shutdown and interrupt handling; application code should normally catch 'Exception' or more specific subclasses. Option A is not a smell: 'finally' is the correct construct for guaranteed cleanup such as closing files or releasing locks. Option C is not a smell: catching specific exception types is the recommended practice for precise, safe error handling. Option E is not a smell: defining and raising custom exceptions improves clarity and lets callers handle domain-specific errors.

Answer

Using 'finally' for cleanup.

Answer

Catching specific exceptions.

Answer

Raising custom exceptions.

Question 15

Which TWO practices ensure secure handling of sensitive environment configurations?

Accepted Answer

Add '.env' to your '.gitignore' file.. Option D is correct because adding '.env' to '.gitignore' prevents the file containing sensitive configuration values from being tracked and pushed to the Git repository, keeping secrets out of version control history. Option E is correct because using a library like 'python-dotenv' loads configuration from a local '.env' file into environment variables at runtime, so secrets stay out of source code and can be managed per-environment. Options A and C are insecure because committing '.env' files to the repository or emailing them exposes secrets to unintended parties and version history. Option B is also wrong since storing secrets in code comments still embeds them in source code that may be shared or committed.

Answer

Commit .env files to the code repository.

Answer

Store secrets in code comments.

Answer

Share the '.env' file via email.