Build Your Own Module

By the end of this lesson you can:

• Save a function in helpers.py and import it in main.py with from helpers import ....
• Explain what __name__ == "__main__" guards against.
• Pick what belongs in a module (reusable functions) vs what belongs in the main script (the run order).
• Run a script from the terminal and confirm both files are in the right place.

Make a fresh folder. Inside, create two files side by side:

helpers.py

def greet(name):
    return f"Hello, {name}!"

def double(x):
    return x * 2

main.py

from helpers import greet, double

print(greet("Aisyah"))
print(double(7))

Run main.py. You should see:

Hello, Aisyah!
14

You just made your own module. helpers is a Python file Python can import — just like math or random — except you wrote it.

How import finds your file

When you write from helpers import greet, Python looks for helpers.py in three places, in this order:

1. The folder of the file you're running.
2. The folders in the PYTHONPATH environment variable.
3. The standard-library and site-packages folders.

For today, step 1 is all that matters. Put both files in the same folder. Run the main file. It works.

What to put in a module

• Functions you might want to use from many places.
• Constants you reuse — colour codes, file paths, magic numbers.
• Classes (Level 3).
• Not anything that runs immediately (input prompts, prints, game loops) — those belong in the main script.

The __name__ == "__main__" trick

Sometimes you want a file to also be runnable on its own — for testing, demos, or quick scripts. The convention:

# helpers.py

def greet(name):
    return f"Hello, {name}!"

def double(x):
    return x * 2

# Optional demo when this file is run directly
if __name__ == "__main__":
    print(greet("anyone"))
    print(double(21))

Python sets the special variable __name__ to the string "__main__" only when this file is the one being run. When the file is imported, __name__ is the module's name instead — "helpers". So:

python helpers.py    →  __name__ is "__main__"  →  demo runs
python main.py
  (which imports helpers)  →  __name__ is "helpers"  →  demo skipped

This pattern is so common in Python that you'll see it in almost every real project file. Use it for self-test code or a tiny CLI demo.

The two-file shape

For most projects:

my_project/
   ├─ helpers.py        ← shared functions, no game logic
   ├─ main.py           ← the game / app — imports from helpers
   └─ scores.txt        ← data files

A common bug · circular imports

If a.py imports b.py and b.py imports a.py, Python gets stuck in a loop. The fix is usually to move the shared code into a third file c.py that both import from. We'll meet this properly in Level 3 — for now, keep your imports flowing in one direction only.

The story

You wrote safe_inputs.py as homework for PY-L2-27. Today, use it from a separate game file. The same module will serve every future game you write.

safe_inputs.py

# safe_inputs.py — reusable input helpers

def ask_int(prompt, lo=None, hi=None):
    while True:
        try:
            n = int(input(prompt))
        except ValueError:
            print("  ! Whole numbers only.")
            continue
        if lo is not None and n < lo: continue
        if hi is not None and n > hi: continue
        return n

def ask_yes_no(prompt):
    while True:
        s = input(prompt).strip().lower()
        if s in ("y", "yes"): return True
        if s in ("n", "no"):  return False
        print("  ! Please answer yes or no.")

if __name__ == "__main__":
    print("safe_inputs.py demo")
    n = ask_int("Pick a number 1-10: ", 1, 10)
    again = ask_yes_no("Was that easy? (y/n) ")
    print(f"You picked {n}; was it easy? {again}")

guesser.py

# guesser.py — number-guessing game using safe_inputs

import random
from safe_inputs import ask_int, ask_yes_no

def play_one():
    target  = random.randint(1, 100)
    guesses = 0
    while True:
        g = ask_int("Guess 1-100: ", 1, 100)
        guesses += 1
        if g == target:
            print(f"Got it in {guesses} guesses!")
            return guesses
        elif g < target:
            print("Higher.")
        else:
            print("Lower.")

while True:
    play_one()
    if not ask_yes_no("Play again? (y/n) "):
        print("Bye!")
        break

Run guesser.py. It uses safe_inputs without copying any code from it. If you find a bug in ask_int, you fix it once and every game that imports it benefits.

Run safe_inputs.py directly. The __main__ demo runs. When guesser.py imports it, the demo does NOT run — only the function definitions get pulled in.

Any .py file is a module — name it, import from it, reuse it from many places. Put functions and constants in modules; put the run order in the main script. The if __name__ == "__main__": guard lets a file act as both a library and a runnable script. Keep your modules small and focused — one job per file makes everything easier to find later. Big programs are dozens of small files, not one giant one.