Lesson 12 - Modules & Code Reusability

Learning Objective

Split code across multiple files using modules, import functions between them, and understand what an import statement actually does.

Introduction

Every lesson so far has lived inside a single Python file.

That works well for small programs, but as software grows, putting everything into one file becomes difficult to manage.

Python solves this with modules.

A module is simply a Python file (.py) that contains code you want to reuse elsewhere.

Instead of copying and pasting functions between files, you can place them in one module and import them wherever they’re needed.

You’ve actually been using modules since Lesson 1.

For example:

from bonicbot_bridge import BonicBot

Here, bonicbot_bridge is a module (technically a package made up of multiple modules), and you’re importing the BonicBot class from it.

Modules help make programs:

• Easier to organize
• Easier to maintain
• Easier to test
• Easier to reuse

What Is a Module?

Any Python file can be a module.

Example:

# helpers.py
 
def greet(name):
    print(f"Hello, {name}!")

Another file can use it:

from helpers import greet
 
greet("Aditi")

Output:

Hello, Aditi!

The function only needs to be written once.

Why Use Modules?

Creating Your First Module

File:

# helpers.py
 
def is_prime(n):
    if n < 2:
        return False
 
    for divisor in range(2, n):
        if n % divisor == 0:
            return False
 
    return True

Another file:

# main.py
 
from helpers import is_prime
 
print(is_prime(17))

Output:

True

Code

helpers.py

# helpers.py — a module: just function definitions, nothing runs on its own
 
def is_prime(n):
    if n < 2:
        return False
 
    for divisor in range(2, n):
        if n % divisor == 0:
            return False
 
    return True
 
def is_palindrome(word):
    cleaned = word.lower()
    return cleaned == cleaned[::-1]

main.py

# main.py — imports and uses the module above
 
from helpers import is_prime, is_palindrome
 
print(is_prime(17))
print(is_palindrome("radar"))
 
import helpers
 
print(helpers.is_prime(18))

Expected Output

True
True
False

Two Ways to Import

Import Specific Names

from helpers import is_prime

Usage:

print(is_prime(17))

This places is_prime directly into your current file’s namespace.

Import the Entire Module

import helpers

Usage:

print(helpers.is_prime(17))

The function remains grouped under the module name.

Comparing Import Styles

Both approaches are valid.

Choose whichever improves readability for your project.

Where Does Python Look for Modules?

When Python sees:

import helpers

it searches for:

1. The current folder
2. Installed packages
3. Python’s standard library locations

That’s why:

import math

works immediately.

And why:

from bonicbot_bridge import BonicBot

works after the SDK has been installed.

Reusing Code Across Projects

One of the biggest advantages of modules is that they encourage reusable code.

Instead of:

# project_a.py
# copy function here
 
# project_b.py
# copy function again

you can write:

# helpers.py

once and import it everywhere.

This eliminates duplication and reduces maintenance work.

🔧 Under the Hood

from helpers import is_prime

is_prime(17)

import helpers

helpers.is_prime(17)

import helpers

import helpers

helpers.py

math
random
pathlib
bonicbot_bridge

Student Challenge

Challenge 1

Build a reusable statistics module named stats.py with helper functions, and import them into a main reporting script report.py.

• In stats.py, define two functions:
  • mean(numbers): Calculates and returns the average of a list of numbers.
  • max_value(numbers): Finds and returns the highest value in a list.
• In report.py, import mean and max_value from stats, pass in a list of test scores (such as [82, 91, 76, 88, 95]), and print the average (86.4) and highest score (95).

# stats.py
 
def mean(numbers):
    return sum(numbers) / len(numbers)
 
def max_value(numbers):
    highest = numbers[0]
 
    for n in numbers[1:]:
        if n > highest:
            highest = n
 
    return highest

# report.py
 
from stats import mean, max_value
 
scores = [82, 91, 76, 88, 95]
 
print(f"Average: {mean(scores):.1f}")
print(f"Highest: {max_value(scores)}")

Average: 86.4
Highest: 95

Challenge 2

Create a custom robot movement module named robot_moves.py and import its functions into a main control script challenge_use_robot_moves.py.

• In robot_moves.py, define functions for robot actions:
  • patrol_square(bot, side_m=0.4, speed=0.2): Drives in a square using loops.
  • scan_surroundings(bot): Scans left/right with obstacle distance checks and returns a dictionary of readings.
  • wave_hello(bot): Moves arm or head servos to greet.
• In challenge_use_robot_moves.py, import patrol_square, scan_surroundings, and wave_hello from robot_moves, and run them inside a BonicBot context block.

Full SDK method details are available in the Python SDK reference.

robot_moves.py

from robot_moves import wave_hello

# robot_moves.py
 
def patrol_square(bot, side_m=0.4, speed=0.2):
    for _ in range(4):
        bot.drive_distance(side_m, speed=speed)
        bot.rotate_angle(90, speed=45.0)
 
    bot.stop()
 
def scan_surroundings(bot):
    bot.look_left()
    left_distance = bot.get_min_obstacle_distance()
 
    bot.look_right()
    right_distance = bot.get_min_obstacle_distance()
 
    bot.look_center()
 
    return {
        "left": left_distance,
        "right": right_distance
    }
 
def wave_hello(bot):
    print("Waving hello!")
    bot.move_left_arm(shoulder=90, elbow=30)
    bot.move_left_arm(shoulder=90, elbow=0)
    bot.move_left_arm(shoulder=0, elbow=0)

# challenge_use_robot_moves.py
 
from bonicbot_bridge import BonicBot
from robot_moves import patrol_square, scan_surroundings, wave_hello
 
with BonicBot(host='192.168.0.188') as bot:
    wave_hello(bot)
 
    readings = scan_surroundings(bot)
    print(f"Obstacle readings: {readings}")
 
    patrol_square(bot, side_m=0.3)

Common Module Structure

A small project might look like:

project/
│
├── main.py
├── helpers.py
├── stats.py
└── robot_moves.py

Each file has a clear responsibility.

This organization becomes increasingly important as projects grow.

Reflection Question

robot_moves.py is a module you wrote yourself, and bonicbot_bridge is a module BonicBot Robotics wrote — but both get imported with the exact same from ... import ... syntax. What does that tell you about what an SDK or library actually is, underneath the name?