Modules and Packages practice questions

A developer is working on a project that requires the use of a third-party package hosted on a private repository. The developer wants to ensure that the package can be imported without specifying the full repository URL each time. Which approach should be taken?

Trap 1: Append the repository path to sys.path in the script.

sys.path is for local file system paths, not remote repositories.

Trap 2: Place the package files in the site-packages directory manually.

Manual placement is error-prone and not maintainable.

Trap 3: Use os.system to run a pip install command from within the script.

Running pip from within a script is bad practice and unreliable.

A
Append the repository path to sys.path in the script.
Why wrong: sys.path is for local file system paths, not remote repositories.
B
Place the package files in the site-packages directory manually.
Why wrong: Manual placement is error-prone and not maintainable.
C
Configure the repository URL in pip's configuration file or in requirements.txt.
pip configuration allows specifying extra index URLs for package resolution.
D
Use os.system to run a pip install command from within the script.
Why wrong: Running pip from within a script is bad practice and unreliable.

Question 2easymultiple choice

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?

Trap 1: if __name__ == '__main__': run()

Double underscores are missing; correct is '__main__'.

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

Environment variables are not the standard mechanism.

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

sys.argv[0] is the script name, not reliable for imported modules.

A
if __name__ == '__main__': run()
Why wrong: Double underscores are missing; correct is '__main__'.
B
if __name__ == '__main__': run()
This is the standard Python idiom for executable scripts.
C
if os.environ.get('RUN_MAIN'): run()
Why wrong: Environment variables are not the standard mechanism.
D
if sys.argv[0] == 'my_module': run()
Why wrong: sys.argv[0] is the script name, not reliable for imported modules.

Question 3hardmultiple choice

A developer creates a package named 'analytics' with the following structure:

analytics/ __init__.py stats.py models/ __init__.py regression.py

The developer wants the statement 'from analytics import *' to import only the functions 'mean' and 'std' from stats.py. What should be added to analytics/__init__.py?

Trap 1: Nothing; by default, all names are exported.

Default behavior does not export anything via star import; __all__ is needed.

Trap 2: from analytics.stats import *

This would export all names from stats, not just mean and std.

Trap 3: __all__ = ['stats.mean', 'stats.std']

The syntax is incorrect; __all__ should contain simple names.

A
Nothing; by default, all names are exported.
Why wrong: Default behavior does not export anything via star import; __all__ is needed.
B
from analytics.stats import *
Why wrong: This would export all names from stats, not just mean and std.
C
__all__ = ['stats.mean', 'stats.std']
Why wrong: The syntax is incorrect; __all__ should contain simple names.
D
__all__ = ['mean', 'std']
This defines the public API of the package.

Question 4mediummultiple choice

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?

Trap 1: sys.path.append('utils/config.py')

append expects a directory, not a file path.

Trap 2: sys.path = os.path.join(sys.path, 'utils')

os.path.join returns a string, not a list.

Trap 3: os.chdir('utils')

Changing directory does not add the directory to sys.path.

A
sys.path.append('utils/config.py')
Why wrong: append expects a directory, not a file path.
B
sys.path.append('utils')
This adds the utils directory to the module search path.
C
sys.path = os.path.join(sys.path, 'utils')
Why wrong: os.path.join returns a string, not a list.
D
os.chdir('utils')
Why wrong: Changing directory does not add the directory to sys.path.

Question 5easymultiple choice

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?

Trap 1: import formulas

This imports the whole module, requiring formulas.calculate.

Trap 2: import calculate from formulas

Invalid syntax; correct order is 'from module import name'.

Trap 3: import formulas as f

This gives an alias to the module, not the function.

A
import formulas
Why wrong: This imports the whole module, requiring formulas.calculate.
B
import calculate from formulas
Why wrong: Invalid syntax; correct order is 'from module import name'.
C
from formulas import calculate
This imports only the specified function.
D
import formulas as f
Why wrong: This gives an alias to the module, not the function.

Question 6hardmultiple choice

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?

Trap 1: print(mypackage)

This prints the module object representation, not its location.

Trap 2: print(__file__)

This shows the path of the currently executing script, not the imported module.

Trap 3: import os; print(os.getcwd())

This shows the current working directory, not the module location.

A
print(mypackage)
Why wrong: This prints the module object representation, not its location.
B
print(__file__)
Why wrong: This shows the path of the currently executing script, not the imported module.
C
print(mypackage.__file__)
This attribute contains the path to the module's file.
D
import os; print(os.getcwd())
Why wrong: This shows the current working directory, not the module location.

Question 7mediummultiple choice

A developer is creating a package that contains a subpackage. The subpackage has an init.py file that imports a module named 'helper' from the parent package. Which import statement in the subpackage's init.py will correctly import 'helper'?

Trap 1: from

This tries to import helper from the same subpackage, not the parent.

Trap 2: from ..

Three dots refer to the grandparent, not the parent.

Trap 3: from .

This is a relative import that may work but is less clear and can break.

A
from mypackage import helper
This absolute import explicitly specifies the package hierarchy.
B
from . import helper
Why wrong: This tries to import helper from the same subpackage, not the parent.
C
from ... import helper
Why wrong: Three dots refer to the grandparent, not the parent.
D
from .. import helper
Why wrong: This is a relative import that may work but is less clear and can break.

Question 8mediummulti select

Which TWO of the following are valid ways to import a module named 'math' and give it an alias 'm'?

Trap 1: from math import * as m

Cannot alias a wildcard import.

Trap 2: import math m

Missing 'as' keyword.

Trap 3: import math alias m

'alias' is not a Python keyword.

A
from math import * as m
Why wrong: Cannot alias a wildcard import.
B
import math as m
Correct alias syntax.
C
import math m
Why wrong: Missing 'as' keyword.
D
import math alias m
Why wrong: 'alias' is not a Python keyword.
E
from math import sin as m
This aliases the function sin as m, but the question says 'module named math' so aliasing the module is the intent; however, this is still a valid import statement, though it aliases a function. The stem is ambiguous, but among the options, D is valid syntax.

Question 9hardmulti select

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

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

sys.path is a mutable list that can be appended to.

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

In Python 3.3+, namespace packages can exist without __init__.py.

A
The sys.path list is read-only and cannot be modified at runtime.
Why wrong: sys.path is a mutable list that can be appended to.
B
A package must contain an __init__.py file to be importable.
Why wrong: In Python 3.3+, namespace packages can exist without __init__.py.
C
A module is a single .py file containing Python definitions and statements.
This is the definition of a module.
D
The __all__ variable defines the public API of a module or package.
__all__ controls what is exported with 'from module import *'.
E
Relative imports use dots to refer to the current and parent packages.
A single dot refers to current package, two dots to parent, etc.

Question 10hardmultiple choice

You are a developer at a company that builds a data processing pipeline. The pipeline consists of several Python modules organized in a package called 'pipeline'. The package structure is:

pipeline/ __init__.py load.py transform.py analyze.py

The pipeline is deployed on a server where Python 3.8 is installed. The server also has a globally installed package called 'pipeline' (from a different project) in the site-packages directory. When you run your scripts that import 'pipeline', you get unexpected behavior because Python is importing the wrong package. You need to ensure that your local 'pipeline' package is used instead of the global one. You cannot uninstall the global package because it is used by another application. You have the following options:

A) Modify the PYTHONPATH environment variable to include the directory containing your 'pipeline' package before the site-packages directory. B) Rename your local 'pipeline' package to something else and update all imports. C) Use a virtual environment specific to your project and install your package there. D) Add an __init__.py file with a special import hook to override the global package.

Which course of action is the most appropriate and reliable?

Trap 1: Add an __init__.py file with a special import hook to override the…

Import hooks are complex and not intended for this purpose.

Trap 2: Rename your local 'pipeline' package to something else and update…

Renaming works but is not the recommended approach; it can cause confusion and requires code changes.

Trap 3: Modify the PYTHONPATH environment variable to include the directory…

PYTHONPATH can be overridden and is less reliable than a virtual environment.

A
Use a virtual environment specific to your project and install your package there.
Virtual environments provide clean isolation and are best practice.
B
Add an __init__.py file with a special import hook to override the global package.
Why wrong: Import hooks are complex and not intended for this purpose.
C
Rename your local 'pipeline' package to something else and update all imports.
Why wrong: Renaming works but is not the recommended approach; it can cause confusion and requires code changes.
D
Modify the PYTHONPATH environment variable to include the directory containing your 'pipeline' package before the site-packages directory.
Why wrong: PYTHONPATH can be overridden and is less reliable than a virtual environment.

Question 11mediummultiple choice

A developer is troubleshooting a Python application that fails to import a custom module named 'utils'. The file 'utils.py' exists in the same directory as the main script. Which of the following is the most likely cause of the import failure?

Trap 1: There is a circular import between utils.py and the main script.

A circular import would cause an ImportError but with a specific message about partially initialized module.

Trap 2: The directory lacks an __init__.py file.

__init__.py is only required for directories to be treated as packages, not for a standalone module in the same directory.

Trap 3: The utils.py file contains a syntax error.

A syntax error would cause an ImportError, but the error message would indicate a syntax error, not simply a missing module.

A
There is a circular import between utils.py and the main script.
Why wrong: A circular import would cause an ImportError but with a specific message about partially initialized module.
B
The directory containing utils.py is not in sys.path.
Python searches for modules in directories listed in sys.path. If the script's directory is not included, the import will fail unless the script is run from that directory.
C
The directory lacks an __init__.py file.
Why wrong: __init__.py is only required for directories to be treated as packages, not for a standalone module in the same directory.
D
The utils.py file contains a syntax error.
Why wrong: A syntax error would cause an ImportError, but the error message would indicate a syntax error, not simply a missing module.

Question 12hardmultiple choice

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?

Trap 1: Only mypackage/__init__.py is executed.

The __init__.py of each package in the path is executed, including subpackage1.

Trap 2: No __init__.py files are executed because the import uses a dotted…

__init__.py files are executed to initialize packages.

Trap 3: After the import, 'mypackage' is not available as a name in the…

The import makes 'mypackage' available as a name referencing the top-level package.

A
Only mypackage/__init__.py is executed.
Why wrong: The __init__.py of each package in the path is executed, including subpackage1.
B
No __init__.py files are executed because the import uses a dotted path.
Why wrong: __init__.py files are executed to initialize packages.
C
After the import, 'mypackage' is not available as a name in the namespace.
Why wrong: The import makes 'mypackage' available as a name referencing the top-level package.
D
Both mypackage/__init__.py and mypackage/subpackage1/__init__.py are executed.
Python executes __init__.py for each package in the dotted path when importing a submodule.

Question 13easymultiple choice

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

Trap 1: analytics/, analytics/statistics/ (__init__.py), analytics/ml/…

The top-level directory must have __init__.py to be a package.

Trap 2: analytics/ (__init__.py), analytics/statistics/ (__init__.py),…

Multiple __init__.py files in the same directory is redundant and incorrect.

Trap 3: analytics/ (__init__.py), analytics/statistics/, analytics/ml/

Subdirectories without __init__.py are not packages.

A
analytics/, analytics/statistics/ (__init__.py), analytics/ml/ (__init__.py)
Why wrong: The top-level directory must have __init__.py to be a package.
B
analytics/ (__init__.py), analytics/statistics/ (__init__.py), analytics/ml/ (__init__.py), analytics/__init__.py (file)
Why wrong: Multiple __init__.py files in the same directory is redundant and incorrect.
C
analytics/ (__init__.py), analytics/statistics/, analytics/ml/
Why wrong: Subdirectories without __init__.py are not packages.
D
analytics/ (__init__.py), analytics/statistics/ (__init__.py), analytics/ml/ (__init__.py)
Each directory must contain an __init__.py file to be recognized as a package.

Question 14mediummultiple choice

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?

Trap 1: The import statement in app.py is placed inside a function, so it…

Imports inside functions are executed when the function is called.

Trap 2: The module was imported using 'from config import DATABASE_URL'…

Even with 'from', the module is executed once and the value is determined at that time.

Trap 3: The environment variable is only read when the function is called,…

os.getenv is called at import time, so the value is set immediately.

A
The import statement in app.py is placed inside a function, so it is not executed.
Why wrong: Imports inside functions are executed when the function is called.
B
The module was imported using 'from config import DATABASE_URL' which creates a separate copy.
Why wrong: Even with 'from', the module is executed once and the value is determined at that time.
C
The environment variable is only read when the function is called, not at import time.
Why wrong: os.getenv is called at import time, so the value is set immediately.
D
Python caches modules; config.py was imported earlier without the environment variable, and the cached version is reused.
Modules are cached in sys.modules. If config.py was imported previously, the cached version is used, and the code is not re-executed.

Question 15hardmultiple choice

A Python package 'shapes' has the following __init__.py:

# shapes/__init__.py
from .circle import Circle
from .square import Square

A user writes:

import shapes

c = shapes.Circle(5)

This works correctly. However, when the user writes:

import shapes.circle

c = shapes.circle.Circle(5)

It fails with AttributeError: module 'shapes' has no attribute 'circle'. What is the most likely reason?

Trap 1: The __init__.py file must include 'import shapes.circle' to make…

Even without explicit import, importing the submodule directly should add it to the package's namespace.

Trap 2: The submodule name 'circle' conflicts with the class name 'Circle'…

Case sensitivity does not cause conflicts; 'circle' and 'Circle' are different.

Trap 3: The import statement 'import shapes.circle' is invalid because…

'import shapes.circle' is a valid syntax for importing submodules.

A
The submodule 'circle' is not added to the package's namespace because the __init__.py does not import it as a submodule.
The __init__.py only imports the class Circle, not the submodule name. When 'import shapes.circle' is executed, Python attempts to load the submodule and add it as an attribute, but if the submodule has import errors or is not a proper module, it may fail. However, the most likely reason is that the submodule import does not automatically make the submodule accessible via the package if the package's __init__.py does not import it. Actually, Python does add the submodule to the package after a successful import. But the error suggests that the import of shapes.circle failed silently? The correct answer is that the submodule is not loaded because of a circular import or because the submodule's name is the same as a class and Python gets confused. In PCAP, the typical answer is that importing the submodule using 'import shapes.circle' does not make 'circle' available as an attribute of 'shapes' unless the package's __init__.py explicitly imports it. I'll go with D.
B
The __init__.py file must include 'import shapes.circle' to make the submodule accessible.
Why wrong: Even without explicit import, importing the submodule directly should add it to the package's namespace.
C
The submodule name 'circle' conflicts with the class name 'Circle' due to case sensitivity.
Why wrong: Case sensitivity does not cause conflicts; 'circle' and 'Circle' are different.
D
The import statement 'import shapes.circle' is invalid because submodules must be imported using 'from' syntax.
Why wrong: 'import shapes.circle' is a valid syntax for importing submodules.

Question 16mediummulti select

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

Trap 1: Packages cannot be imported using the import statement with dot…

Packages and submodules can be imported using dot notation.

Trap 2: An __init__.py file is required in every directory to make it a…

Python 3.3+ introduced namespace packages that do not require __init__.py.

Trap 3: A package is a single .py file.

A single .py file is a module, not a package.

A
A package can contain subpackages.
Packages can be nested.
B
An __init__.py file can be empty.
An empty __init__.py is sufficient to mark a directory as a package.
C
Packages cannot be imported using the import statement with dot notation.
Why wrong: Packages and submodules can be imported using dot notation.
D
An __init__.py file is required in every directory to make it a package.
Why wrong: Python 3.3+ introduced namespace packages that do not require __init__.py.
E
A package is a single .py file.
Why wrong: A single .py file is a module, not a package.

Question 17hardmulti select

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'?

Trap 1: import app.operations.math_ops.calculate

Cannot import a function directly with import; that syntax is for modules.

Trap 2: from app.import operations.math_ops import calculate

Invalid syntax; cannot have two 'import' keywords.

A
from app.operations.math_ops import calculate
Valid direct import of the function.
B
import importlib; module = importlib.import_module('app.operations.math_ops'); module.calculate()
importlib.import_module can import a module by its dotted path.
C
import app.operations.math_ops.calculate
Why wrong: Cannot import a function directly with import; that syntax is for modules.
D
from app.import operations.math_ops import calculate
Why wrong: Invalid syntax; cannot have two 'import' keywords.
E
import app.operations.math_ops; app.operations.math_ops.calculate()
Valid absolute import.

Question 18mediummultiple choice

You are working on a Python-based data processing pipeline that runs on a Linux server. The pipeline consists of several custom packages and modules located in /opt/mypipeline. The directory structure includes:

/opt/mypipeline/ __init__.py core/ __init__.py processor.py utils/ __init__.py logger.py

The main entry point is /opt/mypipeline/run.py, which imports modules from core and utils. The pipeline is executed using the command:

python /opt/mypipeline/run.py

Recently, the system administrator added a new Python package 'external_lib' to /opt/external_lib, and updated the PYTHONPATH environment variable to include /opt/external_lib. However, after this change, the pipeline fails to start with the following error:

ImportError: cannot import name 'process' from 'core.processor' (unknown location)

You check the PYTHONPATH and find it contains:

/opt/mypipeline:/opt/external_lib

The 'core.processor' module defines a function 'process' that is imported in run.py as:

from core.processor import process

The 'core' package has an __init__.py file. The 'external_lib' package also has a subpackage named 'core' with an __init__.py. What is the most likely cause of the import error?

Trap 1: The __init__.py file in /opt/mypipeline/core/ is missing or empty.

The file exists and was working before; the error is about importing 'process', not about the package itself.

Trap 2: The import statement in run.py is incorrect; it should use 'from…

The import syntax is correct and was previously working.

Trap 3: The PYTHONPATH environment variable is set incorrectly; it should…

It does include /opt/mypipeline first, but even so, if external_lib's core is a namespace package or if there's a .pth file, it could still interfere. However, the most direct cause is the conflict.

A
The 'external_lib' package contains a 'core' subpackage that shadows the 'core' package from mypipeline, and Python is resolving to the wrong one.
Both packages have a 'core' subpackage. Depending on sys.path order, Python might import the wrong 'core' package, causing the import of 'processor' to fail.
B
The __init__.py file in /opt/mypipeline/core/ is missing or empty.
Why wrong: The file exists and was working before; the error is about importing 'process', not about the package itself.
C
The import statement in run.py is incorrect; it should use 'from core.processor import process as process' or similar.
Why wrong: The import syntax is correct and was previously working.
D
The PYTHONPATH environment variable is set incorrectly; it should include /opt/mypipeline before /opt/external_lib.
Why wrong: It does include /opt/mypipeline first, but even so, if external_lib's core is a namespace package or if there's a .pth file, it could still interfere. However, the most direct cause is the conflict.

Question 19mediummultiple choice

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?

Trap 1: Create a wrapper function in `__init__.py` that delegates calls to…

This adds an unnecessary layer; direct import is simpler and more efficient.

Trap 2: Include `__all__` in each submodule and ensure `__init__.py` is…

`__all__` in submodules controls their exports, but does not bring them into the package namespace.

Trap 3: Define a list named `__all__` in the package's `__init__.py` that…

`__all__` only affects `from package import *`, not `import package`.

A
Create a wrapper function in `__init__.py` that delegates calls to the submodule functions.
Why wrong: This adds an unnecessary layer; direct import is simpler and more efficient.
B
Include `__all__` in each submodule and ensure `__init__.py` is empty.
Why wrong: `__all__` in submodules controls their exports, but does not bring them into the package namespace.
C
In `__init__.py`, import the desired functions from the submodules, e.g., `from .submodule import func1`.
Importing into `__init__.py` makes those names available directly on the package object.
D
Define a list named `__all__` in the package's `__init__.py` that lists the functions.
Why wrong: `__all__` only affects `from package import *`, not `import package`.

Question 20hardmulti select

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

Trap 1: The current working directory is always the first element in…

It's the script's directory, not the CWD, that is added first.

Trap 2: `sys.path` is a tuple of strings.

sys.path is a list, not a tuple.

A
The current working directory is always the first element in `sys.path`.
Why wrong: It's the script's directory, not the CWD, that is added first.
B
Module search stops at the first matching directory in `sys.path`.
Python searches sys.path in order and stops when it finds the module.
C
`sys.path` is initialized from the PYTHONPATH environment variable.
PYTHONPATH is one of the sources for initializing sys.path.
D
`sys.path` is a tuple of strings.
Why wrong: sys.path is a list, not a tuple.
E
The directory containing the script being run is added to the beginning of `sys.path` at startup.
This is true for typical script execution.