Python Modules and Packages Exercises

This example demonstrates how modules in Python work as a way to organize and reuse code.

• The file math_utils.py is a module containing functions like add.
• By using import math_utils, you bring all the functions and classes from that module into your current script’s namespace (under the math_utils prefix).
• This allows you to call math_utils.add(5, 3) to reuse the function without rewriting it.

Modules make Python programs more modular, easier to maintain, and enable collaboration across multiple files.
When you organize multiple modules into directories with an __init__.py file, you create packages, which provide a hierarchical structure for large projects.

The import keyword is used to bring in modules so you can access their functions, classes, and variables. For example, import math allows you to use functions like math.sqrt(). It is one of the foundational keywords in Python for modularity.

Using from math import sqrt imports just the sqrt function from the math module. This is useful when you only need a specific function and want to avoid loading the entire module namespace.

In Python versions before 3.3, a folder must contain a __init__.py file to be recognized as a package. This file can be empty or contain initialization code. From Python 3.3 onward, implicit namespace packages are allowed, but it's still good practice to include it for compatibility.

The math module provides a constant pi with high precision. When print(math.pi) is executed, it displays 3.141592653589793, which is a more accurate representation of π compared to the approximation 3.14.

This code defines a function hello() in a separate module called greetings.py. In main.py, the module is imported using import greetings, and the function is accessed as greetings.hello(). This is standard module usage in Python, and it correctly prints the message.

Using from module import * brings in all public names from the module into the current namespace. However, names starting with an underscore (like _private_var) are not imported by default. This form of import is generally discouraged for large modules, as it can cause namespace collisions and reduce code clarity.

When a Python file is executed directly, the special variable __name__ is set to "__main__". This condition is used to separate code meant to run on direct execution from code that should only run when the file is imported as a module. It is a common Python idiom used for script entry points.

The __init__.py file is used to initialize a Python package. It can contain setup code that runs when the package is imported, or it can be left empty. Its presence was required in older Python versions (before 3.3) to mark a directory as a package, though it's still used in modern Python for customization.

You can use the as keyword to assign an alias to a module during import. This is especially useful for long module names or when avoiding name collisions. In the example, datetime is imported as dt, and you can access datetime.now() using dt.datetime.now().

To import a function from a submodule within a package, you use the full dotted path: from maths.algebra import solve. This works as long as maths is a subpackage and both __init__.py files exist. Option4 would work only if you are importing from outside the myapp package and it is installed or in the Python path.

The __all__ list is a special variable in a module that controls what gets imported when a user writes from module import *. If it's not defined, Python imports all names not starting with an underscore. Defining __all__ helps make a module’s API explicit and avoid namespace pollution.

By default, from module import * imports all names that do not start with an underscore. In this case, visible will be imported, while _hidden remains private to the module. This convention helps protect internal functions from being accidentally exposed when using wildcard imports.

To import a module from a sibling package in a package hierarchy, you can use relative imports like from ..sibling import module. This goes one level up and accesses the sibling directory. Relative imports only work within packages, not in standalone scripts, and require the directory to be a valid package with __init__.py.

When a package is imported, Python executes the code inside its __init__.py file. So, print("Initializing mypackage") will execute and display the message. This file is often used to initialize the package or define what should be exposed when using from mypackage import *.

The syntax import utils.PI is invalid because Python expects PI to be a submodule or package, not a variable. You can only import modules or attributes using dot notation if you use from utils import PI. Thus, the interpreter raises an error that 'utils.PI' is not a module.

The variable config is first used to import the module, but then it is reassigned locally to a dictionary. This overwrites the original reference to the imported module within the current scope. Therefore, when print(config["debug"]) runs, it accesses the dictionary version of config, which has "debug": False.

Python allows circular imports, but they can lead to partially initialized modules. If one module accesses another before its definitions have completed, the result may be undefined or raise AttributeError. Circular imports are legal but risky, and best avoided by reorganizing code or using local imports.

The standard Python idiom to prevent code from executing on import is wrapping it in if __name__ == "__main__":. This ensures the code only runs when the file is executed directly, not when it’s imported as a module. It's essential for reusable scripts or libraries.

Once a module is imported in Python, it is cached in sys.modules. Re-importing it does not re-run the module or reset its attributes. In this case, after modifying package.x = 100, the value remains changed across future imports in the same runtime environment. Hence, it prints 100.