Ein Tutorial zu Schleifen in R – Einsatz und Alternativen

For-Schleifen erklärt

Diese Struktur aus dem rechteckigen Kasten „init“ (Initialisierung), der rautenförmigen Entscheidung und dem Rechteck i1 wird eine bekannte Anzahl von Malen ausgeführt.

Im Flussdiagramm bedeuten Rechtecke so viel wie „tue etwas ohne Entscheidung“. Rauten stehen für Entscheidungssymbole und damit Fragen mit genau zwei logischen Antworten: True (T) oder False (F).

Hinweis: Um es einfach zu halten, wurden weitere mögliche Symbole im Bild weggelassen.

Auf die Initialisierung folgt die Prüfung einer Bedingung für eine Variable, die Werte aus einer vorgegebenen Sequenz annimmt. Im Diagramm fragt die Raute: „Gehört der aktuelle Wert von v zur Sequenz seq?“.

Anders gesagt: Du prüfst, ob der aktuelle Wert von v im festgelegten Bereich liegt. Diesen Bereich definierst du in der Initialisierung, z. B. mit 1:100, damit die Schleife startet.

Ist die Bedingung False, wird die Schleife gar nicht ausgeführt. Das zeigt der offene Pfeil rechts an der for-Struktur. Das Programm macht dann mit der ersten Anweisung nach dem Schleifenblock weiter.

Ist die Bedingung erfüllt, wird die Anweisung bzw. der Block i1 ausgeführt. Möglicherweise ist dieser Block selbst eine Schleife — dann spricht man von verschachtelten Schleifen.

Danach wird die Bedingung erneut geprüft. Das zeigen die Linien von i1 zurück nach oben, direkt hinter den Initialisierungskasten. In R — wie auch in Python — lässt sich das quasi in Umgangssprache ausdrücken, indem du prüfst, ob eine Variable zu einem Wertebereich gehört.

Hinweis: In anderen Sprachen, etwa C, wird die Bedingung expliziter mit Vergleichsoperatoren formuliert.

Ein einfaches Beispiel für eine for-Schleife:

# Create a vector filled with random normal values
u1 <- rnorm(30)
print("This loop calculates the square of the first 10 elements of vector u1")

# Initialize `usq`
usq <- 0. 

for (i in 1:10) {
    # i-th element of `u1` squared into `i`-th position of `usq`
    usq[i] <- u1[i] * u1[i]
    print(usq[i])
}

print(i)

Der for-Block steht in geschweiften Klammern. Diese können direkt hinter die Bedingung oder in die nächste Zeile mit Einrückung gesetzt werden. Pflicht sind sie nicht, aber sie erhöhen die Lesbarkeit und helfen, den Block und mögliche Fehler schnell zu erkennen.

Hinweis: Der Vektor der Quadrate, usq, wird initialisiert. In reinem RStudio-Code wäre das nicht nötig, aber im Markup-Kontext würde knitr sonst nicht kompilieren, da die Referenz auf den Vektor vor seiner Verwendung fehlt. Mehr zu knitr: R Markdown.

For-Schleifen verschachteln

Jetzt, da du weißt, dass for-Schleifen verschachtelt werden können, fragst du dich wahrscheinlich, warum und wann das sinnvoll ist.

Angenommen, du willst ein zweidimensionales Array manipulieren, indem du seine Elemente positionsabhängig setzt.

Dann könnte das so aussehen:

# Insert your own integer here
my_int <- 42

nr <- as.integer(my_int)

# Create a `n` x `n` matrix with zeros
mymat <- matrix(0, nr, nr)

# For each row and for each column, assign values based on position
# These values are the product of two indexes
for (i in 1:dim(mymat)[1]) {
    for (j in 1:dim(mymat)[2]) {
        mymat[i, j] = i * j
    }
}

Tipp: Mehr zur Funktion matrix() findest du in der R-Dokumentation.

# Show the first 10x10 chunk or the first `nr` x `nr` chunk
if (nr > 10) {
    mymat[1:10, 1:10]
} else
    mymat[1:nr, 1:nr]

Hinweis: Um die Ausgabe zu begrenzen, prüfst du am Ende, ob nr größer als 10 ist. Dann wird nur der erste 10 x 10-Ausschnitt ausgegeben, sonst der erste n x n-Ausschnitt.

Der komplette Code sieht so aus:

# Insert your own integer here
my_int <- 42

nr <- as.integer(my_int)

# Create a `n` x `n` matrix with zeroes
mymat <- matrix(0, nr, nr)

# For each row and for each column, assign values based on position
# These values are the product of two indexes
for (i in 1:dim(mymat)[1]) {
    for (j in 1:dim(mymat)[2]) {
        mymat[i, j] = i * j
    }
}

# Show the first 10x10 chunk or the first `nr` x `nr` chunk
if (nr > 10) {
    mymat[1:10, 1:10]
} else
    mymat[1:nr, 1:nr]

For-Schleifen: beliebt, aber nicht immer die beste Wahl

Die for-Schleife ist am verbreitetsten, und ihr Konstrukt impliziert eine im Voraus feste und bekannte Anzahl an Iterationen, etwa „die ersten 200 Primzahlen erzeugen“ oder „die 10 wichtigsten Kundinnen und Kunden auflisten“.

Aber was, wenn du die Anzahl der Iterationen nicht kennst oder nicht kontrollierst und Bedingungen eintreten können, die vorher nicht absehbar sind?

Zum Beispiel möchtest du die Anzahl der Kundinnen und Kunden in einem Postleitzahlgebiet zählen oder die Klicks auf einen Banner in den letzten zwei Tagen.

In solchen Fällen helfen while-Schleifen und ihre Cousine repeat …

Schleifen mit break beenden

Trifft der R-Interpreter auf break, springt er zur Anweisung direkt nach der Schleife (falls vorhanden). Bei verschachtelten Schleifen beendet break nur die innerste Schleife.

Hier ein Beispiel.

Der Code erzeugt eine m x n-Nullmatrix und füllt per verschachtelter for-Schleife nur die Positionen, bei denen sich die beiden Indizes unterscheiden. Ziel ist eine untere Dreiecksmatrix: Elemente unter der Hauptdiagonalen sind ungleich Null, die anderen bleiben 0.

Wenn die Indizes gleich sind, erfüllt die innere Bedingung (Spaltenindex j) zu „gleich“, wird break ausgeführt und die innere Schleife beendet. Danach folgt eine print()-Anweisung. Anschließend wird die äußere Schleifenbedingung wieder geprüft.

Wenn die Indizes verschieden sind, erfolgt die Zuweisung und der Zähler wird um 1 erhöht. Am Ende wird der Zähler ctr ausgegeben.

# Make a lower triangular matrix (zeroes in upper right corner)
m = 10
n = 10

# A counter to count the assignment
ctr = 0

# Create a 10 x 10 matrix with zeroes
mymat = matrix(0, m, n)

for (i in 1:m) {
    for (j in 1:n) {
        if (i == j) {
            break
        } else {
            # you assign the values only when i<>j
            mymat[i, j] = i * j
            ctr = ctr + 1
        }
    }
    print(i * j)
}

# Print how many matrix cells were assigned
print(ctr)

Hinweis: Geschweifte Klammern auch dann zu setzen, wenn sie nicht zwingend sind, ist oft eine sichere Wahl. So stellst du sicher, dass jedes { ein passendes } hat und findest Unstimmigkeiten schneller.

next in Schleifen verwenden

next bricht die aktuelle Iteration ab und springt direkt zur nächsten — konkret zur erneuten Prüfung der Schleifenbedingung.

In anderen Sprachen heißt das Pendant oft „continue“ und bedeutet dasselbe.

Ein einfaches Beispiel, das die Schleife fortsetzt, einzelne Durchläufe aber überspringt:

m = 20

for (k in 1:m) {
    if (!k %% 2)
        next
    print(k)
}

Dieser Code druckt alle ungeraden Zahlen im Intervall 1:m (hier m=20). Zahlen mit Rest 0 bei Division durch 2 werden übersprungen („Modulus“ %%), da next direkt zur Bedingung zurückspringt und z. B. print(k) nicht ausführt.

Vektorisierung in R erklärt

Warum läuft Vektorisierung schneller, obwohl die Anzahl elementarer Operationen ähnlich erscheint?

Kurz gesagt: R ist eine interpretierte Sprache. Details wie Typen und Speicherverwaltung übernimmt der Interpreter, und zwar Anweisung für Anweisung. Selbst bei Wiederholungen muss er diese Dinge jedes Mal klären.

Ein Compiler löst Definitionen und Deklarationen zur Kompilierzeit für den gesamten Code, übersetzt in optimierten Binärcode — effizienter.

Viele R-Funktionen sind in C/C++/Fortran implementiert und dadurch schneller.

Zweitens: In Sprachen mit Vektorisierung (R, Matlab) wirken Anweisungen auf Objekte, die nativ Vektoren sind — selbst wenn sie nur ein Element enthalten. Der Interpreter muss Definitionen dann nur einmal für den gesamten Vektor erledigen statt für jedes Skalar einzeln. Das spart Zeit.

Außerdem nutzt R bei Vektoroperationen hochoptimierte Lineare-Algebra-Routinen (BLAS). Bearbeite daher nach Möglichkeit ganze Datenstrukturen in einem Funktionsaufruf, um Kopieraufwände zu vermeiden.

Genug Theorie — schauen wir uns ein allgemeines Beispiel an, bevor wir zu konkreten vektorisierten R-Funktionen als Schleifen-Ersatz kommen.

Ein Beispiel für Vektorisierung in R

Zurück zum „wachsenden“ Datensatz — eine typische Ineffizienz beim „Aktualisieren“ eines Data Frames.

Zuerst erzeugst du eine m x n-Matrix mit replicate(m, rnorm(n)) mit m=10 Spaltenvektoren zu je n=10 Elementen (rnorm(n) erzeugt normalverteilte Zufallszahlen).

Dann wandelst du sie in einen Data Frame um (also 10 Beobachtungen von 10 Variablen) und führst eine algebraische Operation mit einer verschachtelten for-Schleife auf jedem Element aus: Eine Sinusfunktion erhöht jedes adressierte Element.

Das Beispiel ist etwas künstlich, könnte aber das Hinzufügen eines Signals zu Rauschen darstellen:

# This is a bad loop with 'growing' data
set.seed(42)
m = 10
n = 10

# Create matrix of normal random numbers
mymat <- replicate(m, rnorm(n))

# Transform into data frame
mydframe <- data.frame(mymat)

for (i in 1:m) {
  for (j in 1:n) {
    mydframe[i, j] <- mydframe[i, j] + 10 * sin(0.75 * pi)
    print(mydframe)
  }
}

Hier geht viel Laufzeit für Kopieren und Schleifenverwaltung drauf.

Die vektorisierte Lösung sieht so aus:

set.seed(42)
m = 10
n = 10
mymat <- replicate(m, rnorm(n))
mydframe <- data.frame(mymat)
mydframe <- mydframe + 10 * sin(0.75 * pi)
mydframe

Das ist deutlich einfacher: Die letzte Zeile ersetzt die verschachtelte for-Schleife. Hinweis: set.seed() sorgt für identische Ergebnisse beider Varianten.

Jetzt messen wir die Laufzeit beider Lösungen.

Dafür nutzt du Systemfunktionen wie system.time() und übergibst den Codeblock in die Klammern:

Tipp: Schreib den zu messenden Code direkt in die Klammern von system.time().

# Insert `system.time()` to measure loop execution
for (i in 1:m) {
  for (j in 1:n) {
    mydframe[i, j] <- mydframe[i, j] + 10 * sin(0.75 * pi)
  }
}

# Add `system.time()` to measure vectorized execution
mydframe <- mydframe + 10 * sin(0.75 * pi) 

Im obigen Code setzt du m und n, erstellst die Matrix und wandelst sie einmalig um. Dann vergleichst du den for-Block mit der Ein-Zeilen-Variante über zwei getrennte system.time()-Aufrufe.

Schon bei m=n=10 ist die vektorisierte Variante etwa siebenmal schneller — bei kleinen Werten noch wenig relevant.

Mit m=n=100 wird der Unterschied spürbar; bei 1000 wirkt die for-Schleife wie eingefroren, während die vektorisierte Form weiterhin blitzschnell ist.

Bei m=n=10000 hängt die for-Schleife über eine Minute, die vektorisierte benötigt rund 2,54 Sekunden. Die Werte hängen natürlich von Hard- und Software und deiner Auslastung ab, sind aber illustrativ.

Fairerweise: Das Erhöhen von m und n beeinflusst auch die Matrixerstellung stark — das siehst du, wenn du system.time() um die Replikation legst.

Spiele mit m und n und plotte die Laufzeit als Funktion von m x n. Das ist die relevante Größe, denn sie steht für die Matrixdimension — und für die Anzahl Iterationen der verschachtelten for-Schleife.

Das ist ein Beispiel für Vektorisierung. Es gibt viele weitere. In den R News (S. 46) finden sich sehr effiziente Funktionen für Summen und Mittelwerte über bestimmte Dimensionen in Arrays oder Matrizen: rowSums(), colSums(), rowMeans(), colMeans().

Außerdem heißt es dort: „…die Funktionen der ‘apply’-Familie, benannt [s,l,m,t]apply, wenden eine andere Funktion auf Elemente/Dimensionen von Objekten an. Diese ‘apply’-Funktionen bieten eine kompakte Syntax für teils komplexe Aufgaben — lesbarer und schneller als schlecht geschriebene Schleifen.“