Writing Reusable Module Files

🎯 Context Introduction

As you start writing more Python scripts, you'll notice that certain functions and variables get repeated across multiple files. Instead of copying and pasting the same code everywhere, you can create module files — reusable Python files that store your functions, classes, and variables. Think of a module as a toolbox: you build it once, then grab the tools you need whenever you start a new project.

⚙️ What Is a Module File?

A module file is simply a .py file that contains Python code you want to reuse. Any Python file can be imported as a module into another script. This keeps your code organized, reduces duplication, and makes maintenance much easier.

Key points to understand:

• A module is just a regular Python file with a .py extension
• You can store functions, classes, variables, and even runnable code inside a module
• Other scripts can import the module and use its contents
• Modules help you break large programs into smaller, manageable pieces

🛠️ Creating Your First Module

Creating a module is straightforward. You write your Python code in a file, save it with a .py extension, and then import it into other scripts.

Step 1: Create the module file

Create a file named network_utils.py with the following content:

• A function called check_port that takes an IP address and port number, then returns whether the port is open
• A variable called DEFAULT_TIMEOUT set to 5 (seconds)
• A function called ping_host that takes a hostname and returns a success message

Step 2: Use the module in another script

Create a new file called monitor.py in the same folder. At the top of this file, write: import network_utils

Now you can use the module's contents like this:

• Call network_utils.check_port("192.168.1.1", 80) to check if port 80 is open
• Access network_utils.DEFAULT_TIMEOUT to get the default timeout value
• Call network_utils.ping_host("google.com") to ping a host

📊 Where to Place Your Module Files

Python looks for modules in specific locations. Understanding this helps you avoid import errors.

For beginners, the simplest approach is to keep your module file in the same folder as the script that imports it.

🕵️ Importing Specific Items from a Module

You don't always need to import the entire module. Python gives you flexible ways to bring in only what you need.

Option 1: Import the whole module

Write: import network_utils

Then use: network_utils.check_port("10.0.0.1", 22)

This keeps your namespace clean because you always prefix with the module name.

Option 2: Import specific items

Write: from network_utils import check_port, DEFAULT_TIMEOUT

Then use: check_port("10.0.0.1", 22) directly without the module prefix

This is convenient but can cause name conflicts if you import something with the same name as an existing variable.

Option 3: Import with an alias

Write: import network_utils as net

Then use: net.check_port("10.0.0.1", 22)

This is great for modules with long names or when you want to avoid typing the full name repeatedly.

🧪 Testing Your Module with a Guard

When you run a module file directly, Python executes all the code in it. This can cause problems if your module contains test code or examples that shouldn't run when imported.

Use the if name == "main": guard to separate test code from reusable code.

How it works:

• When you run the module file directly, the special variable name is set to "main"
• When you import the module from another script, name is set to the module's name
• Code inside the if name == "main": block only runs when the file is executed directly

Example structure in your module file:

• Write all your reusable functions and variables at the top
• At the bottom, add: if name == "main":
• Inside that block, place test calls like print(check_port("127.0.0.1", 8080))

This way, your tests run when you're developing the module, but they don't interfere when another script imports it.

🔄 Updating and Reloading Modules

When you make changes to a module file while your main script is still running, Python won't automatically pick up the changes. You need to restart your script or explicitly reload the module.

To reload a module in an active session:

• Import the importlib module
• Call importlib.reload(network_utils)

This is useful during development when you're iterating quickly and don't want to restart your entire application.

🚀 Best Practices for Module Design

Follow these guidelines to create modules that are easy to use and maintain:

• Keep modules focused — Each module should have a single purpose, like network utilities or file operations
• Use descriptive names — A module called log_parser.py is clearer than lp.py
• Document your functions — Add a brief comment or docstring explaining what each function does
• Avoid side effects — Module-level code that runs on import (like printing messages) can confuse users
• Group related functions — Put functions that work together in the same module

✅ Summary Checklist

• A module is any .py file that contains reusable Python code
• Place your module in the same folder as your script for easy importing
• Use import module_name or from module_name import item to access module contents
• Add the if name == "main": guard to separate test code from reusable code
• Keep modules focused and well-documented for maximum reusability

You now have the foundation to create your own reusable module files. Start by extracting repeated functions from your scripts into separate module files, and watch your code become cleaner, more organized, and easier to maintain.

A module file is a Python file containing functions and variables that can be imported and reused across multiple programs.

🔧 Example 1: Creating and importing a simple module

This example shows how to create a basic module file and import it into another script.

# Save this as math_tools.py
def double_number(x):
    return x * 2

def half_number(x):
    return x / 2

# Save this as main.py
import math_tools

result_one = math_tools.double_number(5)
result_two = math_tools.half_number(10)

print(result_one)
print(result_two)

📤 Output: 10
📤 Output: 5.0

🔧 Example 2: Using the from import syntax

This example demonstrates importing specific functions from a module instead of the entire module.

# Save this as string_utils.py
def capitalize_words(text):
    return text.title()

def reverse_text(text):
    return text[::-1]

def count_vowels(text):
    vowels = "aeiou"
    count = 0
    for char in text.lower():
        if char in vowels:
            count = count + 1
    return count

# Save this as main.py
from string_utils import capitalize_words, reverse_text

message = "hello world engineers"

capitalized = capitalize_words(message)
reversed_msg = reverse_text(message)

print(capitalized)
print(reversed_msg)

📤 Output: Hello World Engineers
📤 Output: sreenigne dlrow olleh

🔧 Example 3: Module with constants and a configuration file

This example shows how to store configuration values in a module for reuse across projects.

# Save this as config.py
DATABASE_NAME = "engineering_db"
MAX_CONNECTIONS = 10
TIMEOUT_SECONDS = 30
LOG_LEVEL = "INFO"

def get_config_summary():
    summary = f"Database: {DATABASE_NAME}"
    summary = summary + f", Max Connections: {MAX_CONNECTIONS}"
    summary = summary + f", Timeout: {TIMEOUT_SECONDS}s"
    summary = summary + f", Log Level: {LOG_LEVEL}"
    return summary

# Save this as main.py
import config

db_name = config.DATABASE_NAME
timeout = config.TIMEOUT_SECONDS
summary = config.get_config_summary()

print(db_name)
print(timeout)
print(summary)

📤 Output: engineering_db
📤 Output: 30
📤 Output: Database: engineering_db, Max Connections: 10, Timeout: 30s, Log Level: INFO

🔧 Example 4: Module with error handling and validation

This example demonstrates creating a module that validates input data before processing.

# Save this as data_validator.py
def validate_positive_number(value):
    if not isinstance(value, (int, float)):
        return False
    if value <= 0:
        return False
    return True

def validate_email_format(email):
    if "@" not in email:
        return False
    if "." not in email:
        return False
    return True

def validate_age_range(age):
    if not isinstance(age, int):
        return False
    if age < 0 or age > 150:
        return False
    return True

# Save this as main.py
from data_validator import validate_positive_number, validate_email_format, validate_age_range

price_check = validate_positive_number(49.99)
email_check = validate_email_format("[email protected]")
age_check = validate_age_range(25)

print(price_check)
print(email_check)
print(age_check)

bad_price = validate_positive_number(-5)
bad_email = validate_email_format("engineercompany.com")
bad_age = validate_age_range(200)

print(bad_price)
print(bad_email)
print(bad_age)

📤 Output: True
📤 Output: True
📤 Output: True
📤 Output: False
📤 Output: False
📤 Output: False

🔧 Example 5: Practical module for file operations

This example shows a reusable module that handles common file reading and writing tasks for engineers.

# Save this as file_handler.py
def read_file_contents(filename):
    file_handle = open(filename, "r")
    contents = file_handle.read()
    file_handle.close()
    return contents

def write_to_file(filename, content):
    file_handle = open(filename, "w")
    file_handle.write(content)
    file_handle.close()
    return "File written successfully"

def append_to_file(filename, content):
    file_handle = open(filename, "a")
    file_handle.write(content)
    file_handle.close()
    return "Content appended successfully"

def count_lines(filename):
    file_handle = open(filename, "r")
    lines = file_handle.readlines()
    file_handle.close()
    return len(lines)

# Save this as main.py
from file_handler import write_to_file, read_file_contents, append_to_file, count_lines

write_result = write_to_file("data.txt", "Engineer log entry one\n")
append_result = append_to_file("data.txt", "Engineer log entry two\n")
file_content = read_file_contents("data.txt")
line_count = count_lines("data.txt")

print(write_result)
print(append_result)
print(file_content)
print(line_count)

📤 Output: File written successfully
📤 Output: Content appended successfully
📤 Output: Engineer log entry one
Engineer log entry two
📤 Output: 2

📊 Comparison Table: Module Import Methods

🎯 Context Introduction

As you start writing more Python scripts, you'll notice that certain functions and variables get repeated across multiple files. Instead of copying and pasting the same code everywhere, you can create module files — reusable Python files that store your functions, classes, and variables. Think of a module as a toolbox: you build it once, then grab the tools you need whenever you start a new project.

⚙️ What Is a Module File?

A module file is simply a .py file that contains Python code you want to reuse. Any Python file can be imported as a module into another script. This keeps your code organized, reduces duplication, and makes maintenance much easier.

Key points to understand:

• A module is just a regular Python file with a .py extension
• You can store functions, classes, variables, and even runnable code inside a module
• Other scripts can import the module and use its contents
• Modules help you break large programs into smaller, manageable pieces

🛠️ Creating Your First Module

Creating a module is straightforward. You write your Python code in a file, save it with a .py extension, and then import it into other scripts.

Step 1: Create the module file

Create a file named network_utils.py with the following content:

• A function called check_port that takes an IP address and port number, then returns whether the port is open
• A variable called DEFAULT_TIMEOUT set to 5 (seconds)
• A function called ping_host that takes a hostname and returns a success message

Step 2: Use the module in another script

Create a new file called monitor.py in the same folder. At the top of this file, write: import network_utils

Now you can use the module's contents like this:

• Call network_utils.check_port("192.168.1.1", 80) to check if port 80 is open
• Access network_utils.DEFAULT_TIMEOUT to get the default timeout value
• Call network_utils.ping_host("google.com") to ping a host

📊 Where to Place Your Module Files

Python looks for modules in specific locations. Understanding this helps you avoid import errors.

For beginners, the simplest approach is to keep your module file in the same folder as the script that imports it.

🕵️ Importing Specific Items from a Module

You don't always need to import the entire module. Python gives you flexible ways to bring in only what you need.

Option 1: Import the whole module

Write: import network_utils

Then use: network_utils.check_port("10.0.0.1", 22)

This keeps your namespace clean because you always prefix with the module name.

Option 2: Import specific items

Write: from network_utils import check_port, DEFAULT_TIMEOUT

Then use: check_port("10.0.0.1", 22) directly without the module prefix

This is convenient but can cause name conflicts if you import something with the same name as an existing variable.

Option 3: Import with an alias

Write: import network_utils as net

Then use: net.check_port("10.0.0.1", 22)

This is great for modules with long names or when you want to avoid typing the full name repeatedly.

🧪 Testing Your Module with a Guard

When you run a module file directly, Python executes all the code in it. This can cause problems if your module contains test code or examples that shouldn't run when imported.

Use the if name == "main": guard to separate test code from reusable code.

How it works:

• When you run the module file directly, the special variable name is set to "main"
• When you import the module from another script, name is set to the module's name
• Code inside the if name == "main": block only runs when the file is executed directly

Example structure in your module file:

• Write all your reusable functions and variables at the top
• At the bottom, add: if name == "main":
• Inside that block, place test calls like print(check_port("127.0.0.1", 8080))

This way, your tests run when you're developing the module, but they don't interfere when another script imports it.

🔄 Updating and Reloading Modules

When you make changes to a module file while your main script is still running, Python won't automatically pick up the changes. You need to restart your script or explicitly reload the module.

To reload a module in an active session:

• Import the importlib module
• Call importlib.reload(network_utils)

This is useful during development when you're iterating quickly and don't want to restart your entire application.

🚀 Best Practices for Module Design

Follow these guidelines to create modules that are easy to use and maintain:

• Keep modules focused — Each module should have a single purpose, like network utilities or file operations
• Use descriptive names — A module called log_parser.py is clearer than lp.py
• Document your functions — Add a brief comment or docstring explaining what each function does
• Avoid side effects — Module-level code that runs on import (like printing messages) can confuse users
• Group related functions — Put functions that work together in the same module

✅ Summary Checklist

• A module is any .py file that contains reusable Python code
• Place your module in the same folder as your script for easy importing
• Use import module_name or from module_name import item to access module contents
• Add the if name == "main": guard to separate test code from reusable code
• Keep modules focused and well-documented for maximum reusability

You now have the foundation to create your own reusable module files. Start by extracting repeated functions from your scripts into separate module files, and watch your code become cleaner, more organized, and easier to maintain.

A module file is a Python file containing functions and variables that can be imported and reused across multiple programs.

🔧 Example 1: Creating and importing a simple module

This example shows how to create a basic module file and import it into another script.

# Save this as math_tools.py
def double_number(x):
    return x * 2

def half_number(x):
    return x / 2

# Save this as main.py
import math_tools

result_one = math_tools.double_number(5)
result_two = math_tools.half_number(10)

print(result_one)
print(result_two)

📤 Output: 10
📤 Output: 5.0

🔧 Example 2: Using the from import syntax

This example demonstrates importing specific functions from a module instead of the entire module.

# Save this as string_utils.py
def capitalize_words(text):
    return text.title()

def reverse_text(text):
    return text[::-1]

def count_vowels(text):
    vowels = "aeiou"
    count = 0
    for char in text.lower():
        if char in vowels:
            count = count + 1
    return count

# Save this as main.py
from string_utils import capitalize_words, reverse_text

message = "hello world engineers"

capitalized = capitalize_words(message)
reversed_msg = reverse_text(message)

print(capitalized)
print(reversed_msg)

📤 Output: Hello World Engineers
📤 Output: sreenigne dlrow olleh

🔧 Example 3: Module with constants and a configuration file

This example shows how to store configuration values in a module for reuse across projects.

# Save this as config.py
DATABASE_NAME = "engineering_db"
MAX_CONNECTIONS = 10
TIMEOUT_SECONDS = 30
LOG_LEVEL = "INFO"

def get_config_summary():
    summary = f"Database: {DATABASE_NAME}"
    summary = summary + f", Max Connections: {MAX_CONNECTIONS}"
    summary = summary + f", Timeout: {TIMEOUT_SECONDS}s"
    summary = summary + f", Log Level: {LOG_LEVEL}"
    return summary

# Save this as main.py
import config

db_name = config.DATABASE_NAME
timeout = config.TIMEOUT_SECONDS
summary = config.get_config_summary()

print(db_name)
print(timeout)
print(summary)

📤 Output: engineering_db
📤 Output: 30
📤 Output: Database: engineering_db, Max Connections: 10, Timeout: 30s, Log Level: INFO

🔧 Example 4: Module with error handling and validation

This example demonstrates creating a module that validates input data before processing.

# Save this as data_validator.py
def validate_positive_number(value):
    if not isinstance(value, (int, float)):
        return False
    if value <= 0:
        return False
    return True

def validate_email_format(email):
    if "@" not in email:
        return False
    if "." not in email:
        return False
    return True

def validate_age_range(age):
    if not isinstance(age, int):
        return False
    if age < 0 or age > 150:
        return False
    return True

# Save this as main.py
from data_validator import validate_positive_number, validate_email_format, validate_age_range

price_check = validate_positive_number(49.99)
email_check = validate_email_format("[email protected]")
age_check = validate_age_range(25)

print(price_check)
print(email_check)
print(age_check)

bad_price = validate_positive_number(-5)
bad_email = validate_email_format("engineercompany.com")
bad_age = validate_age_range(200)

print(bad_price)
print(bad_email)
print(bad_age)

📤 Output: True
📤 Output: True
📤 Output: True
📤 Output: False
📤 Output: False
📤 Output: False

🔧 Example 5: Practical module for file operations

This example shows a reusable module that handles common file reading and writing tasks for engineers.

# Save this as file_handler.py
def read_file_contents(filename):
    file_handle = open(filename, "r")
    contents = file_handle.read()
    file_handle.close()
    return contents

def write_to_file(filename, content):
    file_handle = open(filename, "w")
    file_handle.write(content)
    file_handle.close()
    return "File written successfully"

def append_to_file(filename, content):
    file_handle = open(filename, "a")
    file_handle.write(content)
    file_handle.close()
    return "Content appended successfully"

def count_lines(filename):
    file_handle = open(filename, "r")
    lines = file_handle.readlines()
    file_handle.close()
    return len(lines)

# Save this as main.py
from file_handler import write_to_file, read_file_contents, append_to_file, count_lines

write_result = write_to_file("data.txt", "Engineer log entry one\n")
append_result = append_to_file("data.txt", "Engineer log entry two\n")
file_content = read_file_contents("data.txt")
line_count = count_lines("data.txt")

print(write_result)
print(append_result)
print(file_content)
print(line_count)

📤 Output: File written successfully
📤 Output: Content appended successfully
📤 Output: Engineer log entry one
Engineer log entry two
📤 Output: 2

📊 Comparison Table: Module Import Methods