# Data analysis with pandas: enjoy the awesome

Within the past months I frequently got my hands on pandas. Pandas is a data analysis framework for Python initiated by Wes McKinney. Unfortunately, I wasn’t aware of this powerful package earlier, that would have saved a lot of time. Pandas is tightly integrated with numpy and matplotlib, so if you are familiar with those, you can smoothly jump into the pandas world. In the short time of working with pandas, I have frequently been amazed by its power and simplicity. In fact, pandas has been named to be a “Python killer app” during the PyCon 2013 keynote, being at eye level with Zope and Django. In this post, I will present a short example giving a feeling for why pandas is so neat.

Consider `N` independent repetitions of the same experiment. Let each experiment yield various metrics for a set of system components. The goal usually is to statistically evaluate the data obtained by repeating the experiment. A simple example: Each experiment consists of measuring `velocity` and `weight` for three different cars: `opel`, `benz`, `audi`. This experiment is repeated three times. From each repetition, we got one data set:

data1.txt:

```car,weight,velocity
audi,2.1,100.3
opel,1.5,55.2
benz,3.2,80.9```

data2.txt:

```car,weight,velocity
audi,2.3,107.1
opel,1.2,50.1
benz,3.3,82.4```

data3.txt:

```car,weight,velocity
audi,2.6,110.7
opel,1.4,51.2
benz,3.2,89.1```

For each system component (`car`), there are `N` (three) values for each metric (`velocity`, `weight`). Let us build the mean value as well as the standard deviation for each metric and car, sort the data set by the mean velocity, and print the result.

## Short version first

```import pandas as pd
import numpy as np

print pd.concat([pd.read_csv("data%s.txt" % i) for i in xrange(1,4)]).groupby(
"car").agg([np.mean, np.std]).sort([('velocity', 'mean')])```

Output:

```        weight              velocity
mean       std        mean       std
car
opel  1.366667  0.152753   52.166667  2.683903
benz  3.233333  0.057735   84.133333  4.366158
audi  2.333333  0.251661  106.033333  5.281414```

It’s as simple as this. Looks like pure magic, but actually is not. The one-liner above is quite straight-forward to develop and simple to understand. What follows now is a slow step-by-step explanation.

## Long version

First of all, a Python list comprehension is used together with panda’s `read_csv` method for reading the three data files. Each data file ends up in one of the most important of pandas data types: a `DataFrame` which is actually based on a numpy array.

```>>> dataframes = [pd.read_csv("data%s.txt" % i) for i in xrange(1,4)]
>>> type(dataframes)
<class 'pandas.core.frame.DataFrame'>```

One of the nice things about pandas is that each of the payload-containing data types has a convenient text representation for the console (but there also are HTML representations for usage of pandas in the context of an IPython notebook!):

```>>> dataframes
car  weight  velocity
0  audi     2.1     100.3
1  opel     1.5      55.2
2  benz     3.2      80.9```

As you can see above in the first column, pandas has assigned a numeric index to each of the rows. The indexing concept is extremely important in general, but not of interest in this article.

Now, let’s just vertically concatenate the three data sets:

```>>> concatenated = pd.concat(dataframes)
>>> concatenated
car  weight  velocity
0  audi     2.1     100.3
1  opel     1.5      55.2
2  benz     3.2      80.9
0  audi     2.3     107.1
1  opel     1.2      50.1
2  benz     3.3      82.4
0  audi     2.6     110.7
1  opel     1.4      51.2
2  benz     3.2      89.1```

I think the concept is clear. We have just merged three `DataFrame`s into one. Next, we make use of pandas’ `groupby` method and group the data by car type:

`>>> grouping = concatenated.groupby("car")`

The resulting grouping is an abstract representation of the groups in the data set. Let’s have a look at their text representation:

```>>> grouping.groups
{'benz': [2, 2, 2], 'opel': [1, 1, 1], 'audi': [0, 0, 0]}```

The concatenated data set was divided into three groups, one for each car type. The numbers above are the ‘indices’ from the concatenated data set, we do not use them here (otherwise we should have made sure that there are no duplicates). `grouping` still contains the raw data, it’s just not contained within the default text representation.

The goal now is to merge the data within each of the groups in a controlled fashion. Remember, for each car we want to calculate mean and standard deviation for each metric. This is where the awesome `aggregate` — or short `agg` — method of a grouping comes into play. Via this method, the user can define any function to be used for aggregating group-internal data. Even better, one can define a list of functions. The aggregation then is performed with each of the functions and the resulting data set has one column for each combination of metric and aggregation function. So this is what we get when we apply numpy’s `mean` as well as `std` functions:

```>>> merged = grouping.agg([np.mean, np.std])
>>> merged
weight              velocity
mean       std        mean       std
car
audi  2.333333  0.251661  106.033333  5.281414
benz  3.233333  0.057735   84.133333  4.366158
opel  1.366667  0.152753   52.166667  2.683903```

The result is a `DataFrame` again, which can be sorted by any column. The column indices now are assembled in a two-level hierarchy (Each original column now has a sub-level containing the `mean` and `std` columns). Let’s sort by the mean value of the velocity:

```>>> merged_sorted = merged.sort([('velocity', 'mean')])
>>> merged_sorted
weight              velocity
mean       std        mean       std
car
opel  1.366667  0.152753   52.166667  2.683903
benz  3.233333  0.057735   84.133333  4.366158
audi  2.333333  0.251661  106.033333  5.281414```

So, what is the slowest car?

```>>> merged_sorted.iloc
weight    mean     1.366667
std      0.152753
velocity  mean    52.166667
std      2.683903
Name: opel, dtype: float64```

An Opel, and we love pandas for telling us.

This simple example could have been solved with the standard library. However, before you end up writing a tabular data type (like I once did), you seriously should consider using pandas instead. pandas’ `DataFrame` supports plenty of convenient selection/indexing schemes as well as data conversion methods that you don’t want to re-implement. The one-liner above does not care how many rows and columns your data has. All this can be done with extreme amounts of data. pandas is using efficient numpy operations where it can, makes heavy use of Cython in other places and is generally designed for efficient large-scale data analysis. Have a look at the documentation to see how powerful pandas is.

1. […] powerful end-to-end data processing using Google Sheets, Python, and Pandas (and I have to notice: my first blog post about data analysis with Pandas is already more than six years old, time flies […]