Python Modules and the import Statement

A module in Python is simply a file ending in ".py" that contains functions, classes, and variables you want to reuse. The moment you save a Python file, you have created a module — there is no special syntax needed to "declare" one, unlike some other languages that require explicit module keywords.

Modules exist to solve a very practical problem: as programs grow, keeping everything in one file becomes unmanageable. Splitting code into modules lets you organize related functionality together, reuse code across multiple programs without copy-pasting, and keep each file focused on a single responsibility.

Why it matters

No real program is a single file. Modules are how code is split into files and reused, and every import line you write depends on how Python finds and loads them. Most "No module named ..." errors, and code that runs unexpectedly when a file is imported, are explained by the few rules in this lesson.

The import Statement

Python offers several forms of the import statement, and each has a slightly different effect on your namespace.

• import module_name — imports the whole module; you access its contents with module_name.thing.
• import module_name as alias — imports the module under a shorter name, commonly seen as import numpy as np.
• from module_name import thing — imports one specific name directly into your namespace, so you can call it without the module prefix.
• from module_name import * — imports everything public from the module; generally discouraged because it makes it unclear where a name came from and can silently overwrite existing names.

The Module Search Path

When you write import something, Python does not search your entire filesystem — it searches a specific, ordered list of locations stored in sys.path. This list includes the directory of the script being run, the directories listed in the PYTHONPATH environment variable, and the standard library's installation directories. Python checks each location in order and uses the first matching module it finds, which is why a file you accidentally name the same as a standard library module (like naming your own script "math.py") can "shadow" the real one and cause confusing errors.

if __name__ == "__main__":

Every module has a built-in variable called __name__. When a file is run directly (e.g. python script.py), Python sets __name__ to the string "__main__" for that file. When the same file is instead imported by another module, __name__ is set to the module's actual name instead. This lets you write code that only runs when the file is executed directly — such as test code or a command-line entry point — while still allowing the file's functions and classes to be safely imported elsewhere without that code running.

Examples

# file: mathutils.py
def square(n):
    return n * n

def cube(n):
    return n * n * n

if __name__ == "__main__":
    # This block only runs when mathutils.py is executed directly,
    # not when another file imports it.
    print("Testing mathutils module:")
    print(square(4))
    print(cube(3))

Testing mathutils module:
16
27

# file: main.py
import mathutils
from mathutils import cube as cb

print(mathutils.square(5))
print(cb(2))
print(__name__)

25
8
__main__

Exercise

Use three forms of import: import one name from math, import statistics under the alias stats, and then print the name of the current module.

Expected output: 12.0, 4, __main__ (one per line)

# TODO: import sqrt from the math module
# TODO: import the statistics module with the alias stats

# TODO: print the square root of 144
# TODO: print the mean of [2, 4, 6]
# TODO: print the value of __name__

from math import sqrt
import statistics as stats

print(sqrt(144))
print(stats.mean([2, 4, 6]))
print(__name__)

Quick quiz

Interview questions