PCAP Modules and Packages Practice Test 3 — 15 Questions

Question 1

A programmer wants to use the sqrt function from the math module. Which import statement is most efficient?

Accepted Answer

from math import sqrt. `from math import sqrt` binds only the `sqrt` function into the current namespace, avoiding name collisions with other math functions. While the `math` module itself is still fully loaded, this form avoids introducing extra global names and provides direct access to `sqrt`, which is more convenient and slightly faster than attribute lookup with `math.sqrt`. It is the most appropriate when only that one function is needed.

Answer

import math.sqrt

Answer

from math import *

Answer

import math

Question 2

A developer appends a custom path to sys.path and then tries to import a function from a module: import sys; sys.path.append('/custom/libs'); from mylib import func. The import fails with ModuleNotFoundError. mylib is a directory. What is the most likely cause?

Accepted Answer

The mylib directory lacks an __init__.py file.. In Python, a directory is recognized as a regular package only if it contains an `__init__.py` file. Without it, Python 3.3+ may treat the directory as a namespace package, but namespace packages are intended for splitting packages across multiple directories. When using `from mylib import func`, Python expects `mylib` to be a regular package that contains the module `func`. Since `mylib` lacks `__init__.py`, it is not a regular package, leading to `ModuleNotFoundError`. While namespace packages exist, they do not allow direct import of modules within the directory unless the directory is part of a proper namespace package structure, which is not the typical scenario. Thus, the most likely cause is the missing `__init__.py` file.

Answer

The import order is wrong; sys.path.append should be after the import.

Answer

mylib.py exists in the same directory as the script.

Answer

The appended path does not exist on the filesystem.

Question 3

A module 'config.py' contains a variable 'settings' that is a dictionary. Another script does: from config import settings. Then the script modifies settings['key'] = 'new_value'. What happens?

Accepted Answer

The change is reflected in config.settings because it is the same object.. Python's import statement binds the name 'settings' in the importing module's namespace to the same dictionary object that exists in config.py. Since dictionaries are mutable, modifying settings['key'] directly mutates the shared object, and the change is visible through config.settings as well.

Answer

The config module is reloaded and the change is lost.

Answer

The script gets a copy of the dictionary, so config.settings is unchanged.

Answer

An error occurs because settings is read-only.

Question 4

A package 'tools' has the structure: tools/__init__.py, tools/calc.py, tools/io.py. In __init__.py, the developer writes: from . import calc. A user tries: import tools; print(tools.add(1,2)). This fails with AttributeError. Why?

Accepted Answer

The add function is not imported into the tools package namespace.. The `__init__.py` file only imports the `calc` module itself into the `tools` package namespace, not the `add` function. When a user calls `tools.add(1,2)`, Python looks for `add` directly in the `tools` namespace, but it is not there — it is only accessible as `tools.calc.add`. The `from . import calc` statement binds the name `calc` to the module, not its contents.

Answer

The function add is not defined in calc.py.

Answer

Relative imports are not allowed in __init__.py files.

Answer

The user should use tools.calc.add instead.

Question 5

A developer runs pip install requests. Later, they need to find out where the module is installed on the system. Which command shows the location?

Accepted Answer

python -c "import requests; print(requests.__file__)". After importing a module in Python, its `__file__` attribute contains the absolute path to the module's `.py` file (or compiled `.pyc` file). The command `python -c "import requests; print(requests.__file__)"` first imports the module, then prints the location where Python found it, which is the exact installation path on the system.

Answer

python -c "print(requests.__path__)"

Answer

pip list --path

Answer

pip show requests

Question 6

Which TWO of the following are valid ways to import a function named 'func' from a module 'mymod' that is in the same directory as the script?

Accepted Answer

from mymod import func as myfunc. The syntax `from mymod import func as myfunc` is a valid Python import statement that imports the function `func` from the module `mymod` and binds it to the local name `myfunc`. Since `mymod` is in the same directory as the script, Python's module search path includes that directory, so the import succeeds without needing a relative import prefix.

Answer

import mymod.func

Answer

import func from mymod

Answer

from .mymod import func

Question 7

Which THREE of the following are true about the __pycache__ directory?

Accepted Answer

It is automatically created when a module is imported.. Python automatically creates the __pycache__ directory when a module is imported for the first time. This directory stores compiled bytecode files (.pyc) that allow Python to skip recompilation on subsequent imports, thereby improving startup time for later runs.

Answer

It is only created when the script is compiled with -O.

Answer

It should be added to version control.

Question 8

Which TWO of the following are true about importing modules using the import statement?

Accepted Answer

The module is executed only once on the first import.. Python caches imported modules in the sys.modules dictionary. When a module is imported for the first time, it is executed and its code is stored; subsequent imports of the same module simply retrieve the cached object from sys.modules without re-executing the module's code. This ensures that module-level initialization runs only once, preventing side effects like repeated resource allocation or redefinition of global variables.

Answer

Relative imports can be used in scripts executed as the main module.

Answer

Importing a module with a different name using 'as' creates a copy of the module.

Answer

Circular imports always cause an ImportError.

Question 9

A user runs script.py and gets the above error: ModuleNotFoundError: No module named 'mypackage'. Which of the following is the most likely cause?

Accepted Answer

The package mypackage is not installed or not in the Python path.. The error message 'ModuleNotFoundError: No module named 'mypackage'' indicates that Python cannot find the module 'mypackage'. This typically occurs when the package is not installed or not present in sys.path. Option C directly addresses this cause. The other options are less plausible: Option A would raise an AttributeError, not a ModuleNotFoundError; Option B might cause import issues but would likely result in a circular import error or import error due to naming conflicts; Option D's syntax error would prevent the script from running at all. Therefore, Option C is the most probable cause.

Answer

The function myfunction does not exist in mypackage.

Answer

The script.py is inside the mypackage directory, causing a conflict.

Answer

There is a syntax error in script.py.

Question 10

A developer runs pip install package==1.0 and gets the above error. What is the most likely solution?

Accepted Answer

Use pip install package==2.0 instead.. The error indicates that version 1.0 of the package does not exist in the repository. By specifying a higher version like 2.0 that does exist, pip can successfully download and install the package. This is a common scenario when a package has never released version 1.0 or has skipped it.

Answer

Run pip update to upgrade pip.

Answer

Install from a different repository.

Answer

Check if the package name is correct.

Question 11

In module_b.py, the developer writes: from mypackage import module_a. When running a script that imports mypackage, an ImportError occurs. Which change should solve the issue?

Accepted Answer

Use from .. import module_a (relative import).. Python relative imports use leading dots: one dot means the current package, two dots mean the parent package. If module_b.py is in mypackage/module_b.py, the correct relative import for module_a in the same package is 'from . import module_a'. 'from .. import module_a' would look for module_a in the parent of mypackage, which is not correct for a top-level package. If module_b.py is in a subpackage, 'from .. import module_a' could be appropriate. Since the stem does not provide the directory structure, answer A cannot be confirmed as correct.

Answer

Add 'module_a' to __all__ in mypackage/__init__.py.

Answer

Move module_b.py to the mypackage directory.

Answer

Use import mypackage.module_a instead.

Question 12

A developer needs to add a custom directory '/home/user/mylibs' to Python's module search path so that modules in that directory can be imported. Which code snippet accomplishes this correctly?

Accepted Answer

import sys; sys.path.append('/home/user/mylibs'). Python's module search path is stored in the list `sys.path`, and the standard way to add a custom directory at runtime is to use the `list.append()` method. This inserts the directory at the end of the search path, allowing modules in that directory to be imported after the standard library and site-packages directories.

Answer

import sys; sys.path.push('/home/user/mylibs')

Answer

import sys; sys.path.add('/home/user/mylibs')

Answer

import path; path.add('/home/user/mylibs')

Question 13

A package named 'utilities' contains a submodule 'strings'. Which import statement allows the use of the function 'reverse' defined in utilities.strings as reverse() without needing to prefix it?

Accepted Answer

from utilities.strings import reverse. It directly imports the `reverse` function from the `utilities.strings` submodule into the current namespace, allowing it to be called as `reverse()` without any prefix. This is the only option that imports the specific function rather than the module or package.

Answer

import utilities.strings

Answer

from utilities import strings

Answer

from utilities import *

Question 14

Two modules, 'module_a' and 'module_b', import each other. When 'module_a' is imported first, it tries to import 'module_b', which in turn tries to import 'module_a' again, causing a circular import error. Which of the following is the most effective strategy to resolve this circular dependency?

Accepted Answer

Move the shared code into a third module that both can import.. The most effective because it removes the circular dependency entirely. Option D (lazy import) can work but is often considered a workaround; restructuring is cleaner. Options B and C are not standard solutions.

Answer

Place all code in a single module.

Answer

Use relative imports instead of absolute imports.

Answer

Use the import statement inside function definitions to defer imports.

Question 15

A package 'shapes' has an __init__.py file. Which statement must be included in the __init__.py file to allow the syntax 'from shapes import *' to import all submodules 'circle', 'square', and 'triangle'?

Accepted Answer

__all__ = ['circle', 'square', 'triangle'] and import each submodule. A wildcard import from a package imports all non-underscore names in the package namespace when __all__ is not defined. Importing each submodule in __init__.py places those names in the package namespace, so 'from shapes import *' will import them. Defining __all__ also works because Python imports the listed submodules. Thus options B, C, and D all satisfy the requirement.

Answer

Set __all__ to an empty list