In this lesson you'll be learning to:

1. Understand functions: Discover how to define and call mini-programs within your code to perform specific tasks, promoting reusability and cleaner code.
2. Work with parameters and return values: Learn to make functions flexible by passing inputs and getting outputs, allowing them to handle different data without rewriting code.
3. Explore reusability: See practical examples of how functions reduce duplication, making your programs easier to maintain and debug.
4. Understand modules: Find out how to import and use pre-written code libraries, like those for the Micro:bit, to add features without starting from scratch.
5. Import and integrate modules: Practise bringing in modules such as random and music, and combining them with your own functions for interactive Micro:bit projects.
6. Apply your skills: Complete exercises to create programs that generate random sounds or speech, reinforcing reusability and module usage.

Functions are like mini-programs within your code that perform a specific task. They promote reusability by allowing you to write code once and call it multiple times from different parts of your program, reducing duplication and making your code easier to maintain. For example, if you need to display a message several times, you can define a function to do it and call it whenever needed, rather than rewriting the display code each time.

In Python, you define a function using the def keyword, followed by the function name and parentheses. The code inside the function is indented. To use the function, you 'call' it by writing its name followed by parentheses. Functions can take inputs (parameters) and return outputs, making them versatile.

Reusability is a key benefit – imagine a function that calculates temperature averages; you can reuse it for different sets of data without rewriting the logic. This saves time, reduces errors, and makes your code cleaner.

Let's start by defining a basic function that scrolls a greeting on the Micro:bit display. This demonstrates the structure: using def to define it, and then calling it to execute the code inside.

Since it's reusable, we could call it multiple times if needed. Remember, functions help you organise your code better – think of them as building blocks that you can use over and over without rewriting the same lines each time. This makes your programs shorter, easier to read, and less prone to mistakes.

In the Micro:bit Python editor, add the following complete code:

from microbit import *

def show_greeting():
    display.scroll("Hello")

show_greeting()

Parameters allow functions to accept inputs, making them more flexible and reusable. You define parameters inside the parentheses when defining the function, and pass values (which are called arguments) when calling it. This way, the same function can behave differently based on the input, like a greeting function that takes a name and personalises the message.

We'll update our function to take a message parameter and scroll whatever is passed to it. This shows reusability – one function for any message.

Update your code to this complete version:

from microbit import *

def show_message(msg):
    display.scroll(msg)

show_message("Hello")
show_message("World")