Functions

Functions are a way to save time and energy by storing commonly used blocks of code into one named set. For example, to connect to the last CoDrone you paired with, you could write multiple lines of code to do all of this:

Have I ever paired with CoDrone?
If so, begin Bluetooth search
Identify CoDrone addresses
Does the address match with what I last paired with?
If so, send the confirm signal
Test the connection 
Send ready signal
If not, keep trying

Or you could just use the function drone.pair()at the beginning of every new program!

The first step to writing your own function is the term def. You are telling Python that you are “defining a function”.

Next comes your function name followed by parentheses and a colon. Your function name can be multiple words, however, you need to add an underscore between words. For example, to create a function that greets a user, your function could look like this:

def greet_user():

Add a new indented line for the body of the function and a comment that explains the function’s purpose.

def greet_user():
    """Display a simple greeting"""

    print("Hello!")

    """ End of function """

greet_user()

The triple quotation marks are known as a docstring and explain the function’s purpose.

Try running this code now. What happened?

Aher every function are parentheses, and this is where the parameters go. Parameters are variables the function needs to use, but not all functions will have parameters! In the previous example, you might have noticed that the function had an empty set of parentheses.

Think of a function as the processes part of a large factory. Some processes can run as is. For example, the function in the last step printed “Hello!” every time it was called. However, some processes need more information to run, like a program that will greet you personally by name!

Let’s add the parameter username into the parentheses in the same example:

def greet_user(username): #username is a parameter
    """Display a simple greeting"""

    print("Hello," + username.title() + "!")

    """ End of function """

Tip: adding the “ .title()” capitalizes the first letter of each word!

Run this example code and notice what the console reads. Notice what’s different between this string and the previous string?

This next part may confuse you so read this carefully. When you call the function and write something to become “username”, that new something is called an argument.

Here’s an example:

def greet_user(username): #username is a parameter
    """Display a simple greeting"""

    print("Hello, " + username.title() + "!")

    """ End of function """

greet_user('kelly') # kelly is the argument

The name “Kelly” is the argument. Kelly was passed from the function “greet_user()” to being stored inside the parameter, “username”. Think of it like Kelly is entering the front door to a candy store. Behind the front door is the actual store that shows the candy being made. She passed from the initial opening into where it will be used.

So the console will print this:

Hello, Kelly!

Make your own function with one parameter. Next, test it by printing the results!

Use this template if you need help.

def insert_function_name_here(insert parameter here):
    """ This is a comment that describes what the function does"""
    insert function statements here

    """ End of function """

Adding another parameter to a function takes a comma and a name for the new parameter.

Like so:

def describe_pet(animal_type, pet_name):
    '''Display pet information'''

    print("I have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name + ".")

    """ End of function """

The comma separates the parameters. Be careful! The order of the parameters is the order that they’ll be printed in.

Use the example code above and run it with your own arguments. Don’t have a pet? Pretend you have one (maybe a flamingo?) and use it with this function.

Make your own function with two parameters: power and time. These two will determine how big your square will be!

def square(power, time):
    # Input square code that uses a for loop

Remember that to make a square you need to execute a pitch forward and turn. What parameter goes into the set_pitch command? Power or time? Don’t forget to set the directions back to 0 after you move.

drone.set_pitch(power)
drone.move(time)
drone.set_pitch(0)
drone.set_yaw(power)
drone.move(time)
drone.set_yaw(0)

The power and time will be set when the function is called. For example, if you want the power to be set at 30 and the time for each command to be 1 second, then you would call your function in your main program like this:

square(30, 1)

Finish the square function to loop the code four times. Try calling the function with various parameter values until you find the right combination of power and time to make a square!

Hint: See the example below if you need some help!

def square(power, time):
""" This function makes a square."""
    for i in range(0,4):
        drone.set_pitch(power)
        drone.move(time)
        drone.set_pitch(0)
        drone.set_yaw(power)
        drone.move(time)
        drone.set_yaw(0)
""" End of function """

A return function is slightly different from the functions you just saw. A return function returns a value or set of values. The values that are returned are called return values. Very creative, we know.

Here’s an example code to follow along:

def get_formatted_name(first_name, last_name):
    """ Return a neatly formatted full name"""

    full_name = first_name + " " + last_name
    return full_name

    """ End of function """

superhero = get_formatted_name('Iron', 'Man')
print(superhero)

The function is called get_formatted_name(). It has two parameters: first_name and last_name. The function prints a third variable called full_name with a “.title()”, allowing it to capitalize the first letter of each word.

Then, the function is called so it can be used for a fourth variable named superhero. This fourth variable is not part of the function, which you can tell by its lack of indentation. The superhero’s name is added using both of the function’s parameters.

Run the code to see which superhero shows up, and then try changing the names to add superheroes of your own!

Make your own function with at least two parameters and a return statement.

Tip: Use the template below if you need help.

def insert_function_name_here(insert parameter here , insert parameter here): """ This is a comment that describes what the  function does"""	insert function statements here
    return some variable	""" End of function """

Make 4 functions and each one should reflect the different types of functions you used today. One function can have one parameter; another can have two parameters; a third can have three or more parameters with a return statement, and the last one could be three or more parameters with a return statement and using an if and else statement.