2  Manipulación de objetos

2.1 ¿Qué es la manipulación de objetos?

En el contexto de R, la manipulación de objetos se refiere a la capacidad de crear, modificar y gestionar diferentes tipos de objetos de datos. R es un lenguaje de programación orientado a objetos, lo que significa que los datos se manipulan mediante la creación y manipulación de objetos. Aquí hay algunas nociones clave sobre la manipulación de objetos en R:

  1. Objetos en R: En R, todo es un objeto. Los datos pueden ser almacenados en diferentes tipos de objetos, como vectores, matrices, data frames, listas, entre otros. Cada tipo de objeto tiene sus propias características y métodos asociados.

  2. Creación de Objetos: Puedes crear objetos en R asignando valores a variables.

    # Crear un vector
a <- c(1, 2, 3, 4, 5)

# Crear una matriz
b <- matrix(1:6, nrow = 2, ncol = 3)

# Crear un data frame
c <- data.frame(ID = c(1, 2, 3), Nombre = c("Damian", "Oliver", "Cruz"))

  3. Operaciones con Objetos: Puedes realizar diversas operaciones con objetos en R, como realizar cálculos, manipular estructuras de datos, y realizar análisis estadísticos.

    # Sumar todos los elementos de un vector
suma_vector <- sum(a)

# Acceder a una columna en un data frame
nombres <- c$Nombre

  4. Funciones y Métodos: R tiene muchas funciones y métodos integrados que se pueden utilizar para manipular objetos de datos. Por ejemplo, la función summary() proporciona un resumen estadístico de un conjunto de datos.

    # Resumen estadístico de un data frame
resumen <- summary(c)

  5. Paquetes: R cuenta con una amplia variedad de paquetes que extienden sus capacidades. Algunos paquetes, como dplyr y tidyr, son especialmente útiles para la manipulación de datos, proporcionando funciones específicas para filtrar, ordenar y transformar datos.

La manipulación de objetos en R es esencial para realizar análisis de datos y estadísticas. Puedes personalizar y manipular objetos para adaptarlos a tus necesidades específicas, lo que facilita la exploración y el análisis de datos de manera eficiente.

2.2 Definir y ejemplificar clases, objetos, matrices, arreglos, vectores

2.3 Clases

Una cuestión muy importante que siempre tenemos que tener en cuenta cuando trabajamos con vectores es que en un vector sólo podemos concatenar elementos del mismo tipo. ¿Qué tipos/clases de elementos (o datos) tenemos en R?

  • Carácter

  • Numéricos

  • Enteros

  • Lógicos

  • Complejos

2.3.1 Ejemplos

x <- c(1,2,3,4)    # creamos el vector x
class(x)           # devuelve el tipo de objeto
[1] "numeric"
y <- c("a","b")
class(y)
[1] "character"
z <- c(1L,2L,3L)   # escribimos L detrás del número para obligar a que sea entero
class(z)
[1] "integer"
w <- c(TRUE, F)    # en general, puede escribirse TRUE/FALSE o T/F
class(w)
[1] "logical"
t <- c(1+2i, 1+3i)
class(t)
[1] "complex"

2.4 Objetos

En R existen varios tipos de objectos que permiten que el usuario pueda almacenar la información para realizar procedimientos estadísticos y gráficos. Los principales objetos en R son vectores, matrices, arreglos, marcos de datos y listas.

2.4.1 Ejemplos

# Definir un objeto de tipo vector
e <- c(15, 82, 74, 115, 1)

# Mostrar el vector
print(e)
[1]  15  82  74 115   1
# Definir un objeto de tipo matriz
f <- matrix(5:6, nrow = 3, ncol = 3)
Warning in matrix(5:6, nrow = 3, ncol = 3): la longitud de los datos [2] no es
un submúltiplo o múltiplo del número de filas [3] en la matriz
# Mostrar la matriz
print(f)
     [,1] [,2] [,3]
[1,]    5    6    5
[2,]    6    5    6
[3,]    5    6    5
# Definir un objeto de tipo lista
i <- list(a = 1, b = "texto", c = TRUE)

# Mostrar la lista
print(i)
$a
[1] 1

$b
[1] "texto"

$c
[1] TRUE

2.5 Matrices

En R, los matrices son estructuras de datos bidimensionales que contienen elementos del mismo tipo de datos. Puedes crear matrices utilizando la función matrix().

  1. Crear una matriz

    # Crear una matriz de 3x3 con números del 1 al 9
matriz <- matrix(1:9, nrow = 3, ncol = 3)
print(matriz)
         [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

  2. Acceder a elementos de una matriz

    # Acceder al elemento en la primera fila y segunda columna
elemento <- matriz[1, 2]
print(elemento)
    [1] 4

  3. Operaciones básicas con matrices

    # Sumar dos matrices
matriz1 <- matrix(1:9, nrow = 3, ncol = 3)
matriz2 <- matrix(rep(2, 9), nrow = 3, ncol = 3)
suma <- matriz1 + matriz2
print(suma)
         [,1] [,2] [,3]
[1,]    3    6    9
[2,]    4    7   10
[3,]    5    8   11
    # Multiplicar una matriz por un escalar
escalar <- 2
multiplicacion <- escalar * matriz1
print(multiplicacion)
         [,1] [,2] [,3]
[1,]    2    8   14
[2,]    4   10   16
[3,]    6   12   18
    # Multiplicar dos matrices
matriz3 <- matrix(1:6, nrow = 3, ncol = 3)
    Warning in matrix(1:6, nrow = 3, ncol = 3): data length differs from size of
matrix: [6 != 3 x 3]
    multiplicacion_matrices <- matriz1 * matriz3
print(multiplicacion_matrices)
         [,1] [,2] [,3]
[1,]    1   16    7
[2,]    4   25   16
[3,]    9   36   27

  4. Funciones relacionadas con matrices

    # Calcular la transpuesta de una matriz
transpuesta <- t(matriz1)
print(transpuesta)
         [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6
[3,]    7    8    9
    # Calcular el determinante de una matriz cuadrada
determinante <- det(matriz1)
print(determinante)
    [1] 0

2.5.1 Ejemplos

  1. Crear matrices con diferentes tipos de datos

    # Matriz de caracteres
matriz_caracteres <- matrix(c("a", "b", "c", "d"), nrow = 2, ncol = 2)
print(matriz_caracteres)
         [,1] [,2]
[1,] "a"  "c" 
[2,] "b"  "d" 
    # Matriz lógica
matriz_logica <- matrix(c(TRUE, FALSE, TRUE, TRUE), nrow = 2, ncol = 2)
print(matriz_logica)
          [,1] [,2]
[1,]  TRUE TRUE
[2,] FALSE TRUE

  2. Combinar matrices

    # Combinar dos matrices por filas
matriz_a <- matrix(1:6, nrow = 2)
matriz_b <- matrix(7:12, nrow = 2)
matriz_combinada <- rbind(matriz_a, matriz_b)
print(matriz_combinada)
         [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6
[3,]    7    9   11
[4,]    8   10   12
    # Combinar dos matrices por columnas
matriz_c <- matrix(13:18, nrow = 2)
matriz_combinada_columnas <- cbind(matriz_a, matriz_c)
print(matriz_combinada_columnas)
         [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1    3    5   13   15   17
[2,]    2    4    6   14   16   18

2.6 Arreglos

En R, un arreglo es una estructura multidimensional que puede contener elementos del mismo tipo de datos. Los arreglos pueden tener una, dos o más dimensiones. Puedes crear arreglos utilizando la función array().

  1. Arreglo unidimensional

    # Crear un arreglo unidimensional
arreglo_unidimensional <- array(1:5)
print(arreglo_unidimensional)
    [1] 1 2 3 4 5

  2. Arreglo bidimensional

    # Crear un arreglo bidimensional
arreglo_bidimensional <- array(1:6, dim = c(2, 3))
print(arreglo_bidimensional)
         [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

  3. Arreglo tridimensional

    # Crear un arreglo tridimensional
arreglo_tridimensional <- array(1:24, dim = c(2, 3, 4))
print(arreglo_tridimensional)
    , , 1

     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

, , 2

     [,1] [,2] [,3]
[1,]    7    9   11
[2,]    8   10   12

, , 3

     [,1] [,2] [,3]
[1,]   13   15   17
[2,]   14   16   18

, , 4

     [,1] [,2] [,3]
[1,]   19   21   23
[2,]   20   22   24

  4. Acceder a elementos de un arreglo

    # Acceder a un elemento en un arreglo bidimensional
elemento <- arreglo_bidimensional[1, 2]
print(elemento)
    [1] 3

  5. Funciones relacionadas con arreglos

    # Obtener las dimensiones de un arreglo
dimensiones <- dim(arreglo_tridimensional)
print(dimensiones)
    [1] 2 3 4
    # Crear un arreglo con todos los elementos iguales a un valor
arreglo_iguales <- array(1, dim = c(2, 3))
print(arreglo_iguales)
         [,1] [,2] [,3]
[1,]    1    1    1
[2,]    1    1    1

2.6.1 Ejemplos

  1. Crear un arreglo con valores específicos

    # Crear un arreglo bidimensional con valores específicos
arreglo_v <- array(c(10, 20, 30, 40, 50, 60), dim = c(2, 3))
print(arreglo_v)
         [,1] [,2] [,3]
[1,]   10   30   50
[2,]   20   40   60

  2. Operaciones aritméticas con arreglos

    # Crear dos arreglos bidimensionales
arreglo_a <- array(1:6, dim = c(2, 3))
arreglo_b <- array(7:12, dim = c(2, 3))

# Sumar los arreglos
suma_arreglos <- arreglo_a + arreglo_b
print(suma_arreglos)
         [,1] [,2] [,3]
[1,]    8   12   16
[2,]   10   14   18
    # Multiplicar los arreglos elemento por elemento
producto_arreglos <- arreglo_a * arreglo_b
print(producto_arreglos)
         [,1] [,2] [,3]
[1,]    7   27   55
[2,]   16   40   72

2.7 Vectores

En R, un vector es una estructura de datos básica que contiene elementos del mismo tipo. Los vectores pueden ser de tipo numérico, lógico, de caracteres, entre otros.

  1. Crear un vector

    # Crear un Vector
vector_A <- c(1, 2, 3, 4, 5)
print(vector_A)
    [1] 1 2 3 4 5

  2. Acceder a elementos de un vector

    # Acceder al tercer elemento del vector A
elemento <- vector_A[3]
print(elemento)
    [1] 3

  3. Operaciones con vectores

    # Sumar dos vectores elemento por elemento
vector1 <- c(1, 2, 3)
vector2 <- c(4, 5, 6)
suma <- vector1 + vector2
print(suma)
    [1] 5 7 9
    # Multiplicar un vector por un escalar
escalar <- 2
multiplicacion <- escalar * vector1
print(multiplicacion)
    [1] 2 4 6
    # Calcular la suma, promedio, máximo y mínimo de un vector
suma_total <- sum(vector1)
promedio <- mean(vector1)
maximo <- max(vector1)
minimo <- min(vector1)
print(c(suma_total, promedio, maximo, minimo))
    [1] 6 2 3 1

  4. Funciones relacionadas con vectores

    # Longitud de un vector
longitud <- length(vector1)
print(longitud)
    [1] 3
    # Ordenar un vector
vector_ordenado <- sort(vector1)
print(vector_ordenado)
    [1] 1 2 3

2.7.1 Ejemplos

  • Crear un vector de caracteres

    # Crear un vector de caracteres
vector_caracter <- c("rojo", "azul", "amarillo")
print(vector_caracter)
    [1] "rojo"     "azul"     "amarillo"

  • Crear un vector lógico

    # Crear un vector lógico
vector_logico <- c(TRUE, FALSE, TRUE)
print(vector_logico)
    [1]  TRUE FALSE  TRUE

  • Crear un vector numérico

    # Crear un vector numérico
vector_numérico <- c(1, 10, 100, 1000)
print(vector_numérico)
    [1]    1   10  100 1000

2.8 ¿Qué es indentación?

En R, la indentación se refiere al formato visual del código, específicamente al uso de espacios o tabulaciones al principio de las líneas de código para estructurar y delimitar bloques de código. Aunque la indentación no es estrictamente necesaria en R (como sí lo es en algunos otros lenguajes de programación), es una práctica recomendada para mejorar la legibilidad del código.

La indentación es comúnmente utilizada para visualizar la estructura de bloques de código que están dentro de funciones, bucles, condicionales y otros bloques estructurales. Aquí hay un ejemplo simple:

# Función en R con indentación
mi_funcion <- function(x) {
  y <- x^2
  if (y > 10) {
    print("El resultado es mayor que 10")
  } else {
    print("El resultado es 10 o menor")
  }
  return(y)
}

# Llamada a la función
resultado <- mi_funcion(3)
[1] "El resultado es 10 o menor"

En este ejemplo, la indentación se utiliza para visualizar claramente que el código dentro de la función está formado por dos bloques (if y else). La indentación facilita la comprensión de la estructura del código y ayuda a evitar errores al programar.

Es importante destacar que en R la indentación se realiza mediante espacios y no mediante tabulaciones. Se suele recomendar usar dos espacios para cada nivel de indentación, pero esto puede variar según las preferencias personales o las convenciones de estilo del código que estés siguiendo. La clave es mantener la consistencia en todo el código. Muchos entornos de desarrollo y editores de texto para R también ofrecen funciones automáticas para mantener una indentación coherente.

2.9 Expresiones condicionales

2.9.1 IF.

En R, la expresión condicional if permite tomar decisiones basadas en una condición específica.

2.9.1.1 Ejemplo.

# Ejemplo de estructura if
x <- 6

if (x > 5) {
  print("x es mayor que 5")
}
[1] "x es mayor que 5"

2.9.2 IF-ELSE.

La expresión condicional if-else en R permite tomar decisiones entre dos opciones alternativas basadas en una condición.

2.9.2.1 Ejemplo.

# Ejemplo de estructura if-else
edad<-18
if (edad >= 18) {
  mensaje <- "Eres mayor de edad."
} else {
  mensaje <- "Eres menor de edad."
}
print(mensaje)
[1] "Eres mayor de edad."

2.9.3 ELIF.

La expresión condicional if-else if (elif) en R te permite evaluar múltiples condiciones de manera secuencial hasta que una de ellas es verdadera.

2.9.3.1 Ejemplo.

# Función para clasificar a los estudiantes
clasificar_estudiante <- function(calificacion) {
  if (calificacion >= 90) {
    mensaje <- "Excelente"
  } else if (calificacion >= 80) {
    mensaje <- "Bueno"
  } else if (calificacion >= 70) {
    mensaje <- "Aprobado"
  } else {
    mensaje <- "Reprobado"
  }
  
  return(mensaje)
}

# Ejemplos de uso
calificacion_estudiante1 <- 95
calificacion_estudiante2 <- 82
calificacion_estudiante3 <- 68

mensaje_estudiante1 <- clasificar_estudiante(calificacion_estudiante1)
mensaje_estudiante2 <- clasificar_estudiante(calificacion_estudiante2)
mensaje_estudiante3 <- clasificar_estudiante(calificacion_estudiante3)

# Mostrar los resultados
cat("Estudiante 1:", mensaje_estudiante1, "\n")
Estudiante 1: Excelente 
cat("Estudiante 2:", mensaje_estudiante2, "\n")
Estudiante 2: Bueno 
cat("Estudiante 3:", mensaje_estudiante3, "\n")
Estudiante 3: Reprobado

2.9.4 OR

En R, la expresión condicional or se utiliza para evaluar si al menos una de varias condiciones es verdadera. El operador | se utiliza para representar el “or” lógico (o inclusivo). Por ejemplo condicion1 | condicion2 evalúa como verdadero si al menos una de las condiciones es verdadera.

2.9.4.1 Ejemplo.

edad <- 25
ingreso <- 50000

if (edad > 21 | ingreso > 40000) {
  mensaje <- "Cumple con al menos una condición."
} else {
  mensaje <- "No cumple ninguna condición."
}
print(mensaje)
[1] "Cumple con al menos una condición."

Ten en cuenta que el uso de paréntesis para agrupar condiciones es importante para evitar ambigüedades en la evaluación lógica.

2.9.5 AND.

En R, la expresión condicional and se utiliza para evaluar si ambas de varias condiciones son verdaderas. El operador & se utiliza para representar el “and” lógico (y inclusivo). Por ejemplo condicion1 & condicion2 evalúa como verdadero solo si ambas condiciones son verdaderas.

2.9.5.1 Ejemplo.

edad <- 25
ingreso <- 50000

if (edad > 21 & ingreso > 40000) {
  mensaje <- "Cumple con ambas condiciones."
} else {
  mensaje <- "No cumple ambas condiciones."
}
print(mensaje)
[1] "Cumple con ambas condiciones."

2.9.6 NOT.

En R, la expresión condicional not se utiliza para invertir el valor de verdad de una condición. El operador ! se utiliza para representar la negación lógica (not). Por ejemplo !condicion evalúa como verdadero si la condición es falsa, y viceversa.

2.9.6.1 Ejemplo.

edad <- 25

if (!(edad > 21)) {
  mensaje <- "No es mayor de 21 años."
} else {
  mensaje <- "Es mayor de 21 años."
}
print(mensaje)
[1] "Es mayor de 21 años."

2.9.7 SWITCH.

La expresión condicional switch en R se utiliza para seleccionar uno de varios bloques de código para ejecutar, dependiendo del valor de una expresión.

2.9.7.1 Ejemplo.

dia_semana <- "lunes"

switch(dia_semana,
       "lunes" = print("Primer día laborable"),
       "viernes" = print("Último día laborable"),
       print("Día no reconocido")
)
[1] "Primer día laborable"