Modules and Packages — Importing from Other Files

Python applications are usually built by splitting work across multiple files and wiring them together. This article walks through the units called modules and packages, plus how the import statement pulls features in from another file.

Module vs. Package vs. Library

Python organizes code in three sizes: module → package → library. A module is a single .py file, a package is a folder of modules, and a library is the next level up — a distributable bundle.

Standard Library vs. Third-Party Library

Python ships with a standard library out of the box, and there are third-party libraries you install on top. Standard ones like math, os, and json work with just import. Third-party ones like pandas or requests need pip install package_name first.

Try the standard math library.

① Print the integer ceiling of 1.7 with math.ceil(1.7).

② Print the square root of 3 with math.sqrt(3).

(If you run it correctly the explanation appears below.)

Importing Your Own Modules

You can import your own .py files just like the standard library. When running Python locally, drop main.py and the file you want to import (math_utility.py) into the same folder — that's it. Files in the same folder load with just import math_utility from main.py (no .py suffix in the import statement).

math_utility.py is attached on the left (open it from 📂 Files to inspect).

① Load it with import math_utility.

② Intentionally call add(10, 20) without the module prefix and confirm with try/except that you get a NameError — import math_utility only brings the name math_utility itself into main's scope, so add is not directly callable.

③ Then print math_utility.add(10, 20) and math_utility.multiply(5, 5) with the module name prefix — the correct way to call them.

import Runs the Whole File Once

When you write import math_utility, Python executes math_utility.py from top to bottom one time. Function definitions (def) are registered in memory at that moment, so you can later call them as math_utility.add(...). The bodies of those functions don't run at import time — only the code outside any function (the module's top level).

Don't Run Heavy Work at Module Top Level

Top level means code that sits at the outermost indent — outside any function or class. Python runs it from top to bottom whenever the module is imported. Putting heavy work there (DB connections, loading huge files, infinite loops) means just importing the module takes forever. Keep the heavy logic inside functions and leave only definitions and minimal initialization at top level.

Telling Direct Run from Import — __name__

Python files come in two flavors: scripts run directly (you launch them with python xxx.py) and modules imported by something else. The same file can play either role, and you often need to tell which is happening — for example, "only run a smoke test when the file is run directly".

The check uses the special variable __name__ that Python sets automatically. When the file is run directly, __name__ is "__main__". When the file is imported, __name__ is the module name (the filename). Code inside if __name__ == "__main__": only runs in the first case.

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


# Smoke test only when run directly
if __name__ == "__main__":
    print("check:", add(10, 20))   # 30

# When another file does `import math_utility`,
# the if block above doesn't run — only the add function is exposed.

The attached math_utility_2.py defines a show_name() function that prints its own __name__, plus an if __name__ == "__main__": block at the bottom (open it from 📂 Files to look).

① From the main side, import math_utility_2 and print main's __name__.

② Call math_utility_2.show_name() and check what __name__ looks like from the imported side.

Combining Several of Your Own Modules

In real applications you typically split functions into separate files by responsibility and pull them all in from main.py. For example, input checks live in validator.py, display formatting in formatter.py. With responsibilities split this way, changes to formatting only touch formatter.py — main.py and validator.py stay untouched.

Fill in the attached validator.py and formatter.py, then import both from main.py.

① In validator.py, implement is_valid_price(price) — return True if price is a positive int, False otherwise.

② In formatter.py, implement format_price(price) — take an int, add a 5% surcharge with int(price + price * 0.05), and return a string like "with tax: $1575".

③ In main.py, import both. Decide whether price = 1500 is valid, format it, and print the result.

This article covered the module / package / library hierarchy, how import pulls functions from other files, what runs at import time, the __name__ == "__main__" pattern for telling direct runs from imports, and the multi-module split where each file owns one responsibility. The next article digs into packages and the __init__.py file.