PCAP Modules and Packages Practice Test 4 — 15 Questions

Question 1

Inside a package 'data', there is a subpackage 'io' and a module 'utils'. Which import statement inside the 'io' subpackage correctly imports the 'helper' function from the sibling module 'utils'?

Accepted Answer

from ..utils import helper. The `..` prefix in a relative import refers to the parent package (`data`), and then `utils` is a sibling module of `io` within that parent package. This allows the `io` subpackage to import the `helper` function from the sibling module `utils` using `from ..utils import helper`.

Answer

import data.utils.helper

Answer

from .utils import helper

Answer

from data.io.utils import helper

Question 2

An application needs to dynamically load a module whose name is provided at runtime (stored in a variable 'mod_name'). Which function from the importlib module should be used?

Accepted Answer

importlib.import_module(mod_name). `importlib.import_module(mod_name)` is the standard Python function designed to dynamically import a module given its name as a string at runtime. It returns the module object, allowing the application to load and use modules whose names are not known until execution.

Answer

importlib.reload(mod_name)

Answer

importlib.load_module(mod_name)

Answer

importlib.import(mod_name)

Question 3

Which TWO of the following are valid ways to import a module 'math' in Python?

Accepted Answer

from math import *. The correct answers are C and E. Option C uses 'from math import *' which imports all names from the math module. Option E uses 'import math' which imports the entire module. Option A ('import Math') is incorrect because Python is case-sensitive and the module name must be lowercase. Option B ('import math,') is invalid due to the trailing comma. Option D ('from math import') is incomplete as it lacks the names to import.

Answer

import Math

Answer

import math,

Answer

from math import

Question 4

Which TWO statements about the sys module are true?

Accepted Answer

sys.exit() raises SystemExit with a default exit code of 0.. `sys.exit()` raises the `SystemExit` exception, and when called without an argument, the default exit code is 0, indicating successful termination. This behavior is defined in the Python documentation for the `sys` module.

Answer

sys.path is a tuple of module search paths.

Answer

sys.modules is a list of all loaded modules.

Answer

The sys module is automatically imported in every Python script.

Question 5

Which THREE of the following are recommended techniques to avoid circular imports in Python?

Accepted Answer

Restructure the code to move shared functionality into a separate module.. Moving shared functionality into a separate module breaks the circular dependency chain at the import level. When two or more modules depend on each other, Python's import system may raise an ImportError or produce partially initialized modules, leading to AttributeError. Restructuring eliminates the mutual dependency by creating a common module that both original modules can import safely.

Answer

Manually check sys.modules before importing.

Answer

Use the __all__ variable to control what is exported.

Question 6

Refer to the exhibit. Which import statement in app.py will successfully import and use the greet function from helpers.py?

Accepted Answer

from .utils.helpers import greet. The package structure shown in the exhibit places app.py inside a package with utils as a subpackage. The relative import `from .utils.helpers import greet` correctly resolves `utils` relative to the current package. Option A fails because it does not bind the `greet` name. Option B fails because `utils` is not a top-level package in the exhibit. Option D fails because it uses `my_package` as the top-level package name, which is not the actual package name shown in the exhibit.

Answer

import utils.helpers; then greet()

Answer

from utils.helpers import greet

Answer

from my_package.utils.helpers import greet

Question 7

Refer to the exhibit. A Python script uses the following code to load the policy. However, it fails with a JSONDecodeError. What is the most likely cause?
```python
import json
with open('policy.json', 'r') as f:
    policy = json.load(f)
```

Accepted Answer

The JSON file contains a trailing comma after the last element.. Python's json.load() strictly follows the JSON specification (RFC 7159), which does not allow trailing commas after the last element in an array or object. When the JSON file contains a trailing comma, the decoder raises a JSONDecodeError. This is a common syntax error in hand-written or poorly generated JSON files.

Answer

The policy variable is used before assignment elsewhere in the script.

Answer

The file should be opened in binary mode ('rb') instead of text mode.

Answer

The JSON decoder cannot handle IP addresses in strings.

Question 8

A Python project has the following directory structure:

project/
    __init__.py
    main.py
    subpackage/
        __init__.py
        module.py

Inside 'module.py', there is a function 'func' that needs to be imported in 'main.py'. The team wants to import 'func' using a relative import from 'main.py'. However, when they run 'python main.py' from the project root, they get an ImportError. What is the most likely reason?

Accepted Answer

Relative imports cannot be used in scripts executed directly as __main__.. When a Python script is executed directly (e.g., `python main.py`), its `__name__` is set to `"__main__"`, not the package name. Relative imports (e.g., `from .subpackage.module import func`) rely on the `__package__` attribute being set to the package hierarchy, which only happens when the module is imported as part of a package. Since `main.py` is run as the top-level script, it has no package context, causing an `ImportError`.

Answer

The 'project' directory does not contain an __init__.py file.

Answer

The function 'func' is not defined as a public function.

Answer

The module name 'module.py' contains a hyphen.

Question 9

A Python project uses namespace packages spread across multiple directories. The package structure is: project/ and lib/ both contain subdirectories 'mypkg/'. Each has an __init__.py file. When importing 'mypkg', which directory's contents are used?

Accepted Answer

Only the directory that appears first in sys.path is used.. When both directories contain an __init__.py file, they are regular packages, not namespace packages. Python's import system uses the first match in sys.path; it does not merge regular packages. Therefore, only the directory that appears first in sys.path is used, making option B correct.

Answer

Both directories are merged into a single namespace package.

Answer

An error is raised due to ambiguous import.

Answer

The last directory in sys.path overrides the previous.

Question 10

A company has a shared internal library stored in a Git repository. Developers need to use this library in multiple projects without copying the code. Which approach is the most Pythonic and maintainable?

Accepted Answer

Package the library as a proper Python package and install it via pip in each project's virtual environment.. Packaging the library as a proper Python package and installing it via pip in each project's virtual environment follows the Python packaging standard (PEP 517/518) and the principle of explicit dependency management. This approach ensures versioning, isolation, and easy updates without modifying sys.path or relying on fragile filesystem links, making it the most maintainable and Pythonic solution.

Answer

Add the library's directory to sys.path in each project's main script.

Answer

Create a symbolic link to the library's directory inside each project.

Answer

Copy the library source code into each project's directory.

Question 11

A developer wants to distribute a package that contains both Python code and data files (e.g., images, configs). Which file is used to specify dependencies and metadata for the package?

Accepted Answer

setup.py. Setup.py is the traditional script used for packaging Python projects; it defines metadata (name, version, author), dependencies via install_requires, and can include data files using package_data. Option B (MANIFEST.in) specifies extra files to include in the source distribution, but it does not define dependencies or metadata. Option C (__init__.py) marks a directory as a Python package but has no role in specifying dependencies. Option D (requirements.txt) lists dependencies for pip to install, but it is not part of the package’s built metadata and is not used for distribution packaging.

Answer

MANIFEST.in

Answer

__init__.py

Answer

requirements.txt

Question 12

Which TWO statements about the __init__.py file in a Python package are true?

Accepted Answer

It can define the __all__ list to control what is exported with 'from package import *'.. The `__all__` list in `__init__.py` explicitly defines the public API of a package, controlling which names are exported when a client uses `from package import *`. This is a standard Python mechanism to prevent unintended internal modules from being exposed.

Answer

It must contain at least one import statement to be valid.

Answer

It is mandatory for all packages, including namespace packages.

Answer

It prevents submodules from being imported directly.

Question 13

Which TWO methods are valid ways to import a function named 'foo' from a module 'bar' that is part of a package 'pkg'?

Accepted Answer

from pkg.bar import foo. The 'from pkg.bar import foo' syntax directly imports the 'foo' function from the 'bar' submodule within the 'pkg' package, making 'foo' available in the current namespace. Option D is also correct because it first imports the 'bar' module from 'pkg' using 'from pkg import bar', then accesses 'foo' as an attribute of 'bar' (bar.foo), which is a valid two-step approach.

Answer

import bar

Answer

import pkg; pkg.bar.foo

Answer

import pkg.bar.foo

Question 14

A team maintains a library 'utils' with multiple modules. They want to expose a clean public API so that users can do `from utils import helper`. However, they also have internal modules that should not be accessible directly. Which approach best achieves this?

Accepted Answer

In utils/__init__.py, set __all__ = ['helper'] and rename internal modules with a leading underscore (e.g., _internal).. Using `__all__` in `__init__.py` explicitly controls what is exported when a user writes `from utils import *`, and renaming internal modules with a leading underscore (e.g., `_internal`) is a Python convention that signals those modules are private and not part of the public API. This combination allows `from utils import helper` to work while discouraging direct access to internal modules; note that Python does not enforce access restrictions, so these are conventions rather than hard barriers.

Answer

Use a single file named 'utils.py' and split functions into classes with private methods.

Answer

Remove all __init__.py files and rely on the module search path.

Answer

Name internal modules starting with 'import' to prevent from import *.

Question 15

Which TWO statements about the __init__.py file in a Python package are true?

Accepted Answer

It can be used to define the __all__ variable for package exports.. The __init__.py file can define the __all__ variable (B), can execute arbitrary code when the package is imported (C), and must be named exactly __init__.py with no other possible names (D). Thus B, C, and D are all correct, so the question has more than two true statements.

Answer

The __init__.py file must contain at least one import statement.

Answer

It is executed every time a submodule is imported.