0Pricing
R Academy · Lección

Conversión de tipos logical y character

Convierta entre tipos logical, character y numeric con as.logical() y as.character().

Conversión de tipos logical y character es una lección gratuita de R Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.

Conversión entre tipos

R proporciona funciones as.*() para convertir entre todos los tipos básicos. En esta lección se estudian las conversiones entre los tipos logical, character y numeric, las conversiones de ida y vuelta más habituales que encontrará en la limpieza de datos.

# 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

Conversión de numérico a lógico

Al convertir un número a lógico: 0 se convierte en FALSE y cualquier número distinto de cero se convierte en TRUE. Esta regla se aplica tanto a enteros como a doubles.

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

Conversión de lógico a numérico

TRUE se convierte en 1 y FALSE en 0. Esta conversión es fundamental para muchas expresiones habituales de R, como utilizar sum() para contar valores TRUE o mean() para calcular proporciones.

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() a partir de cadenas

as.logical('TRUE') y as.logical('FALSE') convierten representaciones de cadenas. R también acepta 'T' y 'F' como abreviaturas. Cualquier otra cosa (incluido 'true' en minúsculas) devuelve 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!)

Conversión de numérico a carácter

as.character(x) convierte un número en su representación como cadena. Resulta útil para crear etiquetas o identificadores, o cuando necesita insertar números en cadenas.

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, '
')

Conversión de carácter a numérico

as.numeric('3.14') interpreta una cadena y la convierte en un double. Si la cadena no se puede interpretar como un número, R devuelve NA con una advertencia. Valide siempre la entrada antes de realizar conversiones en código de producción.

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)

Conversión de lógico a carácter

as.character(TRUE) produce la cadena 'TRUE'. Esto resulta útil cuando necesita incluir valores lógicos en texto de salida, exportaciones de archivos o concatenaciones de cadenas.

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, '
')

Conversión de ida y vuelta

La mayoría de las conversiones son reversibles (de ida y vuelta), aunque pueden producir cierta pérdida: numeric -> character -> numeric puede perder precisión dependiendo de cómo se formatee el número como cadena.

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, '
')

Conversión de vectores de origen mixto

Cuando aplica as.numeric() a un vector de caracteres, cada elemento se convierte de forma independiente. Los elementos que no se pueden interpretar se convierten en NA. Esta es la forma estándar de limpiar datos con apariencia numérica leídos de archivos 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)), '
')

Conversión lógica en ifelse()

Combinar as.numeric() con ifelse() o multiplicar directamente por un vector lógico es una expresión habitual para asignar puntuaciones condicionales o crear variables derivadas en el análisis de datos.

# 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), '
')

Resumen de conversiones

Aquí tiene un resumen de las conversiones lógicas y de caracteres más importantes:

  • as.logical(0) → FALSE; cualquier valor distinto de cero → TRUE
  • as.logical('TRUE'/'T') → TRUE; distingue entre mayúsculas y minúsculas; otros valores → NA
  • as.numeric(TRUE) → 1; as.numeric(FALSE) → 0
  • as.character(x) → representación de x como cadena
  • as.numeric('3.14') → 3.14; las cadenas no numéricas → NA con una advertencia
# 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)), '
')

Comprobación rápida

¿A qué resultado se evalúa as.numeric(TRUE) + as.numeric(FALSE) en R?

Recapitulación: conversión de lógicos y caracteres

¡Excelente! Estas son las ideas clave de la lección:

  • as.logical(0) → FALSE; un valor distinto de cero → TRUE; 'TRUE'/'T' → TRUE
  • as.numeric(TRUE) → 1; as.numeric(FALSE) → 0
  • as.character(x) convierte cualquier valor a su representación como cadena
  • as.numeric('3.14') interpreta una cadena numérica; las cadenas no válidas → NA
  • as.logical('true') es NA: la coincidencia distingue entre mayúsculas y minúsculas ('TRUE' funciona)
  • Las conversiones son en su mayoría reversibles; utilice suppressWarnings() al convertir columnas con entradas que previsiblemente produzcan NA
# 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), '
')

Preguntas frecuentes

¿La lección «Conversión de tipos logical y character» es gratis?

Sí — el texto completo de «Conversión de tipos logical y character» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Conversión de tipos logical y character»?

Convierta entre tipos logical, character y numeric con as.logical() y as.character(). Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar R Academy?

No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Conversión de tipos logical y character»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de R Academy?

Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Descripción general del sistema de tipos de R
  2. Conversión entre tipos numéricos
  3. Conversión de tipos logical y character
  4. Problemas y buenas prácticas de coerción
← Volver a R Academy