Python and R. They are two of the most popular programming languages for science. They are both free, both of them have a strong user community and both of them work pretty well.

Personally, I find Python way more intuitive than R (at least for people who, like me, have a classical mathematics background). Thinking in terms of data frames is great when you work with statistical data, but it gets a bit annoying when you are more interested in analysis. To uneven the score even more, Python’s libraries like NumPy, SciPy, SimPy and Matplotlib are the perfect toolbox for anyone doing mathematical research of any kind.

But… I chose R. Why?

There is only one reason for doing so: knitr[1]. knitr is a package that turns a combination of text and code (the RMarkdown file) into almost any format of human readable text, including a pdf report, slides, or a blog page like the one you are reading now. The interesting point is the integration of the code with the text. This means that an RMarkdown document is not passive. This allows one to write papers that, quite literally, recalculate themselves any time needed. knitr, combined with research code structured as an R package, is clearly my favourite way of writing research. The package structure keeps my code tidy and tested, and knitr allows me to do all and the figures the writing in a single file. The result is a rock-solid, reproducible output. Let me put it like this: knitr is like LaTeX on steroids![2]

But… I keep finding R annoying. A few days ago, after looking for hours for a nice way of ploting phase planes, I gave up. All the possibilities I found were terribly ugly. I had to go back to Python’s Matplotlib and its function streamplot. See for yourself:

With R:

With Python:

After a bit of googling, I found an R library called reticulate that allows to run Python code from inside R. If this works (I thought) I can keep the best of both approaches! And, so far, it works flawlessly!

How to do it

First of all, R and Python are obviously reequired. reticulate can be installed and loaded as usual in R:

install.packages("reticulate")
library(reticulate)

For some reason I still don’t fully understand, I had to add these two lines to make Matplotlib work properly.

matplotlib <- import("matplotlib", convert = TRUE)
matplotlib$use("Agg")

Now, we can insert python chunks in Rmarkdown:

```{python, eval=TRUE}
import numpy as np
x = np.pi
y = np.sin(x/4)
print(y)
```

## 0.707106781187

Interaction

reticulate works creating two different sessions, one of R and another of Python. In order to unleash all the power of this combination, we need a way of passing variables between both sessions. This is done via the dataframe py. See examples below:

From R to Python

Create a variable and store it as a field of py:

```{r}
py$foo <- "Hi!"
```

The variable will be available in the Python session:

```{python}
print(foo)
```

## Hi!

From Python to R

Create a variable inside the Python session:

```{python}
bar = "How are you?"
```

The variable will be available as a field of the dataframe py in the R session:

```{r}
py$bar
```

## [1] "How are you?"

This entry appears in R-bloggers.com

[1] Actually, there is a second (and less important) reason: Shiny.

[2] It is true that Python also has Jupyter for reproducible research, but the results are just not as neat as with R.