Introduction

Welcome! My name is Trey, and I’ll be guiding you through 3 acts of what I like to call Scripted Harmony: A Guide to R & Python. In collaboration with Dr. Nicole Dalzell, we’ve built a learning experience that will heighten your technological abilities and begin your exposure to the usage of two different programming languages, practicing with them simultaneously.

In my experience, I had no idea where to start learning a new language, so these activities will serve as an easy-to-use, thought-provoking simulation. As a note, this is the only time you’ll see a long introduction, promise ;).

This is a set of modules geared towards teaching you Python techniques from R or vice versa. Through practicing certain data science methods, we’ll work towards developing an understanding of the fundamental concepts of data manipulation in both R and Python code through Quarto documentation.

If you are beginning these modules at Wake Forest, you’re probably aware the basis for your statistical learning is mostly R and RStudio-focused. We want to make sure we diversify our coding abilities as much as possible! This helps diversify your programming palette as you prepare to enter industry (or higher education).

Whether you’re an experienced coder, or just freshly enrolled in your Introduction to Statistics class, you’ll have all the resources you’ll need to practice the fundamentals of coding in both languages. Just remember, this public resource gets progressively more difficult in the 3 learning modules you’ll see. You’ll encounter many concepts that can build your resilience and hone your programming skills as you learn more difficult statistical prowess in parallel.

Okay, I’m done with my introduction, so with all of this jargon in mind, let’s start with some basics of data wrangling and usage in both R and Python!

Note: A link to the answer key can be found here: ___, but make sure to give it your best before relying too heavily on it ;)

Another Note: This lab assumes that you have already installed the software and gone through a RMarkdown tutorial. If you have not done so, make sure to do these before starting the lab.

Goal

Starting with some simple functions, we’ll explore a data set, and its missing data, and begin to look at how the basics of linear regression are coded in both R and Python.

Loading the Data

Using Quarto allows you to easily switch between Python and R code, allowing you to practice both simultaneously, rather than separately. Open up a new Quarto document.

After you’ve opened up a new Quarto document, we’ll first need to load the data into our environment. Today, we’ll be working with data already set up in the software, but in future Acts, we’ll use data from various sources.

To do so, we’ll be working with a data set that’s my personal favorite, the Palmer Penguins data set.

The Penguins data set is already built into the data infrastructure of R, so we can use code to extract it from its already pre-loaded position in memory. If you do not have the palmerpenguins library downloaded onto your computer, make sure to do that now.

(If you’re like: “I have no idea how to do that”, don’t fret. Click “Tools” at the top of your screen and select “Install Packages”. Afterwards, type in “palmerpenguins” and hit install. This will take a minute. An intermission, one may say)

Now, open a new chunk in your Quarto document (The shortcut for my friends using Windows, is Ctrl + Alt + I). Copy this code chunk into a new R chunk:

library(palmerpenguins)
data(penguins)
penguins <- data.frame(penguins)

Hit the little play button on the top right corner of this code chunk. You should see a green bar flash on the side of the code chunk as it runs. Once finished, you can see this in your global environment located (most likely) on the top right side of your screen.

Let’s go ahead and try this in Python.

Create another code chunk. Once you create a code chunk, rather than wanting to run R code, we want to switch to Python. To do so, just delete the lowercase “r” in your brackets at the top of the code chunk and type “python”. The Quarto document will automatically switch over and check for Python code. Now, input the same code as we did before.

An error? Gah, already? It hasn’t even been 2 chunks and we’ve already seen issues. Don’t worry, we’ll encounter a couple of these throughout our journey. Just remember, debugging is just as important as coding itself. Translating data from an R package requires a few alterations in our code to load our data.

We need to download the penguins data set as a CSV, or comma-separated value file, and load it in from our directory. This is going to differ for everybody considering we’re all working in different spaces, folders, and file paths, so I’ll give you a general idea of what needs to be done to load the data. First, let’s download the data using this R code:

write.csv(penguins, "penguins.csv", row.names = FALSE)

Let’s load this data using Python. Don’t worry about all the intricacies of this code, we’ll discuss a lot of these concepts later in this lab, but for now, trust me:

import pandas as pd
penguins_py = pd.read_csv("*Insert Filepath to get to the Dataset*/penguins.csv")

This file path (or directory) I’ve inputted as a general note is how your computer searches through your files and finds the CSV or file that you’re telling it to grab and put in your global environment.

If you need help finding this file path, go into your files in the folder with the data set. Now click the search bar that contains all the folders you aimlessly clicked on to get to the data set. Copy and paste that into the asterisk portion of the code I provided.

Last error check: If you have a question box that looks like this:

INSERT LAST PIC

Don’t worry, this beast isn’t a difficult one to tackle. Go ahead and press no and continue with your code. You’ll usually have to do this each time you restart an R session or exit the program. If you didn’t get this box, that’s great, ignore everything I just said.

But why did this work? When utilizing R objects in our Python code, we access them with Python-specific functions rather than R code. Some of this code may seem very similar, like write.csv and read_csv, but there are subtle differences you’ll discover through these Acts. In this case, we were accessing our penguins’ data set and called it penguins_py.

Here’s another question, you see the penguins data set in your environment from the R code, but where did our penguins_py data get stored?

Task

We’re going to perform some preliminary data manipulations, exploratory data analysis (EDA), and linear regression modeling.

Our client wants to learn more about penguins in Antarctica and has asked us to monitor their growth and any features related to such. More specifically, they’d like to build a model with the body mass of our penguin as the response variable.

Data Summaries

If you want to find out how this data was collected and the motivation behind it, you can always type ?penguins into your console to access the help/tutorial page on this data set.

Fun note, putting a ? in front of any function you wish to run in R will allow you to see what parameters are needed to use that function, and will provide proper examples of that code in use! However, make sure you have run a code chunk in R prior to this, or else the console will still run code under a Python pretense.

With our response variable, we’ve got seven different features we could look at in our model:

penguins$flipper_length_mm
summary(penguins[,“flipper_length_mm”])

penguins_py.body_mass_g.min()

Basics of Missing Data

Before we proceed, we need to use a data set without any missing values. There are a multitude of methods used to rid your data set of missing values. For now, we’ll use a complete case analysis, which basically means we’ll remove the missing data (NAs) in both of our data sets, renaming them penguins_noNA and penguins_py_noNA, respectively.

In R, not only do we need to drop the rows that contain missing values, but we also need to assign it to a new name. Create a new code chunk and copy the following R code:

penguins_noNA <- na.omit(penguins)

The new name of our data is penguins_noNA (very subtle). The <- is R’s way of assigning a data frame, variable, function, etc. The na.omit function contains our previous data frame penguins, where it removes all missing values from our data set.

In Python, the logic is very similar. Instead of <-, we use =. The function to use instead of na.omit() is dropna().

There are a ton of pros and cons to using this method, and if you want to learn more, there’s a ton of literature on the differences in handling missing data. So, we’ve explored our target variables and cleaned our data set, so we need to do a little more EDA!

EDA (Data Visualizations)

Our client is particularly interested in exploring the association between body mass and the flipper length of a penguin.

In order to proceed with a Linear Regression Model, we want to make sure it’s the right choice and fit for our data. There are certain conditions we need to consider before jumping to any one solution for our data.

In R, we’re going to use the package ggplot2. Make sure this is installed, and load the library, like we did using the Palmer Penguins data set.

This is a skill you’ll use A LOT in your data science journey. There are so many different libraries out there for so many different purposes. But, you can’t use the meticulous methods buried in a library unless you load it. And, loading them in can always be a pain. You get messages telling you how they’ve been loaded, what version they are, and so much more information where you go: “why do I need all this”.

Well, there’s actually a way to load these libraries in softly, not giving you all the information you don’t want to see after loading a specific library. While loading in the library, you can use the R code:

suppressMessages(library(ggplot2))

This will prevent any automatic reply from R coming at you after you hit play. We’ll run through sections of our Exploratory Data Analysis using R, and then repeat the process with some Python. Some of this may be reviewed, so take it at your own pace, and feel free to bounce around whenever you deem necessary.

ggplot(penguins_noNA, aes(x = body_mass_g)) + geom_histogram(fill = 'cyan', col = 'black', bins = 20) + labs(title = "Figure 1: A Nice Graph (with color!)", x = "Body Mass (grams)", y = "Count") 

import matplotlib as plt

x = penguins_py_noNA.body_mass_g
plt.hist(x)
plt.show()

x = penguins_py_noNA.body_mass_g
x = penguins_py_noNA[,’body_mass_g’]

x = penguins_py_noNA.body_mass_g
plt.hist(x)

plt.title("Python Figure 1")
plt.xlabel("Body Mass (g)")
plt.ylabel("Count")

plt.show()

x = penguins_py_noNA.flipper_length_mm
y = penguins_py_noNA.body_mass_g
plt.scatter(x,y)

plt.title("Python Figure 2")
plt.xlabel("Flipper Length (mm)")
plt.ylabel("Body Mass (g)"")

Import seaborn as sns
sns.lmplot(x='flipper_length_mm', y= ‘body_mass_g’, data=penguins_py_noNA, hue='sex', fit_reg=False)

penguins_py_noNA.sex.value_counts()

Rendering/Knitting your Document

If you want to export this beautiful lab of yours, with all your hard work, you can click the render button towards the top of your screen. After a while, Quarto will generate an .html (or .pdf) depending on your default setting or preferences when creating the document itself, that you can then right click and save to (re)view at a later date!

Conclusion

That’s it! You’ve muscled your way through the first act in your journey to becoming more well-versed in a completely new coding language. The second act of this play focuses more on complex statistical learning in both languages. As you’ve seen visualizations look better in R, you’ll find Python relies heavily on its machine learning.

Keep practicing! After practice, this switch in between languages will begin to become light work, and you’ll soon develop not just a new programming language, but hone your statistical and R programming skills as well!

(If you’d like to read the research that went into these modules, and other work I’ve done, click here ____, shout out shameless plugs).

References