Toán tử trong R: số học, so sánh, logic, %in% và %%

Các toán tử R cung cấp

Toán tử (operator) của R chia thành bốn nhóm: số học (+ - * / ^ %% %/%), so sánh (== != < <= > >=), logic (& | && || ! xor) và phép kiểm tra thuộc tập hợp %in%. Có hai điều khiến chúng khác với hầu hết các ngôn ngữ: gần như tất cả đều được vector hóa, tức là xử lý cả vector cùng lúc, theo từng phần tử; và R có hai toán tử AND cùng hai toán tử OR không thể dùng thay cho nhau. Trang này trình bày tất cả, kèm những bẫy về thứ tự ưu tiên khiến kết quả sai mà không báo gì.

Số học: +, -, *, /, ^, %% và %/%

Năm toán tử đầu làm đúng như bạn nghĩ. Hai toán tử bọc trong dấu phần trăm, %% (chia lấy dư, cho số dư) và %/% (chia lấy phần nguyên, cho thương), là những toán tử mọi người hay tìm kiếm:

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

Lưu ý rằng / luôn thực hiện phép chia số thực: 17 / 5 là 3.4, không bao giờ là 3. Nếu bạn muốn phần nguyên, đó chính là việc của %/%.

Công việc hằng ngày của %% là kiểm tra tính chia hết. Một số là số chẵn khi chia cho 2 không còn dư:

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

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

Dòng thứ hai đáng để dừng lại: với toán hạng âm, %% của R trả về kết quả mang dấu của số chia (-7 %% 3 là 2, vì -7 = -3 * 3 + 2). Một số ngôn ngữ làm theo cách ngược lại; nếu bạn chuyển code từ ngôn ngữ khác sang, hãy kiểm tra kỹ.

Toán tử so sánh được vector hóa

==, !=, <, <=, >, >= so sánh theo từng phần tử và trả về một vector logic, không phải một đáp án duy nhất:

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

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

Đây là cỗ máy đứng sau hầu như mọi thao tác lọc trong R: bạn so sánh cả một vector với một giá trị, nhận về một mặt nạ logic, rồi dùng mặt nạ đó để lấy tập con. Một lưu ý khi dùng == với số thập phân: số thực dấu phẩy động được lưu xấp xỉ, nên 0.1 + 0.2 == 0.3 là FALSE. Khi so sánh số thập phân, hãy ưu tiên all.equal() hoặc kiểm tra abs(x - y) < 1e-9.

Toán tử logic: & và && (nhầm lẫn kinh điển)

R có hai toán tử AND và hai toán tử OR, và chọn nhầm là chuyện ai học R cũng từng trải qua.

& và | được vector hóa. Chúng kết hợp hai vector logic theo từng phần tử:

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

Dùng chúng mỗi khi bạn xây dựng bộ lọc trên dữ liệu: df[df$age > 30 & df$city == "Lisbon", ].

&& và || làm việc với giá trị đơn và có cơ chế đoản mạch. Chúng nhận giá trị đơn, trả về một TRUE/FALSE duy nhất, và bỏ qua hoàn toàn toán hạng thứ hai nếu toán hạng thứ nhất đã quyết định được đáp án:

x <- 8

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

Dòng thứ hai minh họa cơ chế đoản mạch: vì x < 0 là FALSE, R không bao giờ thực thi lệnh gọi stop(). Đây chính là lý do && thuộc về điều kiện if(): bạn có thể viết if (!is.na(x) && x > 10) và phần x > 10 sẽ được bỏ qua an toàn khi x là NA.

Quy tắc chung: &/| cho vector và lọc dữ liệu, &&/|| cho điều kiện if(). Và từ R 4.3, quy tắc này được áp dụng nghiêm ngặt: đưa cho && hoặc || một vector có độ dài lớn hơn 1 là lỗi (các phiên bản R cũ âm thầm chỉ dùng phần tử đầu tiên, điều đã che giấu nhiều bug thật trong nhiều năm).

xor(a, b) hoàn thiện bộ toán tử: TRUE khi đúng một trong hai giá trị là TRUE:

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

%in%: kiểm tra thuộc tập hợp

x %in% table hỏi, với từng phần tử của x, "phần tử này có xuất hiện ở đâu đó trong table không?" Đây là một trong những toán tử được dùng nhiều nhất trong code R thực tế:

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

Vế được kiểm tra có thể là cả một vector, khiến %in% trở thành công cụ tự nhiên để lọc các hàng theo một tập giá trị cho phép.

Nó cũng tốt hơn cách bạn sẽ phải viết nếu không có nó: một chuỗi == nối với nhau bằng |:

day <- "sat"

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

Với năm giá trị cho phép, chuỗi == trở thành một bức tường lặp lại; còn phiên bản %in% chỉ cần thêm phần tử vào vector. Có một lợi thế thứ hai tinh tế hơn: %in% không bao giờ trả về NA:

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 là NA vì R không thể biết một giá trị không xác định có bằng 1 hay không, hành vi này được trình bày chi tiết trong giá trị thiếu. Giá trị NA đó sẽ làm hỏng mọi if() mà nó đi tới. %in% tránh được toàn bộ vấn đề bằng cách luôn trả lời TRUE hoặc FALSE, đó là lý do nó là lựa chọn an toàn hơn cho các điều kiện trên dữ liệu có thể bị thiếu.

Bẫy thứ tự ưu tiên

Hai bẫy về thứ tự ưu tiên toán tử gây ra phần lớn những khoảnh khắc "R bị hỏng rồi". Thứ nhất, ^ có độ ưu tiên cao hơn dấu trừ một ngôi:

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

Thứ hai, dấu hai chấm có độ ưu tiên cao hơn các phép số học hai ngôi:

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

Khi không chắc, hãy thêm dấu ngoặc. Chúng không tốn gì, và mọi người đọc (kể cả chính bạn sau này) sẽ hiểu chúng giống hệt cách trình thông dịch hiểu.

$ và [ ]: các toán tử truy cập

Bạn cũng sẽ thường xuyên gặp $, [ ] và [[ ]], về mặt kỹ thuật cũng là toán tử, dùng để lấy giá trị ra khỏi cấu trúc dữ liệu chứ không phải để tính toán:

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

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

Chúng được trình bày đầy đủ trong các trang về vector, list và data frame; ở đây chỉ cần nhận ra chúng thuộc cùng họ toán tử.

Những điều cần nhớ

• %% cho số dư, %/% cho thương nguyên; x %% 2 == 0 kiểm tra số chẵn.
• Phép so sánh được vector hóa: chúng trả về một vector logic mà bạn dùng để lọc.
• &/| kết hợp vector theo từng phần tử; &&/|| dành cho giá trị đơn trong if() và có cơ chế đoản mạch. Từ R 4.3, dùng && với vector dài hơn là lỗi.
• x %in% table thay cho chuỗi == và không bao giờ trả về NA.
• -2^2 là -4 và 1:n - 1 bắt đầu từ 0: thêm dấu ngoặc khi không chắc.

Tiếp theo: đưa các toán tử này vào làm việc bên trong if, else và ifelse(), các câu lệnh điều kiện của R.