Eigene Funktionen in R erstellen

Funktionen in R erstellen

Sie können eigene Funktionen erstellen, um Ihren Code effizienter zu machen und Wiederholungen zu vermeiden. Um R zu verwenden, ist es jedoch nicht notwendig, eigene Funktionen zu schreiben. Eine Funktion wird nach folgendem Schema erstellt:

my_function <- function(argument1, argument2) {
  body
}

Beachten Sie Folgendes:

• Die Funktion wird mit function() erstellt.
• In function() werden die Argumente der Funktion festgelegt. Es kann mehrere Argumente geben.
• Innerhalb der geschweiften Klammern ([{}](https://rdrr.io/r/base/Paren.html)) steht der Funktionskörper (engl. body). Dort befinden sich die Anweisungen der Funktion.
• Die Funktion wird dem Objekt my_function zugewiesen, über das die Funktion anschließend ausgeführt werden kann.

Erstellen wir eine Funktion mit zwei Argumenten, die miteinander multipliziert werden. Wir nennen die Funktion my_first_function:

my_first_function <- function(argument1, argument2) {
  argument1*argument2
}

Jetzt testen wir die Funktion:

my_first_function(argument1=5, argument2=5)

[1] 25

Wie bei allen anderen Funktionen können wir darauf verzichten, die Namen der Argumente anzugeben. Die von uns angegebenen Werte werden dann der Reihe nach jeweils einem Argument zugewiesen:

my_first_function(5, 5)

[1] 25

Beachten Sie in diesem Beispiel, dass R den allerletzten Wert zurückgibt, den die Funktion erzeugt hat. Man kann und sollte jedoch explizit angeben, was zurückgegeben werden soll, und zwar mit der Funktion [return()](https://rdrr.io/r/base/function.html). Wir ändern die Funktion so ab, dass ein Objekt (product) erzeugt wird, das wir anschließend zurückgeben:

my_first_function <- function(argument1, argument2) {
  product = argument1*argument2
  return(product)
}

Testen wir die Funktion:

my_first_function(5, 5)

[1] 25

Wenn man return() nicht angibt, gibt R also automatisch das zuletzt erzeugte Objekt zurück.

Erstellen wir nun eine neue Funktion mit zwei Argumenten, nämlich einem x-Wert und einem y-Wert für eine Koordinate in einer Grafik. Wir nennen die Funktion to_plot; sie verwendet die Funktion [plot()](https://rdrr.io/r/graphics/plot.default.html), um die Grafik zu erstellen:

to_plot <- function(x, y) {
  plot(x, y)
}

Wir testen die Funktion und setzen x auf 1 und y auf 5:

to_plot(x=1, y=5)

Mit der nächsten Funktion kann der Anwender Zufallszahlen erzeugen, die anschließend in einer Grafik dargestellt werden. Der Anwender gibt an, wie viele Werte erzeugt werden sollen und welchen Mittelwert die Werte auf der x-Achse und die Werte auf der y-Achse haben sollen.

to_plot <- function(random_numbers, x_mean, y_mean) {
  x <- rnorm(n = random_numbers, mean = x_mean)
  y <- rnorm(n = random_numbers, mean = y_mean)
  return(plot(x, y))
}

Wir testen die Funktion und legen fest, dass 100 Werte erzeugt werden sollen, mit einem Mittelwert von 10 auf der x-Achse und einem Mittelwert von 100 auf der y-Achse:

to_plot(random_numbers=100, x_mean=10, y_mean=100)

Erstellen wir dieselbe Funktion noch einmal, diesmal aber mit Standardwerten (Defaults) für sämtliche Parameter. Dadurch können wir die Funktion ausführen, ohne die Argumente anzugeben!

to_plot <- function(random_numbers=20, x_mean=1, y_mean=10) {
  x <- rnorm(n = random_numbers, mean = x_mean)
  y <- rnorm(n = random_numbers, mean = y_mean)
  plot(x, y)
}

## Testet die Funktion
to_plot()

Die obigen Funktionen sind sehr einfach und eigentlich überflüssig. Sie sollen lediglich veranschaulichen, wie Funktionen in R definiert werden. In der Praxis umfassen Funktionen zwischen 5 und 50 Zeilen. Längere Funktionen lassen sich sinnvollerweise in mehrere Funktionen aufteilen.

Wir erstellen nun eine etwas komplexere Funktion. Sie soll mehrere Dinge erledigen, z. B. ein Package laden, eine Grafik erstellen, die Grafik als PDF-Datei speichern und die Grafik zudem anzeigen. Die Funktion enthält jetzt Kommentare, die erläutern, was in jedem Schritt geschieht:

## Erstellt die Funktion to_plot()
## Die Funktion hat die Argumente random_numbers, x_mean, y_mean, title
to_plot <- function(random_numbers=20, x_mean=10, y_mean=10, my_title) {
  # Lädt das Package ggplot2, das zum Erstellen von Grafiken verwendet wird
  library(ggplot2)

  # Erzeugt x-Werte
  x <- rnorm(n = random_numbers, mean = x_mean)
  # Logarithmiert die x-Werte
  x <- log(x)

  # Erzeugt y-Werte
  y <- rnorm(n = random_numbers, mean = y_mean)
  # Quadriert die y-Werte
  y = y^2

  # Speichert x und y in einem Data Frame
  my_data <- data.frame(x, y)

  # Erstellt eine Grafik
  my_plot <- ggplot(my_data, aes(x=x, y=y)) +
    # Punkte in der Grafik anzeigen
    geom_point() +
    # Der Titel der Grafik soll dem title-Argument der Funktion entsprechen
    labs(title=my_title)

  # Speichert die Grafik als PDF-Datei
  ggsave(plot=my_plot, filename='my_plot.pdf')
  return(my_plot)
}

## Testet die Funktion
to_plot(random_numbers=10, x_mean=10, y_mean=10, my_title="Min första graf")

Saving 7 x 5 in image

Wie andere Funktionen in R können Sie auch Ihre eigenen Funktionen ineinander verschachteln.

Funktionen

• Erstellen Sie eine Funktion mit der Syntax: name <- function(...args...) {...body...}.
• Verwenden Sie die Funktion mit der Syntax: name(...values...).
• Verwenden Sie Kommentare, wenn Sie Funktionen erstellen
• R sucht Variablen zunächst im aktuellen Stack Frame, bevor es auf der obersten Ebene nach ihnen sucht.
• Geben Sie Standardwerte für Argumente an, wenn dies sinnvoll ist