By the end of this chapter you will be able to:
- Write reusable functions with clear inputs and outputs.
- Explain why functions improve maintainability.
- Import and use a simple module.
- Break a small application task into smaller pieces.
Key topics: Defining functions, Parameters and return values, Scope basics, Importing modules, Reusable code structure
Suggested time this week: 0.95 hour lesson, 0.75 hour practice, 0.8 hour lab, 0.5 hour quiz review = 3.0 hours
Small scripts are easy to manage at first, but real application work grows quickly. You may start with a few lines of code, then add validation, reporting, and multiple tasks. Without structure, your script becomes hard to read and even harder to change. Functions and modules solve that problem by helping you organize code into smaller, reusable parts.
A function is a named block of code that performs a task. Instead of writing the same logic many times, you write it once and call it whenever needed. This is especially useful in application development, where you may need to format text, calculate totals, or check values more than once. Functions make your code easier to test because each function can do one job clearly.
A function can take inputs called parameters. For example, a function might accept a user name and return a welcome message. It can also return a result, which lets the rest of your program use the answer. That makes functions more useful than just printing text, because they can support other parts of the application.
Modules are files that hold code you want to reuse elsewhere. Python comes with built-in modules, and you can also create your own. In a technology setting, this means one file might contain helper functions for formatting reports, while another file handles the main workflow. This keeps projects easier to manage when they grow.
A realistic example would be a developer tools script that formats build names. Instead of repeating the same string cleanup in multiple places, you create a function called format_build_name(). Then you call it whenever you need a standard format. This saves time and reduces mistakes.
The mechanics are straightforward. Use def to define a function, then write the function name and parentheses. Inside the parentheses, list any inputs you need. Use return when you want the function to send back a result. To use a module, place related functions in one file and import them into another. Even if that sounds technical, the core idea is simple: group related work together so your code stays organized.
In practice, good function design starts with asking, ‘What is this piece of code supposed to do?’ If the answer is a single clear task, it probably belongs in a function. If you can describe a file as a collection of related helpers, it may be a module. This chapter teaches you to write code that is easier to grow, which is a critical skill for application development.