Python and R are two of the most popular languages in data science, each with its own strengths and dedicated user base. R in Python refers to the practice of integrating the R programming language into Python workflows. In other words, it means running R code inside a Python environment. This might sound unusual at first – after all, Python and R are separate languages – but it’s quite achievable with the right tools. In fact, combining these languages allows you to leverage the unique advantages of both.

Where Python is a general-purpose, object-oriented language with a huge ecosystem of libraries, R is a language developed by statisticians with unmatched support for statistical analysis and visualization. Using R and Python together can turn their individual advantages into a powerful synergy, as “the advantages and disadvantages of both Python and R can become a powerful duo when combined”​

askpython.com. In practical terms, R in Python integration lets you call R functions, use R’s packages, and run R scripts directly from your Python code.

Why would you want to use R inside Python?

Imagine you’re working on a data science project in Python, but there’s an R package that implements a particular statistical method or visualization you need. Instead of porting that R code to Python (which could be time-consuming and error-prone), you can call the R package from your Python script and get the results immediately.

Likewise, if you have legacy R code or a colleague’s R script, you can integrate it into your Python workflow without having to rewrite it. This R-Python interoperability is especially useful in team settings where some people prefer R and others prefer Python. Rather than choosing one language over the other, you can use both together and “move between languages and use the best of both programming languages”​ rviews.rstudio.com within a single project.

Why Use R in Python?

There are several compelling reasons to combine R and Python in a single workflow:

Leverage Unique Strengths:

R excels in statistical analysis and has thousands of specialized packages on CRAN (Comprehensive R Archive Network) implementing cutting-edge algorithms. Python, on the other hand, excels in general-purpose programming, production deployment, and machine learning libraries. By using R inside Python, you get the best of both worlds – for example, use Python to manage data pipelines and use R for specialized statistics or plotting.

As one blog puts it, Python has many great libraries, but “CRAN, R’s central repository, contains thousands of packages implementing sophisticated statistical algorithms that have been field-tested over many years”​rviews.rstudio.com. Integrating R allows Python users to tap into this rich reservoir of tools without leaving the comfort of Python.

Access R-Only Libraries:

Some techniques or domain-specific analyses are available only in R. For instance, the Bioconductor repository for bioinformatics or certain econometrics and time-series analysis packages might not have Python equivalents. Using R in Python via a bridge lets you call those R libraries directly. This means you don’t have to wait for a Python implementation or try to translate R code into Python – you can invoke the R library and get results immediately.

Avoid Duplicating Work:

If you or your team already has code written in R (such as a well-tested function or an R script for data cleaning), you can reuse it in a Python project by running that R code in Python. This saves effort and ensures consistency. Similarly, if a textbook or research paper provides an R script, you can incorporate it into your Python analysis without rewriting it from scratch.

Enhanced Collaboration:

In a team of data scientists, it’s common to have some members who prefer R and others who prefer Python. Integrating R and Python allows each to work in the language they’re most comfortable with, while still combining their work. For example, one teammate can write an R function for a statistical test and another can call that function from a Python-driven data pipeline. The ability to mix Python & R code can make projects more inclusive and robust.

Educational and Verification Purposes:

If you’re learning data science, you might find certain things easier in one language versus the other. Being able to call R from Python allows you to verify results by cross-checking between languages or to slowly transition code from R to Python. It’s also a great way to learn R while primarily working in Python (or vice versa).

Before moving on, it’s worth noting that the integration can work both ways: just as you can run R in Python, you can also run Python in R. For instance, the reticulate package in R “lets you use Python and R together seamlessly in R code”​ rstudio.github.io. In this article, however, we’ll focus on the Python-driven approach (calling R from Python), which is most useful for Python developers who want to use R’s capabilities.

Tools for Integrating R and Python

How can we actually mix R and Python code? There are a few different approaches and tools:

rpy2:

rpy2 is the most popular tool for running R inside Python. It’s a Python library that embeds the R interpreter within a Python process, allowing you to execute R commands and use R objects as if they were part of Python. We’ll explore rpy2 in detail below, as it’s the go-to solution for R-Python integration in scripts and applications. Using rpy2, “Pythonistas can take advantage of the great work already done by the R community”​rviews.rstudio.com by calling R functions directly from Python code.

Jupyter Notebook R Magic:

If you’re working in a Jupyter notebook, you can mix R and Python by using cell magic commands. For example, after installing rpy2, you can load the extension with %load_ext rpy2.ipython and then use %%R at the top of a cell to execute R code in that cell. This is incredibly useful for interactive analysis where you might do data manipulation in Python, then switch to R for a specific plot or analysis, and then back to Python. The notebook handles behind-the-scenes data conversion for certain objects (with the help of rpy2) so you can even pass data between R and Python cells.

Calling R through subprocess:

A simpler (though less flexible) method is to call R’s command-line interface from Python. For instance, you could write an R script and then use Python’s subprocess module to run Rscript my_script.R and retrieve results (perhaps via reading an output file or standard output). This approach doesn’t require special libraries and decouples the two languages (they run as separate processes). However, it’s not interactive – you can’t easily pass variables back and forth in real-time – and you have to handle data exchange via files or other means.

RServe / REST APIs:

Another advanced method is to set up R as a service. RServe is a server that allows other programs to communicate with R over a network (or local) connection. Python clients (such as pyRserve) can send commands to the RServe process. Similarly, one could run an R-based REST API and have Python make HTTP requests to it. These methods are more involved and are typically used in production environments where R is running separately from a Python application.

Using Python in R (reticulate):

As mentioned, reticulate is the R counterpart that allows you to call Python from within R. While this is the inverse of our main topic, it’s good to know it exists. If you’re primarily an R user but occasionally need a Python library (say TensorFlow or scikit-learn), reticulate will let you import Python modules into R. The idea of mixing languages goes both directions; the choice depends on which language is “driving” the analysis.

Among these options, rpy2 stands out as a powerful way to embed R within Python seamlessly. In the next sections, we’ll dive into using rpy2 to run R code in Python, step by step.

Setting Up rpy2 to Use R in Python

To start using R in Python with rpy2, you need to ensure a couple of things are in place:

R Installation: rpy2 acts as a bridge to an actual R interpreter, which means you must have R installed on your system (the same machine where you’re running Python). Make sure you have a compatible R version. For recent versions of rpy2 (e.g., rpy2 3.5.x), you need R 4.0 or above and Python 3.7 or above​rviews.rstudio.com.

Install rpy2: If you already have Python and R set up, installing rpy2 is straightforward using pip (or conda). Run the following command in your environment:

pip install rpy2

If you use Anaconda, you might instead use conda install -c conda-forge rpy2. This will install the rpy2 library as well as any needed dependencies. Once rpy2 is installed, you’re ready to start integrating R into your Python scripts.

Importing rpy2: In your Python code, you’ll typically import the robjects module from rpy2, which provides high-level interfaces to R. For example:

import rpy2.robjects as robjects

The first time you import rpy2.robjects in a session, it will initialize an embedded R engine inside the Python process​

rpy2.github.io. Essentially, Python starts up R behind the scenes. This means any R code we execute via rpy2 will run as if we had an R session open, but it’s controlled from Python. (If you want to check that everything is set up correctly, you can also run import rpy2; print(rpy2.__version__) to see the rpy2 version, or even rpy2.situation.print_info() to get details on the R configuration.)

Once these steps are done, you have a Python environment ready to execute R commands. Next, we’ll look at how to actually run R code and use R objects through this interface.

Running R Code in Python: Basic Examples

Using rpy2, there are a couple of ways to run R code from Python. The simplest is to treat R like a sub-module and execute R commands as strings. The rpy2.robjects module has an object called r that acts like an R console. You can call it with a string of R code, and it will execute that code in the embedded R instance. For example:

import rpy2.robjects as robjects

# Run a simple R command to create a numeric vector in R
robjects.r('x <- c(10, 20, 30, 40)')

# Now calculate the mean of that vector using R's mean() function
robjects.r('result <- mean(x)')

# Retrieve the value of result from R to Python
res = robjects.r('result')
print(res)         # prints an R vector object, e.g., "r[1] 25"
print(float(res[0]))  # convert the R object to a Python float and print 25.0

Let’s break down what happens here:

• robjects.r('x <- c(10, 20, 30, 40)') runs the R command to create a vector x in R’s global environment. If you’re familiar with R, c(...) combines values into a vector. After this line, the R session (running inside Python) now has a variable x defined.
• robjects.r('result <- mean(x)') runs another R command to take the mean of x and store it in result. So in the R session, result is now the average of 10,20,30,40 (which should be 25).
• res = robjects.r('result') fetches the result variable from R into Python. The robjects.r(...) function returns an R object (in this case, an R vector of length 1 containing 25). When we print res, rpy2 will display it in a format like r[1] 25 indicating it’s an R object. We can index into it (like res[0]) to get the actual value out as a Python number. Converting to float gives us a normal Python float that we can use in further Python code.

This example shows the basic workflow: you send some R code for execution and get results back. It’s essentially as if you were typing those commands in an R terminal, but here you wrap them in robjects.r('...') calls. In fact, robjects.r “allows us to essentially use the R console” from within Python askpython.com, because the rpy2 library is executing an embedded R process in the background.

Another way to use rpy2 is by directly calling R functions as if they were Python functions. Every R function in the base packages (and in any library you load) can be accessed through the robjects.r object or via an import mechanism.

For instance, we could call R’s mean() more directly:

# Access the R mean function
r_mean = robjects.r['mean']
# Call R's mean on a Python list by converting it to an R vector
avg = r_mean(robjects.FloatVector([10, 20, 30, 40]))
print(avg[0])  # should output 25.0 as a Python float

Here, robjects.r['mean'] gives us the R function mean as a Python callable. We then prepare data to send to it: robjects.FloatVector([...]) turns a Python list of numbers into an R numeric vector. Calling r_mean on that vector executes the R mean function and returns an R result (which we then index to get the value). This approach is a bit more “pythonic” because you can store references to R functions and reuse them, or pass Python data structures (after converting to R types) without writing R code as strings.

Both approaches – sending R code as strings or calling R functions via rpy2 objects – are valid. You can choose based on what feels easier. For small snippets or one-off commands, robjects.r("some code") is quick. For larger tasks or repeated calls, using the object interface and converters might be cleaner.

Check out: Delete a file or folder in Python

Using R Packages in Python with rpy2

One of the biggest advantages of using R in Python is the ability to call functions from R packages. With rpy2, you can load an R package and then use its functions just like you did with mean() above. To load an R package, rpy2 provides the importr function. This works somewhat like Python’s import but for R’s packages:

from rpy2.robjects.packages import importr

# Import R's "stats" package
stats = importr('stats')
# Now you can use functions from stats via the stats object

When you call importr("stats"), rpy2 will load the R package stats (which is a standard package in R) into the embedded R. The returned stats object in Python acts as a proxy to that R package. For example, the R rnorm() function (which generates random numbers from a normal distribution) is in the stats package. We can call it via the stats object:

# Generate 5 random normal values using R's stats::rnorm function
rand_vals = stats.rnorm(5, mean=0, sd=1)
print(list(rand_vals))
# This will print 5 random numbers, something like: [0.12, -1.34, 0.45, ...]

Similarly, you could importr('ggplot2') to use R’s ggplot2 for plotting, or importr('forecast') to use time series forecasting functions, etc. If the package is not installed in your R, you can install it by calling R’s installation commands via rpy2. For example, you could do utils = importr('utils') and then utils.install_packages('ggplot2') to install a package from CRAN (since R’s utils package has the install.packages function). Once installed, you can load it with importr. Keep in mind that when you install an R package, it’s being installed in your system’s R library, just as if you ran install.packages() in a normal R session.

Note on namespaces: The importr() function will try to make R functions accessible as Python attributes. If an R function name has a dot (like some.function), rpy2 will replace the dot with an underscore for the Python attribute name, because Python identifiers can’t have dots rpy2.github.io. For example, an R function plot.new would be accessed as plot_new in the imported package object.

Data Exchange between Python and R

When integrating R and Python, you’ll often need to pass data from one language to the other. rpy2 handles many basic conversions automatically (like numbers, vectors, etc.), but for complex types like data frames, you may need to use specific converters. The good news is that rpy2 has built-in support for converting pandas DataFrames to R data.frame objects and back, via the pandas2ri module (in recent rpy2 versions, this might be under rpy2.robjects.pandas2ri or integrated in the conversions).

For example, suppose you have a pandas DataFrame df in Python and you want to pass it to an R function for processing:

import pandas as pd
from rpy2.robjects import pandas2ri

# Activate automatic pandas conversion (optional in some versions)
pandas2ri.activate()

# Assume df is a pandas DataFrame already defined
# Convert pandas DataFrame to an R data.frame
r_df = pandas2ri.py2rpy(df)

# Now r_df is an R object that can be used with R functions.
# For instance, call an R function (from a loaded package or base R) on r_df:
robjects.globalenv['r_df'] = r_df  # assign to R global environment for convenience
robjects.r('summary(r_df)')        # this will print the summary of the data frame in R

In this snippet, py2rpy converts a Python object to an R object (here DataFrame to data.frame). There is a complementary rpy2ri.rpy2py (or similar ri2py) that converts R objects back to pandas. If you had an R function that returns a data frame, rpy2 would give you an R object; you could then convert it back to pandas for use in Python. The Medium tutorial “Calling R from Python – Magic of rpy2” demonstrates this conversion in action, noting that “pandas dataframe and an R dataframe are different. Fortunately pandas2ri provides functions to convert to and fro the data frame types.”​

medium.com. In practice, once you set up the converter, you can often just call R functions and get back pandas objects without manual conversion, as rpy2 will auto-convert common types.

For simple types like vectors or lists, rpy2 will map Python lists to R vectors (of appropriate type) if you use the FloatVector, IntVector, etc., or even automatically in some cases. Similarly, R numeric vectors come back as numpy arrays or list-like rpy2 objects that you can turn into Python lists.

Example: Using R’s ggplot2 in a Python Script

To solidify the concept, let’s walk through a slightly more concrete example. Suppose you want to make a plot using R’s famous ggplot2 library, but your data preparation is in Python (pandas). You can do the following:

1. Prepare data in Python (e.g., a pandas DataFrame).
2. Pass the DataFrame to R.
3. Use ggplot2 to create a plot in R.
4. (If in an interactive environment like Jupyter, display the plot; if in a script, save it to a file).

Here’s a short example (this assumes you have ggplot2 installed in R already):

import pandas as pd
from rpy2.robjects import pandas2ri, r
from rpy2.robjects.packages import importr

# Activate pandas conversion between R <-> Python
pandas2ri.activate()

# Sample pandas DataFrame
data = {'category': ['A', 'B', 'C'], 'value': [10, 30, 20]}
df = pd.DataFrame(data)

# Convert pandas DataFrame to R data.frame
r_df = pandas2ri.py2rpy(df)

# Import ggplot2 library from R
ggplot2 = importr('ggplot2')

# Create a ggplot object in R
r_plot = ggplot2.ggplot(r_df) + ggplot2.aes(x='category', y='value') + ggplot2.geom_col()
# r_plot is an R ggplot object. Let's save it to a file from R:
robjects.r('ggsave("myplot.png", plot=plot_obj, width=5, height=4)')  # save to file via R

There are a few new concepts here. We import importr to get ggplot2. We convert the pandas DataFrame df to r_df. Then we use ggplot2’s functions via the imported module: ggplot2.ggplot(r_df) creates a ggplot object using our data, + ggplot2.aes(...) sets up the aesthetics (mapping category to x-axis and value to y-axis), and + ggplot2.geom_col() adds a column chart geometry. In R, you would do something like:

p <- ggplot(df) + aes(x=category, y=value) + geom_col()

rpy2 allows us to do the same thing in Python, constructing the plot step by step. The result r_plot is an R object representing the plot. We then call R’s ggsave function via robjects.r(...) to save the plot to a PNG file. (We had to get plot_obj into R’s environment; one way is to assign r_plot to an R name. We could do something like robjects.globalenv['plot_obj'] = r_plot before calling ggsave so that in R the variable plot_obj refers to our plot.)

If you were in a Jupyter notebook, an easier way to see the plot is to print r_plot or use rpy2’s plotting support. The R Views tutorial on calling R from Python shows how to render ggplot2 charts in a notebook output cell rviews.rstudio.com, rviews.rstudio.com. But for a script environment, saving to file is a solid approach.

This example highlights a real use-case: you can prepare data with Python’s excellent tools (pandas, NumPy, etc.), then hand off the plotting to R’s ggplot2, all within one Python script. Without integration, you might have to export data to a CSV and then run an R script to plot it. With rpy2, it’s all integrated.

When to Use R in Python: Use Cases

Using R within Python adds complexity, so it’s best used when it provides clear benefits. Here are some scenarios where R-Python integration shines:

Using Specialized Analyses:

If you need to perform analysis with an R package that has no equivalent in Python, integration is a lifesaver. For example, certain statistical tests, bioinformatics analyses (many Bioconductor packages), or advanced modeling techniques might only be implemented in R. Instead of foregoing those methods, you can call them from Python.

Advanced Graphics:

Python has great libraries like Matplotlib and Seaborn, but R’s ggplot2 (and extensions of it) is beloved for creating complex and beautiful visualizations with relatively simple code. If you prefer ggplot2’s grammar of graphics for a particular plot, you can generate it via R and still do the rest in Python.

Legacy Code and Team Collaboration:

In companies or research labs that have been using R for a long time, there may be a lot of valuable code in R (from data cleaning routines to predictive models). Rather than rewrite all that in Python to integrate with a new Python codebase, it might be faster to call that R code from Python. Likewise, if one teammate writes a function in R, you can wrap it for use in a larger Python-driven project.

Prototyping and Exploration:

Sometimes, you might try out something quickly in R (because, say, an R library has a convenient function), and later you want to incorporate that into a Python project. During the transition period, you could call the R function from Python while gradually porting logic to Python or simply keep using the R version if it ain’t broke.

Teaching and Comparison:

If you are comparing Python and R approaches for a task (for example, comparing a machine learning model in scikit-learn vs one in R’s caret package), having integration means you can do the comparison side-by-side in one environment. This is especially handy in Jupyter notebooks where you can have Python and R cells interwoven. It’s great for demonstration purposes or verifying that two implementations give the same results.

In summary, the integration is helpful whenever you don’t want language boundaries to limit the tools you can use. It lets you choose the best tool for the job, whether it’s in Python or R, and combine them.

Conclusion

So, what is “R in Python” and what is its purpose? It is the concept of harnessing the R programming language from within Python – essentially embedding R’s capabilities into Python scripts or applications. The purpose of this integration is to empower developers and data scientists to utilize both ecosystems without having to choose one over the other. With libraries like rpy2, you can run R code inside Python processes, calling R functions and using R packages as if they were part of your Python code rviews.rstudio.com.

This means a Python developer isn’t limited to the Python universe; they can directly tap into R’s rich statistical libraries and decades of development in fields like statistics, bioinformatics, and social sciences. Conversely, it means that any investments made in R (such as reliable code or domain-specific packages) can be accessed in new Python projects.

By integrating R and Python, you essentially become bilingual in data science – able to mix both languages to solve problems more efficiently. A key takeaway is that Python and R need not be an either/or choice. Each has its strengths: R for statistics and visualization, Python for engineering and machine learning, etc.

When used together, you can compensate for one language’s weaknesses with the other’s strengths askpython.com. Tools like rpy2 make this combination practically feasible by handling the low-level communication between Python and R for you.

Other:

For anyone starting out, if you are a Python beginner curious about R, using R in Python via rpy2 can be an enlightening way to play with R’s features without leaving familiar territory. And for seasoned data scientists, this integration opens up a wider array of tools for your projects.

Remember to consult the official rpy2 documentation for deeper details on advanced usage, and check out tutorials and community examples for specific use-cases. With “R in Python” at your disposal, you can truly use the best tool for each task, enhancing your productivity and the capabilities of your data science projects.

If you’re a developer looking to study and work for big Tech, MNC, SAAS, IT, companies, Sourcebae can help. Create your profile and provide us with all your details, and we will handle the rest!

References:

1. Isabella Velásquez. “Calling R from Python with rpy2.” R Views, 2022​rviews.rstudio.com​rviews.rstudio.com.
2. Datta Adithya. “Working with R in Python.” AskPython, 2020​askpython.com​askpython.com.
3. rpy2 Documentation – Introduction. rpy2 3.5.13, 2023​rpy2.github.io.
4. Nevin Baiju. “Calling R from Python | Magic of rpy2.” Analytics Vidhya Medium, 2020​medium.com.
5. RStudio. “Use Python with R with reticulate (Cheatsheet).” 2022​rstudio.github.io.