CYBER WEEK SALE: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)


Learn how to create functions to reduce repeated code and increase usability!

Introduction to Functions

As we expand our programs with more functions, we might start to ponder, where exactly do we have access to our variables? To examine this, let's revisit a modified version of the first function we built out together: 

```py
def trip_welcome(destination):
  print(" Looks like you're going to the " + destination + " today. ")
```

What if we wanted to access the variable `destination` outside of the function? Could we use it? Take a second to think about what the following program will output, then check the result below! 

```py
def trip_welcome(destination):
  print(" Looks like you're going to the " + destination + " today. ")

print(destination)
```
<details>
  <summary>Output Results</summary><br>
  
```error
NameError: name 'destination' is not defined
```

If we try to run this code, we will get a NameError, telling us that `destination` is not defined. The variable `destination` has only been defined inside the space of a function, so it does not exist outside the function. 
</details>
<br>

We call the part of a program where `destination` can be accessed its [_scope_](https://www.codecademy.com/resources/docs/python/scope?page_ref=catalog). The _scope_ of `destination` is only inside the `trip_welcome()`. 

Take a look at another example: 

```py
budget = 1000

# Here we are using a default value for our parameter of `destination` 
def trip_welcome(destination="California"):
    print(" Looks like you're going to " + destination)
    print(" Your budget for this trip is " + str(budget))

print(budget)
trip_welcome()
```

Our output would be: 

```bash
1000
Looks like you're going to California 
Your budget for this trip is 1000
```

Here we are able to access the `budget` both inside the `trip_welcome` function as well as our `print()` statement. If a variable lives outside of any function it can be accessed anywhere in the file. 

We will be exploring the concept of _scope_ more after this entire lesson but for now, let's play around!

**Note:** Working with multiple functions can be a bit overwhelming at first. Don't hesitate to use hints or even look at the solution code if you get stuck. 

Variable Access

In Python, there are 3 different types of arguments we can give a function. 

* Positional arguments: arguments that can be called by their position in the function definition.

* Keyword arguments: arguments that can be called by their name.

* Default arguments: arguments that are given default values.


Positional Arguments are arguments we have already been using! Their assignments depend on their positions in the function call. Let's look at a function called  `calculate_taxi_price()` that allows our users to see how much a taxi would cost to their destination 🚕. 

```py
def calculate_taxi_price(miles_to_travel, rate, discount):
  print(miles_to_travel * rate - discount )
```

In this function,  `miles_to_travel` is *positioned* as the first parameter, `rate` is positioned as the second parameter, and `discount` is the third. When we call our function, the position of the arguments will be mapped to the positions defined in the function declaration. 

```py
# 100 is miles_to_travel
# 10 is rate
# 5 is discount
calculate_taxi_price(100, 10, 5)
```

Alternatively, we can use _Keyword Arguments_ where we explicitly refer to what each argument is assigned to in the function call. Notice in the code example below that the arguments do not follow the same order as defined in the function declaration.

```py
calculate_taxi_price(rate=0.5, discount=10, miles_to_travel=100)
```

Lastly, sometimes we want to give our function parameters default values. We can provide a default value to a parameter by using the assignment operator (=). This will happen in the function declaration rather than the function call. 

Here is an example where the discount argument in our `calculate_taxi_price` function will always have a default value of 10:  
```py
def calculate_taxi_price(miles_to_travel, rate, discount = 10):
  print(miles_to_travel * rate - discount )
```

When using a default argument, we can either choose to call the function without providing a value for a discount (and thus our function will use the default value assigned) or overwrite the default argument by providing our own: 

```py
# Using the default value of 10 for discount.
calculate_taxi_price(10, 0.5)

# Overwriting the default value of 10 with 20
calculate_taxi_price(10, 0.5, 20)
```

Let's practice using these different types of arguments! 

Types of Arguments

Consider our welcome function for our trip planning application: 

```py
def trip_welcome():
  print("Welcome to Tripcademy!") 
  print("Let's get you to your destination.")
```

The print statements all run together when `trip_welcome()` is called. This is because they have the same base level of indentation (2 spaces). 

In Python, the amount of [whitespace](https://www.codecademy.com/resources/docs/general/whitespace?page_ref=catalog) tells the computer what is part of a function and what is not part of that function. 

If we wanted to write another statement outside of `trip_welcome()`, we would have to unindent the new line:

```py
def trip_welcome():
  # Indented code is part of the function body
  print("Welcome to Tripcademy!") 
  print("Let's get you to your destination.")

# Unindented code below is not part of the function body
print("Woah, look at the weather outside! Don't walk, take the train!")

trip_welcome()
```

Our `trip_welcome()` function steps will not print `Woah, look at the weather outside! Don't walk, take the train!` on our function call. The `print()` statement was unindented to show it was not a part of the function body but rather a separate statement.

We would see the following output from this program:
```
Woah, look at the weather outside! Don't walk, take the train!
Welcome to Tripcademy!
Let's get you to your destination.
```

Lastly, note that the execution of a program always begins on the first line. The code is then executed one line at a time from top to bottom. This is known as _execution flow_ and is the order a program in python executes code.

`Woah, look at the weather outside! Don't walk, take the train!` was printed before the `print()` statements from the 
function `trip_welcome()`. 

Even though our function was defined before our lone `print()` statement, we didn't call our function until after.

Let's play around with indentation and the flow of execution!

Whitespace & Execution Flow

A _function_ consists of many parts, so let’s first get familiar with its core - a function definition.

Here's an example of a function definition: 

```py
def function_name():
  # functions tasks go here
```

There are some key components we want to note here: 

- The `def` keyword indicates the beginning of a function (also known as a function header). The function header is followed by a name in snake_case format that describes the task the function performs. It’s best practice to give your functions a descriptive yet concise name.

- Following the function name is a pair of parenthesis `( )` that can hold input values known as parameters (more on parameters later in the lesson!). In this example function, we have no parameters.

- A colon `:` to mark the end of the function header.

- Lastly, we have one or more valid python statements that make up the function body (where we have our python comment). 

Notice we've indented our `# function tasks go here` comment. Like loops and conditionals, code inside a function must be indented to show that they are part of the function.

Here is an example of a function that greets a user for our trip planning application: 

```py
def trip_welcome():
  print("Welcome to Tripcademy!") 
  print("Let's get you to your destination.")
```

***Note:*** Pasting this code into the editor and clicking ***Run*** will result in an empty output terminal. The `print()` statements within the function will not execute since our function hasn’t been used. We will explore this further in the next exercise; for now, let’s practice defining a function.


Defining a Function

Now that we’ve practiced defining a function, let’s learn about calling a function to execute the code within its body.

The process of executing the code inside the body of a function is known as calling it (This is also known as "executing a function"). To call a function in Python, type out its name followed by parentheses `( )`.

Let's revisit our `directions_to_timesSq()` function :


```py
def directions_to_timesSq():
  print("Walk 4 mins to 34th St Herald Square train station.")
  print("Take the Northbound N, Q, R, or W train 1 stop.")
  print("Get off the Times Square 42nd Street stop.")
```

To call our function, we must type out the function’s name followed by a pair of parentheses and no indentation:

```py
directions_to_timesSq()
```

Calling the function will execute the `print` statements within the body (from the top statement to the bottom statement) and result in the following output:

```bash
Walk 4 mins to 34th St Herald Square train station.
Take the Northbound N, Q, R, or W train 1 stop.
Get off the Times Square 42nd Street stop.
```

Note that you can only call a function _after_ it has been defined in your code.

Now it’s your turn to call a function!


Calling a Function

Excellent work! 👏 In this lesson, you’ve covered a major fundamental programming concept used in the majority of all programs to organize code into reusable blocks.
To recap, we explored: 

- What problems arise in our programs without functions
- What functions are and how to write them 
- How whitespace plays an important role in how a program will execute our code and more importantly distinguish function code from non-function code 
- How to pass input values into our functions using parameters and arguments
- The difference between built-in and user-defined functions and some common built-in functions python offers
- How we can reuse function output with the `return` keyword, as well as multiple returns. 
- Where variables can be accessed in our programs that use functions 

Let’s practice putting all these concepts together!

Review

In programming, as we start to write bigger and more complex programs, one thing we will start to notice is we will often have to repeat the same set of steps in many different places in our program.

Let’s imagine we were building an application to help people plan trips! When using a trip planning application we can say a simple procedure could look like this: 

```pseudo
 1. Establish your origin and destination
 2. Calculate the distance/route
 3. Return the best route to the user
 
```

We will perform these three steps every time users have to travel between two points using our trip application. In our programs, we could rewrite the same procedures over and over (and over) for each time we want to travel, but there’s a better way! Python gives us a useful concept called [_functions_](https://www.codecademy.com/resources/docs/python/functions?page_ref=catalog). 

Functions are a convenient way to group our code into reusable blocks. A function contains a sequence of steps that can be performed repeatedly throughout a program without having to repeat the process of writing the same code again. 

In this lesson, we are going to explore the idea of a function by slowly building out a Python program for our trip planning steps! 

At the end of this lesson, you’ll know how to:

- Write a function and return values from it.
- Allow functions to take custom input.
- Experiment with how functions access our other python code.

And much more!


At this point, our functions have been using `print()` to help us visualize the output in our interpreter. Functions can also _return_ a value to the program so that this value can be modified or used later. We use the Python keyword `return` to do this.

Here's an example of a program that will `return` a converted currency for a given location a user may want to visit in our trip planner application. 

```py
def calculate_exchange_usd(us_dollars, exchange_rate):
  return us_dollars * exchange_rate

new_zealand_exchange = calculate_exchange_usd(100, 1.4)

print("100 dollars in US currency would give you " + str(new_zealand_exchange) + " New Zealand dollars")
```

This would output: 

```
100 dollars in US currency would give you 140 New Zealand dollars
```

Saving our values returned from a function like we did with `new_zealand_exchange` allows us to reuse the value (in the form of a variable) throughout the rest of the program. 

When there is a result from a function that is stored in a variable, it is called a _returned function value_. 

Let's try to `return` some data in the exercises! 

**Note:** Working with multiple functions can be a bit overwhelming at first. Don't hesitate to use hints or even look at the solution code if you get stuck. 

Returns

Let's return to our `trip_welcome()` function one more time! Let's modify our function to give a welcome that is a bit more detailed.
```py
def trip_welcome():
  print("Welcome to Tripcademy!") 
  print("Looks like you're going to Times Square today.")

trip_welcome()
```

This will output: 
```bash
Welcome to Tripcademy!
Looks like you're going to Times Square today.
```

Our function does a really good job of welcoming anyone who is traveling to Times Square but a really poor job if they are going anywhere else. In order for us to make our function a bit more dynamic, we are going to use the concept of function [_parameters_](https://www.codecademy.com/resources/docs/python/functions/arguments-parameters). 

Function parameters allow our function to accept data as an input value. We list the parameters a function takes as input between the parentheses of a function `( )`.

Here is a function that defines a single parameter:
```py
def my_function(single_parameter)
  # some code
```

In the context of our `trip_welcome()` function, it would look like this: 
```py
def trip_welcome(destination):
  print("Welcome to Tripcademy!") 
  print("Looks like you're going to " + destination + " today.")
```

In the above example, we define a single parameter called `destination` and apply it in our function body in the second `print` statement. We are telling our function it should expect some data passed in for destination that it can apply to any statements in the function body.

But how do we actually use this parameter? Our parameter of `destination` is used by passing in an _argument_ to the function when we call it.

```py
trip_welcome("Times Square")
```

This would output: 

```bash
Welcome to Tripcademy!
Looks like you're going to Times Square today. 
```

To summarize, here is a quick breakdown of the distinction between a parameter and an argument: 

- The parameter is the name defined in the parenthesis of the function and can be used in the function body.


![A function definition in Python](https://static-assets.codecademy.com/Courses/CS101-Intro-to-Programming/Python_FuctionLessonDiagrams_1_v3.svg)


- The argument is the data that is passed in when we call the function, which is then assigned to the parameter name.


![Calling a function with a specific value like trip_welcome("Empire State Building")](https://static-assets.codecademy.com/Courses/CS101-Intro-to-Programming/Python_FuctionLessonDiagrams_2_v2.svg)


Let’s write a function with parameters and call the function with an argument to see it all in action! 


Parameters & Arguments

Let’s come back to the trip planning application we just discussed in the previous exercise. The steps we talked about for our program were: 

```pseudo
 1. Establish an origin and destination
 2. Calculate the distance/route
 3. Return the best route 
```

If we were to convert our steps into Python code, a very simple version that plans a trip between two popular New York tourist destinations might look like this: 

```py
print("Setting the Empire State Building as the starting point and Times Square as our destination.")

print("Calculating the total distance between our points.") 

print("The best route is by train and will take approximately 10 minutes.") 
```

Anytime we want to go between these two points we would need to run these three print statements (for now we can assume the best route and time will stay the same). 

If our program now had 100 new people trying to find the best directions between the Empire State Building and Times Square, we would need to run each of our three print statements 100 times! 

Now, if you're thinking about using a loop here, your intuition would be totally right! Unfortunately, we won’t be always traveling between the same two locations which means a loop won’t be as effective when we want to customize a trip. We will address this in the upcoming sections! 

For now, let's gain an appreciation for functions.


Why Functions?

There are two distinct categories for functions in the world of Python. What we have been writing so far in our exercises are called _User Defined Functions_ -  functions that are written by users (like us!). 

There is another category called [_Built-in functions_](https://www.codecademy.com/resources/docs/python/built-in-functions?page_ref=catalog) - functions that come built into Python for us to use. Remember when we were using [`print`](https://www.codecademy.com/resources/docs/python/built-in-functions/print?page_ref=catalog) or [`str`](https://www.codecademy.com/resources/docs/python/built-in-functions/str?page_ref=catalog)? Both of these functions are built into the language for us, which means we have been using built-in functions all along! 

There are lots of different built-in functions that we can use in our programs. Take a look at this example of using [`len()`](https://www.codecademy.com/resources/docs/python/built-in-functions/len?page_ref=catalog) to get the length of a string:

```py
destination_name = "Venkatanarasimharajuvaripeta"

# Built-in function: len()
length_of_destination = len(destination_name)

# Built-in function: print()
print(length_of_destination)
```

Would output the value of `length_of_destination`: 
```bash
28
```

Here we are using a total of two built-in functions in our example: `print()`, and `len()`. 

And yes, if you're wondering, that is a real [railway station in India](https://en.wikipedia.org/wiki/Venkatanarasimharajuvaripeta_railway_station)!

There are even more obscure ones like `help()` where Python will print a link to documentation for us and provide some details: 

```py
help("string")
```

Would output (shortened for readability):
```bash
NAME
    string - A collection of string constants.

MODULE REFERENCE
    https://docs.python.org/3.8/library/string
    
    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.
.....
```

Check out all the latest built-in functions in the [official Python docs](https://docs.python.org/3/library/functions.html). 

Let's practice using a few of them. You will need to rely on the provided Python documentation links to find your answers!

Built-in Functions vs User Defined Functions

Using a single parameter is useful but functions let us use as many parameters as we want! That way, we can pass in more than one input to our functions. 

We can write a function that takes in more than one parameter by using commas: 

```py 
def my_function(parameter1, parameter2, parameter3):
  # Some code
```

When we call our function, we will need to provide arguments for each of the parameters we assigned in our function definition. 

```py
# Calling my_function
my_function(argument1, argument2)
```

For example take our trip application's `trip_welcome()` function that has two parameters:  

```py
def trip_welcome(origin, destination):
  print("Welcome to Tripcademy")
  print("Looks like you are traveling from " + origin)
  print("And you are heading to " + destination)
```

Our two parameters in this function are `origin` and `destination`. In order to properly call our function, we need to pass argument values for both of them. 

The ordering of your parameters is important as their position will map to the position of the arguments and will determine their assigned value in the function body (more on this in the next exercise!).

Our function call could look like: 

```py
trip_welcome("Prospect Park", "Atlantic Terminal")
```

In this call, the argument value of `"Prospect Park"` is assigned to be the `origin` parameter, and the argument value of`"Atlantic Terminal"` is assigned to the `destination` parameter.

The output would be: 

```
Welcome to Tripcademy
Looks like you are traveling from Prospect Park
And you are heading to Atlantic Terminal
```

Let's practice writing and calling a multiple parameter function! 

Multiple Parameters

Sometimes we may want to return more than one value from a function. We can return several values by separating them with a comma. Take a look at this example of a function that allows users in our travel application to check the upcoming week's weather (starting on Monday): 

```py
weather_data = ['Sunny', 'Sunny', 'Cloudy', 'Raining', 'Snowing']

def threeday_weather_report(weather):
  first_day = " Tomorrow the weather will be " + weather[0]
  second_day = " The following day it will be " + weather[1]
  third_day = " Two days from now it will be " + weather[2]
  return first_day, second_day, third_day
```

This function takes in a set of data in the form of a list for the upcoming week's weather. We can get our returned function values by assigning them to variables when we call the function:

```py
monday, tuesday, wednesday = threeday_weather_report(weather_data)

print(monday)
print(tuesday)
print(wednesday)
```

This will print:

```bash
Tomorrow the weather will be Sunny
The following day it will be Sunny
Two days from now it will be Cloudy
```

Let's practice using multiple returns by `return`ing to our previous code example. 