BBP Lesson 7: Functions :dart:

:dart: Learning Objectives

By the end of this lesson, you'll be able to:

• Understand what functions are and why they're super useful
• Create your own functions using the define block
• Call functions to run your code
• Use parameters and arguments to make functions more powerful
• Build functions with multiple parameters

Definition: A function is a group of predefined codes that will only run when it's called.

Let's Get Started! :rocket:

Understanding Functions - Your Code's Secret Weapon! :muscle:

Think of functions like a recipe! :emoji: When you want to make your favorite snack, you follow the same steps every time. Functions work the same way in programming!

• To create a function, we have to start with the define block.

• The define block is used to define the name of a group of codes.

:information_source: Remember! Functions are like creating your own custom blocks in EduBlocks! Once you create them, you can use them over and over again.

Why Are Functions So Awesome? :star2:

• Functions are useful in grouping codes that need to be repeated. Imagine the steps to make a hot Milo drink:

  • Each time you want to make the drink, you have to repeat the steps.

  • If you're making 4 cups of hot Milo, you don't want to have the steps written repeatedly 4 times.

  • Using a function can simplify your code by grouping and just call it whenever you want to make hot Milo.

Input	Output

• The call function blocks are selected with red rectangles.

• As you can see, we already defined our function. So, just call the function whenever we want to make hot Milo.

:bulb: Pro Tip!

In real Python, functions help programmers avoid copying and pasting the same code. Instead of writing the same instructions 10 times, you write them once in a function and call it 10 times!

Creating Functions - Build Your Own Blocks! :emoji:

Let's create our first function step by step:

Step One: Name Your Function

• First, we have to define any relevant name you like for the function:

:bulb: Naming Tips!

Choose names that describe what your function does! Good names:

• make_milo (tells us it makes Milo)
• draw_square (tells us it draws a square)
• say_hello (tells us it says hello)

Avoid confusing names like function1 or xyz

Step 2: Add Your Code

• Then, you can place any code related to the function inside it.

Step 3: The Important Part!

• If you press run, nothing happens. We have to call the function to run it.

:information_source: Remember! Creating a function is like writing a recipe - it doesn't make the food until someone follows the recipe (calls the function)!

Calling Functions - Making Your Code Come Alive! :emoji:

Now let's learn how to use (or "call") the function we created:

How to Call a Function:

1. Drag the function_name block from the Statements category.

2. Make sure the name matches exactly with your defined function:

:bulb: Watch Out!

The function name when calling MUST be exactly the same as when you defined it. If you defined make_milo, you can't call makemilo or Make_Milo - it won't work!

3. See the magic happen when you run your code:

Input	Output

:runner:‍:emoji:️ Try This Challenge!

Create a function called my_greeting that prints three different messages, then call it twice to see what happens!

Function Parameters and Arguments - Making Functions Super Flexible! :wrench:

What Are Those Empty Spaces?

• Curious what the blanks in the define block and the function_name block do?

• Those are parameters. A parameter is a named variable passed into a function.

:information_source: Remember!

• Parameters = Empty spaces in your function definition (like blanks to fill in)
• Arguments = The actual values you put in those spaces when calling the function

Let's Make Our Functions Smarter!

• Let's use the make Milo function we've created above, and use parameters.

• By using a variable value block, we can pass as parameters:

1. Drag a variable value block into the parameter space
2. Give it a name (like n for number)
3. Use that variable inside your function

Input	Output

How It All Works Together :dart:

• The function_name block is used to call and input an argument.

• An argument is a value passed into a function.

• The function will recognise the input() value as an argument for the n variable.

  • This is because there's only 1 parameter, which is the n variable.

:bulb: Naming Freedom!

Parameters can be any names you want! Common choices:

• n for numbers
• name for text
• x and y for coordinates
• color for colors Choose names that make sense for what they represent!

Example: A Number Doubler Function!

Input	Output

• Input any number and it will multiply by 2.

• Again, this works because the input() is an argument passed into the function as parameter n .

:bulb: Connection to Python!

In real Python code, this would look like:

python

def multiply_by_two(n):
    print(n * 2)

multiply_by_two(5)  # This prints 10

See how similar it is to your blocks? :emoji:

Multiple Parameters - Level Up Your Functions! :rocket:

Sometimes your functions need more than one piece of information! Let's learn how to use multiple parameters:

The Rules for Multiple Parameters:

1. Define parameters first - Set them up in your function definition
2. Separate with commas - Use commas between each parameter
3. Order matters! - Arguments must match the parameter order

:information_source: Remember! Think of parameters like ordering pizza:

• First parameter = Size (small, medium, large)
• Second parameter = Topping (cheese, pepperoni, veggie)
• The order matters: order_pizza(large, pepperoni) is different from order_pizza(pepperoni, large)!

How to Set Up Multiple Parameters:

• The parameters are separated with commas.

• Anything added to the brackets when calling the function is an argument.

• The order of the parameters and arguments are important.

  In the example above, the first argument (1st num) will become x , and the second argument (2nd num) will become y .

:bulb: Pro Tip!

You can have 2, 3, 4, or even more parameters! Just remember:

• More parameters = more flexible function
• But too many parameters can be confusing
• 2-3 parameters is usually perfect!

See It In Action!

Input	Output

:star2: Advanced Challenge!

Create a function called draw_rectangle that takes two parameters: width and height. Make it print a rectangle pattern using stars (*) based on the dimensions you give it!

You're Doing Great! :star2:

Wow! You've learned how to:

• :white_check_mark: Create functions with the define block
• :white_check_mark: Call functions to run your code
• :white_check_mark: Use parameters to make functions flexible
• :white_check_mark: Work with multiple parameters

Functions are one of the most powerful tools in programming. You're now able to create your own custom blocks that can do amazing things!

What's Next?

Practice creating different functions:

• A function that draws shapes
• A function that does math calculations
• A function that tells jokes with different names

Keep experimenting and have fun with functions! Remember, every professional programmer uses functions every day - and now you know how to use them too! :tada: