Creación y Manipulación de data.frames en R

En esta lección aprenderás todo lo necesario para trabajar con data.frames en R: cómo crearlos, explorarlos, modificarlos y acceder a su contenido con precisión. A través de ejemplos claros y explicaciones directas, dominarás la estructura de datos más usada en análisis estadístico y te prepararás para dar el siguiente paso en el manejo profesional de datos.

Objetivos de Aprendizaje
Al finalizar esta clase, el estudiante será capaz de:

• Identificar la estructura interna de un data.frame y sus componentes básicos.
• Distinguir las diferencias clave entre data.frame, list, matrix y tibble.
• Crear data.frames manualmente o a partir de otras estructuras de datos.
• Acceder a los elementos de un data.frame mediante diferentes operadores y técnicas.
• Modificar un data.frame agregando, eliminando o transformando columnas y filas.
• Aplicar transformaciones elementales sobre columnas para preparar los datos para análisis posteriores.

ÍNDICE DE CONTENIDOS:
Introducción a los data.frames
Acceso a elementos dentro de un data.frame
Modificación de data.frames
Ejercicios propuestos: Acceso y modificación de data.frames

Introducción a los data.frames

¿Qué es un data.frame?

Un data.frame es una de las estructuras de datos más fundamentales y versátiles del lenguaje R. Representa una tabla bidimensional compuesta por filas y columnas, donde:

• Cada columna representa una variable o característica.
• Cada fila representa una observación o caso individual.

A diferencia de una matrix (que solo admite un tipo de dato), un data.frame permite que cada columna contenga tipos distintos, como numeric, character o logical. Esta flexibilidad lo convierte en el formato ideal para almacenar y manipular datos observacionales, como los que provienen de encuestas, experimentos o registros administrativos.

Visualmente, puedes imaginar un data.frame como una hoja de cálculo o una tabla de Excel, con nombres de columnas en la parte superior y los datos organizados en filas. Por ejemplo:

Esta tabla puede crearse fácilmente en R con el siguiente código:

nombre <- c("Ana", "Luis", "Marta")
edad <- c(23, 31, 29)
aprobado <- c(TRUE, TRUE, FALSE)
df <- data.frame(nombre, edad, aprobado)
print(df)

Dominar el uso de los data.frames es esencial para cualquier análisis de datos en R. Muchas funciones estadísticas, gráficas y de transformación de datos asumen que los datos están organizados bajo esta estructura. En este artículo aprenderás cómo crearlos, acceder a su contenido, modificarlos y transformarlos de manera eficiente.

Estructura básica de un data.frame

Un data.frame en R no solo se comporta como una tabla visual de datos, sino que también posee una estructura interna bien definida que lo hace especialmente útil para el análisis de datos.

Desde el punto de vista técnico, un data.frame es una lista especial de vectores que cumple las siguientes condiciones:

• Todos los vectores (columnas) deben tener la misma longitud.
• Cada columna puede tener un tipo de dato distinto (numeric, character, logical, etc.).
• El objeto tiene atributos que le permiten comportarse como tabla: nombres de filas, nombres de columnas y la clase "data.frame".

Para examinar esta estructura, puedes usar funciones como str(), attributes() y class(). Veamos un ejemplo práctico:

nombre <- c("Ana", "Luis", "Marta")
edad <- c(23, 31, 29)
aprobado <- c(TRUE, TRUE, FALSE)
df <- data.frame(nombre, edad, aprobado)
# Explorando la estructura del data.frame
str(df)
attributes(df)
class(df)

Estas funciones nos entregan información importante:

• str(df) muestra la estructura interna y los tipos de dato por columna.
• attributes(df) devuelve una lista con atributos del objeto: nombres, dimensiones y clase.
• class(df) confirma que el objeto pertenece a la clase "data.frame".

Recuerda que al ser una lista, puedes acceder a las columnas del data.frame usando el mismo sistema que para listas en R, aunque con comportamientos ligeramente distintos que exploraremos más adelante.

Comparación con listas y matrices

Para entender mejor qué hace especial a un data.frame, es útil compararlo con otras dos estructuras fundamentales de R: las listas y las matrices. El data.frame toma características de ambas, pero con un comportamiento único que lo hace especialmente poderoso para organizar y manipular datos tabulares.

Similitud con listas

Un data.frame es, técnicamente, una lista de vectores, donde cada elemento de la lista representa una columna. Por ello, hereda de las listas la capacidad de contener diferentes tipos de datos en cada componente.

• Cada columna (vector) puede tener un tipo diferente: numérico, lógico, texto, etc.
• Las columnas son accesibles por nombre, como en una lista (df[["edad"]]).

Ejemplo:

lista <- list(nombre = c("Ana", "Luis", "Marta"),
edad = c(23, 31, 29),
aprobado = c(TRUE, TRUE, FALSE))

# Convertir la lista a data.frame
df <- as.data.frame(lista)
print(df)

Similitud con matrices

Al igual que una matriz, un data.frame tiene una estructura bidimensional (filas y columnas) y permite la indexación por posición mediante corchetes dobles [i, j].

• Se puede acceder a elementos por fila y columna, como en una matriz.
• Tiene dimensiones accesibles con dim(), nrow() y ncol().

Ejemplo:

# Acceso como matriz
df[2, 1]     # Segunda fila, primera columna
df[, "edad"] # Toda la columna 'edad'

¿Por qué usar data.frame?

El data.frame combina lo mejor de ambos mundos:

• Como las listas, permite heterogeneidad en los tipos de dato por columna.
• Como las matrices, tiene una forma tabular e indexación bidimensional.
• Incluye nombres para filas y columnas, facilitando operaciones intuitivas y legibles.

Creación de data.frames

Creación manual con data.frame()

La forma más directa y controlada de crear un data.frame en R es utilizando la función base data.frame(). Esta función permite combinar múltiples vectores (columnas) de igual longitud en una estructura tabular. Cada vector se convierte en una columna, y sus elementos se disponen en las filas correspondientes.

Ejemplo básico

Supongamos que queremos almacenar información de cinco estudiantes, incluyendo su identificación, nombre, edad y si obtuvieron calificación destacada. Lo podemos hacer así:

# Vectores de igual longitud
id        <- 1:5
nombre    <- c("Ana", "Ben", "Carla", "Diego", "Eva")
edad      <- c(23, 31, 27, 29, 22)
calif_exc <- c(TRUE, FALSE, TRUE, TRUE, FALSE)
# Construcción del data.frame
alumnos <- data.frame(id, nombre, edad, calif_exc)
# Visualización
print(alumnos)

Verificando la estructura

Algunas funciones útiles para explorar el data.frame recién creado son:

dim(alumnos)     # Dimensiones: número de filas y columnas
str(alumnos)     # Estructura interna
summary(alumnos) # Estadísticas básicas por columna

Control de comportamiento por defecto

En versiones antiguas de R (anteriores a la 4.0.0), la función data.frame() convertía automáticamente columnas de texto (character) en factores (factor). Esto podía ser útil para variables categóricas, pero causaba problemas al realizar manipulaciones de texto. En versiones modernas, este comportamiento ya no es predeterminado, pero aún puede controlarse explícitamente con el argumento stringsAsFactors:

# Versión segura para cualquier R
alumnos <- data.frame(id, nombre, edad, calif_exc,
                      stringsAsFactors = FALSE)

Personalización adicional: nombres de filas y columnas no sintácticos

La función data.frame() permite controlar aspectos avanzados de la tabla como:

• row.names: establecer etiquetas personalizadas para las filas.
• check.names = FALSE: permitir nombres de columnas con espacios o símbolos especiales (por ejemplo, "Precio $" o "Ventas 2025").

Ejemplo:

ventas_diarias <- data.frame(
  "Fecha venta" = as.Date("2025-05-01") + 0:2,
  "Unidades vendidas" = c(10L, 7L, 12L),
  "Precio $" = c(15.5, 15.5, 17.0),
  row.names = paste0("ID", 101:103),
  check.names = FALSE,
  stringsAsFactors = FALSE
)
print(ventas_diarias)

Este ejemplo ilustra cómo construir un data.frame con columnas cuyos nombres incluyen espacios y símbolos, conservando etiquetas personalizadas para las filas:

Resumen

La función data.frame() es una herramienta nativa y flexible para construir tablas de datos. Aunque tiene algunas limitaciones heredadas por compatibilidad histórica, ofrece múltiples argumentos para personalizar la estructura y comportamiento del objeto creado.

• ✅ Ventaja: Versátil, sencilla, nativa de R y sin necesidad de paquetes externos.
• ⚠️ Cuidado: Asegúrate de controlar el argumento stringsAsFactors y evita nombres de columna conflictivos si no activas check.names = FALSE.

Conversión desde otras estructuras (matrix, list)

En muchos casos, los datos ya existen en otras estructuras de R, como matrix o list. Afortunadamente, R permite convertir estos objetos fácilmente a data.frames, manteniendo sus contenidos y adaptándolos a una forma tabular.

Este tipo de conversión es especialmente útil cuando los datos han sido generados programáticamente, provienen de funciones intermedias o se han importado de fuentes externas (como archivos de texto o paquetes).

Desde una matrix

Una matrix es una estructura bidimensional homogénea, es decir, todos sus elementos deben ser del mismo tipo de dato (por ejemplo, todos numeric o todos character). Al convertir una matrix en un data.frame, R transforma cada columna de la matriz en una columna del nuevo data.frame.

Ejemplo: matriz de distancias

Imaginemos que tienes una matriz con las distancias entre tres ciudades:

# Crear matriz 3x3 con distancias entre ciudades
distancias <- matrix(c(0,  5,  8,
                       5,  0, 12,
                       8, 12, 0),
                     nrow = 3, byrow = TRUE)
# Nombrar filas y columnas
colnames(distancias) <- c("A", "B", "C")
rownames(distancias) <- c("A", "B", "C")
# Convertir a data.frame
df_dist <- as.data.frame(distancias)
# Visualizar
print(df_dist)

Observa que:

• Las columnas y filas heredan los nombres asignados en la matriz original.
• Las distancias se preservan y se organizan por ciudad origen y ciudad destino.
• El índice de fila se convierte automáticamente en el atributo row.names del data.frame.

Advertencia

Desde una list

Una list en R es una estructura unidimensional que puede contener objetos de cualquier tipo, incluyendo vectores, matrices, funciones o incluso otras listas. Es la estructura más flexible del lenguaje.

Cuando los elementos de una lista son vectores del mismo largo, y cada elemento representa una variable distinta, se puede convertir directamente a data.frame. Cada componente se convertirá en una columna del nuevo objeto tabular.

Ejemplo: datos de ciudades

# Crear una lista con vectores del mismo largo
datos_lista <- list(
  ciudad = c("SCL", "LIM", "BOG"),
  temp_media = c(14.5, 19.1, 17.8),
  coste_vida = c(90, 75, 70)
)
# Convertir a data.frame
ciudades <- as.data.frame(datos_lista)
# Examinar estructura
str(ciudades)

El resultado es el siguiente data.frame:

Ventajas de esta conversión:

• El data.frame conserva los nombres de cada componente de la lista como nombres de columnas.
• Los tipos de dato se mantienen: numérico, texto, etc.
• La estructura resultante es ideal para análisis estadístico y visualización.

Casos comunes de uso

Este tipo de conversión es útil cuando:

• Estás recolectando datos progresivamente en una lista y luego necesitas organizarlos como tabla.
• Has procesado datos de una API, archivo JSON o lectura en formato estructurado.
• Estás programando funciones que devuelven datos heterogéneos como resultado intermedio.

Uso de tibble::tibble() como alternativa moderna

El paquete tibble, parte del ecosistema tidyverse, ofrece una alternativa moderna y más robusta a los data.frames tradicionales: el tibble.

Aunque conceptualmente son equivalentes, los tibble introducen mejoras significativas en usabilidad, legibilidad y seguridad. Se comportan como data.frames en la mayoría de los contextos, pero corrigen algunas de sus limitaciones heredadas del diseño original de R.

Ventajas clave de los tibble

• Impresión amigable: Solo muestran las primeras filas y columnas que caben en la consola, evitando saturación visual.
• No conversión implícita: Nunca transforman columnas de texto en factores, ni alteran los tipos de datos de forma silenciosa.
• Compatibilidad: Se integran perfectamente con paquetes como dplyr (manipulación) y ggplot2 (visualización).
• Columnas no sintácticas: Permiten nombres de columna con espacios, símbolos o números iniciales sin necesidad de modificar o forzar alias.

# Cargar paquete
library(tibble)
# Crear un tibble
ventas <- tibble(
  fecha = as.Date("2025-01-01") + 0:4,
  producto = c("A", "A", "B", "A", "C"),
  unidades = c(5L, 3L, 4L, 6L, 2L),
  precio_unit = c(12.5, 12.5, 15.0, 12.5, 17.0)
)
# Imprimir tibble
print(ventas)

Resultado en consola (formato tibble)

La salida en consola de un tibble se ve así (respetando el ancho de pantalla):

# A tibble: 5 × 4
  fecha      producto unidades precio_unit
                     
1 2025-01-01 A               5        12.5
2 2025-01-02 A               3        12.5
3 2025-01-03 B               4        15.0
4 2025-01-04 A               6        12.5
5 2025-01-05 C               2        17.0

Diferencias clave entre data.frame y tibble

Ejemplo con nombres complejos

ventas_2025 <- tibble(
  `Fecha de venta` = as.Date("2025-01-01") + 0:2,
  `Precio $` = c(10, 12, 11.5),
  `Unidades vendidas` = c(5, 3, 6)
)
# Acceso usando comillas invertidas
ventas_2025$`Precio $`

Esto funciona sin problemas, y el tibble conserva los nombres sin forzarlos a ser nombres sintácticamente válidos (como haría data.frame()).

¿Cuándo usar tibble?

• Cuando trabajas en un entorno interactivo o proyectos con gran volumen de datos.
• Cuando usas el enfoque del tidyverse para manipular, visualizar y modelar datos.
• Cuando deseas una representación más segura, clara y predecible del comportamiento de tus datos.

Acceso a elementos dentro de un data.frame

Acceso por nombre de columna (df$columna)

Una de las formas más comunes y legibles de acceder a los datos dentro de un data.frame es mediante el operador $. Este operador permite obtener directamente una columna a partir de su nombre, devolviéndola como un vector.

La sintaxis general es:

nombre_data_frame$nombre_columna

Este método es especialmente útil cuando conoces el nombre exacto de la columna que deseas utilizar, y necesitas operar directamente con sus valores.

Ejemplo básico

Supongamos que tienes un data.frame llamado df que contiene información básica de personas:

df <- data.frame(
  ID = 1:3,
  Nombre = c("Ana", "Luis", "María"),
  Edad = c(28, 34, 25)
)

Para acceder a la columna Edad, simplemente escribimos:

# Acceder a la columna Edad
edades <- df$Edad
print(edades)

Salida:

[1] 28 34 25

Este resultado es un vector numérico que puedes usar en cálculos, gráficas o condiciones lógicas.

Ventajas de este método

• ✅ Claridad semántica: el uso de nombres explícitos facilita la lectura del código.
• ✅ Comodidad: especialmente útil en sesiones interactivas o scripts simples.
• ✅ Completado automático: en entornos como RStudio, puedes usar autocompletado al escribir df$.

Limitaciones

• ⚠️ No funciona si el nombre de la columna contiene espacios o símbolos especiales. En esos casos debes usar comillas inversas o [[ ]].
• ⚠️ No es programáticamente flexible si el nombre de la columna se almacena en una variable.

Ejemplo con nombre problemático

Si tienes un nombre de columna como "Precio $", deberás usar comillas invertidas:

df <- data.frame("Precio $" = c(10, 12, 15), check.names = FALSE)
print(df$`Precio $`)

Alternativa con [[ ]] para nombres dinámicos

Cuando el nombre de la columna se guarda en una variable, el operador $ no funciona. Usa [[ ]] en su lugar:

col_name <- "Edad"
df[[col_name]]   # Equivalente a df$Edad

Acceso por índices (df[i, j])

El sistema de indexación [i, j] es una de las formas más flexibles y poderosas para acceder a datos dentro de un data.frame. Esta notación se basa en filas (i) y columnas (j), de manera similar a cómo se accede a los elementos de una matriz.

La sintaxis general es:

df[fila, columna]

Donde:

• fila puede ser un número, un vector de números, un nombre de fila, un vector lógico o NULL.
• columna puede ser un número, un nombre entre comillas, un vector lógico, o NULL.

Ejemplo de uso básico

df <- data.frame(
  ID = 1:3,
  Nombre = c("Ana", "Luis", "María"),
  Edad = c(28, 34, 25)
)
# Acceder al valor en fila 2, columna 3
df[2, 3]
# Acceder a toda la fila 2
df[2, ]
# Acceder a toda la columna 1
df[, 1]

Selección múltiple

También es posible seleccionar subconjuntos:

# Seleccionar filas 1 y 3, columnas 1 y 2
df[c(1, 3), c(1, 2)]

Selección por nombre

# Acceder a la columna 'Edad' usando nombre
df[, "Edad"]
# Acceder a una celda específica por nombre
df["Luis", "Edad"]  # Si row.names están definidos

Filtrado condicional con indexación

# Filtrar filas donde Edad sea mayor a 30
df[df$Edad > 30, ]

Advertencias comunes

• ⚠️ Si omites , y usas df[2], obtendrás un data.frame con una sola columna, no un valor escalar ni vector.
• ⚠️ Si usas drop = TRUE (por defecto), R puede devolver un vector en lugar de un data.frame. Usa drop = FALSE si quieres mantener estructura tabular.

# Mantener estructura de data.frame al seleccionar una sola columna
df[, "Edad", drop = FALSE]

Uso del operador [[ ]] y [ ]

Además de los corchetes dobles [i, j] y el operador $, R ofrece otros dos mecanismos de acceso que tienen comportamientos distintos y muy útiles: [ ] y [[ ]].

Uso de [ ] con una dimensión

Cuando usas un solo índice (por ejemplo, df[1]), el resultado es un data.frame con una sola columna, no un vector. Esto es útil si quieres mantener la estructura tabular, aunque contenga solo una variable.

# Seleccionar la primera columna como data.frame
df[1]
# Seleccionar varias columnas como nuevo data.frame
df[c("ID", "Edad")]

Uso de [[ ]] para extraer vectores

El operador [[ ]] sirve para extraer una única columna de un data.frame como un vector puro. Es útil para cálculos o manipulaciones donde no necesitas mantener la estructura de tabla.

# Extraer columna como vector
edad_vector <- df[["Edad"]]
# Equivalente a df$Edad, pero programáticamente más robusto
col <- "Edad"
df[[col]]

Diferencia clave entre [ ] y [[ ]]

Acceso a elementos individuales

También puedes combinar ambos niveles para acceder directamente a un valor escalar:

# Valor de la segunda fila, columna "Edad"
df[["Edad"]][2]

Recomendaciones prácticas

• ✅ Usa [ ] cuando necesites preservar formato tabular (por ejemplo, para pasar datos a funciones que requieren data.frames).
• ✅ Usa [[ ]] cuando necesites trabajar con vectores directamente (por ejemplo, sumar, filtrar, mapear).

Modificación de data.frames

Renombrar columnas

Una de las tareas más comunes al trabajar con data.frames es renombrar las columnas para que tengan nombres más descriptivos, legibles o compatibles con otros sistemas.

Opción 1: Usar names() o colnames()

Estas funciones permiten acceder y modificar directamente el vector de nombres de las columnas. Puedes asignar un vector nuevo completo, o cambiar nombres individualmente.

# Crear data.frame original
df <- data.frame(A = 1:3, B = letters[1:3])
# Renombrar todas las columnas
names(df) <- c("Numero", "Letra")
# Alternativa equivalente
colnames(df) <- c("Numero", "Letra")
# Renombrar una sola columna por índice
names(df)[1] <- "ID"

Después de la modificación, el data.frame se verá así:

    ID Letra
1    1     a
2    2     b
3    3     c

Opción 2: Usar setNames()

La función setNames() puede usarse para asignar nombres en una sola expresión sin modificar el objeto original directamente.

df <- setNames(df, c("Identificador", "Letra"))

Advertencia

Agregar nuevas columnas o filas

Agregar columnas

Existen dos formas comunes para agregar una nueva columna a un data.frame:

• Usar el operador $ para asignar directamente.
• Usar la función cbind() para combinar por columnas.

Ejemplo: agregar columna con operador $

ventas <- data.frame(producto = c("A", "B"), precio = c(100, 200))
# Agregar nueva columna
ventas$cantidad <- c(5, 10)
# Calcular columna derivada
ventas$total <- ventas$precio * ventas$cantidad

Resultado:

  producto precio cantidad total
1        A    100        5   500
2        B    200       10  2000

Ejemplo: agregar columna con cbind()

ventas <- cbind(ventas, descuento = c(0.1, 0.2))

Ten en cuenta que cbind() puede ser menos seguro si los vectores no tienen la misma longitud o si los nombres no coinciden. En general, se recomienda el uso de $ por claridad y control.

Agregar filas

Para agregar nuevas observaciones (filas), puedes usar la función rbind(). El nuevo objeto debe ser un data.frame con exactamente las mismas columnas (y tipos) que el original.

Ejemplo: agregar una nueva fila

nueva_fila <- data.frame(producto = "C", precio = 150, cantidad = 7, total = 1050)
ventas <- rbind(ventas, nueva_fila)

Resultado:

  producto precio cantidad total
1        A    100        5   500
2        B    200       10  2000
3        C    150        7  1050

Advertencias y buenas prácticas

• ✅ Siempre asegúrate de que las columnas estén en el mismo orden y con los mismos nombres al usar rbind().
• ⚠️ Las diferencias en tipos (por ejemplo, integer vs numeric) pueden causar coerción o errores.
• ✅ Cuando agregues muchas filas de forma iterativa, es más eficiente usar listas y convertirlas al final en un solo data.frame (por rendimiento).

Eliminar columnas o filas

En R, puedes eliminar columnas o filas de un data.frame de manera directa utilizando índices negativos o asignando NULL a una columna específica. Ambos métodos son eficientes y se utilizan en diferentes contextos.

Eliminar columnas

Opción 1: Asignar NULL

Este método es claro y expresivo: al asignar NULL a una columna, la eliminas del data.frame.

ventas <- data.frame(producto = c("A", "B"),
                     precio = c(100, 200),
                     cantidad = c(5, 10),
                     total = c(500, 2000))
# Eliminar la columna 'total'
ventas$total <- NULL

Resultado:

  producto precio cantidad
1        A    100        5
2        B    200       10

Opción 2: Usar índices negativos

Puedes usar el operador de indexación para excluir una o más columnas por su posición o nombre.

# Eliminar la tercera columna
ventas <- ventas[, -3]
# O eliminar por nombre
ventas <- ventas[, !names(ventas) %in% "cantidad"]

Eliminar filas

Eliminar filas sigue la misma lógica, pero se aplica al primer índice (i) del data.frame.

# Eliminar la primera fila
ventas <- ventas[-1, ]

Resultado:

  producto precio
2        B    200

Eliminar múltiples filas o columnas

Puedes eliminar varias filas o columnas pasando un vector de índices negativos:

# Eliminar filas 1 y 3
df <- df[-c(1, 3), ]
# Eliminar columnas 2 y 4
df <- df[, -c(2, 4)]

Advertencias

• ⚠️ No olvides reasignar el resultado: la operación no modifica el objeto original a menos que lo guardes de nuevo.
• ⚠️ Eliminar columnas por índice puede ser peligroso si el orden cambia. Usar nombres suele ser más robusto.

Transformaciones elementales sobre columnas

Una transformación elemental consiste en modificar los valores de una columna existente, o crear nuevas columnas a partir de operaciones matemáticas, lógicas o textuales sobre una o más columnas del data.frame.

Asignación directa

Puedes modificar una columna directamente usando el operador $, o bien añadir nuevas variables a partir de cálculos simples.

# Aplicar IVA del 19%
ventas$precio <- ventas$precio * 1.19

Crear columnas derivadas

Es común derivar columnas que representen transformaciones útiles para el análisis.

ventas$precio_con_descuento <- ventas$precio * 0.90
ventas$importe_final <- ventas$precio_con_descuento * ventas$cantidad

Uso de la función transform()

Para realizar múltiples transformaciones simultáneamente, puedes usar transform(), lo cual mejora la legibilidad:

ventas <- transform(ventas,
                    precio_sin_iva = precio / 1.19,
                    importe_total = precio * cantidad)

Funciones comunes para transformar columnas

• round(), ceiling(), floor(): redondeos.
• paste(), substr(): manipulación de texto.
• as.numeric(), as.character(): conversiones de tipo.
• ifelse(): condiciones lógicas para crear categorías.

Ejemplo con condiciones

# Clasificar productos como "caro" o "barato"
ventas$clasificacion <- ifelse(ventas$precio > 150, "caro", "barato")

Buenas prácticas

• ✅ Utiliza nombres descriptivos para las nuevas columnas.
• ✅ Verifica los tipos de datos antes de aplicar transformaciones.
• ✅ Prefiere transformaciones vectorizadas en lugar de bucles para eficiencia.

Ejercicios propuestos: Acceso y modificación de data.frames

Ejercicio 1: Análisis de notas académicas

Supón que estás trabajando con un conjunto de datos de estudiantes que contiene las columnas: Nombre, Asignatura, Nota1, Nota2 y Nota3.

notas <- data.frame(
  Nombre = c("Ana", "Luis", "María", "Jorge"),
  Asignatura = c("Matemáticas", "Matemáticas", "Física", "Física"),
  Nota1 = c(5.5, 6.2, 4.8, 7.0),
  Nota2 = c(6.0, 5.9, 5.5, 6.5),
  Nota3 = c(5.8, 6.4, 6.1, 6.9)
)

• Accede a todas las notas de María y calcula su promedio individual usando acceso por nombre.
• Crea una nueva columna Promedio con el promedio de las tres notas para cada estudiante.
• Agrega una columna Estado que indique si el estudiante aprobó (promedio ≥ 5.5) o reprobó.
• Filtra el data.frame para mostrar solo los estudiantes que aprobaron Física con promedio superior a 6.0.

Ejercicio 2: Gestión de inventario de productos

Trabajas en una tienda y tienes el siguiente inventario:

inventario <- data.frame(
  Producto = c("A", "B", "C"),
  PrecioUnitario = c(1200, 850, 1500),
  Stock = c(15, 8, 0)
)

• Agrega una columna Disponible que indique TRUE si el stock es mayor que cero.
• Agrega otra columna ValorTotal que calcule el valor monetario total de cada producto en stock.
• Actualiza el precio del producto B aumentando un 10%, usando acceso por nombre.
• Elimina del data.frame todos los productos sin stock.

Ejercicio 3: Construcción de reporte con transformación estructurada

Usando el data.frame del ejercicio anterior (actualizado), realiza lo siguiente:

• Renombra las columnas en español por nombres más técnicos en inglés: Producto → Item, PrecioUnitario → UnitPrice, etc.
• Usa transform() para crear simultáneamente las siguientes columnas:
  • PrecioConIVA: precio con un IVA del 19%
  • ValorBruto: stock multiplicado por el precio sin IVA
• Extrae como vector puro los precios con IVA mediante el operador [[ ]] y calcula su promedio.