Capítulo 1 Objetos
En el mundo de la programación, un objeto es como un contenedor que guarda información. Esta información puede ser de diferentes tipos: números, texto, datos complejos, e incluso código. Lo importante es que un objeto agrupa todo lo necesario para representar una entidad o concepto.
En R, prácticamente todo es un objeto. Las variables que usaremos para guardar datos, las funciones que usaremos para procesar esos datos, e incluso los propios datos en sí mismos, son objetos.
1.1 ¿Qué son los objetos en R?
Imagina que estás organizando tu mudanza a Estados Unidos. Cada elemento que empacas en una caja (ropa, libros, electrodomésticos) puede ser considerado un objeto. Cada objeto tiene características que lo definen: un nombre, un tipo, un tamaño, un peso, etc.
En R, los objetos también tienen características que los definen. Estas características se llaman atributos. Algunos atributos comunes son:
- Nombre: El nombre que le damos al objeto para poder referirnos a él.
- Tipo: El tipo de dato que contiene el objeto (numérico, carácter, lógico, etc.).
- Clase: La clase del objeto, que define su estructura y comportamiento (vector, lista, data frame, función, etc.).
- Longitud: La cantidad de elementos que contiene el objeto (si es un vector, una lista, etc.).
1.1.1 R como un lenguaje orientado a objetos
R es un lenguaje de programación orientado a objetos. Esto significa que se basa en el concepto de objetos para organizar y procesar la información.
La programación orientada a objetos tiene varias ventajas:
- Modularidad: Los objetos permiten dividir un programa en partes más pequeñas y manejables.
- Reutilización: Los objetos se pueden reutilizar en diferentes partes del programa o en otros programas.
- Encapsulación: Los objetos ocultan los detalles de implementación, lo que facilita su uso y mantenimiento.
1.1.2 El poder de la abstracción
El concepto de objeto nos permite abstraer la complejidad del mundo real. En lugar de pensar en los detalles de cómo se almacenan y procesan los datos en la memoria de la computadora, podemos pensar en términos de objetos que representan entidades del mundo real.
Por ejemplo, en lugar de pensar en una serie de números que representan las temperaturas de diferentes ciudades, podemos pensar en un objeto “temperaturas” que contiene toda esa información.
Esta abstracción facilita la comprensión y el manejo de la información, y nos permite concentrarnos en la lógica del problema que queremos resolver.
1.2 Variables: Los primeros objetos en tu viaje
Antes de empezar a empacar para nuestra mudanza a Estados Unidos, necesitamos saber qué cosas nos llevaremos. Cada objeto que decidamos llevar se representa en R como una variable.
Piensa en las variables como etiquetas que ponemos a cada objeto. Por ejemplo, podríamos usar la variable estado para guardar el nombre del estado al que nos mudaremos, o la variable num_maletas para guardar el número de maletas que llevaremos.
1.2.1 Creando variables en R
En R, no necesitamos declarar una variable antes de usarla. Simplemente le asignamos un valor usando el símbolo <-.
Ejemplo:
# Asignar el valor "California" a la variable "estado"
estado <- "California"
# Asignar el valor 5 a la variable "num_maletas"
num_maletas <- 5Para ver el valor que hemos guardado en una variable, simplemente escribimos su nombre en la consola de RStudio y presionamos Enter.
Ejemplo:
Al ejecutar este código, verás que en la consola aparece el valor "California".
1.2.2 Operaciones con variables
También podemos usar variables para realizar operaciones. Por ejemplo, si queremos calcular el costo total de nuestro viaje en avión, podríamos usar las variables precio_boleto y num_personas.
Ejemplo:
precio_boleto <- 300
num_personas <- 4
costo_total <- precio_boleto * num_personas
costo_total
#> [1] 1200En este ejemplo, primero asignamos valores a las variables precio_boleto y num_personas. Luego, multiplicamos estas variables para calcular el costo_total y mostramos su valor en la consola.
1.2.3 Buenas prácticas para nombrar variables
¡Cuidado con las mayúsculas!
R distingue entre mayúsculas y minúsculas. Si creas una variable llamada estado y luego intentas acceder a ella como Estado, R no la encontrará.
Nombres descriptivos
Es importante usar nombres descriptivos para las variables, que indiquen claramente qué información contienen. En lugar de usar variables como x o y, es mejor usar nombres como precio_boleto o num_maletas.
Reglas para nombrar variables
- Los nombres de las variables pueden contener letras, números y guiones bajos (
_). - No pueden empezar con un número.
- No pueden contener espacios.
- R distingue entre mayúsculas y minúsculas.
1.2.4 Tipos de datos
Las variables en R pueden contener diferentes tipos de datos:
Numéricos: Representan números, como la población de una ciudad o el costo de un boleto de avión.
Caracteres: Representan texto, como el nombre de un estado o una ciudad.
Lógicos: Representan valores de verdad:
TRUE(verdadero) oFALSE(falso). Podríamos usar una variable lógica para indicar si queremos visitar una ciudad o no.
1.3 Tipos de objetos para datos complejos
Las variables que hemos visto hasta ahora son muy útiles para guardar información individual, como el nombre de una ciudad o la cantidad de maletas que llevaremos en nuestra mudanza. Sin embargo, en el mundo real, a menudo necesitamos trabajar con conjuntos de datos más complejos.
Imagina que quieres guardar el nombre de todas las ciudades que piensas visitar en tu viaje a Estados Unidos. ¿Tendrías que crear una variable para cada ciudad? ¡Sería muy tedioso!
Afortunadamente, R nos ofrece otros tipos de objetos que nos permiten organizar y manipular información de maneras más eficientes. Veamos algunos de ellos:
1.3.1 Vectores: organizando información del mismo tipo
Los vectores son como trenes que transportan una serie de objetos del mismo tipo. Pueden ser números, texto o valores lógicos, pero todos los elementos de un vector deben ser del mismo tipo. Por ejemplo, podríamos usar un vector para guardar el nombre de cada estado de Estados Unidos, o un vector para guardar la población de cada estado.
Creando vectores: Para crear un vector, podemos usar la función c() (que significa “combinar”) y listar los elementos que queremos incluir, separados por comas.
# Crear un vector con los nombres de algunos estados
estados <- c("California", "Texas", "Florida", "Nueva York")
# Crear un vector con la población de cada estado (en millones)
poblacion <- c(39.2, 29.0, 21.4, 19.4) Si queremos saber la cantidad de datos que tiene nuestro vector, su longitud, usaremos la función length(). La función class() nos indica la clase del objeto, es decir, qué tipo de datos contiene.
Podemos usar la función names() para asignar nombres a los elementos de un vector. Esto puede ser útil para identificar cada elemento.
Además de c(), existen otras funciones útiles para crear vectores:
seq(): Crea una secuencia de números. Podemos especificar el valor inicial, el valor final y el incremento.rep(): Repite un valor o un vector un número determinado de veces.
Accediendo a los elementos de un vector: Cada elemento de un vector tiene una posición, que se indica con un número entre corchetes. El primer elemento está en la posición 1, el segundo en la posición 2, y así sucesivamente.
# Mostrar el primer elemento del vector "estados"
estados[1] # Output: "California"
# Mostrar el tercer elemento del vector "poblacion"
poblacion[3] # Output: 21.4También podemos acceder a varios elementos a la vez usando el operador :. Por ejemplo, para acceder a los elementos del segundo al cuarto del vector estados:
Operaciones con vectores: Podemos realizar operaciones matemáticas con vectores numéricos. Por ejemplo, si queremos calcular la población total de los cuatro estados, podemos usar el operador + para sumar los elementos del vector poblacion.
poblacion <- c(39.2, 29.0, 21.4, 19.4)
poblacion[1] + poblacion[2] + poblacion[3] + poblacion[4]
#> [1] 109Si queremos realizar la misma operación de forma más concisa, R nos permite sumar todos los elementos de un vector directamente:
R también nos ofrece otras herramientas para realizar operaciones con vectores. Por ejemplo, si queremos calcular la raíz cuadrada de la población de cada estado:
En este caso, la función sqrt() calcula la raíz cuadrada de cada elemento del vector poblacion de forma individual. Esto es posible gracias a que muchas funciones en R están vectorizadas, lo que significa que pueden operar directamente sobre vectores, elemento por elemento. Las funciones vectorizadas son muy eficientes, ya que evitan la necesidad de escribir bucles para procesar cada elemento del vector por separado.
Más adelante exploraremos con mayor profundidad las funciones en R y cómo utilizarlas para realizar análisis de datos más complejos.
Coerción de vectores: A diferencia de otros lenguajes de programación, R intenta interpretar o cambiar un valor cuando encuentra un error. Por ejemplo, si intentamos convertir un vector de caracteres a numérico, R convertirá los elementos que pueda y reemplazará los que no pueda por NA.
ejemplo <- c("3", "b", "6", "a", "puente", "4")
as.numeric(ejemplo)
#> Warning: NAs introduced by coercion
#> [1] 3 NA 6 NA NA 4Ordenamiento de vectores: Podemos ordenar los elementos de un vector usando la función sort().
distritos <- c("Comas", "Lince", "Miraflores", "Lurigancho", "Chorrillos")
sort(distritos)
#> [1] "Chorrillos" "Comas" "Lince" "Lurigancho" "Miraflores"También podemos ordenar un vector usando sus índices con la función order(). De esta forma, obtenemos un vector con las posiciones que ocuparían los elementos del vector original si estuvieran ordenados. Esto puede ser útil cuando queremos ordenar un vector en base a otro vector o cuando queremos preservar el vector original sin modificarlo.
indices <- order(distritos) # Output: 5 1 2 4 3
distritos[indices]
#> [1] "Chorrillos" "Comas" "Lince" "Lurigancho" "Miraflores"NA en vectores: Si un vector contiene valores NA, algunas operaciones pueden devolver NA. Podemos usar la función is.na() para identificar los valores NA y filtrarlos.
1.3.2 Listas: agrupando objetos de diferentes tipos
Las listas son como contenedores que pueden guardar diferentes tipos de objetos. Imagina una caja donde puedes guardar ropa, libros, herramientas, y cualquier otro objeto que necesites. En R, las listas te permiten agrupar información diversa en un solo objeto.
Creando listas: Para crear una lista, usamos la función list() y especificamos los elementos que queremos incluir, separados por comas. Cada elemento puede tener un nombre, que se indica con el símbolo =.
# Crear una lista con información sobre una ciudad
ciudad_info <- list(nombre = "San Francisco",
poblacion = 880000,
costo_vida = 3.8,
clima = "Templado")Accediendo a los elementos de una lista: Para acceder a los elementos de una lista, podemos usar sus nombres o sus posiciones.
1.3.3 Matrices: organizando datos en filas y columnas
Las matrices son como tablas que organizan la información en filas y columnas. Todos los elementos de una matriz deben ser del mismo tipo.
Creando matrices: Para crear una matriz, usamos la función matrix(). Debemos especificar los datos que queremos incluir, el número de filas (nrow) y el número de columnas (ncol).
# Crear una matriz con las distancias entre ciudades (en millas)
distancias_ciudades <- matrix(c(0, 2600, 2100, 950,
2600, 0, 1100, 2700,
2100, 1100, 0, 2100,
950, 2700, 2100, 0),
nrow = 4, ncol = 4)
distancias_ciudades
#> [,1] [,2] [,3] [,4]
#> [1,] 0 2600 2100 950
#> [2,] 2600 0 1100 2700
#> [3,] 2100 1100 0 2100
#> [4,] 950 2700 2100 0Accediendo a los elementos de una matriz: Para acceder a los elementos de una matriz, usamos corchetes y especificamos la fila y la columna del elemento que queremos.
1.3.4 Arrays: matrices multidimensionales
Los arrays son como matrices que tienen más de dos dimensiones. Imagina una matriz que, además de filas y columnas, tiene profundidad. En R, los arrays te permiten organizar datos en estructuras más complejas.
Creando arrays: Para crear un array, usamos la función array().
# Crear un array con las temperaturas máximas y mínimas de
# tres ciudades durante los meses de verano (junio, julio, agosto)
temperaturas <- array(c(25, 28, 30, 22, 25, 28, # Ciudad 1
28, 20, 32, 25, 18, 30, # Ciudad 2
22, 25, 28, 18, 23, 25), # Ciudad 3
dim = c(3, 2, 3)) # 3 ciudades, 2 temperaturas (max/min), 3 meses
temperaturas
#> , , 1
#>
#> [,1] [,2]
#> [1,] 25 22
#> [2,] 28 25
#> [3,] 30 28
#>
#> , , 2
#>
#> [,1] [,2]
#> [1,] 28 25
#> [2,] 20 18
#> [3,] 32 30
#>
#> , , 3
#>
#> [,1] [,2]
#> [1,] 22 18
#> [2,] 25 23
#> [3,] 28 25Accediendo a los elementos de un array: Para acceder a los elementos de un array, usamos corchetes y especificamos la posición del elemento en cada dimensión.
1.3.5 Factores: representando datos categóricos
Los factores son un tipo especial de objeto que se usa para representar datos categóricos, es decir, datos que se pueden clasificar en grupos. Por ejemplo, el tipo de clima (“cálido”, “templado”, “frío”), la región de un país (“norte”, “sur”, “este”, “oeste”), o el tipo de vivienda (“casa”, “apartamento”).
Creando factores: Para crear un factor, usamos la función factor().
# Crear un factor con los tipos de clima de diferentes ciudades
tipos_clima <- factor(c("Templado", "Cálido", "Frío"))Niveles de un factor: Los diferentes valores que puede tomar un factor se llaman niveles. En el ejemplo anterior, los niveles del factor tipos_clima son “Templado”, “Cálido” y “Frío”.
Utilidad de los factores: Los factores son muy útiles para el análisis de datos, ya que permiten agrupar y comparar información de manera eficiente. Por ejemplo, podríamos usar el factor tipos_clima para analizar cómo varía el costo de vida en ciudades con diferentes climas.
1.4 El Universo de los Objetos en R
A lo largo de este capítulo, hemos explorado los diferentes tipos de objetos que habitan el universo de R. Desde las variables más simples hasta los arrays multidimensionales, cada objeto tiene un papel importante en la construcción de nuestros análisis de datos.
1.4.1 Filosofía de los objetos en R
En R, todo es un objeto. Esta filosofía tiene profundas implicaciones en la forma en que se escribe y se ejecuta el código. Al tratar todo como un objeto, R promueve la consistencia, la modularidad y la reutilización.
Los objetos nos permiten encapsular la información y el comportamiento, lo que facilita la organización y el mantenimiento del código. Además, la capacidad de crear nuestros propios objetos nos da un gran poder para modelar y resolver problemas complejos.
Al comprender la filosofía de los objetos en R, podemos aprovechar al máximo las capacidades del lenguaje para el análisis de datos.
1.4.2 Comparación con otros lenguajes
Si bien muchos lenguajes de programación modernos utilizan el paradigma de la orientación a objetos, R tiene un enfoque particular. En lenguajes como Python o Java, la creación de clases y objetos es una parte fundamental del lenguaje. En R, si bien es posible crear clases y objetos, el lenguaje se centra más en el uso de funciones para manipular y transformar datos.
Esta diferencia se debe en parte a la historia de R como un lenguaje para el análisis estadístico. En este contexto, las funciones son una herramienta natural para realizar cálculos y análisis.
1.5 Ejercicios
Ahora que ya conoces los diferentes tipos de objetos en R, es hora de poner a prueba tus conocimientos.
- Crea las siguientes variables:
nombre_ciudad: Almacena el nombre de la ciudad de Estados Unidos a la que te gustaría mudarte.poblacion: Almacena la población de esa ciudad (puedes buscarla en internet).distancia: Almacena la distancia en kilómetros desde tu ciudad actual hasta la ciudad de Estados Unidos.quiero_vivir_alli: Almacena un valor lógico (TRUEoFALSE) que indique si realmente te gustaría vivir en esa ciudad.
Solución
- Crea un vector llamado
ciudades_cercanasque contenga los nombres de tres ciudades cercanas a la ciudad que elegiste en el ejercicio anterior.
- Crea una lista llamada
mi_listaque contenga los siguientes elementos:
- Tu nombre.
- Tu edad.
- Un vector con los nombres de tus tres colores favoritos.
- Un valor lógico que indique si te gusta el chocolate.
Solución
- Crea una matriz llamada
gastos_mensualesque contenga tus gastos mensuales estimados en las siguientes categorías:
| Categoría | Enero | Febrero | Marzo |
|---|---|---|---|
| Vivienda | |||
| Transporte | |||
| Alimentación | |||
| Entretenimiento |
Completa la matriz con valores numéricos.
Solución
- Crea un factor llamado
tipos_climaque contenga los nombres de los diferentes tipos de clima en Estados Unidos (puedes usar “Templado”, “Cálido”, “Frío”, etc.). Asigna etiquetas a los niveles del factor para que sean más descriptivos (por ejemplo, “Clima cálido”, “Clima templado”, etc.).
Solución
- Crea un vector llamado
ciudades_visitarcon los nombres de 5 ciudades que te gustaría visitar en Estados Unidos. Luego, crea otro vector llamadodias_por_ciudadcon la cantidad de días que te gustaría pasar en cada ciudad. Finalmente, crea un tercer vector llamadocosto_diariocon el costo estimado por día en cada ciudad (en dólares).
Solución
- Crea un vector llamado
temperaturas_maximascon las temperaturas máximas promedio (en grados Celsius) de las ciudades que quieres visitar durante el mes de julio. Luego, crea un vector llamadotemperaturas_minimascon las temperaturas mínimas promedio. Finalmente, crea una matriz que contenga estos dos vectores como columnas, y nombra las filas con los nombres de las ciudades.
Solución
temperaturas_maximas <- c(29, 28, 27, 22, 31) # Temperaturas máximas en julio
temperaturas_minimas <- c(21, 18, 19, 15, 25) # Temperaturas mínimas en julio
# Crear la matriz
temperaturas <- matrix(c(temperaturas_maximas, temperaturas_minimas), nrow = 5, ncol = 2,
dimnames = list(ciudades_visitar, c("Máxima", "Mínima")))
temperaturas
#> Máxima Mínima
#> Nueva York 29 21
#> Los Ángeles 28 18
#> Chicago 27 19
#> San Francisco 22 15
#> Miami 31 25- Crea un array tridimensional que contenga información sobre el clima de las ciudades que quieres visitar. La primera dimensión debe representar las ciudades, la segunda dimensión debe representar los meses del año (“Enero”, “Febrero”, …, “Diciembre”), y la tercera dimensión debe representar dos variables: “Temperatura” y “Precipitación”. Puedes usar valores ficticios para llenar el array.
Solución
# Crear un array con dimensiones 5 ciudades x 12 meses x 2 variables
clima <- array(dim = c(5, 12, 2),
dimnames = list(ciudades_visitar,
month.name,
c("Temperatura", "Precipitación")))
# Llenar el array con valores ficticios (ejemplo)
clima[,, "Temperatura"] <- sample(10:35, 60, replace = TRUE) # Temperaturas entre 10 y 35 grados
clima[,, "Precipitación"] <- sample(0:100, 60, replace = TRUE) # Precipitación entre 0 y 100 mm
clima
#> , , Temperatura
#>
#> January February March April May June July August September
#> Nueva York 26 10 33 19 19 14 15 17 14
#> Los Ángeles 19 32 34 27 21 30 31 10 21
#> Chicago 14 18 34 15 21 15 28 21 34
#> San Francisco 14 27 15 18 22 20 17 24 21
#> Miami 25 11 32 33 20 24 20 28 17
#> October November December
#> Nueva York 19 24 13
#> Los Ángeles 20 26 28
#> Chicago 17 13 35
#> San Francisco 16 25 20
#> Miami 27 31 32
#>
#> , , Precipitación
#>
#> January February March April May June July August September
#> Nueva York 50 26 6 44 36 35 85 81 41
#> Los Ángeles 68 4 2 51 100 59 14 56 18
#> Chicago 55 96 63 18 87 35 91 89 15
#> San Francisco 22 29 30 50 53 67 61 59 83
#> Miami 77 11 31 16 53 43 6 54 46
#> October November December
#> Nueva York 97 68 96
#> Los Ángeles 46 45 5
#> Chicago 97 28 75
#> San Francisco 46 5 30
#> Miami 74 25 12- Imagina que tienes un vector con las temperaturas máximas de cada día de un año en una ciudad de Estados Unidos. Crea un programa que, utilizando únicamente los conceptos aprendidos en este capítulo (variables, vectores, matrices, arrays y factores), identifique la racha más larga de días consecutivos con temperaturas máximas por encima de un valor umbral dado (por ejemplo, 25 grados Celsius).
Solución
Este ejercicio requiere un manejo eficiente de vectores y una lógica algorítmica para identificar la racha más larga. Aquí te presento una posible solución:
# Crear un vector con temperaturas máximas ficticias para un año
temperaturas <- sample(10:35, 365, replace = TRUE)
# Definir el umbral de temperatura
umbral <- 25
# Crear un vector lógico que indique si la temperatura supera el umbral
dias_calurosos <- temperaturas > umbral
# Inicializar variables para rastrear la racha más larga
racha_actual <- 0
racha_mas_larga <- 0
inicio_racha_mas_larga <- 0
# Recorrer el vector de días calurosos
for (i in 1:length(dias_calurosos)) {
if (dias_calurosos[i]) {
racha_actual <- racha_actual + 1
} else {
if (racha_actual > racha_mas_larga) {
racha_mas_larga <- racha_actual
inicio_racha_mas_larga <- i - racha_actual
}
racha_actual <- 0
}
}
# Mostrar la racha más larga y su posición
cat("La racha más larga de días calurosos es:", racha_mas_larga, "\n")
#> La racha más larga de días calurosos es: 5
cat("Comienza en el día:", inicio_racha_mas_larga, "\n")
#> Comienza en el día: 199Este código utiliza un bucle for para recorrer el vector de días calurosos y dos variables (racha_actual y racha_mas_larga) para rastrear la racha más larga.
- Imagina que tienes un vector con los precios diarios de las acciones de una empresa durante un año. Crea un programa que, utilizando únicamente los conceptos aprendidos en este capítulo, determine el período de tiempo en el que podrías haber comprado y vendido las acciones para obtener la máxima ganancia. Asume que solo puedes comprar y vender una vez.
Solución
Este ejercicio es una variante del problema clásico de “maximizar ganancias en la bolsa”. Resolverlo de manera óptima puede ser complejo, pero con los conceptos del capítulo 1, podemos crear un algoritmo que encuentre una solución (aunque no necesariamente la óptima).
# Crear un vector con precios de acciones ficticios para un año
precios <- sample(50:150, 365, replace = TRUE)
# Inicializar variables para rastrear la máxima ganancia
max_ganancia <- 0
dia_compra <- 1
dia_venta <- 1
# Recorrer el vector de precios
for (i in 1:(length(precios) - 1)) {
for (j in (i + 1):length(precios)) {
ganancia <- precios[j] - precios[i]
if (ganancia > max_ganancia) {
max_ganancia <- ganancia
dia_compra <- i
dia_venta <- j
}
}
}
# Mostrar la máxima ganancia y los días de compra y venta
cat("Máxima ganancia:", max_ganancia, "\n")
#> Máxima ganancia: 100
cat("Día de compra:", dia_compra, "\n")
#> Día de compra: 21
cat("Día de venta:", dia_venta, "\n")
#> Día de venta: 196for anidados para comparar todos los posibles pares de días de compra y venta.