Alumnos: **

Semestre 2023-II

Fundamentos del programa

¿Qué es R?

R es enguaje de programación interpretado, es decir, ejecuta las instrucciones directamente, sin una previa compilación del programa a instrucciones en lenguaje máquina. El término entorno, en R, se refiere a un sistema totalmente planificado y coherente, en lugar de una acumulación de herramientas específicas e inflexibles, como suele ser el caso en otros softwares de análisis de datos.

Historia R se presentó al mercado en 1993 de la mano de sus creadores Robert Gentleman y Ross Ihaka, que desarrollaron la herramienta en el Departamento de Estadística de la Universidad de Auckland. Sin embargo la base de sus orígenes se encuentra en el desarrollo del lenguaje S. R es producto de la filosofía Open Source.

¿Qué es IDE - RStudio?

Aunque podemos usar R directamente, es recomendable instalar y usar un entorno integrado de desarrollo (IDE, por sus siglas en inglés).

Podemos utilizar R ejecutando nuestro código directamente desde documentos de texto plano, pero esta es una manera poco efectiva de trabajar, especialmente en proyectos complejos.

Un IDE nos proporciona herramientas para escribir y revisar nuestro código, administrar los archivos que estamos usando, gestionar nuestro entorno de trabajo y algunas otras herramientas de productividad. Tareas que serían difíciles o tediosas de realizar de otro modo, son fáciles a través de un IDE.

Hay varias opciones de IDE para R, y entre ellas mi preferido es RStudio. Este entorno, además de incorporar las funciones esenciales de una IDE, es desarrollado por un equipo que ha contribuido de manera significativa para lograr que R sea lenguaje de programación más accesible, con un énfasis en la colaboración y la reproducción de los análisis.

Programación orientada a objetos

R utiliza programación orientada a objetos. Ello significa que una misma función hace cosas distintas según la clase del objeto que recibe como argumento, pudiendo incluso no hacer nada (o producir un error) si se le pasan argumentos de una clase inadecuada

Manipulación de objetos.

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

La manipulación de objetos en RStudio es una habilidad esencial para cualquier usuario de este entorno de programación. Se refiere a la capacidad de trabajar con diferentes tipos de objetos, como vectores, matrices, dataframes, listas y más.

RStudio es una interfaz de desarrollo integrada (IDE) que se utiliza comúnmente para trabajar con el lenguaje de programación R, que es ampliamente utilizado en estadísticas y análisis de datos. En RStudio, la manipulación de objetos es el proceso de crear, modificar, eliminar y acceder a objetos de datos.

Los objetos de datos son estructuras de datos que almacenan información, como números, texto, vectores, matrices, dataframes, listas y funciones. En RStudio, los objetos de datos se pueden crear utilizando el operador assign(), que asigna un valor o una expresión a un nombre de objeto.

Una vez que se ha creado un objeto de datos, se puede modificar utilizando una variedad de funciones y operadores. Por ejemplo, la función c() se puede utilizar para concatenar valores o objetos de datos, la función rep() se puede utilizar para replicar valores o objetos de datos, y la función subset() se puede utilizar para extraer elementos de un objeto de datos.

La manipulación de objetos es una parte esencial del trabajo en RStudio. Permite al usuario realizar operaciones básicas como crear, leer, escribir, modificar y eliminar objetos. También permite al usuario realizar operaciones más complejas, como combinar objetos, aplicar funciones a objetos y subconjunto objetos.

##Definir y ejemplificar Clases, objetos, matrices, arreglos, vectores Clases:

Las clases son un concepto de programación orientada a objetos, son una forma de clasificar los objetos de datos. Cada objeto de datos tiene una clase, que determina su tipo de datos y los métodos que se pueden utilizar con él. Hay clases predefinidas en R, como los vectores, matrices, arreglos, dataframes, listas, etc., pero también se pueden crear clases personalizadas. Ejemplo:

# Clases predefinidas
 class(1)
## [1] "numeric"
#> "numeric"
class("Hola mundo")
## [1] "character"
#"character"
class(TRUE)
## [1] "logical"

Objetos

Los objetos son instancias de clases en RStudio, que almacenan datos y métodos asociados. Un objeto es una instancia de una clase. Los objetos se crean usando el operador <- o la función new().

Ejemplo:

# Objeto de clase numérica
x <- 1:10
class(x)
## [1] "integer"
 # Objeto de clase carácter
y <- c("Odio", "trabajar")
class(y)
## [1] "character"
# Objeto de clase lógica
z <- TRUE
class(z)
## [1] "logical"

Matrices:

Una matriz es un objeto que contiene una colección de datos organizados en filas y columnas. Las matrices se crean usando la función matrix() Ejemplo:

# Creación de una matriz en RStudio
matriz_ejemplo <- matrix(c(1, 2, 3, 4, 5, 6), nrow = 2, ncol = 3)
print(matriz_ejemplo)
##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6
# Matriz de números
B <- matrix(1:10, nrow = 2, ncol = 5)
B
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    3    5    7    9
## [2,]    2    4    6    8   10
# Matriz de caracteres
C <- matrix(c("Trabajo", "duro", "como un", "esclavo"), nrow = 2, ncol = 2)
C
##      [,1]      [,2]     
## [1,] "Trabajo" "como un"
## [2,] "duro"    "esclavo"

###Arreglos: Un arreglo es un objeto que contiene una colección de datos de la misma clase. Los arreglos se crean usando la función array(). Ejemplo:

# Arreglo de números
C <- array(40:50, dim = c(2, 5, 2))
C
## , , 1
## 
##      [,1] [,2] [,3] [,4] [,5]
## [1,]   40   42   44   46   48
## [2,]   41   43   45   47   49
## 
## , , 2
## 
##      [,1] [,2] [,3] [,4] [,5]
## [1,]   50   41   43   45   47
## [2,]   40   42   44   46   48
# Arreglo de caracteres
D <- array(c("Quizas","nunca","fuiste","para", "mia"), dim = c(2, 3, 2))
D
## , , 1
## 
##      [,1]     [,2]     [,3]    
## [1,] "Quizas" "fuiste" "mia"   
## [2,] "nunca"  "para"   "Quizas"
## 
## , , 2
## 
##      [,1]     [,2]   [,3]    
## [1,] "nunca"  "para" "Quizas"
## [2,] "fuiste" "mia"  "nunca"

Vectores:

Un vector es un objeto que contiene una colección de datos de la misma clase. Los vectores se crean usando la función c(). Ejemplo:

# Vector de números
x <- 12:30
x
##  [1] 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
# Vector de caracteres
y <- c("Yo", "te", "olvidaré", "desde", "las", "fuentes", "de", "Ortiz.")
y
## [1] "Yo"       "te"       "olvidaré" "desde"    "las"      "fuentes"  "de"      
## [8] "Ortiz."

¿Qué es indentación?

La indentación es un proceso de sangrar las líneas de código para indicar su estructura. Se utiliza para mejorar la legibilidad del código y facilitar la comprensión de su flujo.

En RStudio, la indentación es un elemento importante de la programación. Es una buena práctica indentar siempre su código para mejorar su legibilidad y facilitar su mantenimiento.

La indentación se refiere a la forma en que se estructuran los bloques de código mediante la inserción de espacios o tabulaciones al principio de cada línea. Se utiliza para resaltar la estructura jerárquica del código y facilitar su legibilidad. Es una convención de estilo comúnmente utilizada en lenguajes de programación, incluido R, para mostrar la relación entre bloques de código anidados, como bucles, condicionales y funciones. La indentación generalmente se utiliza para:

Bloques de código anidados: Cuando tienes estructuras de control anidadas, como bucles dentro de condicionales, la indentación ayuda a identificar claramente la jerarquía de estos bloques. Ejemplo:

for (i in 1:10) {
  if (i %% 2 == 0) {
    print(i)
  }
}
## [1] 2
## [1] 4
## [1] 6
## [1] 8
## [1] 10

En este ejemplo, el bucle for está anidado dentro del condicional if. La indentación ayuda a distinguir entre los dos bloques de código, lo que hace que sea más fácil entender el flujo del código.

-Funciones: Las funciones en R también suelen estar indentadas para mostrar claramente su estructura y los argumentos que toman. Ejemplo:

mi_funcion <- function(x, y) {
  return(x + y)
}
resultado <- mi_funcion(5, 3)
print(resultado)
## [1] 8

En este ejemplo, la función tiene dos argumentos, x e y. La indentación ayuda a mostrar que los argumentos se encuentran dentro del cuerpo de la función.

La indentación es una parte importante de la programación en R. Al indentar su código, puede mejorar su legibilidad y facilitar su mantenimiento.

Expresiones condicionales (if, if else, Elif ,or, and, Not, entre otros).

Las expresiones condicionales son fundamentales en la programación y se utilizan para tomar decisiones basadas en ciertas condiciones. En R, al igual que en otros lenguajes, puedes utilizar varias expresiones condicionales para controlar el flujo del programa. Aquí se detallan algunas de las expresiones condicionales más comunes:

  1. if:
    • La expresión if se utiliza para ejecutar un bloque de código si una condición es verdadera
# Ejemplo 1
x <- 10
if (x > 5) {
  print("x es mayor que 5")
}
## [1] "x es mayor que 5"
# Ejemplo 2
y <- 3
if (y == 3) {
  print("y es igual a 3")
}
## [1] "y es igual a 3"
  1. if else:
    • La expresión if else se utiliza para ejecutar un bloque de código si la condición en el if es verdadera y otro bloque si la condición es falsa.
# Ejemplo 1
x <- 3
if (x > 5) {
  print("x es mayor que 5")
} else {
  print("x no es mayor que 5")
}
## [1] "x no es mayor que 5"
# Ejemplo 2
y <- 7
if (y > 10) {
  print("y es mayor que 10")
} else {
  print("y no es mayor que 10")
}
## [1] "y no es mayor que 10"
  1. else if (elif en otros lenguajes):
    • Puedes usar else if para evaluar múltiples condiciones en secuencia.
# Ejemplo 1
z <- 5
if (z > 10) {
  print("z es mayor que 10")
} else if (z == 10) {
  print("z es igual a 10")
} else {
  print("z es menor que 10")
}
## [1] "z es menor que 10"
# Ejemplo 2
w <- 15
if (w < 10) {
  print("w es menor que 10")
} else if (w == 10) {
  print("w es igual a 10")
} else {
  print("w es mayor que 10")
}
## [1] "w es mayor que 10"
  1. Operadores lógicos:
    • & (AND): Combina dos condiciones y devuelve TRUE si ambas son verdaderas.
# Ejemplo 1
e <- 7
f <- 9
if (e > 5 & f > 5) {
  print("Ambas condiciones son verdaderas")
}
## [1] "Ambas condiciones son verdaderas"
  • | (OR): Combina dos condiciones y devuelve TRUE si al menos una de ellas es verdadera.
# Ejemplo 1
a <- 7
b <- 2
if (a > 5 | b > 5) {
  print("Al menos una de las condiciones es verdadera")
}
## [1] "Al menos una de las condiciones es verdadera"
# Ejemplo 2
c <- 3
d <- 2
if (c > 5 | d > 5) {
  print("Al menos una de las condiciones es verdadera")
} else {
  print("Ninguna de las condiciones es verdadera")
}
## [1] "Ninguna de las condiciones es verdadera"
# Ejemplo 2
g <- 3
h <- 9
if (g > 5 & h > 5) {
  print("Ambas condiciones son verdaderas")
} else {
  print("Al menos una de las condiciones no es verdadera")
}
## [1] "Al menos una de las condiciones no es verdadera"
  • ! (NOT): Invierte el valor lógico de una condición.
# Ejemplo 1
i <- 7
if (!(i == 10)) {
  print("i no es igual a 10")
}
## [1] "i no es igual a 10"
# Ejemplo 2
j <- 10
if (!(j > 5)) {
  print("j no es mayor que 5")
}

Estas son las expresiones condicionales y operadores lógicos básicos en R que te permiten controlar el flujo de tu programa en función de condiciones específicas. Puedes combinarlos para crear lógica más compleja en tus programas. # Bucles.

¿Qué es un bucle?

Un bucle es una estructura de control que permite ejecutar un conjunto de instrucciones repetidamente hasta que se cumpla una condición específica. Los bucles son esenciales en la programación para automatizar tareas repetitivas.

Ejemplo en R:

#Ejemplo 1: 
for (i in 1:5) {
  print(i)
}
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5
#Ejemplo 2 - Bucle while:
x <- 1
while (x <= 5) {
  print(x)
  x <- x + 1
}
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

Este bucle imprimirá los números del 1 al 5, al igual que el ejemplo anterior.

#Ejemplo 3 - Bucle repeat:
x <- 1
repeat {
  print(x)
  x <- x + 1
  if (x > 5) {
    break
  }
}
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

Este bucle repeat imprimirá los números del 1 al 5 y se detendrá cuando x sea mayor que 5.

##Construcción de Bucles en R:

En R, puedes construir bucles utilizando tres estructuras principales: for, while, y repeat. Cada uno de estos bucles tiene un propósito y uso específico:

  1. Bucle for: Se utiliza para iterar sobre una secuencia o una lista de elementos. La estructura típica de un bucle for en R es:

for (variable in secuencia) { # Código a ejecutar en cada iteración }

Ejemplo de un bucle for:

for (i in 1:5) {
  print(i)
}
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

Este bucle for imprimirá los números del 1 al 5.

  1. Bucle while: Se utiliza para ejecutar un conjunto de instrucciones mientras se cumple una condición específica. La estructura de un bucle while en R es:

while (condición) { # Código a ejecutar mientras la condición sea verdadera }

Ejemplo de un bucle while:

x <- 1
while (x <= 5) {
  print(x)
  x <- x + 1
}
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

Este bucle while imprimirá los números del 1 al 5.

  1. Bucle repeat: Crea un bucle infinito que debe romperse manualmente con la declaración break. La estructura de un bucle repeat es:

repeat { # Código a ejecutar en cada iteración if (condición_de_salida) { break } }

Ejemplo de un bucle repeat:

x <- 1
repeat {
  print(x)
  x <- x + 1
  if (x > 5) {
    break
  }
}
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

Este bucle repeat imprimirá los números del 1 al 5 y se detendrá cuando x sea mayor que 5.

Tipos de Bucles en R:

Hay varios tipos de bucles en R, pero dos de los más comunes son “for” and “while”.

  1. Bucle for: El bucle for se utiliza cuando se conoce de antemano la cantidad de veces que deseas ejecutar un bloque de código. Por lo general, se usa para iterar sobre una secuencia de números o elementos.
# Ejemplo de bucle for para sumar los números del 1 al 10
   suma <- 0
   for (i in 1:10) {
     suma <- suma + i
   }
   print(suma)
## [1] 55

Este bucle for suma los números del 1 al 10 e imprime el resultado.

  1. Bucle while: El bucle for se utiliza cuando se conoce de antemano la cantidad de veces que deseas ejecutar un bloque de código. Por lo general, se usa para iterar sobre una secuencia de números o elementos.
# Ejemplo de bucle while para contar hasta 10
   contador <- 1
   while (contador <= 10) {
     print(contador)
     contador <- contador + 1
   }
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5
## [1] 6
## [1] 7
## [1] 8
## [1] 9
## [1] 10
  1. Bucle repeat: El “bucle repeat” no es un tipo de bucle en sí mismo, sino una construcción que se utiliza para crear bucles infinitos. En R, puedes usar repeat para crear un bucle que se ejecuta continuamente y se detiene solo cuando se cumple una condición específica. Para evitar un bucle infinito, generalmente se utiliza la declaración break dentro del bucle para salir de él cuando se cumple cierta condición.
 # Ejemplo de bucle repeat para generar números aleatorios hasta que se obtenga un 5
   contador <- 0
   repeat {
     numero <- sample(1:10, 1)
     print(numero)
     contador <- contador + 1
     if (numero == 5) {
       break
     }
   }
## [1] 4
## [1] 4
## [1] 10
## [1] 4
## [1] 5
   print(paste("Se necesitaron", contador, "intentos para obtener un 5."))
## [1] "Se necesitaron 5 intentos para obtener un 5."

Este bucle repeat genera números aleatorios del 1 al 10 y continúa hasta que se obtiene un 5, luego muestra cuántos intentos se necesitaron.

Declaraciones de control

Las declaraciones de control son estructuras que permiten influir en el flujo de ejecución de un programa, como decidir si ejecutar una porción de código, saltar a una parte específica del programa o repetir ciertas acciones. En R, las declaraciones de control son fundamentales para tomar decisiones y crear bucles. Aquí te presento algunas de las declaraciones de control más comunes en R:

  1. Declaración if:
    • La declaración if se utiliza para tomar decisiones basadas en una condición.
    • Ejemplo:
edad <- 18
   if (edad >= 18) {
     print("Eres mayor de edad.")
   } else {
     print("Eres menor de edad.")
   }
## [1] "Eres mayor de edad."

En este ejemplo, se utiliza if para verificar si edad es mayor o igual a 18 y se imprime un mensaje en función de esa condición. 2. Declaración else: - Se utiliza junto con if para proporcionar un bloque de código que se ejecuta cuando la condición en if es falsa. - Ejemplo:

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

En este caso, como edad es menor de 18, se ejecutará el bloque de código dentro de else. 3. Declaración else if: - Se utiliza cuando tienes múltiples condiciones a verificar en orden. - Ejemplo:

nota <- 75
   if (nota >= 90) {
     print("Aprobado con A")
   } else if (nota >= 80) {
     print("Aprobado con B")
   } else if (nota >= 70) {
     print("Aprobado con C")
   } else {
     print("Reprobado")
   }
## [1] "Aprobado con C"

Esta declaración else if permite verificar varias condiciones en secuencia y ejecutar el bloque de código correspondiente.

  1. Declaración switch:

    • Se utiliza para seleccionar un caso específico de un conjunto de posibles valores.
    • Ejemplo:
    dia_semana <- "lunes"
   mensaje <- switch(
     dia_semana,
     lunes = "Comienzo de la semana laboral.",
     viernes = "¡Viernes! Fin de la semana laboral.",
     "Día no reconocido."
   )
   print(mensaje)
    ## [1] "Comienzo de la semana laboral."

    En este caso, se selecciona un mensaje diferente según el valor de dia_semana.

  2. Declaración while:

    • Se utiliza para crear bucles que ejecutan un conjunto de instrucciones mientras una condición sea verdadera.
    • Ejemplo:
     contador <- 1
   while (contador <= 5) {
     print(contador)
     contador <- contador + 1
   }
    ## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

    En este ejemplo, el bucle while imprime los números del 1 al 5 mientras contador sea menor o igual a 5.

  3. Declaración for:

    • Se utiliza para crear bucles que recorren una secuencia o elementos en una lista.
    • Ejemplo:
 for (i in 1:5) {
     print(i)
   }
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

Este bucle for imprimirá los números del 1 al 5.

  1. Declaración repeat:
    • Crea un bucle infinito que se ejecuta continuamente y se detiene solo cuando se usa la declaración break.
    • Ejemplo:
contador <- 1
   repeat {
     print(contador)
     contador <- contador + 1
     if (contador > 5) {
       break
     }
   }
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

En este ejemplo, el bucle repeat imprimirá los números del 1 al 5 y se detendrá cuando contador sea mayor que 5.

  1. Declaración next:

    • Se utiliza dentro de un bucle para saltar a la siguiente iteración sin ejecutar el código restante en la iteración actual.
    • Ejemplo:
    for (i in 1:5) {
     if (i == 3) {
       next
     }
     print(i)
   }
    ## [1] 1
## [1] 2
## [1] 4
## [1] 5

    Este bucle for imprimirá los números del 1 al 5, pero saltará la iteración cuando i sea igual a 3.

  2. Declaración break:

    • Se utiliza para salir de un bucle antes de que se cumplan las condiciones normales de finalización.
    • Ejemplo:
    for (i in 1:10) {
     if (i > 5) {
       break
     }
     print(i)
   }
    ## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

Este bucle for imprimirá los números del 1 al 5 y se detendrá cuando i sea mayor que 5.

Conclusiones

En este trabajo, hemos explorado los fundamentos de la programación en R utilizando RStudio y RMarkdown, un entorno ampliamente utilizado en la comunidad de análisis de datos y estadísticas. A lo largo de nuestro estudio, hemos abordado los siguientes aspectos clave:

Fundamentos del programa: En esta sección, hemos establecido una comprensión sólida de lo que es R y cómo se integra en el entorno de desarrollo RStudio. Además, hemos explorado la definición de un entorno de desarrollo integrado (IDE) y cómo RStudio proporciona un espacio de trabajo eficiente para el desarrollo de proyectos en R. Hemos definido la programación orientada a objetos en esta sección, un concepto clave que facilita la organización y reutilización del código. Comprender estos fundamentos es crucial para aquellos interesados en programar en R con éxito.

Manipulación de objetos: En esta sección, nos hemos adentrado en la manipulación de objetos en R, incluyendo definiciones y ejemplos de clases, objetos, matrices, arreglos y vectores. Estos componentes son esenciales para representar y manipular datos en R. Además, hemos explorado conceptos como la indentación y las expresiones condicionales, que son fundamentales para la toma de decisiones en la programación. Estas habilidades son aplicables a cualquier proyecto en R, incluyendo aquellos desarrollados en RStudio.

Bucles: La sección sobre bucles se centró en el concepto de bucles y su importancia en la automatización de tareas repetitivas. Hemos explorado cómo construir bucles, los diferentes tipos de bucles disponibles en R y las declaraciones de control que permiten modificar el flujo del programa.

Este trabajo nos ha proporcionado una comprensión sólida de la programación en R utilizando RStudio y RMarkdown. Hemos explorado los fundamentos de R, la programación orientada a objetos, la manipulación de objetos, las expresiones condicionales y los bucles, todos los cuales son elementos clave para desarrollar aplicaciones y scripts efectivos en este entorno.