Python Modules and Packages Exercises

Which of the following best describes a module in Python?

A folder that contains multiple Python files.

A single Python file that can contain variables, functions, or classes.

A built-in tool used only for mathematical operations.

A function that automatically loads other functions.

A module in Python is simply a single .py file that contains Python code. This code may include functions, variables, classes, or even executable statements.

Key points to remember:

A module is always a single file, not a folder.
You can import a module using import module_name.
Modules help organize code and make it reusable across multiple programs.

Example of a Python module:

# file: greetings.py
def hello():
    return "Hello!"

Then it can be imported in another file:

import greetings
print(greetings.hello())

Tip: Use modules to break large programs into smaller, manageable parts.

Which import statement correctly imports the math module in Python?

include math

using math

import math

require math

In Python, the correct and standard way to load a built-in or user-defined module is by using the import statement.

import math loads the entire math module.
After importing, you can access its functions like math.sqrt() or math.pi.
Other keywords like include, using, or require do not exist in Python’s import system.

Example usage:

import math

result = math.sqrt(25)
print(result)  # 5.0

Tip: When in doubt, remember that Python uses the import keyword for all module-loading operations.

You want to import only the `sqrt` function from the `math` module. Which statement should you use?

import sqrt from math

from math import sqrt

using math.sqrt

include math.sqrt

Python allows you to import specific functions from a module using the from module import name syntax. This makes it easy to use the imported function directly without prefixing it with the module name.

In this case, importing sqrt from the math module looks like this:

from math import sqrt
print(sqrt(16))  # 4.0

import sqrt from math is not valid Python syntax.
using and include are not Python import keywords.

Tip: Use this import style when you only need a few specific functions from a large module.

What is the primary purpose of a `init.py` file inside a folder?

To store the main function of the program.

To mark the folder as a Python package.

To automatically run all modules in the folder.

To delete unused modules in the package.

The __init__.py file is used to tell Python that a folder should be treated as a package. This allows you to import modules from that folder using standard import statements.

Without an __init__.py file, older versions of Python would not recognize the folder as a package.
In modern Python versions, it's still commonly used for organizing package behavior.
You can also add initialization code inside __init__.py if needed.

Example structure:

my_package/
    __init__.py
    utils.py

Then you can import like this:

from my_package import utils

Tip: Even when optional, including __init__.py helps keep your package structure clear and predictable.

Which of the following statements is true about built-in Python modules?

They are already included with Python and do not need installation.

They must always be downloaded using pip.

They cannot be imported into custom scripts.

They are only available in Python 2, not Python 3.

Python comes with many built-in modules that are ready to use without any additional installation. Examples include:

math – for mathematical functions
os – for interacting with the operating system
sys – for system-specific parameters and functions
random – for generating random numbers

Key points:

You do not need to install these modules using pip.
They can be imported in your scripts using import module_name.
Built-in modules are maintained as part of Python’s standard library and are compatible with Python 3.

Tip: Familiarize yourself with Python’s standard library. It can save time by providing pre-built functions for common tasks.

You have created a custom module `calculator.py` with the following content:

# calculator.py
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

Which of the following statements correctly imports and uses the `add` function in another Python file?

import calculator
print(calculator.add(5, 3))

from calculator import add
print(add(5, 3))

import add from calculator
print(add(5, 3))

Both Option 1 and Option 2

When using custom modules, Python allows multiple ways to import and use functions:

Option 1: import calculator imports the entire module. You access functions with the module prefix: calculator.add().
Option 2: from calculator import add imports only the add function. You can call it directly as add() without prefixing.
Option 3: import add from calculator is invalid Python syntax.

Example using Option 1:

import calculator
print(calculator.add(5, 3))  # 8

Example using Option 2:

from calculator import add
print(add(5, 3))  # 8

Tip: Use from module import function if you only need specific functions, and import module if you plan to use multiple functions to avoid polluting the namespace.

You want to import the `random` module but refer to it with a shorter name `rnd` in your code. Which statement achieves this?

import random as rnd
print(rnd.randint(1, 10))

from random import rnd
print(rnd.randint(1, 10))

import random as random_short
print(random_short.randint(1, 10))

using random as rnd
print(rnd.randint(1, 10))

Python allows you to assign an alias to a module using the as keyword. This is useful for shortening module names or avoiding conflicts.

Option 1: Correctly imports the random module as rnd, allowing usage like rnd.randint().
Option 2: Invalid syntax. You cannot alias a function directly with from module import alias in this way.
Option 3: Correct syntax but not the option we chose; it works but the alias is different.
Option 4: using is not a Python keyword.

Example:

import random as rnd

number = rnd.randint(1, 100)
print(number)  # Outputs a random number between 1 and 100

Tip: Use aliases for long module names or to avoid conflicts, especially with modules from external libraries.

Which of the following statements correctly imports multiple functions `sin` and `cos` from the `math` module?

from math import sin, cos
print(sin(0), cos(0))

import math.sin, math.cos
print(sin(0), cos(0))

from math import sin as s, cos as c
print(s(0), c(0))

Both Option 1 and Option 3

Python allows importing multiple functions from a module using from module import func1, func2. You can also alias them using as.

Option 1: Correctly imports sin and cos and uses them directly.
Option 2: Invalid syntax. You cannot import functions this way with dot notation.
Option 3: Correct syntax using aliases s and c for the functions.
Option 4: Correct because both Option 1 and Option 3 work properly.

Example using Option 1:

from math import sin, cos

print(sin(0))  # 0.0
print(cos(0))  # 1.0

Example using Option 3:

from math import sin as s, cos as c

print(s(0))  # 0.0
print(c(0))  # 1.0

Tip: Use aliases if function names conflict with your own variables or if you want shorter names for readability.

Which of the following correctly distinguishes a module from a package in Python?

A module is a single Python file; a package is a folder containing multiple modules and an __init__.py file.

A module is always a folder; a package is a single Python file.

Modules can only contain functions; packages can only contain classes.

Modules and packages are exactly the same in Python.

Understanding the difference between modules and packages is crucial for organizing Python projects:

Module: A single .py file containing Python code (functions, classes, variables).
Package: A folder containing multiple modules and an __init__.py file, which allows Python to treat it as a package.
Packages can also contain sub-packages (nested folders with their own __init__.py).

Example:

# File structure
my_package/
    __init__.py
    module1.py
    module2.py

Now you can import a module from the package:

from my_package import module1

Tip: Use packages to logically group related modules and avoid namespace conflicts.

Examine the following code. Which line will cause an ImportError?

# file: my_module.py
def greet(name):
    return f"Hello, {name}!"

# file: main.py
import my_module
print(my_module.say_hello("Alice"))

import my_module

print(my_module.say_hello("Alice"))

It will work fine

The code will raise a SyntaxError instead of ImportError

Let's analyze the code carefully:

my_module.py defines a function called greet.
In main.py, the code tries to call my_module.say_hello("Alice").
Since there is no function named say_hello in my_module, Python will raise an AttributeError, which is a subclass of ImportError when accessed via a module. For import-specific problems, Python raises ImportError.

The correct way to use the function would be:

import my_module
print(my_module.greet("Alice"))  # Hello, Alice!

Tip: Always check the names of functions and classes when importing from custom modules to avoid runtime errors.

Consider the following package structure:

my_package/
    __init__.py
    math_ops/
        __init__.py
        addition.py
        subtraction.py
    string_ops/
        __init__.py
        uppercase.py
        lowercase.py

Which import statement correctly imports the `addition` module from `math_ops`?

import my_package.math_ops.addition

from my_package.math_ops import addition

from my_package import math_ops.addition

Both Option 1 and Option 2

When working with nested packages, Python provides two common ways to import modules:

Option 1: import my_package.math_ops.addition imports the entire module with its full namespace. Functions or classes inside are accessed like my_package.math_ops.addition.function_name().
Option 2: from my_package.math_ops import addition imports the module directly, allowing access via addition.function_name().
Option 3: Invalid syntax. You cannot use dot notation inside the from … import … statement in this way.

Example usage:

# Using Option 1
import my_package.math_ops.addition
result = my_package.math_ops.addition.add(5, 3)

# Using Option 2
from my_package.math_ops import addition
result = addition.add(5, 3)

Tip: Use Option 1 for clarity with deeply nested packages; Option 2 can simplify access when the module name is sufficient.

Consider the following module `counter.py`:

# counter.py
count = 0

def increment():
    global count
    count += 1
    return count

If you import this module in two different scripts as shown, what will be the output?

# file: script1.py
import counter
print(counter.increment())

# file: script2.py
import counter
print(counter.increment())

1 2

1 1

2 2

0 0

This exercise tests understanding of module-level variables and how Python handles imports.

Each Python script that imports a module gets its own reference if the interpreter is restarted or if scripts are run independently.
Module-level variables retain state only within the same Python process. In this case, script1 and script2 are separate processes.
Therefore, both scripts start with count = 0 and increment it once, resulting in 1 in both cases.

Key takeaway:

Module variables are shared only within the same Python process/session.
Running scripts separately does not preserve module state across runs.

Example within a single session:

import counter
print(counter.increment())  # 1
print(counter.increment())  # 2

Tip: Avoid relying on module-level variables for persistent state across separate scripts; use files, databases, or other storage methods.

Given the following structure:

project/
    main.py
    utils.py

If `main.py` contains:

import utils
from utils import helper_function

Which statement is correct regarding how Python handles the `utils` module?

Python loads the module once and both import statements refer to the same module object.

Python loads the module twice, creating two separate objects.

The second import will overwrite the first import.

Python will raise an ImportError because the module is imported twice.

When a module is imported in Python, it is loaded into memory the first time it is imported. Subsequent imports of the same module, even using different forms, reference the same module object.

Example:

import utils          # loads utils.py
from utils import helper_function  # references the same utils module

This prevents multiple copies of the module from being created, saving memory and maintaining state.
The second import does not overwrite the first; it simply provides a direct reference to the function or variable.
Importing the same module multiple times does not raise an ImportError.

Tip: Be aware of Python’s module caching mechanism (sys.modules), which ensures modules are loaded only once per interpreter session.

Suppose you have a module `config.py`:

# config.py
setting = 10

You run the following in Python shell:

import config
print(config.setting)  # Line 1

config.setting = 20
print(config.setting)  # Line 2

import config
print(config.setting)  # Line 3

What will be the output?

10 20 10

10 20 20

10 10 10

20 20 20

This exercise tests understanding of how Python handles module imports and re-imports.

Line 1: Imports config, initial setting = 10.
Line 2: Modifies config.setting to 20. This change affects the module object in memory.
Line 3: Re-importing config does not reload the module if it’s already in memory. Python uses the cached module from sys.modules, so setting remains 20.

Key points:

Python imports a module only once per interpreter session.
Changes to module-level variables persist in memory.
To force a reload, you can use import importlib; importlib.reload(config).

Output:

10 20 20

Tip: Avoid modifying module-level variables if you expect re-imports to reset them. Use functions or class instances for mutable state.

Consider the following package structure:

my_package/
    __init__.py
    math_ops/
        __init__.py
        addition.py
        subtraction.py
    main.py

If `main.py` wants to import the `addition` module using a relative import, which statement is correct?

from .math_ops import addition

import my_package.math_ops.addition

from ..math_ops import addition

import addition

Relative imports are used to import modules within the same package or subpackage without specifying the full package path.

Option 1: Correct. The single dot . refers to the current package (my_package), allowing import of the submodule math_ops.addition.
Option 2: Absolute import using the full path works too, but the question specifically asks for relative import.
Option 3: Double dot .. refers to the parent package, which is invalid here since main.py is at the top level of my_package.
Option 4: Invalid unless addition.py is in the same directory as main.py.

Example usage:

from .math_ops import addition

result = addition.add(5, 3)
print(result)  # 8

Tip: Use relative imports within packages to make your code easier to reorganize, but absolute imports are often clearer for readability in larger projects.

Consider the following package structure with potential circular imports:

project/
    module_a.py
    module_b.py

Contents:

# module_a.py
from module_b import func_b

def func_a():
    return "A"

# module_b.py
from module_a import func_a

def func_b():
    return "B"

What will happen if you try to import `module_a` in a script?

Python will successfully import module_a and module_b without issues.

Python will raise an ImportError or AttributeError due to circular import.

Python will ignore module_b and only import module_a.

Python will merge both modules automatically.

This is a classic example of a circular import, where two modules depend on each other.

module_a imports func_b from module_b.
module_b imports func_a from module_a.
When Python tries to import module_a, it starts executing it. During execution, it encounters from module_b import func_b, which triggers loading module_b.
While loading module_b, Python again tries to import func_a from module_a. At this point, func_a is not yet defined, causing an ImportError or AttributeError.

Key points:

Circular imports occur when two or more modules depend on each other directly or indirectly.
They can often be fixed by rearranging imports, using local imports inside functions, or redesigning the code.

Tip: Avoid placing imports at the top if it creates a circular dependency. Consider importing inside the function that uses the other module.

You have a large module `data_processing.py` with many functions. You only need the `clean_data` function in your script. Which import strategy is most efficient?

import data_processing
clean_data(data)

from data_processing import clean_data
clean_data(data)

from data_processing import *
clean_data(data)

import data_processing as dp
dp.clean_data(data)

When working with large modules, efficiency and readability are important.

Option 1: Imports the entire module. While it works, you load all functions and variables, which is unnecessary if you only need one function.
Option 2: Imports only the clean_data function. This is memory-efficient and keeps your namespace clean.
Option 3: Using from module import * imports all names into the current namespace. This can cause name conflicts and is not recommended.
Option 4: Aliasing the module works, but you still import everything unnecessarily.

Example usage:

from data_processing import clean_data

cleaned = clean_data(raw_data)

Tip: For better efficiency and maintainability, always import only what you need from large modules.

You have two modules:

# module_x.py
value = 10

# module_y.py
value = 20

In your script, you write:

from module_x import *
from module_y import *
print(value)

What will be printed, and why?

10, because module_x was imported first

20, because module_y was imported last and overwrites the name

Both 10 and 20 printed as a tuple

Python will raise a NameError

This exercise highlights the risk of namespace pollution when using from module import *.

Both modules define a variable named value.
Using from module import * imports all names directly into the current namespace.
Since module_y is imported after module_x, its value overwrites module_x's value.
Therefore, print(value) outputs 20.

Better practices:

Use module prefixes to avoid conflicts: import module_x and import module_y.
Avoid from module import * in large projects.

Example of safe import:

import module_x
import module_y

print(module_x.value)  # 10
print(module_y.value)  # 20

Tip: Star imports are convenient for small scripts but can lead to unexpected behavior in larger projects.

You have the following package structure:

analytics/
    __init__.py
    preprocessing/
        __init__.py
        clean.py
        transform.py
    modeling/
        __init__.py
        train.py
        predict.py

You want to import the `clean_data` function from `clean.py` into `train.py`. Which is the correct relative import?

from ..preprocessing.clean import clean_data

from preprocessing.clean import clean_data

import analytics.preprocessing.clean as clean
clean.clean_data()

from ..modeling.clean import clean_data

This is a tricky exercise involving nested packages and relative imports.

Option 1: Correct. The double dot .. refers to the parent package analytics, allowing access to the sibling subpackage preprocessing and the module clean.py.
Option 2: Incorrect. Without a proper absolute import setup, this will fail because Python needs to know the full package path.
Option 3: Works as an absolute import if analytics is in PYTHONPATH, but the question asks for relative import.
Option 4: Incorrect. modeling is a sibling to preprocessing, not its parent.

Example usage inside train.py:

from ..preprocessing.clean import clean_data

data = load_data()
cleaned = clean_data(data)

Tip: Use relative imports for internal package modules to make code relocatable and easier to maintain. Remember: . = current package, .. = parent package.

You have two modules with a circular dependency:

# module_a.py
import module_b

def func_a():
    return "A"

# module_b.py
import module_a

def func_b():
    return "B"

Which of the following is the best way to resolve the circular import?

Remove one of the modules entirely.

Use `from module import *` in both modules.

Move the import inside the function that uses the other module.

Merge both modules into a single file.

Circular imports occur when two modules depend on each other directly. This can lead to ImportError or AttributeError at runtime.

Option 1: Removing a module may not be feasible; the functionality could be required.
Option 2: Using from module import * does not solve the circular import and can pollute the namespace.
Option 3: Correct. By moving the import inside the function that actually uses the other module, Python only performs the import when the function is called, avoiding the circular dependency at load time.
Option 4: Merging both modules works but may not be desirable for code organization or maintainability.

Example:

# module_a.py
def func_a():
    from module_b import func_b  # Import inside function
    return "A uses " + func_b()

Tip: For complex packages, consider restructuring your code, using local imports, or splitting shared functions into a third module to avoid circular imports.

Concept	Description
Module	a `.py` file containing Python code (functions, classes, variables).
Package	a folder with one or more modules (and possibly sub-packages), with an `__init__.py` file.
Import statement	Use `import` or `from … import …` to access module/package contents.
Benefits	Modules and packages help you write modular, maintainable, reusable, and scalable code.
Project growth	As your Python projects grow, proper use of modules & packages becomes increasingly important for good structure and clarity.

Python Modules and Packages Practice Questions

Which of the following best describes a module in Python?

Which import statement correctly imports the math module in Python?

You want to import only the sqrt function from the math module. Which statement should you use?

What is the primary purpose of a __init__.py file inside a folder?

Which of the following statements is true about built-in Python modules?

You have created a custom module calculator.py with the following content:

Which of the following statements correctly imports and uses the add function in another Python file?

You want to import the random module but refer to it with a shorter name rnd in your code. Which statement achieves this?

Which of the following statements correctly imports multiple functions sin and cos from the math module?

Which of the following correctly distinguishes a module from a package in Python?

Examine the following code. Which line will cause an ImportError?

Consider the following package structure:

Which import statement correctly imports the addition module from math_ops?

Consider the following module counter.py:

If you import this module in two different scripts as shown, what will be the output?

Given the following structure:

If main.py contains:

Which statement is correct regarding how Python handles the utils module?

Suppose you have a module config.py:

You run the following in Python shell:

What will be the output?

Consider the following package structure:

If main.py wants to import the addition module using a relative import, which statement is correct?

Consider the following package structure with potential circular imports:

What will happen if you try to import module_a in a script?

You have a large module data_processing.py with many functions. You only need the clean_data function in your script. Which import strategy is most efficient?

You have two modules:

In your script, you write:

What will be printed, and why?

You have the following package structure:

You want to import the clean_data function from clean.py into train.py. Which is the correct relative import?

You have two modules with a circular dependency:

Which of the following is the best way to resolve the circular import?

Quick Recap of Python Modules and Packages Concepts

What is a Module in Python?

What is a Package in Python — and Why Use It?

Why Modules & Packages Matter — Their Benefits

Basic Usage Examples

Key Points to Remember

Test Your Python Modules and Packages Knowledge

About This Exercise: Python – Modules and Packages

What You Will Learn

Why Learning Modules and Packages Matters

Start Strengthening Your Python Skills

Need a Quick Refresher?

You want to import only the `sqrt` function from the `math` module. Which statement should you use?

What is the primary purpose of a `init.py` file inside a folder?

You have created a custom module `calculator.py` with the following content:

Which of the following statements correctly imports and uses the `add` function in another Python file?

You want to import the `random` module but refer to it with a shorter name `rnd` in your code. Which statement achieves this?

Which of the following statements correctly imports multiple functions `sin` and `cos` from the `math` module?

Which import statement correctly imports the `addition` module from `math_ops`?

Consider the following module `counter.py`:

If `main.py` contains:

Which statement is correct regarding how Python handles the `utils` module?

Suppose you have a module `config.py`:

If `main.py` wants to import the `addition` module using a relative import, which statement is correct?

What will happen if you try to import `module_a` in a script?

You have a large module `data_processing.py` with many functions. You only need the `clean_data` function in your script. Which import strategy is most efficient?

You want to import the `clean_data` function from `clean.py` into `train.py`. Which is the correct relative import?