Python alongside R

Calling Python REPL from within R

This first option allows us to switch between R and Python sessions in terminal and access shared objects. For those who do not know what REPL is here is a short definition:

A read–eval–print loop (REPL), also termed an interactive toplevel or language shell, is a simple interactive computer programming environment that takes single user inputs, executes them, and returns the result to the user …

We can access Python REPL interface directly from R by running:

# Call Python REPL
repl_python()

We can then interact with Python session as we would typically do, as if R did not exist. What is more, we can reach R objects, created in our R session. All such objects are accessible from within r object in Python session. To return back into R session we can execute command exit or quit. Then, in our R session we would be able to reach previously created Python objects as parts of py object. A quick example:

REPL Python example

Now it becomes more clear how the different interfaces interact through dummy objects py and r

Importing Python modules into R

Another option, if you do not want to switch between different languages and interpreters is to load (or import) Python modules inside R. This can be done via import() function.

# Import numpy
os = import("os")

# List directory contents with Python toolset
os$listdir(".")

## [1] "script.py"       "index.Rmd"       "index.html"      "index.Rmd.lock~"
## [5] "index_files"

As one can see, the Python libraries are imported into R as separate objects with desired functionalities inside.

Sourcing Python code from files

The same principles may be used with scripts. Meaning you can write the desired Python script for importing data or session setup into a standalone file and then source it from within your R session.

For example, we can create a short script creating a new variable, and save into a file:

# Write into file
cat(
    "import os\nld = os.listdir('.')", 
    append = FALSE,
    file = "script.py"
)

And then call it from within our R session, and print results:

# Source Python script
source_python("script.py")

# Results
py$ld

## [1] "script.py"       "index.Rmd"       "index.html"      "index.Rmd.lock~"
## [5] "index_files"

Python chunks inside .Rmd

The final option is brought to us alongside rmarkdown format functionality. In particular, we can simply create entire Python chunks inside .Rmd file. It remains only to specify the correct language in chunk’s parameters:

```python
import os
os.listdir(".")
```

```
## ['script.py', 'index.Rmd', 'index.html', 'index.Rmd.lock~', 'index_files']
```

The general idea behind this method is common to all other methods. We can access the objects created within Python chunks in R chunks and vice versa:

# Import os
import os

# Check directory contents
dc = os.listdir(".")

Then we can access the results from within R:

# Print results
py$dc

## [1] "script.py"       "index.Rmd"       "index.html"      "index.Rmd.lock~"
## [5] "index_files"