PCAP Modules and Packages Practice Test 3 — 15 Questions

Question 1

A Python script imports the module 'my_module'. The developer wants to ensure that when the script is run directly, it executes a specific function, but when imported as a module, that function is not executed. Which code snippet achieves this?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

if __name__ == '__main__': run(). Both options A and B are correct because they are identical and represent the standard Python idiom `if __name__ == '__main__': run()`. When the script is run directly, Python sets `__name__` to `'__main__'`, triggering the function. When imported, `__name__` is the module name, so the function is not executed. Options C and D are incorrect: C relies on an environment variable that is not standard, and D checks `sys.argv[0]` which is the script path, not the module name.

Answer

if os.environ.get('RUN_MAIN'): run()

Answer

if sys.argv[0] == 'my_module': run()

Question 2

A developer is troubleshooting an ImportError: 'No module named 'config''. The config module is located in a subdirectory 'utils' relative to the script. The script's current working directory is the parent of 'utils'. Which of the following lines, added to the script, will resolve the issue?

Accepted Answer

sys.path.append('utils'). The ImportError occurs because Python's module search path (sys.path) does not include the 'utils' subdirectory. Adding 'utils' to sys.path via sys.path.append('utils') tells Python to look inside that directory for modules, resolving the import. Option B is correct because it extends the search path to include the directory containing the config module, without altering the script's working directory or incorrectly appending a file path.

Answer

sys.path.append('utils/config.py')

Answer

sys.path = os.path.join(sys.path, 'utils')

Answer

os.chdir('utils')

Question 3

A developer wants to import a specific function 'calculate' from a module named 'formulas' without importing the entire module. Which import statement should be used?

Accepted Answer

from formulas import calculate. The `from module import name` syntax in Python allows you to import a specific function (or other attribute) from a module directly into the current namespace, without importing the entire module. This avoids unnecessary memory usage and keeps the namespace clean by only bringing in the needed `calculate` function.

Answer

import formulas

Answer

import calculate from formulas

Answer

import formulas as f

Question 4

A developer notices that a custom package 'mypackage' is not being found when importing, even though it is installed in the site-packages directory. The developer suspects a conflict with another package of the same name. Which command should the developer run to diagnose the location from which Python is importing the package?

Accepted Answer

print(mypackage.__file__). `mypackage.__file__` returns the filesystem path from which the module was loaded, allowing the developer to see exactly which `mypackage` Python is using. This directly reveals if the wrong package (e.g., from a different location or a conflicting installation) is being imported instead of the intended one.

Answer

print(mypackage)

Answer

print(__file__)

Answer

import os; print(os.getcwd())

Question 5

Which THREE of the following statements about Python packages and modules are true?

Accepted Answer

A module is a single .py file containing Python definitions and statements.. A module in Python is defined as a single .py file that contains Python definitions, such as functions, classes, and variables, as well executable statements. This is the fundamental unit of code organization in Python, and any .py file can be imported as a module.

Answer

The sys.path list is read-only and cannot be modified at runtime.

Answer

A package must contain an __init__.py file to be importable.

Question 6

A Python package 'mypackage' contains the following hierarchy:

mypackage/
    __init__.py
    subpackage1/
        __init__.py
        module_a.py
    subpackage2/
        __init__.py
        module_b.py

From a script outside the package, a programmer writes:

import mypackage.subpackage1.module_a

Which statement is true about the import?

Accepted Answer

Both mypackage/__init__.py and mypackage/subpackage1/__init__.py are executed.. When Python encounters an import statement with a dotted path like `import mypackage.subpackage1.module_a`, it executes the `__init__.py` files for each package in the path in order: first `mypackage/__init__.py`, then `mypackage/subpackage1/__init__.py`. This is because Python must initialize each package before it can access its subpackages or modules. Option D correctly states that both `__init__.py` files are executed.

Answer

Only mypackage/__init__.py is executed.

Answer

No __init__.py files are executed because the import uses a dotted path.

Answer

After the import, 'mypackage' is not available as a name in the namespace.

Question 7

A programmer wants to create a package named 'analytics' with subpackages 'statistics' and 'ml'. Which directory structure correctly defines these packages?

Accepted Answer

analytics/ (__init__.py), analytics/statistics/ (__init__.py), analytics/ml/ (__init__.py). In Python, a directory is recognized as a package only if it contains an `__init__.py` file (even if empty). To create the 'analytics' package with 'statistics' and 'ml' subpackages, each directory must have its own `__init__.py`. Option D correctly places `__init__.py` in all three directories: `analytics/`, `analytics/statistics/`, and `analytics/ml/`.

Answer

analytics/, analytics/statistics/ (__init__.py), analytics/ml/ (__init__.py)

Answer

analytics/ (__init__.py), analytics/statistics/ (__init__.py), analytics/ml/ (__init__.py), analytics/__init__.py (file)

Answer

analytics/ (__init__.py), analytics/statistics/, analytics/ml/

Question 8

A developer has a module 'config.py' with the following content:

# config.py
import os
DATABASE_URL = os.getenv('DATABASE_URL', 'localhost')

Another module 'app.py' imports config and uses DATABASE_URL. During testing, the environment variable is set correctly, but the import still uses the default value 'localhost'. What is the most likely reason?

Accepted Answer

Python caches modules; config.py was imported earlier without the environment variable, and the cached version is reused.. Python caches imported modules in `sys.modules`. If `config.py` was imported earlier in the test session (e.g., during test discovery or another import) before the environment variable `DATABASE_URL` was set, the cached module would retain the default value `'localhost'`. Subsequent imports, even after setting the environment variable, reuse the cached module, so `os.getenv('DATABASE_URL', 'localhost')` is not re-evaluated.

Answer

The import statement in app.py is placed inside a function, so it is not executed.

Answer

The module was imported using 'from config import DATABASE_URL' which creates a separate copy.

Answer

The environment variable is only read when the function is called, not at import time.

Question 9

Which TWO of the following statements about Python packages are true?

Accepted Answer

A package can contain subpackages.. Python packages are directories that can contain subpackages (nested directories with their own __init__.py files), forming a hierarchical namespace. This allows for organized module grouping, such as `package.subpackage.module`, which is a core feature of Python's module system.

Answer

Packages cannot be imported using the import statement with dot notation.

Answer

An __init__.py file is required in every directory to make it a package.

Answer

A package is a single .py file.

Question 10

Which THREE of the following are valid ways to import a function named 'calculate' from a module named 'math_ops' located in a subpackage 'operations' of a package 'app'?

Accepted Answer

from app.operations.math_ops import calculate. It uses the standard Python import syntax to directly import the 'calculate' function from the 'math_ops' module, which is located in the 'operations' subpackage of the 'app' package. This is the most straightforward and recommended way to import a specific attribute from a module.

Answer

import app.operations.math_ops.calculate

Answer

from app.import operations.math_ops import calculate

Question 11

A developer is writing a package that contains multiple modules. The package should allow users to import it directly and have all commonly used functions available at the package level. For example, after `import mypackage`, the user should be able to call `mypackage.func1()` without needing to import submodules. Which is the best way to achieve this?

Accepted Answer

In `__init__.py`, import the desired functions from the submodules, e.g., `from .submodule import func1`.. `__init__.py` is executed when a package is imported, and importing functions from submodules into `__init__.py` makes them directly accessible as attributes of the package object. This allows `mypackage.func1()` to work without requiring the user to import submodules explicitly, satisfying the requirement of a flat namespace at the package level.

Answer

Create a wrapper function in `__init__.py` that delegates calls to the submodule functions.

Answer

Include `__all__` in each submodule and ensure `__init__.py` is empty.

Answer

Define a list named `__all__` in the package's `__init__.py` that lists the functions.

Question 12

Which TWO of the following statements about Python's `sys.path` are true?

Accepted Answer

Module search stops at the first matching directory in `sys.path`.. Python's import mechanism iterates through `sys.path` in order and stops at the first directory containing the requested module. Option E is correct: the directory containing the script (or the current directory when running interactively) is inserted at the beginning of `sys.path` at startup. Options A, C, and D are false: the current working directory is not always first (the script's directory takes precedence), `sys.path` is initialized from the `PYTHONPATH` environment variable *in addition to* default paths, and `sys.path` is a list, not a tuple. Therefore, only two statements are true.

Answer

The current working directory is always the first element in `sys.path`.

Answer

`sys.path` is initialized from the PYTHONPATH environment variable.

Answer

`sys.path` is a tuple of strings.

Question 13

You are developing a Python application that processes financial transactions. The application is structured as a package named `finance`. Inside `finance`, there are subpackages: `models`, `services`, and `utils`. The `services` subpackage contains a module `validator.py` that defines a function `validate_transaction()`. This function uses a helper function `check_amount()` defined in `utils.helpers`. The package is used by multiple other projects, and you want to ensure that importing `finance` does not accidentally expose internal helper functions. You also want to allow users to easily import the main validation function via `from finance import validate_transaction`. Which of the following approaches best achieves these goals?

Accepted Answer

In `finance/__init__.py`, write `from .services.validator import validate_transaction`. Then users can call `finance.validate_transaction()`.. It imports the `validate_transaction` function directly into the `finance` package namespace via `from .services.validator import validate_transaction` in `finance/__init__.py`. This allows users to use `from finance import validate_transaction` as desired, while keeping internal helper functions like `check_amount` in `utils.helpers` unexposed, since they are not imported into the package's top-level namespace. This approach follows the principle of explicit imports and encapsulation.

Answer

In `finance/__init__.py`, write `from . import services` and `from .services import validator`. Then users can call `finance.services.validator.validate_transaction()`.

Answer

In `finance/__init__.py`, write `from .services import validator`. Then users can call `finance.validator.validate_transaction()`.

Answer

In `finance/__init__.py`, write `from .utils.helpers import *` and `from .services.validator import validate_transaction`.

Question 14

Drag and drop the steps to create and activate a virtual environment in Python into the correct order.

Accepted Answer

Create virtual environment, Activate virtual environment, Install packages, Deactivate virtual environment. Virtual environments isolate project dependencies. The typical workflow is install virtualenv, create environment, activate it, install packages, and deactivate when finished.

Answer

Activate virtual environment, Create virtual environment, Install packages, Deactivate virtual environment

Answer

Create virtual environment, Install packages, Activate virtual environment, Deactivate virtual environment

Answer

Create virtual environment, Activate virtual environment, Deactivate virtual environment, Install packages

Question 15

Drag and drop the steps to create a simple HTTP server using the http.server module in Python into the correct order.

Accepted Answer

Import http.server, define handler class, create HTTPServer instance, call serve_forever(). Creating an HTTP server involves importing http.server, defining a handler, overriding methods, creating an HTTPServer instance, and calling serve_forever().

Answer

Define handler class, import http.server, create HTTPServer instance, call serve_forever()

Answer

Import http.server, create HTTPServer instance, define handler class, call serve_forever()

Answer

Import http.server, define handler class, call serve_forever(), create HTTPServer instance