Funktionen in R verwenden: Tutorial

Wenn du mit einer Karriere in der Data Science liebäugelst, gilt: Je früher du mit dem Coden startest, desto besser. Unabhängig von der Programmiersprache, mit der du deine Lernreise beginnst – irgendwann kommst du an Funktionen nicht vorbei. 

Funktionen sind ein zentrales Konzept in nahezu jeder modernen Programmiersprache, darunter die in der Data Science beliebten Sprachen Python, Julia und natürlich R.

In diesem Tutorial schauen wir uns an, was R-Funktionen sind und wie du sie nutzt. Wir beleuchten Zweck, Syntax und Typen von Funktionen in R – alles, was du brauchst, um dieses zentrale Programmierkonzept zu meistern. Außerdem bekommst du einen Einstieg in die Kunst, eigene Funktionen zu schreiben. 

Was ist eine Funktion in R?

In der Programmierung sind Funktionen Anweisungen, die so organisiert sind, dass sie eine bestimmte Aufgabe erledigen. Die Idee dahinter: in sich geschlossene Programmteile zu schaffen, die du nur dann aufrufst, wenn du sie brauchst. 

Mit Funktionen musst du Programme nicht jedes Mal neu schreiben, vermeidest Wiederholungen und verbesserst Robustheit sowie Lesbarkeit deines Codes. Als Faustregel gilt: Immer dann eine Funktion schreiben, wenn du denselben Anweisungssatz voraussichtlich mehr als zweimal im Code verwenden wirst.

Funktionen lassen sich für unzählige Zwecke einsetzen und treten in vielen Formen auf. In der Regel nehmen die meisten Funktionen Eingabedaten entgegen, verarbeiten sie und liefern ein Ergebnis zurück. Auf welchen Daten die Funktion arbeitet, bestimmst du über sogenannte Argumente. Sie steuern außerdem, wie die Funktion ihre Aufgabe ausführt.

Je nach Herkunft unterscheiden wir in R drei Haupttypen von Funktionen:

• Eingebaute Funktionen
• Funktionen aus R-Paketen
• Benutzerdefinierte Funktionen (UDF)

In den folgenden Abschnitten erklären wir die Besonderheiten der verschiedenen Funktionstypen in R. 

Eingebaute Funktionen in R

R ist eine leistungsstarke Programmiersprache und bringt einen großen Katalog an eingebauten Funktionen mit, die du jederzeit aufrufen kannst. Als mathematikorientierte Sprache bietet R zahlreiche Funktionen für numerische Operationen. Hier eine Auswahl besonders nützlicher Funktionen:

• print(). Gibt ein R-Objekt in der R-Konsole aus
• min(), max(). Berechnet Minimum und Maximum eines numerischen Vektors
• sum(). Berechnet die Summe eines numerischen Vektors
• mean(). Berechnet den Mittelwert eines numerischen Vektors
• range(). Ermittelt den Wertebereich (Minimum und Maximum) eines numerischen Vektors
• str(). Zeigt die Struktur eines R-Objekts an
• ncol(). Gibt die Anzahl der Spalten einer Matrix oder eines Dataframes zurück
• length(). Gibt die Anzahl der Elemente eines R-Objekts zurück, z. B. eines Vektors, einer Liste oder einer Matrix.

Im folgenden Code siehst du, wie einfach sich mit diesen Funktionen Statistiken für einen Vektor berechnen lassen:

>>> v <- c(1, 3, 0.2, 1.5, 1.7)
>>> print(v)
[1] 1.0 3.0 0.2 1.5 1.7
>>> sum(v)
[1] 7.4
>>> mean(v)
[1] 1.48
>>> length(v)
[1] 5

Mehr zu R-Funktionen und vieles mehr lernst du im umfassenden R Skill Track, mit dem du Schritt für Schritt wie ein Programmierer codest. 

Funktionen in R-Paketen

So zahlreich und vielfältig eingebaute Funktionen auch sind – für vieles, was R ausmacht, reichen sie nicht: von überzeugenden Daten-Visualisierungen bis zum Trainieren leistungsstarker Machine-Learning-Modelle. 

Der Großteil der dafür nötigen Funktionen steckt in externen Paketen bzw. Bibliotheken. Pakete sind Sammlungen aus R-Funktionen, Daten und kompiliertem Code in einem definierten Format, die gezielt Funktionalität erweitern. Die meisten Pakete sind frei verfügbar und finden sich in bekannten Repositorien wie CRAN – dort sind aktuell fast 20.000 Pakete gelistet. 

Um die Funktionen eines Pakets zu nutzen, musst du es zunächst installieren. Möchtest du zum Beispiel stringr installieren – ein beliebtes Paket für reguläre Ausdrücke –, verwendest du folgenden Befehl:

install.packages('stringr')

Nach der Installation lädst du es mit dem library-Befehl in deine R-Umgebung:

library(stringr)

Jetzt kannst du alle Funktionen aus dem stringr-Paket nutzen. Testen wir z. B. str_detect(). Die Funktion gibt einen logischen Vektor zurück: TRUE für jedes Element, das dem Muster entspricht, sonst FALSE.

str_detect('DataCamp', "Data")
[1] TRUE

Wenn du mehr über R-Pakete und ihre Anwendung erfahren möchtest, schau dir dieses DataCamp-R-Pakete-Tutorial an.

Benutzerdefinierte Funktionen

Am besten verstehst du Funktionen in R, indem du eigene schreibst. Benutzerdefinierte Funktionen (User-Defined Functions, UDF) werden von Programmierenden entworfen, um eine konkrete Aufgabe zu erledigen. 

R-Funktionen folgen in der Regel dieser Syntax:

function_name <- function(argument_1, argument_2) { 
  function body
  return (output)
}

Wir unterscheiden dabei vier Hauptelemente:

• Funktionsname. Gib deiner UDF zunächst einen Namen und speichere sie als neues Objekt. Den Namen rufst du auf, sobald du die Funktion verwenden willst. 
• Argumente. Die Funktionsargumente (auch Parameter) stehen in Klammern. Sie geben an, welche Daten als Input dienen und/oder wie sich das Verhalten der Funktion steuern lässt. 
• Funktionskörper. Zwischen geschweiften Klammern steht der Funktionskörper, also die Anweisungen, mit denen die Aufgabe basierend auf den Argumenten gelöst wird. 
• Return-Statement. Das return-Statement brauchst du, wenn das Ergebnis bzw. die Ergebnisse als Variablen gespeichert werden sollen. 

Beispiel: Du möchtest eine Funktion schreiben, die den Mittelwert zweier Zahlen berechnet:

mean_two_numbers <- function(num_1, num_2) {
  mean <- (num_1 + num_2) / 2
  return (mean)
}

Wenn du nun den Mittelwert von 10 und 20 berechnen willst, rufst du die Funktion so auf:

>>> mean_two_numbers(10,20)
[1] 15

Arten von Argumenten in R-Funktionen

Argumente sind essenziell für jede Funktion. Theoretisch kannst du zwar auch eine Funktion ohne Parameter schreiben (siehe unten), die meisten Funktionen haben aber Argumente – logisch, denn sie liefern die Eingabedaten. Und wenn eine Funktion mehrere Wege zur Aufgabenerfüllung bieten soll, ermöglichen das ebenfalls Argumente.

hello <- function() {
  print('hello, my friend')
}

>>> hello()
[1] "hello, my friend"

Die Anzahl der Argumente ist in R nicht begrenzt; du fügst sie in Klammern, durch Kommata getrennt, hinzu. Generell gilt: Je mehr Argumente, desto komplexer ist die Funktion.

Hast du eine Funktion mit Parametern definiert, musst du bei jedem Aufruf Werte für die Parameter angeben – sonst wirft R einen Fehler. Lässt du z. B. bei unserer Mittelwert-Funktion die beiden Zahlen weg, funktioniert sie nicht.

Diesen Fehler kannst du vermeiden, indem du Standardargumente beim Definieren der Funktion setzt. Sie liefern einen Standardwert, falls du beim Aufruf keinen Wert für dieses Argument übergibst. Zurück zu unserer Mittelwert-Funktion: Dieses Mal fügen wir einen Standardwert für die zweite Zahl hinzu.

mean_two_numbers <- function(num_1, num_2 = 30) {
  mean <- (num_1 + num_2) / 2
  return (mean)
}

Wenn wir die Funktion nun ohne Wert für den Parameter num_2 aufrufen, nimmt R automatisch den Standardwert (also 30):

>>> mean_two_numbers(num_1 = 10)
[1] 20

Return-Werte in R-Funktionen verstehen

Funktionen nehmen in der Regel Daten als Input entgegen und liefern ein Ergebnis als Output. In manchen Programmiersprachen musst du das Ergebnis mit einem return-Statement am Ende des Funktionskörpers explizit zurückgeben, damit es als Variable gespeichert werden kann. Andernfalls wird nur ein Wert angezeigt, der nur innerhalb des Gültigkeitsbereichs der Funktion existiert.

In R ist das anders: Es wird immer ein Wert zurückgegeben, den du in einer Variablen speichern kannst. Aus Gründen der Lesbarkeit ist es dennoch gute Praxis, beim Definieren einer Funktion ein return-Statement einzubauen.

mean_two_numbers <- function(num_1, num_2) {
  # Funktion mit return 
  mean <- (num_1 + num_2) / 2
  return (mean)
}
mean_two_numbers_2 <- function(num_1, num_2) {
  # Funktion ohne return
  mean <- (num_1 + num_2) / 2
  mean
}

> mean_two_numbers(10,50)
[1] 30
 > mean_two_numbers_2(10,50)
[1] 30

Wenn deine Funktion mehrere Werte zurückgeben soll, speicherst du die Ergebnisse in einer Liste und gibst sie im return-Statement zurück:

mean_sum <- function(num_1, num_2) {
  mean <- (num_1 + num_2) / 2
  sum <- num_1 + num_2
  return (list(mean, sum))
}

>>> mean_sum (10, 20)
[[1]]
[1] 15
[[2]]
[1] 30

Funktionen in R aufrufen

Oben haben wir bereits verschiedene Beispiele gesehen, wie man eine Funktion aufruft. Wichtig ist dabei, wie R intern mit den Argumenten umgeht. 

R kennt zwei Wege, Argumente zu übergeben: nach Position und nach Name. Bei der ersten Variante gibst du die Werte in derselben Reihenfolge an, in der die Argumente in der Funktion definiert sind. 

Übergibst du Argumente nach Name, musst du die Namen der Argumente und die zugehörigen Werte explizit angeben. Da die Zuordnung eindeutig ist, spielt die Reihenfolge dann keine Rolle.

Du kannst beide Strategien auch mischen. Dann werden benannte Argumente zuerst zugeordnet, der Rest wird nach Position gematcht.

hello <- function(name, surname) {
  print(paste('Hello', name, surname))
}

# Aufruf nach Position
> hello('Greta','Thunberg')
[1] "Hello, Greta Thunberg"
# Aufruf nach Name
> hello(surname='Thunberg', name='Greta')
[1] "Hello, Greta Thunberg"
# Gemischter Aufruf
> hello(surname='Thunberg', 'Greta')
[1] "Hello, Greta Thunberg"

Funktionen in R dokumentieren

Gute Praxis beim Schreiben von Funktionen ist eine kurze Anleitung zur Nutzung – insbesondere bei komplexeren Funktionen. Informell geht das über Kommentare im Funktionskörper. Du kannst dir die Dokumentation anzeigen lassen, indem du die Funktion ohne Parameter aufrufst:

hello <- function(name, surname) {
  # Begrüße eine Person mit Vor- und Nachnamen
  print(paste('Hello', name, surname))
}

>>> hello
function(name, surname) {
  # Begrüße eine Person mit Vor- und Nachnamen
  print(paste('Hello,', name, surname))

Gehört deine Funktion zu einem größeren Paket und du möchtest sie formal dokumentieren, erstellst du eine separate .Rd-Datei. Das Ergebnis siehst du in der Hilfeansicht einer Funktion, z. B. bei ?mean. 

Fazit

Geschafft – du bist am Ende des Tutorials angekommen. Glückwunsch! Wie in vielen anderen Sprachen sind Funktionen auch in R unverzichtbar. Ob eingebaut, als Teil externer Pakete oder von dir selbst entwickelt: Funktionen zu meistern ist ein wichtiger Meilenstein in deiner Programmierreise. Wenn du deine R-Funktionskompetenz weiter ausbauen willst, schau dir diese Ressourcen an:

• Introduction to Writing Functions in R Course
• Intermediate R Course
• R-Apply-Familie: Funktionen-Tutorial
• R Programming Track