PCAP Practice Test 20 — 15 Questions

Question 1

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__.. Option C is correct because 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 2

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). Option C is correct because 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 3

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. Option B is correct because 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 4

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'). Option C is correct because `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 5

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.. Option C is correct because 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 6

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.

Question 7

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. Option A is correct because 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 8

Refer to the exhibit. Which of the following correctly shows the MRO of class D?

Accepted Answer

[D, B, C, A, object]. Option A is correct because Python's Method Resolution Order (MRO) for class D, which inherits from B and C (where B inherits from A and C inherits from A), follows the C3 linearization algorithm. The MRO is computed as D -> B -> C -> A -> object, ensuring that each class appears before its parents and that the order respects the local precedence order of D's bases (B before C).

Answer

[D, A, B, C, object]

Answer

[D, B, A, C, object]

Answer

[D, C, B, A, object]

Question 9

Which TWO statements about the sys module are true?

Accepted Answer

sys.exit() raises SystemExit with a default exit code of 0.. Option C is correct because `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 10

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.. Option A is correct because 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 11

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).. Option B is correct because 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 preventing direct access to internal modules, as Python's import system respects the underscore convention and `__all__` restricts wildcard imports.

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 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 *'.. Option D is correct because 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

Consider the following directory structure:
project/
  main.py
  pkg/
    __init__.py
    mod1.py
    subpkg/
      __init__.py
      mod2.py
From main.py, you write: from pkg.subpkg import mod2
Which THREE of the following are true regarding relative imports?

Accepted Answer

Relative imports only work when the importing module is part of a package.. Option A is correct because relative imports (using dot notation like `..` or `.`) are only valid when the importing module is itself part of a package. This is because relative imports rely on the `__package__` attribute to resolve the import path; if the module is not inside a package (e.g., a top-level script), `__package__` is `None` or empty, and relative imports will raise an `ImportError`.

Answer

In main.py, you can use `from . import pkg` to import pkg.

Answer

A directory must contain an __init__.py file to be a package for relative imports to function.

Question 14

Consider the following code: class A: x = 1; class B(A): pass; class C(A): x = 2; class D(B, C): pass. What is D.x?

Accepted Answer

2. Option C is correct because Python's method resolution order (MRO) for class D, which uses multiple inheritance, follows the C3 linearization algorithm. The MRO for D is D, B, C, A, and since C defines x = 2, that attribute overrides the x = 1 from A in the inheritance chain, so D.x resolves to 2.

Answer

AttributeError

Answer

1

Answer

(1, 2) tuple

Question 15

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

Accepted Answer

It is automatically created when a module is imported.. Option B is correct because 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.