Python in R

Kann man Python in R ausführen? Ja, das geht! Die Kombination der leistungsstarken Funktionen von R und Python kann dir helfen, das Beste aus beiden Welten zu nutzen. Dank des reticulate-Pakets ist es möglich, Python-Code nahtlos in R-Skripten und RMarkdown-Dokumenten auszuführen. In diesem Beitrag zeige ich dir Schritt für Schritt, wie du das machen kannst.

Integration von Python in R

Installation und Einrichtung

Bevor wir beginnen, müssen wir sicherstellen, dass neben R auch Python auf deinem System installiert ist. Außerdem benötigen wir das reticulate-Paket.

Paket installieren und laden

Wie mit allen neuen Paketen, nutzen wir install.packages für die Installation und library für das Laden.

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

Überprüfung der Python-Installation

Wie bereits erwähnt, muss Python installiert sein. Mit py_config können wir die Version überprüfen. So kannst du sicherstellen, dass Python korrekt installiert und von R erkannt wird.

py_config()

Python in R ausführen

Nachdem wir reticulate eingerichtet haben, können wir mit der Ausführung von Python-Befehlen in R beginnen.

Ein einfaches Beispiel

# Einfache Python-Befehle
py_run_string("x = 10; y = 5; z = x + y")
py$x
py$y + py$z

In diesem Beispiel führen wir einige einfache Python-Befehle aus und greifen anschließend auf die Ergebnisse in R zu.

Python-Skripte in R ausführen

Wir können auch komplette Python-Skripte aus R heraus ausführen.

# Erstellung eines Python-Skripts
writeLines('
def add(a, b):
    return a + b

result = add(10, 5)
', con = "script.py")

# Ausführen des Python-Skripts
py_run_file("script.py")
py$result

In diesem Beispiel erstellen wir ein Python-Skript, das eine Funktion zur Addition zweier Zahlen definiert und ausführt. Das Ergebnis wird in der Variable result gespeichert. Das Skript speichern wir als script.py und führen es mit py_run_file aus. Anschließend können wir über py$result auf die Variable result zugreifen.

Einbinden von Python-Paketen in R

Einer der größten Vorteile der Integration von Python ist die Möglichkeit, auf die umfangreiche Sammlung von Python-Paketen zuzugreifen.

NumPy in R

Schauen wir uns an, wie man das bekannte Paket numpy in R ausführen kann.

# Installation von NumPy
py_install("numpy")

# Paket importieren
np <- import("numpy")

# Nutzung von NumPy-Funktionen
array <- np$array(c(1, 2, 3, 4, 5))
np$mean(array)

Wie du siehst, können wir NumPy mit py_install installieren. Dies trifft natürlich auch auf alle weiteren Pakete zu; in den kommenden Beispielen vernachlässige ich diese Zeile. Anschließend importieren wir numpy und nutzen es, um ein Array zu erstellen.

Das Beispiel ist natürlich minimal – wir könnten auch einen Vektor erstellen und die mean-Funktion nutzen. Aber es dient als guter Einstieg in die Funktionalität von reticulate.

Scikit-Learn in R

Eine der größten Stärken von Python ist seine umfangreiche Sammlung an Bibliotheken für Machine Learning wie Scikit-Learn, TensorFlow und Keras. Mit reticulate können wir diese direkt in R nutzen.

# Scikit-Learn importieren
sk <- import("sklearn")

# Beispieldaten erstellen
x <- matrix(rnorm(200 * 2), ncol = 2)
y <- sample(0:1, 200, replace = TRUE)

# Daten splitten
split_data <- sk$model_selection$train_test_split(x, y)
x_train <- split_data[[1]]
y_train <- split_data[[3]]

# Logistische Regression trainieren
logistic <- sk$linear_model$LogisticRegression()
model <- logistic$fit(x_train, y_train)

Hier haben wir Scikit-Learn importiert, Beispieldaten erstellt, diese in Train- und Testdatensätze aufgeteilt und schließlich einen logistischen Regressionsklassifikator mit den Trainingsdaten trainiert; das alles innerhalb von R. Wie man sieht: Mit nur wenigen Zeilen Code können wir die Leistungsfähigkeit von Scikit-Learn in unseren R-Workflow einbinden.

Pandas in R

Noch ein Beispiel: Pandas ist eine weitere erstklassige Python-Bibliothek, die der Standard für Datenmanipulation und -analyse in Python ist. Lass uns sehen, wie wir sie in R nutzen können.

# Pandas importieren
pd<- import("pandas")

# DataFrame aus R-Matrix erstellen
some_data <- matrix(rnorm(20), nrow=5)
df <- pd$DataFrame(some_data)

# Daten anzeigen
print(df)

# Deskriptive Statistiken anzeigen
pd$DataFrame$describe(df)

Zuerst importieren wir Pandas, dann erstellen wir aus einer R-Matrix einen Pandas DataFrame (das Äquivalent zum R DataFrame bzw. data.table). Mit nur einer Codezeile haben wir die ganze Funktionalität von Pandas in R verfügbar!

Matplotlib in R

Als letztes Beispiel schauen wir uns an, wie wir matplotlib für Visualisierungen in R einbinden können.

# Matplotlib importieren
plt <- import("matplotlib.pyplot")

# Testdaten erstellen
x <- c(1, 2, 3, 4, 5)
y1 <- c(2, 3, 5, 7, 11)
y2 <- c(8, 5, 4, 4, 6)

# Matplotlib in R nutzen
plt$plot(x, y1, label="Wichtige Werte", c="firebrick")
plt$plot(x, y2, label="Noch wichtigere Werte", c="darkorange")
plt$title("Einfaches Liniendiagramm")
plt$xlabel("X-Achse")
plt$ylabel("Y-Achse")
plt$legend()
plt$show()

Hier haben wir matplotlib verwendet, um ein Liniendiagramm zu erstellen. Matplotlib bietet natürlich noch mehr Möglichkeiten und je nach Use Case oder Erfahrung kann es Sinn ergeben, es statt ggplot2 oder base zu verwenden.

Hier ist übrigens der Plot:

Weitere Möglichkeiten

Es gibt noch viele weitere Möglichkeiten, wie du Python einbinden kannst. Zum Beispiel lässt sich Python-Code direkt in RMarkdown-Dokumente einbetten. Oder du kannst R-Funktionen in Python-Skripten aufrufen, indem du das rpy2 Paket verwendest.

Python-Code in RMarkdown

Mit reticulate kannst du Python-Code in RMarkdown-Dokumenten ausführen. Dies ist besonders nützlich, wenn du Berichte erstellen möchtest, die Code beider Sprachen enthalten. Hier ist ein kurzes Beispiel für ein RMarkdown-Dokument.

---
title: "Python-Code in RMarkdown"
output: html_document
---

## R Code

```{r setup, include=FALSE}
library(reticulate)

x <- c(1, 2, 3, 4, 5)
mean(x)
```

## Python Code

```{python}
import numpy as np
array = np.array([1, 2, 3, 4, 5])
np.mean(array)
```

Wie du siehst, können beide Sprachen nahtlos nebeneinander in einem einzigen Bericht verwendet werden. Der erste Chunk berechnet den Mittelwert eines Vektors mit R, während der zweite Chunk dasselbe für ein NumPy-Array tut.

R in Python

Das rpy2-Paket ist das Python-Äquivalent zu reticulate.

# Nutzen von rpy2
import rpy2.robjects as robjects

# Eine R-Funktion definieren und in Python verwenden
r_sum = robjects.r['sum']
values = robjects.FloatVector([1.0, 2.0, 3.0, 4.0])
result = r_sum(values)
print(result[0])

# R-Objekt in Python erstellen und verwenden
r_vector = robjects.r.c(1, 2, 3, 4)
r_vector = robjects.r.append(r_vector, 5)
print(list(r_vector))

In diesem Beispiel importieren wir das rpy2-Paket und verwenden sum, um die Summe eines Vektors in Python zu berechnen. Außerdem erstellen wir einen Vektor mit c und modifizieren ihn mit append.

Fazit

Die Integration von Python in R erweitert die Möglichkeiten der Datenanalyse und -verarbeitung erheblich. Mit dem reticulate-Paket kannst du die Stärken beider Sprachen kombinieren und komplexe Analysen effizient durchführen. Das rpy2-Paket ist das Python-Äquivalent.

Hast du Fragen oder Anregungen? Schreib mir gerne eine E-Mail oder hinterlasse einen Kommentar. Für weitere Informationen und Updates, kannst du den R-Coding Newsletter abonieren.

Viel Erfolg!