In this lesson we will learn about using functions in our programs to remove repetitions in our code.


Introduction to Functions

A basic function allows us to repeat an action. However, we often will want our functions to perform slightly different tasks each time. We can achieve these differences with function **parameters**.

When we define a function with parameters, we provide the function name, parameters, and code. The parameters are variables that act as inputs to the function. We can provide their values when the function is called, and access them inside of the function's block of code.

For example, if we were writing Python program to print the average of two numbers, we could have a parameter for each number:

```python
def print_average(num1, num2):
    avg = (num1 + num2) / 2
    print('average of', num1, 'and', num2, 'is', avg)
```

The variables `num1` and `num2` are the function's parameters, which are the two values the function is going to average.

We can then call this function like this:

```python
print_average(10,12)
```

Here, we pass the input of 10 as `num1` and 12 as `num2`. These inputs will result in the following output:

``` 
average of 10 and 12 = 11.0
```

Let's practice using parameters with functions.

Function Parameters

Sometimes we want our functions to provide information back to the program that called them.
  
A function can give a value back to the caller using the `return` keyword. The code that calls the function can assign the value returned to a variable.

For example, we could change our Python program to calculate the average of two numbers, instead of printing it:

```python
def calculate_average(num1, num2):
    return (num1 + num2) / 2
```

Now our function will *return* the average back to the code that called it. Let's write some code that calls the function, assigns the returned value to a variable, and prints that variable:

```python
avg = calculate_average(12,48)
print('average is', avg)
```

When we called `calculate_average` with the inputs of `12` and `48`, the function returns a value of `30.0`. We then store that returned value into the variable `avg`. When we print `avg` it's equal to `30.0`, resulting in the following output:

``` 
average is 30.0
```


Returning Values

We can use functions to organize our code and make it easier to understand. One main function can call slightly smaller functions that each have a specific goal. Those functions can call more specific functions if necessary. Each function does a part of a larger task.

Imagine we were making a program that creates a random bag of marbles and describes it to us. We would need to create and describe each marble. We could have a `main` program that looks like:

```python
def main():
  random_bag = create_random_bag()
  display_bag()
```

Our `create_random_bag` function might look like:

```python
def create_random_bag():
   marble1 = create_random_marble()
   marble2 = create_random_marble()
   marble3 = create_random_marble()
   return [marble1, marble2, marble3]
```

The `create_random_marble` might contain logic for what the marble looks like, and on the program would go, describing more and more detailed logic. With this kind of structure, our programs become more organized and easy to read.

Now, we'll practice organizing a program by creating functions.

Using Functions to Structure Your Code

Programs can get long and complicated. Our code may start simple but grow into thousands of lines, often using the same commands over and over. When we write that much code, we make more mistakes and create bugs.

When we find repetitive code, we should consider moving it into functions. Functions are a named group of multiple commands that can make our code shorter and easier to read. Once we've defined a function, we can use one line to repeat that block of code.

Let's get started with functions.


Introduction To Functions

When we define a basic function, we only specify the function name and code (commands).
For example, if we were writing a Python program, we could write a function to print the results of flipping a coin:

```python
def print_coin_flip():
    # The next line checks whether a random value is 0 or 1
    if random.randrange(0, 2) == 0:
        print('heads')
    else:
        print('tails')
```

We can call it as many times as we need to, using the name and empty parentheses:

```python
print_coin_flip()
print_coin_flip()
print_coin_flip()
```

And the result would be something like this:

```plaintext
tails
heads
tails
```

Now we're ready to try using functions.


Creating a Basic Function

Functions are a very important tool for you to use when programming. They will save you a great deal of time, improve your code structure and help you avoid making mistakes. Throughout this lesson we've covered

* What functions are and what they are for
* Function parameters and return values
* Defining functions
* Using our functions for code organization

Let's review:

#### Using Functions

We can organize and remove repeated code by moving it to functions. Once the functions are written then they can be called from other parts of your program, using the function name.

```python
describe_cat(molly)
```

#### Parameters and Returned Values

Function **parameters** enable us to pass data to functions, making the function able to change what it does based on the input.

Functions also enable you to **return** values back to the code that calls the function.

#### Defining Functions

When we define a function, we specify its name, code, and whether it has any parameters and returned values.

```python
def calculate_average(num1, num2):
    return (num1 + num2) / 2
```

#### Functions for Organization

Functions are also very useful for breaking your code into structured, logical blocks. Using functions, we can organize our programs into more readable function calls.

```python
def main():
  random_bag = create_random_bag()
  display_bag()
```

That's it! When creating programs, consider using functions to organize their logic.
