R-Operatoren: Arithmetik, Vergleich, Logik, %in% und %%

Die Operatoren, die R dir gibt

R's Operatoren teilen sich in vier Arbeitsgruppen: Arithmetik (+ - * / ^ %% %/%), Vergleich (== != < <= > >=), Logik (& | && || ! xor) und den Zugehörigkeitstest %in%. Zwei Dinge unterscheiden sie von den meisten Sprachen: Fast alle sind vektorisiert - sie arbeiten auf ganzen Vektoren gleichzeitig, elementweise - und R hat zwei UND-Operatoren und zwei ODER-Operatoren, die nicht austauschbar sind. Diese Seite behandelt sie alle, dazu die Vorrangfallen, die still falsche Ergebnisse erzeugen.

Arithmetik: +, -, *, /, ^, %% und %/%

Die ersten fünf tun, was du erwartest. Die beiden prozentumrahmten - %% (Modulo, der Rest) und %/% (Ganzzahldivision, der Quotient) - sind die, nach denen Leute suchen:

a <- 17
b <- 5

print(a + b)    # 22
print(a - b)    # 12
print(a * b)    # 85
print(a / b)    # 3.4
print(a ^ b)    # 1419857
print(a %% b)   # 2  - the remainder of 17 / 5
print(a %/% b)  # 3  - how many whole times 5 fits into 17

Beachte, dass / immer eine Fließkommadivision ausführt - 17 / 5 ist 3.4, nie 3. Willst du den ganzzahligen Teil, ist genau dafür %/% da.

Die Alltagsaufgabe von %% ist Teilbarkeit. Eine Zahl ist gerade, wenn die Division durch 2 keinen Rest lässt:

n <- 42
print(n %% 2 == 0)   # TRUE - even

print(-7 %% 3)       # 2, not -1

Diese zweite Zeile ist eine Pause wert: Bei einem negativen Operanden gibt R's %% ein Ergebnis mit dem Vorzeichen des Divisors zurück (-7 %% 3 ist 2, denn -7 = -3 * 3 + 2). Manche Sprachen machen es andersherum; falls du Code portierst, prüf das.

Vergleichsoperatoren sind vektorisiert

==, !=, <, <=, >, >= vergleichen elementweise und geben einen logischen Vektor zurück, keine einzelne Antwort:

scores <- c(45, 72, 88, 60)

print(scores >= 60)           # FALSE TRUE TRUE TRUE
print(scores[scores >= 60])   # 72 88 60

Das ist der Motor hinter fast allem Filtern in R - du vergleichst einen ganzen Vektor mit einem Wert, bekommst eine logische Maske und nutzt die Maske zum Teilmengenbilden. Eine Warnung zu == bei Dezimalzahlen: Fließkommazahlen werden näherungsweise gespeichert, deshalb ist 0.1 + 0.2 == 0.3 gleich FALSE. Für Dezimalvergleiche nimm lieber all.equal() oder prüfe abs(x - y) < 1e-9.

Logische Operatoren: & vs. && (die klassische Verwirrung)

R hat zwei UND-Operatoren und zwei ODER-Operatoren, und den falschen zu wählen ist ein Initiationsritus.

& und | sind vektorisiert. Sie kombinieren zwei logische Vektoren elementweise:

sunny <- c(TRUE, TRUE, FALSE, FALSE)
warm  <- c(TRUE, FALSE, TRUE, FALSE)

print(sunny & warm)   # TRUE FALSE FALSE FALSE
print(sunny | warm)   # TRUE TRUE TRUE FALSE
print(!sunny)         # FALSE FALSE TRUE TRUE

Nutze diese immer dann, wenn du einen Filter über Daten baust: df[df$age > 30 & df$city == "Lisbon", ].

&& und || sind skalar und werten verkürzt aus. Sie nehmen Einzelwerte, geben ein einzelnes TRUE/FALSE zurück und überspringen den zweiten Operanden vollständig, wenn der erste die Antwort bereits festlegt:

x <- 8

print(x > 0 && x %% 2 == 0)         # TRUE - both checked
print(x < 0 && stop("never runs"))  # FALSE - stop() is never evaluated

Diese zweite Zeile zeigt die verkürzte Auswertung: Weil x < 0 gleich FALSE ist, wertet R den stop()-Aufruf nie aus. Genau deshalb gehört && in if()-Bedingungen - du kannst if (!is.na(x) && x > 10) schreiben, und der Teil x > 10 wird sicher übersprungen, wenn x gleich NA ist.

Die Faustregel: &/| für Vektoren und Datenfilter, &&/|| für if()-Bedingungen. Und seit R 4.3 wird das mit Zähnen durchgesetzt: && oder || einen Vektor der Länge größer 1 zu übergeben ist ein Fehler (ältere R-Versionen nutzten stillschweigend nur das erste Element, was jahrelang echte Bugs verbarg).

xor(a, b) rundet die Sammlung ab - TRUE, wenn genau einer der beiden TRUE ist:

print(xor(TRUE, FALSE))  # TRUE
print(xor(TRUE, TRUE))   # FALSE

%in%: Zugehörigkeit prüfen

x %in% table fragt für jedes Element von x: "Kommt das irgendwo in table vor?" Es ist einer der meistgenutzten Operatoren in echtem R-Code:

basket <- c("apple", "banana", "cherry")

print("banana" %in% basket)   # TRUE
print("mango" %in% basket)    # FALSE

wanted <- c("cherry", "mango", "apple")
print(wanted %in% basket)     # TRUE FALSE TRUE

Die geprüfte Seite darf ein ganzer Vektor sein, was %in% zum natürlichen Werkzeug macht, um Zeilen anhand einer Menge erlaubter Werte zu filtern.

Es schlägt außerdem die Alternative, die du sonst schreiben würdest - eine Kette von ==, mit | zusammengeklebt:

day <- "sat"

print(day == "sat" | day == "sun")   # works, but scales badly
print(day %in% c("sat", "sun"))      # same answer, stays readable

Bei fünf erlaubten Werten wird die ==-Kette zu einer Wand aus Wiederholung; die %in%-Version lässt einfach den Vektor wachsen. Es gibt einen zweiten, subtileren Vorteil - %in% gibt nie NA zurück:

print(NA == 1)             # NA - comparison with a missing value is unknown
print(NA %in% c(1, 2, 3))  # FALSE - %in% gives a definite answer

NA == 1 ist NA, weil R nicht wissen kann, ob ein unbekannter Wert gleich 1 ist - ein Verhalten, das ausführlich unter fehlende Werte behandelt wird. Dieses NA vergiftet dann jedes if(), das es erreicht. %in% umgeht das ganze Problem, indem es stets TRUE oder FALSE antwortet - deshalb ist es die sicherere Wahl für Bedingungen auf möglicherweise fehlenden Daten.

Vorrangfallen

Zwei Operator-Vorrangfallen machen einen überproportionalen Anteil an "R ist kaputt"-Momenten aus. Erstens bindet ^ stärker als das unäre Minus:

print(-2^2)     # -4  - parsed as -(2^2)
print((-2)^2)   #  4  - the square of negative two

Zweitens bindet der Doppelpunkt stärker als binäre Arithmetik:

n <- 5

print(1:n - 1)     # 0 1 2 3 4  - parsed as (1:n) - 1
print(1:(n - 1))   # 1 2 3 4    - probably what you meant

Im Zweifel setz Klammern. Sie kosten nichts, und jeder Leser (auch dein zukünftiges Ich) liest sie genauso wie der Interpreter.

$ und [ ]: die Zugriffsoperatoren

Du wirst außerdem ständig $, [ ] und [[ ]] sehen - technisch ebenfalls Operatoren, genutzt zum Herausholen von Werten aus Strukturen statt zum Rechnen:

person <- list(name = "Rosa", age = 30)

print(person$name)     # by name, with $
print(person[["age"]]) # by name, with [[ ]]

Sie werden ausführlich auf den Seiten zu Vektoren, Listen und Data Frames behandelt - hier reicht es, sie als Mitglieder derselben Operatorfamilie zu erkennen.

Was du mitnimmst

• %% liefert den Rest, %/% den ganzzahligen Quotienten; x %% 2 == 0 prüft auf gerade Zahlen.
• Vergleiche sind vektorisiert - sie geben einen logischen Vektor zurück, mit dem du filtern kannst.
• &/| kombinieren Vektoren elementweise; &&/|| sind für Einzelwerte in if() und werten verkürzt aus. Seit R 4.3 ist && auf einem längeren Vektor ein Fehler.
• x %in% table ersetzt verkettete == und gibt nie NA zurück.
• -2^2 ist -4 und 1:n - 1 beginnt bei 0 - im Zweifel klammern.

Als Nächstes: diese Operatoren in if, else und ifelse() einsetzen - R's bedingte Anweisungen.