Working with Modules

🧩 Python Modules: Your Code’s Toolbox

Imagine you have a big toy box. Inside, you keep all your favorite toys organized in smaller boxes—one for cars, one for blocks, one for action figures. When you want to play, you grab just the box you need instead of dumping everything on the floor!

Python modules work exactly like that. They’re small boxes of code that you can grab and use whenever you need them.

🎯 What You’ll Learn

• Creating your own modules (making your own toy boxes)
• The import statement (grabbing a whole box)
• The from import statement (picking just one toy)
• Module aliasing (giving a nickname to your box)
• The __name__ variable (knowing who’s the boss)
• Module search path (where Python looks for boxes)

📦 Creating Modules

What Is a Module?

A module is simply a Python file with code inside. That’s it! Any .py file you create is automatically a module.

Think of it like this: You write your favorite recipes in a notebook. Later, you can share that notebook with friends so they can make the same dishes.

Your First Module

Let’s create a module called greetings.py:

# greetings.py

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

def say_goodbye(name):
    return f"Goodbye, {name}!"

favorite_color = "blue"

That’s your first module! You’ve just created a little toolbox with:

• Two functions (say_hello, say_goodbye)
• One variable (favorite_color)

📥 Import Statement

Grabbing the Whole Toolbox

The import statement brings an entire module into your code. It’s like saying, “Bring me that whole toy box!”

# main.py
import greetings

# Use the tools with the module name
message = greetings.say_hello("Alex")
print(message)  # Hello, Alex!

print(greetings.favorite_color)  # blue

Why Use the Module Name?

When you write greetings.say_hello(), you’re telling Python: “Use the say_hello function from the greetings box.”

This keeps things organized—imagine if two boxes had a toy named “car.” You’d need to say “the red box’s car” or “the blue box’s car”!

graph TD
    A["Your Code main.py"] -->|import greetings| B["greetings module"]
    B --> C["say_hello function"]
    B --> D["say_goodbye function"]
    B --> E["favorite_color variable"]

🎯 From Import Statement

Picking Just What You Need

Sometimes you don’t want the whole toolbox—you just want one specific tool. The from import statement lets you grab exactly what you need.

# main.py
from greetings import say_hello

# Now use it directly (no module name needed!)
message = say_hello("Sam")
print(message)  # Hello, Sam!

Grab Multiple Items

Want several tools but not everything? List them with commas:

from greetings import say_hello, say_goodbye

print(say_hello("Kim"))   # Hello, Kim!
print(say_goodbye("Kim")) # Goodbye, Kim!

Grab Everything (Use Carefully!)

The star * means “give me everything”:

from greetings import *

print(say_hello("Pat"))      # Hello, Pat!
print(favorite_color)        # blue

⚠️ Warning: This can get messy if you import from many modules. It’s like dumping all your toy boxes on the floor at once—you might mix things up!

🏷️ Module Aliasing

Giving Nicknames to Modules

Some modules have long names. Typing them over and over is tiring! Aliasing lets you create a short nickname.

import greetings as gr

# Use the nickname instead
print(gr.say_hello("Jordan"))  # Hello, Jordan!

Real-World Example

Python’s data libraries have famous nicknames everyone uses:

import numpy as np        # Everyone calls it np
import pandas as pd       # Everyone calls it pd
import matplotlib.pyplot as plt  # Short and sweet!

Aliasing with From Import

You can also rename specific functions:

from greetings import say_hello as hi

print(hi("Casey"))  # Hello, Casey!

Why use aliases?

• Shorter names = less typing
• Avoid name conflicts
• Follow community conventions

🎭 The __name__ Variable

Who’s the Boss?

Every Python file has a special built-in variable called __name__. It answers one question: “Is this file running directly, or was it imported?”

The Two Scenarios

Scenario 1: Running directly

# greetings.py
print(__name__)  # Output: __main__

When you run python greetings.py, the file is the “main” program, so __name__ equals "__main__".

Scenario 2: Being imported

# main.py
import greetings
# Inside greetings.py, __name__ = "greetings"

When imported, __name__ becomes the module’s name.

The Magic Pattern

This lets you write code that only runs when the file is executed directly:

# greetings.py

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

# This only runs if YOU run this file directly
if __name__ == "__main__":
    print("Testing my module!")
    print(say_hello("Developer"))

Run directly: Shows the test message Imported: No test message—just provides the function

graph TD
    A["greetings.py"] --> B{How is it used?}
    B -->|python greetings.py| C["__name__ = '__main__'"]
    B -->|import greetings| D["__name__ = 'greetings'"]
    C --> E["Test code RUNS"]
    D --> F["Test code SKIPPED"]

🔍 Module Search Path

Where Does Python Look for Modules?

When you write import something, Python becomes a detective. It searches for the module in specific places, in this order:

1. Current directory (where your script lives)
2. PYTHONPATH (folders you’ve added)
3. Standard library (Python’s built-in modules)
4. Site-packages (installed packages like numpy)

See the Search Path

import sys

# Print all the folders Python searches
for path in sys.path:
    print(path)

Adding Your Own Paths

import sys

# Add a custom folder to the search
sys.path.append('/my/custom/folder')

# Now Python will also look here!
import my_custom_module

What If Python Can’t Find It?

import nonexistent_module
# ModuleNotFoundError: No module named
# 'nonexistent_module'

Python checked everywhere and gave up. Make sure:

• The file exists
• The file is in a searchable folder
• The filename doesn’t have typos

graph TD
    A["import my_module"] --> B["Check current folder"]
    B -->|Found?| C["Use it!"]
    B -->|Not found| D["Check PYTHONPATH"]
    D -->|Found?| C
    D -->|Not found| E["Check standard library"]
    E -->|Found?| C
    E -->|Not found| F["Check site-packages"]
    F -->|Found?| C
    F -->|Not found| G["ModuleNotFoundError"]

🌟 Quick Summary

🎉 You Did It!

You now understand how Python organizes code into modules—like a master organizer keeping all their toys in perfectly labeled boxes. You can:

✅ Create modules with functions and variables ✅ Import whole modules or specific pieces ✅ Give modules short, easy nicknames ✅ Know when your code is the “boss” with __name__ ✅ Understand where Python hunts for your modules

Next time you write Python, think in modules. Your future self will thank you for keeping things organized!