Basic Plotting with R and Python

R has two main contenders in the plotting domain: base and ggplot. This topic takes a look at both.

Plotting in R is not one thing. There are at least three plotting libraries you could choose from in R, and two are very common. Base plot and ggplot are the two most common. They can do similar things, but the libraries authors took very different design approaches. With base you build up your plot line by line, entry by entry. With ggplot you create a description of your plot. It is easier to get nice plots quickly with ggplot. It is easier to tweak a plot to perfection in base. These are my personal opinions and I find that different users feel comfortable in the different libraries. You should try both and draw your own conclusions.

First, make some pseudo-data. We can use the random number generators of R to supply us some data for plotting.¹

xs <- 1:10
ysquare <- xs^2
ydouble  <- 2*ysquare
yrandom  <- rnorm(10)
mapply(function (x,y,z,q) {c(x,y,z,q)}, xs, ysquare, ydouble, yrandom)

	  [,1]       [,2]       [,3]       [,4]   [,5]       [,6]       [,7]
[1,] 1.0000000 2.00000000  3.0000000  4.0000000  5.000  6.0000000  7.0000000
[2,] 1.0000000 4.00000000  9.0000000 16.0000000 25.000 36.0000000 49.0000000
[3,] 2.0000000 8.00000000 18.0000000 32.0000000 50.000 72.0000000 98.0000000
[4,] 0.3516467 0.08102127 -0.7312347 -0.6682148 -1.983 -0.2623215  0.1662537
	   [,8]         [,9]     [,10]
[1,]   8.000000   9.00000000  10.00000
[2,]  64.000000  81.00000000 100.00000
[3,] 128.000000 162.00000000 200.00000
[4,]  -1.328868  -0.04187366  -1.70868

We use R's assignment operator to create a sequence from 1 to 10 for our x values and then create three different y values as deterministic or random values. Then I use a map to apply a function to four arguments to create a tuple with elements from each list. This map takes a function as the first argument. That is, functions can be "data". This function is anonymous. The use of anonymous functions and map's is advanced, so just note the potential power of being able to zip four lists together pretty easily, and worry about whether you can do that later in the course.

To get some hands on experience with plotting I suggest creating scatter plots and box plots with R using one of the built in data sets.

1. Using the R data set mtcars create in both base plot and ggplot a scatterplot of mpg and wt. What would you expect this to show even before you plot it. One way to make sure your code is doing what you want is to visualize what you expect. If that is not what you see then either your code is wrong or your understanding of the functions and what they do is wrong. Either way you know something is not right and you can set about fixing it.
2. Using the R data set ToothGrowth generate boxplots for len and dose. If you are feeling creative overlay the data points on top of the box plot. Here are a couple of links to help you get started:
   1. box-plots-r-base-graphs
   2. scatter-plots-r-base-graphs
   3. ggplot2-scatter-plots
   4. ggplot2-boxplots

This example is included because SPSS, a common and powerful statistical package used by many psychologists, makes interaction plots difficult to achieve (or so I am told - I have never used SPSS). If you are taking an advanced statistics course knowing how to create these kinds of plots could be very useful.

For this example we will use the data from http://personality-project.org/r/datasets/heating.txt, but you don't need to download it manually. We can do this from within python itself. Instead of using the request library (a general library in python for making internet requests) we will use the read_csv functionality of pandas to read data from a url (universal resource locator - an address on the world wide web). ²

import os
os.chdir(".")

The above code block is a little bit of housekeeping to make sure it is easy for me to embed the plots. It is not too important here, but I wanted to leave it visible in case you run into problems.

import pandas as pd
url = "http://personality-project.org/r/datasets/heating.txt"
d = pd.read_csv(url, sep="\t")
d.columns

For this exercise, we want to get plots of degree days versus therms, but we want to do it separately for each type of house to see if there is an interaction. That is, is the relationship between degree days and therms different for the different types of houses. Types of houses interacts with degreedays when we want to predict therms.

We will also use some additional python modules to help us make this easier, specifically scipy, matplotlib, and statsmodels. These can be installed via pip.

from statsmodels.graphics.factorplots import interaction_plot
from matplotlib import pyplot as plt
interaction_plot(d['degreedays'], d['Location'], d['therms'])
plt.savefig(f)
f

This gives us a "connect-the-dots" sort of look to our data. We would prefer to fit a line, a best possible line, to our data. We want to pick the line that runs through the data points and is as close as possible (measured in the y direction) to all the data points. The techniques for doing this, and the theory, come from your stats courses, but we can use those tools here without explanation just to get some practice with the libraries and functions that will later come in handy.

from statsmodels.formula.api import ols
ols_d = ols(formula="therms ~ degreedays * Location", data=d)
my_fits = ols_d.fit()
plt.clf()
f = plt.figure()
a = f.gca()
ip1 = interaction_plot(d['degreedays'], d['Location'], my_fits.fittedvalues, plottype="line", ax=a)
ip2 = interaction_plot(d['degreedays'], d['Location'], d['therms'], plottype='scatter', ax=a)
lines, labels = f.axes[0].get_legend_handles_labels()
a.legend_ = None
f.legend(lines[0:3], labels[0:3], loc='upper left', bbox_to_anchor=(0.15, 0.85))
plt.savefig(fn)
fn

Note that figuring out how to get the legend only for the plot with the lines and not a redundant legend for the scatterplot, and to place it properly took me about an hour. This is not as easy a system to get started in as the R commands are.

1. Do exactly what we did in the topic, but reverse which language you use to do each.
2. Use python functions to generate a sequence (for the x), a function to get a y from the x, and a random number generator to get y_randoms as long as the x and y values, and then generate a line and scatter plot for your x and y's and y_random's all on the same plot.
3. The interaction plot should be done with R

An *.org file that includes code blocks for the plots (and the included files for the plots) that accomplish the assigned tasks. It should export to a nice html.

• R can read in data from a url as well as pandas. See thisstack overflow question/answer.
• R has a built in function for interaction plots that might work.
• It might be easier with ggplot. Here is a blog showing how.
• Random numbers are easy in python.
• What you need for plotting lines in python is shown in the interaction plot example - just skip the "ols" model part.