PCAP Modules and Packages Practice Test 7 — 15 Questions

Question 1

A package 'mypackage' has subpackages 'sub1' and 'sub2'. In sub1/__init__.py, there is: from sub2 import helper. When importing mypackage, an ImportError occurs: No module named 'sub2'. What is the most likely cause?

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

Accepted Answer

The import should be from .sub2 import helper (relative import).. When a subpackage (sub1) tries to import from a sibling subpackage (sub2) using a bare name (from sub2 import helper), Python looks for 'sub2' as a top-level module, not as a sibling within the same parent package. Since 'sub2' is not installed as a top-level module, an ImportError occurs. Using a relative import (from .sub2 import helper) explicitly tells Python to look for sub2 as a sibling package under the same parent, resolving the import correctly.

Answer

Sub2 is not installed in the Python environment.

Answer

Sub2 must be imported before sub1 in the package's __init__.py.

Answer

Sub1 should not have an __init__.py file.

Question 2

A team uses virtual environments to manage dependencies. They need to ensure that a script runs with the exact same module versions across different environments. Which approach is best?

Accepted Answer

Run pip freeze and store the output in a requirements.txt file, then use pip install -r on other systems.. `pip freeze` outputs the exact versions of all installed packages in the current environment, and storing that output in a `requirements.txt` file allows you to reproduce the same environment on another system by running `pip install -r requirements.txt`. This ensures deterministic dependency management across different environments, which is the standard practice for reproducible builds in Python.

Answer

Use sys.path.append to add module directories.

Answer

Copy the entire virtual environment folder to other systems.

Answer

Include the modules in a __pycache__ directory.

Question 3

A script runs: import sys; print(sys.path[0]). The output is an empty string. What does this indicate?

Accepted Answer

The script is being read from stdin.. When a script is read from stdin (e.g., via `python < script.py` or `echo 'print(1)' | python`), Python sets `sys.path[0]` to an empty string because there is no script file path to derive the directory from. This is the documented behavior: `sys.path[0]` is the directory containing the script, or an empty string if the script is read from standard input.

Answer

Python was launched with the -I flag.

Answer

The current working directory is not in sys.path.

Answer

The script is running from an interactive shell.

Question 4

A Python script is written to be used both as a standalone program and as an imported module. Which condition should the script use to execute code only when run directly?

Accepted Answer

if __name__ == '__main__':. Python sets the global variable `__name__` to `'__main__'` when the script is executed directly (e.g., `python script.py`). When the script is imported as a module, `__name__` is set to the module's name. The condition `if __name__ == '__main__':` is the standard Python idiom to guard code that should only run in the direct execution context.

Answer

if __import__ == '__main__':

Answer

if __name__ == '__module__':

Answer

if __file__ == 'main':

Question 5

A developer has two separate directories on sys.path: /home/user/libs and /opt/libs. Both directories contain a subdirectory 'mypackage' without an __init__.py file. The developer wants to import a module from 'mypackage' that exists only in one of the directories. What concept allows Python to treat these two directories as a single namespace package?

Accepted Answer

Implicit namespace packages (PEP 420). PEP 420 introduced implicit namespace packages, which allow multiple directories on sys.path to contribute to the same package without requiring __init__.py files. When Python encounters a directory without __init__.py, it treats it as a namespace package, merging all matching directories across sys.path into a single logical package. This enables the developer to import a module from 'mypackage' that exists in only one of the directories, as Python searches all paths and resolves the module from the first location where it is found.

Answer

Regular packages with __init__.py

Answer

sys.path merging

Answer

Package overriding

Question 6

A user wants to ensure that a custom module 'mymod' located at '/home/user/custom' takes precedence over a standard library module with the same name. Which operation on sys.path should be performed?

Accepted Answer

sys.path.insert(0, '/home/user/custom'). `sys.path.insert(0, '/home/user/custom')` adds the custom module's directory to the very beginning of the module search path. Python's import system scans `sys.path` in order, so placing the custom directory first ensures that `mymod` is found there before any standard library or site-packages directory that might contain a module with the same name.

Answer

sys.path.replace('/', '/home/user/custom')

Answer

sys.path.append('/home/user/custom')

Answer

sys.prefix = '/home/user/custom'

Question 7

Refer to the exhibit. Which of the following is the most likely cause of this error?

Accepted Answer

mypackage is a module file, not a package directory.. The error indicates that Python cannot import 'mypackage' as a package. If 'mypackage' is a single module file (e.g., mypackage.py) rather than a directory containing an __init__.py file, Python treats it as a module, not a package. This prevents the expected package-style import of submodules like 'mymodule', causing the ImportError.

Answer

The __init__.py file in mypackage is empty.

Answer

There is a circular import between mypackage and mymodule.

Answer

mymodule.py does not exist in mypackage directory.

Question 8

A developer creates a package named 'mypkg' with an __init__.py file. Inside the package, there is a module 'utils.py'. Which of the following is the correct way to import the function 'helper' from 'utils' from outside the package?

Accepted Answer

from mypkg.utils import helper. It uses the standard Python syntax for importing a specific name from a submodule within a package: `from package.module import name`. This directly imports the `helper` function into the current namespace, making it callable without any prefix. The `__init__.py` file marks `mypkg` as a package, and `utils.py` is a module inside it, so `from mypkg.utils import helper` is the proper way to access `helper` from outside the package.

Answer

import mypkg.utils.helper

Answer

import mypkg; mypkg.utils.helper

Answer

from mypkg import utils.helper

Question 9

A team is developing a large Python application with multiple modules. They encounter an ImportError when module A tries to import from module B, and module B tries to import from module A. What is the most likely cause and best practice to resolve this?

Accepted Answer

Restructure the code to eliminate circular dependencies by extracting shared logic into a third module.. Circular imports occur when two modules depend on each other at the top level, causing an ImportError due to incomplete module initialization. The best practice is to restructure the code to eliminate the circular dependency, typically by extracting the shared functionality into a third module that both A and B can import without mutual dependence. This approach aligns with Python's module loading mechanism, which executes a module fully before making its names available for import.

Answer

Use 'from module import *' to bring all names into the namespace.

Answer

Use lazy imports (inside functions) to defer the import until runtime.

Answer

Move all imports from module A to the bottom of the file.

Question 10

A developer installs a third-party package using pip, but when they try to import it in their script, Python raises a ModuleNotFoundError. The package is definitely installed (pip list shows it). What is the most likely cause?

Accepted Answer

The Python interpreter being used is different from the one where the package was installed.. When a package is installed via pip, it is placed into the site-packages directory of a specific Python interpreter. If the developer runs their script with a different Python interpreter (e.g., one from a virtual environment, a different version, or a system Python vs. a user-installed Python), that interpreter's import system will not search the site-packages where the package was installed, resulting in a ModuleNotFoundError even though pip list shows the package. This is the most common cause of such a mismatch.

Answer

The package name contains a hyphen.

Answer

The script is in a directory that shadows the package name.

Answer

The package does not have an __init__.py file.

Question 11

A module 'shapes.py' defines several classes: Circle, Square, Triangle. The developer wants to allow users to import only Circle and Square when they use 'from shapes import *'. Which mechanism should be used?

Accepted Answer

Define a list variable named __all__ containing the string names 'Circle' and 'Square'.. The `__all__` variable in a module explicitly controls which names are exported when a client uses `from shapes import *`. By setting `__all__ = ['Circle', 'Square']`, only those two classes are imported, while `Triangle` is excluded. This is the standard Python mechanism for restricting wildcard imports.

Answer

Prefix the Triangle class with an underscore to make it private.

Answer

Use the import_explicit function.

Answer

Create an __init__.py file in the same directory.

Question 12

A package 'pkg' is installed as an egg-link in development mode. Inside the package, there is a module 'submod.py' that uses relative imports. When a developer modifies 'submod.py', they find that changes are not always reflected on import. What is the most likely reason?

Accepted Answer

Python's module caching in sys.modules prevents re-loading the modified source.. Python caches imported modules in `sys.modules`. When a module is imported, Python stores the module object in `sys.modules` and subsequent imports retrieve it from this cache without re-executing the module's code. Modifying the source file of `submod.py` does not automatically invalidate this cache, so the changes are not reflected unless the module is explicitly reloaded (e.g., with `importlib.reload()`) or the interpreter is restarted.

Answer

The sys.path is altered by the egg-link, causing a different module to be loaded.

Answer

Relative imports are cached in the __init__.py file.

Answer

The __pycache__ directory is not cleared automatically.

Question 13

Which THREE factors influence Python's module search path (sys.path)?

Accepted Answer

The site-packages directory where pip installs packages. The site-packages directory is automatically included in sys.path by the site module during Python's initialization. This directory is the default location where pip installs third-party packages, making them importable without manual path manipulation.

Answer

The HOME environment variable

Answer

The current working directory at runtime

Question 14

You are a Python developer working on a project with the following structure:

myapp/
    __init__.py
    main.py
    modules/
        __init__.py
        utils.py
        helpers.py

The file main.py contains:

from modules import utils
from modules import helpers

utils.some_function()
helpers.another_function()

When you run main.py, you get an ImportError: No module named 'modules'. However, the modules directory exists and both __init__.py files are present. The directory myapp is not installed as a package; you are running main.py directly from the myapp directory. What is the most likely cause and how should you fix it?

Accepted Answer

Move main.py to the parent directory of myapp and use 'from myapp.modules import utils' or run with 'python -m myapp.main' from the parent.. When running main.py directly, Python adds the directory containing main.py (myapp) to sys.path, not its parent. Since 'modules' is a subdirectory of myapp, Python cannot find it as a top-level module. Moving main.py to the parent directory or using the -m flag (which sets the working directory as the script's location) allows 'from myapp.modules import utils' to resolve correctly, as myapp becomes a package.

Answer

Add the parent directory of myapp to sys.path at the beginning of main.py.

Answer

Add an __all__ variable in modules/__init__.py to explicitly export the submodules.

Answer

Rename modules/__init__.py to something else.

Question 15

You are a DevOps engineer managing a Python application that consists of multiple microservices. One microservice, 'data_processor', imports a shared library 'common_lib' which is also used by other microservices. The shared library is developed in a separate repository and is installed via pip in each microservice's virtual environment as an editable package (pip install -e). Recently, you updated 'common_lib' with new functions, but when you redeploy 'data_processor' (by restarting the container), the new functions are not available; the old version is still used. The container uses a Docker image built from a requirements file that specifies 'common_lib' from a Git repository. You verify that the Git commit hash in the requirements file points to the latest version. What is the most likely cause and what is the correct course of action?

Accepted Answer

Update the commit hash or use a version tag that points to the latest, and rebuild the Docker image without using cache (--no-cache).. When a Docker image is built, pip installs the package from the Git repository at the commit hash specified in the requirements file. Even if the requirements file points to the latest commit, Docker's layer caching may reuse a previously built layer that contains the old version of the package. Rebuilding the image with --no-cache forces Docker to re-execute the pip install step, fetching the latest code from Git and installing the updated common_lib. Simply restarting the container does not rebuild the image, so the old installed package persists.

Answer

Add the common_lib source directory to sys.path in the microservice code.

Answer

Rename the package in the requirements file to force a fresh install.

Answer

Change the Python interpreter to a different version.