Tutorial R: Tipos de datos y variables

Tipos primitivos: numeric, character y logical

En R, los datos son la materia prima con la que trabajamos. Antes de manipular información o realizar análisis, es fundamental comprender los tipos básicos que maneja este lenguaje. Los tipos primitivos son los bloques fundamentales sobre los que se construyen estructuras más complejas.

Tipo numeric

El tipo numeric representa valores numéricos en R. Este tipo incluye tanto números enteros como decimales (también llamados de punto flotante). R maneja automáticamente la precisión necesaria según el valor.

# Ejemplos de valores numéricos
42      # Entero
3.14159  # Decimal
2.5e6    # Notación científica (2500000)

Cuando trabajamos con números en R, no necesitamos especificar si son enteros o decimales, ya que el sistema los trata como numeric por defecto. Sin embargo, podemos verificar el tipo específico:

# Verificando el tipo
typeof(42)      # "double" (R almacena numeric como double internamente)
typeof(3.14159) # "double"

R también permite crear números enteros explícitos añadiendo una L al final:

# Creando un entero explícito
42L      # Entero explícito
typeof(42L)  # "integer"

Tipo character

El tipo character se utiliza para representar texto o cadenas de caracteres. Cualquier secuencia de caracteres encerrada entre comillas simples o dobles se considera de tipo character en R.

# Ejemplos de valores character
"Hola mundo"    # Con comillas dobles
'R es genial'   # Con comillas simples
"42"            # Un número como texto (¡no es numeric!)

Las cadenas de caracteres pueden contener letras, números, símbolos y espacios. Es importante distinguir entre un número como valor numérico y un número como texto:

# Diferencia entre numeric y character
num <- 42       # Valor numérico
texto <- "42"   # Texto que contiene dígitos

# Verificando los tipos
typeof(num)     # "double"
typeof(texto)   # "character"

Para crear cadenas con comillas dentro, podemos alternar entre comillas simples y dobles:

# Incluyendo comillas en una cadena
"Ella dijo 'hola'"    # Usando comillas simples dentro de dobles
'El valor es "42"'    # Usando comillas dobles dentro de simples

Tipo logical

El tipo logical (también conocido como booleano) representa valores de verdad: verdadero o falso. En R, estos valores se expresan como TRUE y FALSE.

# Ejemplos de valores logical
TRUE      # Verdadero
FALSE     # Falso

Los valores lógicos son fundamentales para realizar comparaciones y condiciones en R:

# Ejemplos de expresiones que generan valores logical
5 > 3     # TRUE (5 es mayor que 3)
10 == 10  # TRUE (10 es igual a 10)
7 < 2     # FALSE (7 no es menor que 2)

R también permite usar las abreviaturas T y F para representar TRUE y FALSE, pero no es recomendable ya que estas abreviaturas pueden ser sobrescritas:

# Abreviaturas (no recomendadas para código profesional)
T    # Equivalente a TRUE
F    # Equivalente a FALSE

Valor especial NA

Además de los tres tipos primitivos mencionados, R incluye un valor especial llamado NA (Not Available) que representa datos ausentes o desconocidos:

# Ejemplo de valor ausente
edad <- NA    # Valor desconocido

El valor NA es compatible con todos los tipos primitivos y mantiene su tipo:

# NA con diferentes tipos
NA_character_  # NA de tipo character
NA_integer_    # NA de tipo integer
NA_real_       # NA de tipo numeric (double)
NA_logical_    # NA de tipo logical

Otros valores especiales

R también incluye otros valores especiales para casos particulares:

# Valores especiales numéricos
Inf    # Infinito positivo
-Inf   # Infinito negativo
NaN    # Not a Number (resultado de operaciones indefinidas)

Estos valores especiales son útiles en cálculos matemáticos y manejo de errores:

# Ejemplos de generación de valores especiales
5/0      # Inf
-10/0    # -Inf
0/0      # NaN

Los tipos primitivos en R son la base para construir estructuras de datos más complejas y realizar operaciones. Dominar estos tipos fundamentales es esencial para avanzar en el aprendizaje del lenguaje y desarrollar análisis de datos efectivos.

Asignación de variables con <- y =

En R, las variables funcionan como contenedores que almacenan datos para su uso posterior. Para crear una variable, necesitamos asignarle un valor, y R nos ofrece dos operadores principales para realizar esta tarea: el operador flecha (<-) y el signo igual (=).

El operador flecha (<-)

El operador flecha es la forma tradicional y más recomendada para realizar asignaciones en R:

# Asignación con el operador flecha
edad <- 25
nombre <- "Ana"
es_estudiante <- TRUE

La flecha indica claramente la dirección de la asignación: el valor de la derecha se asigna a la variable de la izquierda. Esta sintaxis es característica de R y forma parte de su identidad como lenguaje.

También es posible usar la flecha en dirección opuesta, aunque es menos común:

# Asignación con flecha invertida
42 -> resultado

El signo igual (=)

R también permite usar el signo igual para asignar valores a variables:

# Asignación con el signo igual
peso = 68.5
apellido = "García"
tiene_mascota = FALSE

Aunque funciona de manera similar al operador flecha, existen algunas diferencias importantes en su comportamiento.

Diferencias entre <- y =

La principal diferencia entre ambos operadores se relaciona con su ámbito de uso y precedencia:

1. Ámbito global vs. local: El operador <- funciona en cualquier contexto, mientras que = tiene limitaciones en ciertos contextos, especialmente dentro de funciones.

# Ejemplo de diferencia de ámbito
# Ambos funcionan en el ámbito global
x <- 10
y = 20

# Dentro de funciones o expresiones, <- es más consistente
mean(x = 1:10)    # 'x' es un argumento de la función, no una variable
mean(x <- 1:10)   # Asigna 1:10 a 'x' y luego calcula la media

2. Precedencia: El operador <- tiene una precedencia diferente a = en las expresiones.

# Diferencia de precedencia
x <- y <- 5    # Asigna 5 a 'y' y luego asigna 'y' a 'x'
x = y = 5      # Puede generar error en algunos contextos

3. Legibilidad en el código: La flecha <- hace más visual la dirección de la asignación, lo que mejora la legibilidad.

# La flecha muestra claramente la dirección de asignación
resultado_final <- calcular_promedio(datos)

Convenciones y buenas prácticas

En la comunidad de R, existen ciertas convenciones sobre el uso de estos operadores:

• El operador <- es preferido para asignaciones generales de variables.
• El signo = se usa principalmente para especificar argumentos en funciones.

# Convención recomendada
# <- para asignaciones de variables
promedio <- 8.7

# = para argumentos de funciones
resultado <- mean(x = 1:10, trim = 0.1)

Asignación en la consola interactiva

Cuando trabajamos en la consola interactiva de R, podemos usar el atajo de teclado Alt + - (en Windows/Linux) o Option + - (en Mac) para insertar el operador <- rápidamente:

# En la consola, Alt+- (Windows/Linux) o Option+- (Mac) produce:
edad <- 30

Este atajo facilita seguir la convención recomendada sin tener que escribir los dos caracteres por separado.

Asignación múltiple

R permite realizar asignaciones múltiples en una sola línea, lo que resulta útil para inicializar varias variables:

# Asignación múltiple con el mismo valor
x <- y <- z <- 0

# Asignación de múltiples variables en una línea (menos recomendado)
nombre <- "Carlos"; edad <- 28; altura <- 175

Nombres de variables

Al asignar variables, debemos seguir ciertas reglas para los nombres:

• Pueden contener letras, números, puntos (.) y guiones bajos (_)
• Deben comenzar con una letra o un punto seguido de una letra
• Son sensibles a mayúsculas y minúsculas

# Ejemplos de nombres válidos
valor <- 42
mi_variable <- "texto"
Edad.Usuario <- 25

# Estos nombres se refieren a variables diferentes
edad <- 30
Edad <- 40
EDAD <- 50

Es recomendable usar nombres descriptivos que indiquen claramente el propósito de la variable, facilitando así la lectura y mantenimiento del código:

# Nombres descriptivos
temperatura_maxima <- 32.5
nombre_completo <- "María López"
es_mayor_de_edad <- TRUE

La elección entre <- y = para asignaciones puede parecer una cuestión de preferencia personal, pero seguir las convenciones establecidas en la comunidad de R mejorará la consistencia y legibilidad de tu código, especialmente cuando colabores con otros programadores.

Verificación y conversión de tipos

Cuando trabajamos con datos en R, es fundamental saber qué tipo tiene cada variable y, en ocasiones, necesitaremos transformar datos de un tipo a otro. R proporciona funciones específicas tanto para verificar como para convertir tipos de datos.

Verificación de tipos

Para determinar el tipo de una variable, R ofrece varias funciones que nos permiten inspeccionar sus características:

# Creamos algunas variables de ejemplo
numero <- 42
texto <- "Hola"
logico <- TRUE

La función más básica para verificar tipos es typeof(), que nos devuelve el tipo interno que R usa para almacenar el valor:

typeof(numero)   # "double"
typeof(texto)    # "character"
typeof(logico)   # "logical"

R también proporciona funciones específicas que devuelven TRUE o FALSE según el tipo del valor:

# Verificación de tipos específicos
is.numeric(numero)    # TRUE
is.character(texto)   # TRUE
is.logical(logico)    # TRUE

# Comprobaciones cruzadas
is.numeric(texto)     # FALSE
is.character(numero)  # FALSE

Estas funciones son particularmente útiles en condicionales o para validar datos antes de realizar operaciones:

# Ejemplo de uso en validación
valor <- "42"
if (is.numeric(valor)) {
  resultado <- valor * 2
} else {
  print("El valor no es numérico")
}

Para obtener información más detallada sobre una variable, podemos usar la función str() (estructura):

str(numero)   # num 42
str(texto)    # chr "Hola"
str(logico)   # logi TRUE

Conversión de tipos

En muchas situaciones, necesitaremos convertir datos de un tipo a otro. R proporciona un conjunto de funciones que comienzan con as. para realizar estas conversiones:

# Conversión de character a numeric
texto_numero <- "42"
numero_convertido <- as.numeric(texto_numero)
typeof(numero_convertido)   # "double"

Las conversiones más comunes incluyen:

• De texto a número:

# Conversión de texto a número
as.numeric("3.14")      # 3.14
as.integer("42")        # 42

# Texto no numérico genera NA con advertencia
as.numeric("abc")       # NA con warning

• De número a texto:

# Conversión de número a texto
as.character(42)        # "42"
as.character(3.14159)   # "3.14159"

• Entre tipos numéricos:

# Entre tipos numéricos
decimal <- 3.7
entero <- as.integer(decimal)  # 3 (trunca, no redondea)

• A y desde valores lógicos:

# Conversión a lógico
as.logical(1)           # TRUE
as.logical(0)           # FALSE
as.logical("TRUE")      # TRUE
as.logical("false")     # FALSE

# Conversión desde lógico
as.numeric(TRUE)        # 1
as.numeric(FALSE)       # 0
as.character(TRUE)      # "TRUE"

Comportamiento de las conversiones

Es importante entender cómo se comportan las conversiones en diferentes situaciones:

• Truncamiento: Al convertir de decimal a entero, R trunca el valor (elimina la parte decimal) en lugar de redondearlo:

as.integer(4.9)   # 4, no 5
as.integer(-3.7)  # -3, no -4

• Valores NA: Cuando una conversión no es posible, R genera un valor NA y normalmente muestra una advertencia:

as.numeric("R")    # NA con advertencia
as.integer(TRUE)   # 1 (TRUE se convierte a 1)
as.integer("3.14") # 3 (se trunca después de convertir)

• Vectores: Las conversiones funcionan elemento por elemento en vectores:

# Conversión de vector
numeros_texto <- c("1", "2", "3", "4")
numeros <- as.numeric(numeros_texto)  # c(1, 2, 3, 4)

Verificación de valores especiales

R también proporciona funciones para verificar valores especiales:

# Verificación de valores NA
x <- NA
is.na(x)           # TRUE

# Verificación de valores infinitos
y <- 1/0
is.infinite(y)     # TRUE

# Verificación de NaN (Not a Number)
z <- 0/0
is.nan(z)          # TRUE

Coerción automática

R realiza coerción automática de tipos en ciertas operaciones. Esto significa que R intentará convertir valores a un tipo común cuando sea necesario:

# Coerción en operaciones aritméticas
resultado <- 5 + TRUE    # TRUE se convierte a 1, resultado es 6

En operaciones con vectores, R convierte todos los elementos al tipo más general:

# Coerción en vectores
mixto <- c(1, 2, "3")    # Todo se convierte a character: c("1", "2", "3")

La jerarquía de coerción es: logical → integer → numeric → character

Aplicaciones prácticas

La verificación y conversión de tipos son fundamentales en el análisis de datos:

• Limpieza de datos: Convertir columnas al tipo adecuado después de importar datos:

# Después de importar datos
datos$edad <- as.numeric(datos$edad)
datos$activo <- as.logical(datos$activo)

• Validación de entrada: Verificar que los datos son del tipo esperado:

entrada <- readline("Introduce tu edad: ")
if (is.na(as.numeric(entrada))) {
  print("Por favor, introduce un número válido")
} else {
  edad <- as.numeric(entrada)
  print(paste("Tu edad es:", edad))
}

• Transformación de datos: Convertir entre tipos para realizar operaciones específicas:

# Convertir códigos numéricos a factores para análisis
codigos <- c(1, 2, 3, 1, 2, 1)
categorias <- as.factor(codigos)

Dominar la verificación y conversión de tipos te permitirá manipular datos con mayor precisión y evitar errores comunes en tus análisis y programas en R.