# Lesson 2. Data Wrangling With Numpy Arrays

In this lesson, you will learn how to run functions that execute multiple tasks on a `numpy array`

and combine multiple `numpy arrays`

into a new `numpy array`

.

## Learning Objectives

After completing this lesson, you will be able to:

- Write functions that execute multiple tasks on
`numpy array`

and save the final output - Append
`numpy arrays`

to create a new`numpy array`

## Write Function That Executes Multiple Tasks on Numpy Array and Save Output

In previous lessons, you have written multiple functions, including a function that converts the units of a `numpy array`

from inches to millimeters and another that calculates the mean across each column of a `numpy array`

.

### Definitions of Existing Functions

```
# define function to convert inches to millimeters
def in_to_mm(x):
# multiply an input parameter by 25.4 to convert from inches to millimeters
# function can take a single value, single value variable, or numpy array as input
# function can not take list or pandas dataframe as input
# returns values multiplied by 25.4
return (x * 25.4)
# define function to calculate mean across columns of two-dimensional numpy array
def mean_stats_columns(array):
# calculate mean of two-dimensional numpy array for each column
# function can take a numpy array as input
# function can not take list or pandas dataframe as input
# returns the mean of each column (axis = 0)
stat_mean_column = np.mean(array, axis = 0)
return(stat_mean_column)
```

### Review Running Functions on Numpy Array

You already know that you can run each function separately and save the output to a new `numpy array`

using `new_array = np.array(function(input_array))`

.

Begin by reviewing how to run functions and save the output.

First, create some data that has a familiar structure for precipitation data: one row for each year of data and columns for each month of year.

```
# import necessary package
import numpy as np
# manually create a new numpy array for monthly precip in 2002 and 2003 for Boulder, CO
monthly_precip_2002_2003_in = np.array([[1.07, 0.44, 1.50, 0.20, 3.20, 1.18, 0.09, 1.44, 1.521, 2.44, 0.78, 0.02],
[0.09, 1.52, 5.44, 2.99, 2.62, 2.69, 0.71, 3.52, 0.35, 0.45, 0.80, 0.84]])
```

Then, run the first function to convert the values from inches to millimeters and save the output.

```
# call in_to_mm function with input parameter and create new array from output
monthly_precip_2002_2003_mm = np.array(in_to_mm(monthly_precip_2002_2003_in))
#print data
monthly_precip_2002_2003_mm
```

```
array([[ 27.178 , 11.176 , 38.1 , 5.08 , 81.28 , 29.972 ,
2.286 , 36.576 , 38.6334, 61.976 , 19.812 , 0.508 ],
[ 2.286 , 38.608 , 138.176 , 75.946 , 66.548 , 68.326 ,
18.034 , 89.408 , 8.89 , 11.43 , 20.32 , 21.336 ]])
```

Last, run the second function on the output from the first function to calculate the mean of the columns.

```
# call the function mean_stats_columns with input parameter
mean_monthly_precip_2002_2003_mm = np.array(mean_stats_columns(monthly_precip_2002_2003_mm))
# print data in new array
mean_monthly_precip_2002_2003_mm
```

```
array([14.732 , 24.892 , 88.138 , 40.513 , 73.914 , 49.149 , 10.16 ,
62.992 , 23.7617, 36.703 , 20.066 , 10.922 ])
```

### Combine Existing Functions into One Function

Instead of calling two functions separately on the same `numpy array`

, you can write a new function that will execute both of these functions at one time.

This is useful in cases when you only want to save the output of the last function (i.e. the mean of each column already converting to millimeters).

Begin by defining your function, as you have before, using the keyword def.

In your code before the return statement, include the function `in_to_mm`

. Pass the implicit output of this function to the next function `mean_stats_columns`

.

```
# define function to convert values in a numpy array and then calculate mean across columns
def mean_columns_mm(array_in):
# function can take a numpy array as input
# function can not take list or pandas dataframe as input
# returns the max of each column, already converted to millimeters
# use function to convert from inches to millimeters
array_mm = in_to_mm(array_in)
# use function to calculate mean of two-dimensional numpy array for each column
stat_mean_column = mean_stats_columns(array_mm)
return(stat_mean_column)
```

Note that within a function, you do not have save an output in order for the next function to use it. Once again, the implicit variables (`array_in`

and `array_mm`

) are acting as placeholders for the input data as it moves through the workflow.

### Run the New Function and Save Output

Now that you have one function that completes multiple tasks, you can simply run that new function and save the output, just as you have done before.

```
# call mean_columns_mm function with input parameter and create new array from output
mean_monthly_precip_2002_2003_mm = np.array(mean_columns_mm(monthly_precip_2002_2003_in))
#print data
mean_monthly_precip_2002_2003_mm
```

```
array([14.732 , 24.892 , 88.138 , 40.513 , 73.914 , 49.149 , 10.16 ,
62.992 , 23.7617, 36.703 , 20.066 , 10.922 ])
```

How simple was that! Functions make it very easy to run multiple tasks on the same `numpy array`

, and you can include as many operations and functions as needed to complete an entire workflow on a single `numpy array`

.

What are the dimensions of your final output `mean_monthly_precip_2002_2003_mm`

? How do you know?

**What does each element in this final array represent?**

## Combine Numpy Arrays Using Append

Another useful operation is being able to combine `numpy arrays`

, so that you can run calculations and statistics across them.

You can use the `np.append()`

method to combine `numpy arrays`

by appending one array after another.

For example, you have two one-dimensional arrays that have the same structure but contain data for different years (e.g. one array for 2004 data and another array for 2005 data).

```
# manually create a new numpy array for monthly precip in 2004 for Boulder, CO
monthly_precip_2004_in = np.array([0.82, 1.31, 1.09, 5.66, 1.28, 3.96, 3.44, 2.88, 2.07, 2.32, 1.99, 0.35])
# manually create a new numpy array for monthly precip in 2005 for Boulder, CO
monthly_precip_2005_in = np.array([1.40, 0.31, 1.22, 3.86, 1.91, 2.68, 0.42, 1.63, 0.52, 2.80, 0.34, 0.43])
```

To calculate a summary statistic across the years, you can append the array for 2005 to the array for 2004, using the following syntax:

`new_array = np.append([first_array], [second_array], axis = 0)`

.

The `axis = 0`

indicates that you want to use the column structure to append the data, so that the elements in the one-dimensional arrays become columns in the new two-dimensional array.

```
# append 2005 array to 2004 array and save to new array
monthly_precip_2004_2005_in = np.append([monthly_precip_2004_in], [monthly_precip_2005_in], axis = 0)
monthly_precip_2004_2005_in
```

```
array([[0.82, 1.31, 1.09, 5.66, 1.28, 3.96, 3.44, 2.88, 2.07, 2.32, 1.99,
0.35],
[1.4 , 0.31, 1.22, 3.86, 1.91, 2.68, 0.42, 1.63, 0.52, 2.8 , 0.34,
0.43]])
```

Now you can run calculations and statistics on this new combined two-dimensional array!

## Optional Challenge 1

Test your `Python`

skills to:

Write a new function that calculates the sum of an input array (e.g.

`sum_stats`

).- Write another function that combines the sum function with
`in_to_mm`

, to calculate the sum of an array that has units in millimeters (e.g.`sum_mm`

).- Hint: define a new function that executes both
`in_to_mm`

and`sum_stats`

in the correct order.

- Hint: define a new function that executes both
Execute your new function on

`monthly_precip_2004_in`

and print the output.- Why do you only get a single value returned from this function?

```
690.1179999999999
```

## Optional Challenge 2

Test your `Python`

skills to:

Write a new function that calculates the

**sum across columns**of a two-dimensional array (e.g.`sum_stats_columns`

).- Write another function that combines the sum function with
`in_to_mm`

, to calculate the sum across the columns of an array that has units in millimeters.- Hint: define a new function that executes both
`in_to_mm`

and`sum_stats_columns`

in the correct order.

- Hint: define a new function that executes both
Execute your new function on

`monthly_precip_2004_2005_in`

and save and print the output.- How many values are in the output array? What does each value represent?

```
array([ 56.388, 41.148, 58.674, 241.808, 81.026, 168.656, 98.044,
114.554, 65.786, 130.048, 59.182, 19.812])
```

## Leave a Comment