R Academy · Lekcja

Konwersja typów logicznych i znakowych

Konwertuj wartości między typami logicznym, znakowym i liczbowym za pomocą as.logical() i as.character().

Konwersja typów logicznych i znakowych to bezpłatna lekcja R Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej R Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs R Academy zawiera 4 lekcji w sumie.

Konwersja między typami

R udostępnia funkcje as.*() do konwersji między wszystkimi podstawowymi typami. W tej lekcji omówiono konwersje między typami logical, character i numeric — najczęstsze konwersje wykonywane w obie strony podczas czyszczenia danych.

# Quick overview of as.*() functions
cat('as.logical(1):    ', as.logical(1), '
')     # TRUE
cat('as.numeric(TRUE): ', as.numeric(TRUE), '
')  # 1
cat('as.character(3.14):', as.character(3.14), '
') # "3.14"
cat('as.logical("TRUE"):', as.logical('TRUE'), '
') # TRUE

Konwersja typu numerycznego na logiczny

Podczas konwersji liczby na wartość logiczną: 0 staje się FALSE, a każda liczba różna od zera staje się TRUE. Ta reguła dotyczy zarówno liczb całkowitych, jak i typu double.

cat('as.logical(0):    ', as.logical(0), '
')     # FALSE
cat('as.logical(1):    ', as.logical(1), '
')     # TRUE
cat('as.logical(-5):   ', as.logical(-5), '
')    # TRUE (non-zero)
cat('as.logical(0.001):', as.logical(0.001), '
') # TRUE (non-zero)
cat('as.logical(0L):   ', as.logical(0L), '
')    # FALSE
cat('as.logical(3L):   ', as.logical(3L), '
')    # TRUE

Konwersja typu logicznego na numeryczny

TRUE jest konwertowane na 1, a FALSE na 0. Ta konwersja leży u podstaw wielu idiomów R — na przykład używania sum() do zliczania wartości TRUE lub mean() do obliczania proporcji.

cat('as.numeric(TRUE):  ', as.numeric(TRUE), '
')   # 1
cat('as.numeric(FALSE): ', as.numeric(FALSE), '
')  # 0
cat('as.integer(TRUE):  ', as.integer(TRUE), '
')   # 1L

# Practical use: count TRUEs by summing
passed <- c(TRUE, FALSE, TRUE, TRUE, FALSE, TRUE)
cat('Passed count:', sum(as.numeric(passed)), '
')  # 4
cat('Pass rate:   ', mean(passed) * 100, '%
')      # 66.67%

as.logical() z ciągów znaków

as.logical('TRUE') i as.logical('FALSE') konwertują tekstowe reprezentacje wartości logicznych. R akceptuje również 'T' i 'F' jako skróty. Wszystko inne (w tym zapis 'true' małymi literami) zwraca NA.

cat('as.logical("TRUE"):  ', as.logical('TRUE'), '
')   # TRUE
cat('as.logical("FALSE"): ', as.logical('FALSE'), '
')  # FALSE
cat('as.logical("T"):     ', as.logical('T'), '
')      # TRUE
cat('as.logical("F"):     ', as.logical('F'), '
')      # FALSE
cat('as.logical("yes"):   ', as.logical('yes'), '
')    # NA (not recognised)
cat('as.logical("true"):  ', as.logical('true'), '
')   # NA (case-sensitive!)

Konwersja typu numerycznego na znakowy

as.character(x) konwertuje liczbę na jej reprezentację tekstową. Jest to przydatne podczas tworzenia etykiet i identyfikatorów lub gdy trzeba wstawić liczby do ciągów znaków.

num_val <- 3.14159
char_val <- as.character(num_val)
cat('as.character(3.14159):', char_val, '
')  # '3.14159'
cat('class:', class(char_val), '
')           # character

# Building labels
ids <- 1:5
labels <- paste0('Item_', as.character(ids))
cat('Labels:', labels, '
')

Konwersja typu znakowego na numeryczny

as.numeric('3.14') interpretuje ciąg znaków jako liczbę typu double. Jeśli ciągu nie można zinterpretować jako liczby, R zwraca NA i wyświetla ostrzeżenie. W kodzie produkcyjnym przed konwersją należy zawsze sprawdzić dane wejściowe.

cat('as.numeric("3.14"):  ', as.numeric('3.14'), '
')   # 3.14
cat('as.numeric("100"):   ', as.numeric('100'), '
')    # 100
cat('as.numeric("-5.5"):  ', as.numeric('-5.5'), '
')   # -5.5
cat('as.numeric("abc"):   ', as.numeric('abc'), '
')    # NA with warning
cat('as.numeric("1e3"):   ', as.numeric('1e3'), '
')    # 1000 (sci notation OK)

Konwersja typu logicznego na znakowy

as.character(TRUE) tworzy ciąg znaków 'TRUE'. Jest to przydatne, gdy trzeba uwzględnić wartości logiczne w tekście wynikowym, eksportowanych plikach lub konkatenacji ciągów znaków.

flag_t <- TRUE
flag_f <- FALSE

cat('as.character(TRUE): ', as.character(flag_t), '
')  # 'TRUE'
cat('as.character(FALSE):', as.character(flag_f), '
')  # 'FALSE'
cat('class:', class(as.character(flag_t)), '
')         # character

# In paste()
message <- paste('System status:', as.character(flag_t))
cat(message, '
')

Konwersja w obie strony

Większość konwersji jest odwracalna (w obie strony), ale może wiązać się z utratą informacji: numeric -> character -> numeric może powodować utratę precyzji zależnie od sposobu sformatowania liczby jako ciągu znaków.

original <- 3.141592653589793
char_version <- as.character(original)
back_to_num <- as.numeric(char_version)

cat('Original:  ', original, '
')
cat('As string: ', char_version, '
')
cat('Back:      ', back_to_num, '
')
cat('Identical?:', identical(original, back_to_num), '
')
cat('Equal?:    ', original == back_to_num, '
')

Konwersja wektorów o mieszanym pochodzeniu

Po zastosowaniu as.numeric() do wektora znakowego każdy element jest konwertowany niezależnie. Elementy, których nie można zinterpretować, stają się NA. Jest to standardowy sposób czyszczenia danych wyglądających jak liczbowe, odczytanych z plików CSV.

# Simulated data from CSV (all read as character)
raw_data <- c('42', '37.5', 'N/A', '55', '', '28.0')
cat('Raw character data:', raw_data, '
')

numeric_data <- suppressWarnings(as.numeric(raw_data))
cat('Converted:         ', numeric_data, '
')  # 42 37.5 NA 55 NA 28
cat('NA count:          ', sum(is.na(numeric_data)), '
')

Konwersja logiczna w ifelse()

Łączenie as.numeric() z ifelse() lub bezpośrednie mnożenie przez wektor logiczny to częsty idiom używany do warunkowego punktowania lub tworzenia cech w analizie danych.

# Score: 1 for correct, 0 for incorrect
quiz_answers <- c('A', 'C', 'B', 'D', 'B')
correct      <- c('A', 'B', 'B', 'D', 'C')

is_correct <- quiz_answers == correct
cat('Correct:  ', is_correct, '
')
cat('As 0/1:   ', as.numeric(is_correct), '
')
cat('Score:    ', sum(is_correct), '/', length(is_correct), '
')

Podsumowanie konwersji

Oto podsumowanie najważniejszych konwersji typów logicznych i znakowych:

as.logical(0) → FALSE; dowolna wartość różna od zera → TRUE
as.logical('TRUE'/'T') → TRUE; wielkość liter ma znaczenie; pozostałe wartości → NA
as.numeric(TRUE) → 1; as.numeric(FALSE) → 0
as.character(x) → tekstowa reprezentacja x
as.numeric('3.14') → 3.14; ciągi nienumeryczne → NA i ostrzeżenie

# All conversions in one snippet
cat('logical->num:  ', as.numeric(c(TRUE, FALSE)), '
')
cat('num->logical:  ', as.logical(c(0, 1, -1, 0.5)), '
')
cat('char->num:     ', suppressWarnings(as.numeric(c('5', 'abc', '3.1'))), '
')
cat('char->logical: ', as.logical(c('TRUE', 'FALSE', 'yes')), '
')
cat('logical->char: ', as.character(c(TRUE, FALSE)), '
')

Szybkie sprawdzenie

Do jakiej wartości oblicza się w R wyrażenie as.numeric(TRUE) + as.numeric(FALSE)?

Podsumowanie: konwersja typów logicznych i znakowych

Świetnie! Najważniejsze wnioski z tej lekcji:

as.logical(0) → FALSE; wartość różna od zera → TRUE; 'TRUE'/'T' → TRUE
as.numeric(TRUE) → 1; as.numeric(FALSE) → 0
as.character(x) konwertuje dowolną wartość do postaci tekstowej
as.numeric('3.14') interpretuje ciąg numeryczny; nieprawidłowe ciągi → NA
as.logical('true') to NA — dopasowanie uwzględnia wielkość liter ('TRUE' działa)
Konwersje są w większości odwracalne; podczas konwersji kolumn zawierających przewidywane wartości powodujące NA należy używać suppressWarnings()

# Practical: parse a messy survey score column
raw_scores <- c('8', '7', 'N/A', '9', 'skip', '6')
numeric_scores <- suppressWarnings(as.numeric(raw_scores))
cat('Parsed:', numeric_scores, '
')
cat('Valid responses:', sum(!is.na(numeric_scores)), '
')
cat('Average score:  ', round(mean(numeric_scores, na.rm = TRUE), 2), '
')

Często zadawane pytania

Czy lekcja „Konwersja typów logicznych i znakowych” jest bezpłatna?

Tak — pełny tekst „Konwersja typów logicznych i znakowych” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu R Academy, przejdź na CoddyKit PRO. Kurs R Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Konwersja typów logicznych i znakowych”?

Konwertuj wartości między typami logicznym, znakowym i liczbowym za pomocą as.logical() i as.character(). Ćwiczysz R Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć R Academy?

Nie wymagamy żadnego doświadczenia. R Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Konwersja typów logicznych i znakowych”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji R Academy?

Tak. Każda lekcja R Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Przegląd systemu typów R
Konwersja między typami liczbowymi
Konwersja typów logicznych i znakowych
Pułapki konwersji typów i dobre praktyki

← Powrót do R Academy