rpy2: Python interface to the R language

Warnings

• gotcha rpy2 requires a working R installation. Issues often arise from R not being in the system's PATH or the R_HOME environment variable not being set, leading to `OSError: cannot load library` on import.
  Fix: Ensure R is correctly installed and its `bin` directory is in your system's PATH. Alternatively, set the R_HOME environment variable to your R installation directory. On Windows, explicitly setting `RPY2_CFFI_MODE=API` might be necessary for some functionalities after R 3.6.5.
• breaking Significant architectural and API changes occurred between major versions (e.g., RPy-1.x to rpy2, and further changes in rpy2 3.x, including a shift to `cffi` for its R interface). Code written for older versions will likely break.
  Fix: Refer to the official rpy2 documentation for the specific version you are upgrading to. Pay close attention to migration guides, especially for the `rpy2.rinterface` and `rpy2.robjects` modules, and how R objects are represented in Python.
• gotcha R packages (e.g., ggplot2, dplyr) must be installed within R or explicitly managed by rpy2 for `importr` to find them. Simply installing them in R might not make them immediately visible to rpy2 if R's library paths are not correctly configured or unique for the rpy2 environment.
  Fix: Use `rpy2.robjects.packages.importr('utils').install_packages('your_package')` from within Python, or ensure that the R packages are installed in a location Rpy2 can find, typically in R's default library paths. Check `base._libPaths()` to see R's active library paths.
• gotcha While `pandas2ri.activate()` provides convenient automatic conversion between pandas and R data structures, it's a global setting that can sometimes lead to unexpected behavior or conflicts. For more controlled conversions, consider using explicit converter objects.
  Fix: For fine-grained control, avoid `pandas2ri.activate()` and instead use `pandas2ri.py2rpy()` and `pandas2ri.rpy2py()` for explicit conversions within specific contexts or with custom converters.
• gotcha Errors originating from R code executed via rpy2 are typically raised as `rpy2.rinterface.RRuntimeError`. However, some low-level R errors (e.g., from R's C++ components) can lead to Python crashing with a core dump rather than raising a catchable exception.
  Fix: Wrap R code execution in `try-except rpy2.rinterface.RRuntimeError` blocks. For persistent crashes, inspect the R code for deeper C++-level issues or consult R's error messages for diagnostics.

Install

• pip install rpy2 Install rpy2
• # System requirements (install R first) sudo apt-get install r-base r-base-dev # Debian/Ubuntu brew install r # macOS Install R (system-level dependency)

Imports

• robjects
  wrong:

  import rpy2.r as r

  correct:

  import rpy2.robjects as robjects

  `robjects` is the high-level interface for R objects; `rpy2.r` is less common for direct interaction.
• importr

  from rpy2.robjects.packages import importr

  Used to import R packages into Python.
• pandas2ri

  from rpy2.robjects import pandas2ri

  Module for converting between pandas DataFrames and R data.frames.

Quickstart

This quickstart demonstrates how to initialize rpy2, activate automatic conversion between pandas DataFrames and R data.frames, execute arbitrary R code, access R objects from Python, and call R functions with Python data structures. It showcases the core `rpy2.robjects` and `rpy2.robjects.pandas2ri` modules.

import rpy2.robjects as ro
from rpy2.robjects.packages import importr
from rpy2.robjects import pandas2ri
import pandas as pd

# Activate conversion between pandas and R (optional, but common)
pandas2ri.activate()

# Import an R package (e.g., base R's 'stats' for statistical functions)
stats = importr('stats')
base = importr('base')

# Define R code as a Python string and execute it
ro.r('''
    # Generate a sequence of numbers
    x <- 1:10
    # Calculate the mean
    mean_x <- mean(x)
    # Create an R data frame
    r_df <- data.frame(A=c(1,2,3), B=c('x','y','z'))
''')

# Access R variables from Python
mean_x = ro.r['mean_x'][0]
print(f"Mean of x from R: {mean_x}")

# Get an R data frame and convert it to pandas (if pandas2ri is activated)
r_dataframe = ro.r['r_df']
py_dataframe = pandas2ri.rpy2py(r_dataframe)
print("Python DataFrame from R:")
print(py_dataframe)
print(f"Type of py_dataframe: {type(py_dataframe)}")

# Example: Call an R function with Python objects
py_data = pd.DataFrame({'value': [10, 20, 30], 'group': ['A', 'B', 'A']})
r_data = pandas2ri.py2rpy(py_data)

# Use an R function (e.g., 't.test') from the 'stats' package
t_test_result = stats.t_test(ro.Formula('value ~ group'), data=r_data)
print("\nT-test result from R:")
print(t_test_result)