Summary  
This chapter explains how to retrieve the distinct levels of a factor, create ordered factors, and define a custom ordering of factor levels.  

General domain of usage  
Statistical data analysis

**Levels** in einem Faktor stellen die Menge der unterschiedlichen Kategorien dar, die der Faktor annehmen kann.

Definition

## Anzeigen der Levels
Die Funktion `levels()` zeigt alle eindeutigen Werte, die in einem Faktor gespeichert sind.

curr_f <- factor(c('USD', 'EUR', 'AUD', 'NOK', 
                   'CHF', 'EUR', 'AUD', 'EUR'))

# Display all levels
levels(curr_f)

## Geordnete Faktoren
In einigen Fällen besitzen Kategorien eine natürliche Reihenfolge (z. B. "kurz" < "mittel" < "groß"). Faktoren können als geordnet deklariert werden, indem `ordered = TRUE` gesetzt wird.

sizes <- c('short', 'tall', 'medium',
           'medium', 'short', 'tall')

# Ordered factor (alphabetical order)
factor(sizes, ordered = TRUE)

## Benutzerdefinierte Reihenfolge
Standardmäßig ordnet R die Stufen alphabetisch, was nicht immer der gewünschten Hierarchie entspricht. Eine bestimmte Reihenfolge kann festgelegt werden, indem ein Vektor mit den Stufen in der gewünschten Reihenfolge übergeben wird.

sizes <- c('short', 'tall', 'medium',
           'medium', 'short', 'tall')
order <- c('short', 'medium', 'tall')

# Ordered factor (correct order)
factor(sizes, ordered = TRUE, levels = order)

Dies stellt sicher, dass die Reihenfolge Ihrer beabsichtigten Bedeutung entspricht.

# =====================================================================
# СКРЫТЫЕ ТЕСТЫ ДЛЯ user_code.R
#
# КАК МЫ РАБОТАЕМ:
#  1) Один раз выполняем пользовательский файл в отдельном окружении
#     через run_user_code(...). Получаем:
#       - res$values$...  — переменные из окружения
#       - res$logs        — весь печатный вывод (включая результаты выражений)
#  2) Каждый кейс — отдельный dynamic_test(...), то есть отдельная строка
#     в отчёте, с «говорящим» названием (успех/ошибка).
# =====================================================================

library(testthat)
source(testthat::test_path("helper-run_user_code.R"), local = TRUE)

# Ищем user_code.R
candidates <- c(
  testthat::test_path("..", "..", "user_code.R"),
  testthat::test_path("user_code.R")
)

candidates_norm <- vapply(candidates, function(p) {
  tryCatch(normalizePath(p, winslash = "/", mustWork = FALSE), error = function(e) NA_character_)
}, character(1))

exists_flags <- file.exists(candidates_norm)
if (!any(exists_flags)) {
  stop(
    sprintf(
      "user_code.R not found.\nChecked paths:\n  - %s\nWorking dir: %s",
      paste(candidates, collapse = "\n  - "),
      getwd()
    )
  )
}

user_file <- candidates_norm[which(exists_flags)[1]]

# Выполняем user_code.R и перехватываем консольный вывод
res <- run_user_code(
  file       = user_file,
  capture    = c("grades", "grades_f"),
  echo       = FALSE,
  print.eval = TRUE
)

# ---------- CASE 1 ----------
{
  ok <- !is.null(res$values$grades) && is.character(res$values$grades)

  dynamic_test(
    ok,
    "Variable 'grades' is declared and character type",
    "Expected variable 'grades' to exist and be a character vector."
  )
}

# ---------- CASE 2 ----------
{
  ok <- !is.null(res$values$grades_f) && is.factor(res$values$grades_f) && is.ordered(res$values$grades_f)

  dynamic_test(
    ok,
    "Variable 'grades_f' is declared and ordered factor type",
    "Expected variable 'grades_f' to exist and be an ordered factor."
  )
}

# ---------- CASE 3 ----------
{
  expected_levels <- c('F', 'D', 'C', 'B', 'A')
  ok <- identical(levels(res$values$grades_f), expected_levels)

  dynamic_test(
    ok,
    "Factor 'grades_f' has correct ordered levels (F < D < C < B < A)",
    sprintf("Expected levels: %s. Got: %s",
            paste(expected_levels, collapse = ", "),
            paste(levels(res$values$grades_f), collapse = ", "))
  )
}

# ---------- CASE 4 ----------
{
  out <- trimws(paste(res$logs, collapse = " "))
  ok <- grepl("A", out) && grepl("F", out) && grepl("C", out) &&
        grepl("B", out) && grepl("D", out) && grepl("Levels", out)

  dynamic_test(
    ok,
    "Console output contains factor values and 'Levels:'",
    sprintf("Expected console output to include grades and 'Levels:'. Actual: %s", out)
  )
}


test_hidden.R

# =====================================================================
# ВСПОМОГАТЕЛЬНЫЕ ХЕЛПЕРЫ ДЛЯ ТЕСТОВ
#
# Файл называется helper-*.R: testthat автоматически подхватывает такие
# файлы перед выполнением любых тестов в каталоге tests/testthat.
# =====================================================================

# -----------------------------------------------------------------------------
# run_user_code(...)
#  - безопасно запускает user_code.R в отдельном окружении (env)
#  - перехватывает ВЕСЬ вывод (stdout): как результаты выражений, так и print()/cat()
#  - возвращает:
#       values  — список запрошенных переменных (по именам из аргумента capture)
#       logs    — вектор строк перехваченного вывода
#       env     — окружение, где выполнялся user_code (можно исследовать при необходимости)
#
# ПАРАМЕТРЫ:
#   file        — путь к user_code.R
#   capture     — character-вектор имён переменных, которые нужно извлечь после выполнения
#   inject      — список объектов/функций, которые нужно «подложить» в среду исполнения
#                 (можно использовать для моков/маскировки опасных функций: system, file.remove и т.д.)
#   echo        — печатать код при исполнении (обычно FALSE)
#   print.eval  — ПЕЧАТАТЬ РЕЗУЛЬТАТЫ ВЫРАЖЕНИЙ. Ключевая опция, чтобы строки вида
#                 `prices['Armchair']` попадали в stdout без явного print().
#
# БЕЗОПАСНОСТЬ:
#   - В базовом R нет полноценной «песочницы». Мы изолируем код в новом env,
#     но ОС-доступ не блокируется магически.
#   - Для задач онлайн-платформы можно частично «глушить» опасные вызовы через inject,
#     например:
#       inject = list(
#         system      = function(...) stop("system disabled"),
#         file.remove = function(...) stop("file.remove disabled")
#       )
# -----------------------------------------------------------------------------
run_user_code <- function(
  file = "user_code.R",
  capture = character(0),
  inject = list(),
  echo = FALSE,
  print.eval = TRUE
) {
  # Бросаем явную ошибку, если файла нет (проще диагностировать)
  stopifnot(file.exists(file))

  # Изолированное окружение: parent=baseenv() (без лишних пользовательских объектов сверху)
  env <- new.env(parent = baseenv())

  # Подмешиваем моки/данные в окружение (при необходимости)
  if (length(inject)) list2env(inject, envir = env)

  # ВАЖНО: перехватываем весь вывод выполнения файла.
  # source(..., local=env, echo, print.eval) исполняет код ВНУТРИ env.
  # print.eval=TRUE заставляет R печатать результаты выражений (как в консоли),
  # что позволяет проверять «голые» выражения без print().
  logs <- utils::capture.output(
    base::source(file, local = env, echo = echo, print.eval = print.eval)
  )

  # Собираем запрошенные значения переменных
  values <- setNames(vector("list", length(capture)), capture)
  for (nm in capture) {
    if (exists(nm, envir = env, inherits = FALSE)) {
      values[[nm]] <- get(nm, envir = env, inherits = FALSE)
    } else {
      values[[nm]] <- NULL
    }
  }

  list(values = values, logs = logs, env = env)
}

# -----------------------------------------------------------------------------
# dynamic_test(condition, success, failure)
#  - Создаёт ОДИН тест с «динамическим» названием.
#  - Если condition=TRUE → тест называется success.
#  - Если condition=FALSE → тест называется failure, и тест проваливается.
#  - Используем настоящую expectation (expect_true(TRUE)), чтобы репортёры всегда
#    печатали имя успеха (TAP, progress и т.д.).
# -----------------------------------------------------------------------------
dynamic_test <- function(condition, success, failure) {
  if (isTRUE(condition)) {
    testthat::test_that(success, {
      testthat::expect_true(TRUE)
    })
  } else {
    testthat::test_that(failure, {
      testthat::fail(failure)
    })
  }
}
# =====================================================================

helper-run_user_code.R

Erwerben Sie ein fundiertes Verständnis von R, einer der am weitesten verbreiteten Programmiersprachen für Datenanalyse. Erkunden Sie grundlegende Datentypen und eindimensionale Werte und vertiefen Sie sich anschließend in mehrdimensionale Strukturen wie Matrizen, Data Frames und Listen. Entwickeln Sie die Fähigkeiten, R effektiv in der statistischen Analyse und datenbasierten Entscheidungsfindung einzusetzen.

Erlernen Sie die Grundlagen der R-Syntax, wie Arithmetik, Variablen, Ausgabefunktionen und Kommentare. Vertiefen Sie Ihr Verständnis der rechnerischen Logik durch Übungen.

Erkunden Sie die Datentypen in R und verstehen Sie deren Rolle bei der Datenverarbeitung. Entwicklung von Fähigkeiten im Umgang mit Vektoren als grundlegende Strukturen zur Organisation und Analyse von Informationen.

Entwicklung der Fähigkeit, kategoriale Daten effektiv zu verwalten. Entdecken, wie Rohdaten durch Umwandlung in klare Kategorien strukturiert, gruppiert und interpretiert werden können.

Verstehen, wie strukturierte zweidimensionale Daten dargestellt und bearbeitet werden. Sicherheit beim Transformieren, Beschriften und Anwenden von Operationen auf Matrizen für analytische Aufgaben gewinnen.

Beherrschen Sie die am weitesten verbreitete Datenstruktur in R für tabellarische Informationen. Lernen Sie, Datensätze zu organisieren, zu transformieren und Erkenntnisse daraus zu gewinnen, um datenbasierte Entscheidungen zu unterstützen.

Erfahren Sie, wie Listen über Vektoren hinausgehen, indem sie Elemente unterschiedlichen Typs und unterschiedlicher Länge speichern. Entwickeln Sie die Fähigkeit, Listen zu erstellen, darauf zuzugreifen und sie zu modifizieren, um komplexe Datenstrukturen zu organisieren.

Stufen in Faktoren

Anzeigen der Levels

Beispiel

Geordnete Faktoren

Beispiel

Benutzerdefinierte Reihenfolge

Beispiel

Lösung