Line and Bar Plots¶
Tyler Caraza-Harter
Previously, we learned how to create matplotlib pie charts and scatter plots by calling Pandas plotting methods for Series and DataFrames.
In this document, we'll also learn how to also create line plots and bar plots.
Let's start by doing our matplotlib setup and usual imports:
%matplotlib inline
import pandas as pd
from pandas import Series, DataFrame
For readability, you may also want to increase the default font size at the start of your notebooks. You can do so by copy/pasting the following:
import matplotlib
matplotlib.rcParams.update({'font.size': 15})
Line Plot from a Series¶
We can create a line plot from either a Series (with s.plot.line()) or a DataFrame (with df.plot.line()).
s = Series([0,100,300,200,400])
s
s.plot.line()
The y values are clearly the values in the Series, but where are the x-values coming from? You guessed it, the Series' index. Let's try the same values with a different index.
s = Series([0,100,300,200,400], index=[1,2,30,31,32])
s
s.plot.line()
Now we see that the plot starts from 1 (instead of 0) and a bigger gap in the index (between 2 and 30) corresponds to a bigger line segment over the x-axis.
What happens if our index is not in order?
s = Series([0,100,300,200,400], index=[1,11,2,22,3])
s
s.plot.line()
Oops! That's probably not what we want. 99% of the time, people making a line plot want readers to be able to lookup a single y-value (per line) given a point along the x-axis. So even though this line passes through all of our data points, the lines between the points are very misleading.
If your data isn't already sorted, you'll probably want to sort it by the index first:
s.sort_index()
Don't get confused about this function! If we have a Python list L and we call L.sort(), the items in L are rearranged in place and the sort function doesn't return anything.
In contrast, if we have a Pandas Series s and we call s.sort_index(), the items in S are not moved, but the sort_index function returns a new Series that is sorted. So if we print s again, we see the original (unsorted) data:
s
Because sort_index() returns a new Series and we can call .plot.line() on a Series, we can do the following on an unsorted Series s in one step:
s.sort_index().plot.line()
Line Plot from a DataFrame¶
In addition to the Series.plot.line() method, there is also a DataFrame.plot.line() method. Whereas the line function for a Series creates a plot with a single line, the line plot for a DataFrame draws a line for each column in the DataFrame (remember that each column in a DataFrame is essentially just a Series).
Let's try with a DataFrame containing temperature patterns for Madison, WI. The data was copied from https://www.usclimatedata.com/climate/madison/wisconsin/united-states/uswi0411, and contains the typical daily highs and lows for each month of the year.
df = DataFrame({
"high": [26, 31, 43, 57, 68, 78, 82, 79, 72, 59, 44, 30],
"low": [11, 15, 25, 36, 46, 56, 61, 59, 50, 39, 28, 16]
})
df
df.plot.line()
Not bad! We can see the temperatures vary througout the year, with highs correlated with lows. But what is the x-axis? What is the y-axis?
Remember that calling an AxesSubplot object. There are AxesSubplot.set_xlabel and AxesSubplot.set_ylabel functions that will help us out here. Just to make sure to call them in the same cell where .plot.line is called, or the plot will be displayed before they can have an effect.
ax = df.plot.line()
ax.set_xlabel('Month')
ax.set_ylabel('Temp (Fehrenheit)')
What if we want the plot in Celcius? That's easy enough with some element-wise operations.
c_df = DataFrame()
c_df["high"] = (df["high"] - 32) * (5/9)
c_df["low"] = (df["low"] - 32) * (5/9)
c_df
ax = c_df.plot.line()
ax.set_xlabel('Month')
ax.set_ylabel('Temp (Celsius)')
That's looking good!
One small thing: did you notice the extra print above the plot that says Text(0,0.5,'Temp (Celsius)')? That happened because the call to set_ylabel returned that value. We could always put None at the end of our cell to supress that:
ax = c_df.plot.line()
ax.set_xlabel('Month')
ax.set_ylabel('Temp (Celsius)')
None
Tick Labels¶
The above plot would be nicer if we saw actual month names along the y-axis. Let's create a DataFrame with the same data, but month names for the index.
df = DataFrame({
"month": ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
"high": [26, 31, 43, 57, 68, 78, 82, 79, 72, 59, 44, 30],
"low": [11, 15, 25, 36, 46, 56, 61, 59, 50, 39, 28, 16]
})
df = df.set_index("month")
df.head()
Let's try plotting it.
ax = df.plot.line()
ax.set_xlabel('Month')
ax.set_ylabel('Temp (Fehrenheit)')
None
Unfortunately, even though we now have months for the index, matplotlib won't use them for the x-axis unless we specifically tell it to. We can explicitly give matplotlib tick labels with the set_xticklabels method.
# careful, this is an example of a bad plot!
ax = df.plot.line()
ax.set_xticklabels(df.index)
None
Yikes! That's not what we wanted at all. The above plot starts at Feb (instead of Jan), and it only covers half a year. We've set the tick labels, but not the tick positions. Let's take a look at the positions:
ax.get_xticks()
You should read the above as follows:
- the first tick label (Jan) is drawn at position -2, which is out of the plots range (so we don't see Jan)
- the second tick label (Feb) is drawn at position 0 (the leftmost)
- the third tick label (Mar) is drawn at position 2
- and so on
Fortunately, we can set the tick positions explicitly. The only correct configuration in this case is 0, 1, 2, 3, ...
ax = df.plot.line()
ax.set_xticks([0, 1, 2, 3])
ax.set_xticklabels(df.index)
None
If we want to count from 0 to 11, we can use range(len(df.index)).
ax = df.plot.line()
ax.set_xticks(range(len(df.index)))
ax.set_xticklabels(df.index)
None
This plot is correct, but crowded! There are two solutions: (1) make the plot wider or (2) rotate the labels. We'll demo both. We'll also add back the axis labels.
# approach 1: wider plot
ax = df.plot.line(figsize=(8,4)) # this is the (width,height)
ax.set_xticks(range(len(df.index)))
ax.set_xticklabels(df.index)
ax.set_xlabel('Month')
ax.set_ylabel('Temp (Fehrenheit)')
None
# approach 2: rotate ticks
ax = df.plot.line()
ax.set_xticks(range(len(df.index)))
ax.set_xticklabels(df.index, rotation=90) # 90 is in degrees
ax.set_xlabel('Month')
ax.set_ylabel('Temp (Fehrenheit)')
None
Bar Plots¶
Just like a line plot, bar plots can be created from either a Pandas Series or DataFrame. For our example data, let's learn a bit about the fire hydrants around the city of Madison. Data describing each fire hydrant can be found at http://data-cityofmadison.opendata.arcgis.com/datasets/54c4877f16084409849ebd5385e2ee27_6. We have already downloaded the data to a file named "Fire_Hydrants.csv". Let's read it and preview a few rows.
df = pd.read_csv('Fire_Hydrants.csv')
df.head()
For our first example, let's see what nozzle colors are most common. We can get a Series summarizing the data by first extracting the nozzle_color column, then using the Series.value_counts() function to produce a summary Series.
df['nozzle_color'].head()
df['nozzle_color'].value_counts()
The above data means, for example, that there are 5810 "blue" nozzles and 1148 "Blue" nozzles. We can already see there is a lot of blue, but we would really like a total count, not confused by whether the letters are upper or lower case.
df['nozzle_color'].str.upper().value_counts()
Great! It's not clear what "C" means, but the data is clean enough. Let's plot it with Series.plot.bar.
counts = df['nozzle_color'].str.upper().value_counts()
counts.plot.bar()
Is the data reasonable? Try to notice next time you're walking by a hydrant. Consider it a challenge to spot a green nozzle (bonus points for orange!).
For our second question, let's create a similar plot that tells us what model of hydrants are most common. The model is represented by the Style column in the table. The following code is a copy/paste of above, just replacing "nozzle_color" with "Style":
counts = df['Style'].str.upper().value_counts()
counts.plot.bar()
Woah! That's way too much data. Let's just consider the top 10 models.
top10 = counts[:10]
top10
How many others are not in the top 10? We should show that in our results too.
others = sum(counts[10:])
top10["others"] = others
top10
Now that looks like what we want to plot.
top10.plot.bar()
Nice! This shows us what we want. We see Pacer is easily the most common. Some of the longer texts are harder to read vertically, so we also have the option to use .barh instead of .bar to rotate the bars.
top10.plot.barh()
I wonder what is up with all those Pacer hydrants? Have they always been so popular with the city? Turns out we can find out, because we also have a column called year_manufactured.
Let's find all the rows for Pacer hydrants and extract the year.
pacer_years = df[df['Style'] == 'Pacer']['year_manufactured']
pacer_years.head()
Let's round to the decade. We can do that by dividing by 10 (integer division), then multiplying by 10 again.
pacer_decades = pacer_years // 10 * 10
pacer_decades.head()
How many Pacers were there each decade?
pacer_decades.value_counts()
Let's do the same thing in one step for non-pacers. That is, we'll identify non-pacers, extract the year, round to the decade, and then count how many entries there are per decade.
other_decades = df[df['Style'] != 'Pacer']['year_manufactured'] // 10 * 10
other_decades.value_counts()
Let's line up these two Series side-by-side in a DataFrame
pacer_df = DataFrame({
"pacer":pacer_decades.value_counts(),
"other":other_decades.value_counts()
})
pacer_df
That looks plottable!
pacer_df.plot.bar()
That plot shows that the city started getting Pacers in the 90's. Most were from the 2000 decade, and it seems there is finally a shift to other styles.
While this plot is fine, when multiple bars represent a breakdown of a total amount, it's more intuitive to stack the bars over each other. This is easy with the stacked= argument.
pacer_df.plot.bar(stacked=True)
This data supports all the same conclusions as before, and now one more thing is obvious: although there was stead growth in the number of hydrants over several decades, things seem to have leveled off more recently. Why? Further probing of the data might provide an answer. One explanation is that the 2000 decade contains 10 years, but we have a couple years left for the 10's. Perhaps this decade will still catch up.
Conclusion¶
After this reading, you should now be ready to create four types of plots: pie charts, scatter plots, line plots, and bar plots.
We saw that both line and bar plots can be created from either a single Series or a DataFrame. When created from a single Series, we end up with either a single line (for a line plot) or one set of bars (for a bar plot).
When we create from a DataFrame, we get multiple lines (one per column) for a line plot. And for a bar plot, we get multiple sets of bars. We can control whether those bars are vertical (with .bar) or horizontal (with .barh), as well as whether the bars are stacked or side-by-side.