R es un lenguaje de programación y un entorno de software de código abierto diseñado específicamente para el análisis estadístico, la manipulación de datos y la generación de gráficos.
Caracteristica de R:
Lenguaje de Programación: proporciona un conjunto de operaciones y funciones para realizar análisis estadísticos avanzados y manipular datos de diversas formas.
Entorno de Software: ofrece un entorno de trabajo interactivo que permite a los usuarios cargar datos, realizar análisis, generar gráficos y comunicar resultados en un solo lugar.
Código Abierto: es un proyecto de código abierto, lo que significa que su código fuente es gratuito y accesible para la comunidad. Gracias a eso hay una gran cantidad de paquetes y extensiones desarrollados por la comunidad de usuarios de R.
Análisis Estadístico: es ampliamente utilizado en la estadística y la investigación científica. Ofrece una amplia gama de herramientas estadísticas y métodos
Ventajas de R
Ahorra gastos en licencias: Al ser un software GNU no pertenece a nadie, y por lo tanto no debes pagar ninguna licencia.
Accesible: Funciona con paquetes fáciles de descargar que otras personas previamente han programado.
Libre: El usuario puede distribuir, estudiar, cambiar y mejorar libremente el software bajo la GNU de la Free Software Foundation.
Excelente para el análisis y cálculo estadístico: Es un lenguaje estadístico creado por estadísticos. Por eso, actualmente es el más utilizado para desarrollar herramientas estadísticas.
Soporte multiplataforma: Es un programa independiente de la máquina, compatible con la operación multiplataforma, así que se puede utilizar en diferentes sistemas operativos.
Admite varios tipos de datos: Desde vectores hasta matrices y datos de diferentes tamaños.
Gráficos potentes: Puede producir gráficos y visualizaciones de alta calidad, ya sean de naturaleza estática o dinámica.
Computación paralela y distribuida: Puede procesar grandes conjuntos de datos utilizando bibliotecas como ddR o multiDplyr.
RStudio es un entorno de desarrollo integrado (IDE) especialmente diseñado para programadores y analistas de datos que trabajan con el lenguaje de programación R, proporciona una interfaz de usuario amigable y muchas herramientas útiles para trabajar de manera efectiva con R. Un IDE es un software que proporciona un conjunto de herramientas y características integradas que hacen que la programación y el desarrollo de software sean más eficientes.
CARACTERISTICAS
Editor de código: RStudio proporciona un editor de código que resalta la sintaxis y facilita la escritura y edición de scripts en R.
Consola interactiva: Los usuarios pueden ejecutar comandos R en una consola interactiva directamente desde RStudio, lo que facilita la experimentación y la depuración de código.
Gestión de proyectos: RStudio permite a los usuarios organizar sus proyectos y trabajar en múltiples archivos relacionados con un análisis de datos específico.
Herramientas de visualización: El IDE incluye paneles interactivos para crear y visualizar gráficos, tablas y resultados directamente en la aplicación.
Depuración y perfiles: RStudio proporciona herramientas de depuración para encontrar y corregir errores en el código, así como herramientas de perfil para analizar el rendimiento del código.
Explorador de paquetes: Facilita la instalación y gestión de paquetes y bibliotecas de R.
Integración con Git: Permite a los usuarios trabajar con sistemas de control de versiones como Git para gestionar cambios en el código.
La programación orientada a objetos (POO) es un paradigma de programación que se utiliza en R y otros lenguajes de programación para organizar y estructurar el código de una manera más modular y reutilizable. En R, la POO se basa en el sistema de clases y objetos y ofrece las siguientes características clave:
Clases y Objetos: En la programación orientada a objetos, una clase es un plano o plantilla que define las propiedades (atributos) y los comportamientos (métodos) de un objeto. Un objeto es una instancia de una clase y puede contener datos y funcionalidad relacionada.
Encapsulación: La encapsulación es el concepto de agrupar datos y los métodos que operan en esos datos dentro de una clase. Esto permite ocultar la complejidad y los detalles internos de la clase y proporcionar una interfaz pública para interactuar con el objeto.
Herencia: La herencia permite crear nuevas clases basadas en clases existentes. Una nueva clase (llamada subclase) hereda propiedades y comportamientos de una clase existente (llamada superclase) y puede agregar sus propias características o modificar el comportamiento heredado.
Polimorfismo: El polimorfismo es la capacidad de diferentes objetos de responder al mismo método de manera diferente. Esto permite a las clases derivadas o subclases redefinir o sobrecargar métodos heredados de sus superclases para adaptarlos a sus propias necesidades.
Abstracción: La abstracción implica la simplificación de objetos y sus interacciones para enfocarse en los aspectos más relevantes. Las clases y objetos proporcionan una forma de abstracción al modelar conceptos del mundo real en el código.
En R, puedes crear y trabajar con clases y objetos utilizando
paquetes específicos como S3, S4, o
R6. Estos sistemas de clases permiten definir clases,
métodos y objetos orientados a objetos en R. La elección del sistema de
clases depende de la complejidad del proyecto y de tus preferencias
personales.
La programación orientada a objetos en R puede facilitar la creación de código más modular, mantenible y reutilizable, lo que es especialmente útil en proyectos grandes y complejos.
La manipulación de objetos en RStudio se refiere a las acciones que puedes realizar para crear, modificar, analizar y gestionar objetos de datos en el entorno de RStudio. Los objetos de datos pueden ser variables, vectores, matrices, data frames, listas y otros tipos de estructuras de datos utilizados en R. RStudio es un entorno de desarrollo integrado (IDE) que proporciona herramientas y funcionalidades para facilitar la manipulación y el análisis de objetos de datos de manera eficiente.
Aquí hay algunas acciones comunes que puedes realizar para manipular objetos en RStudio:
mi_vector <- c(1, 2, 3, 4, 5)
mi_vector## [1] 1 2 3 4 5Visualización de Objetos: RStudio te permite ver los
contenidos de un objeto simplemente escribiendo el nombre del objeto en
la consola o utilizando funciones como print() o
head() para mostrar una vista previa de los datos.
Edición de Objetos: Puedes modificar objetos existentes cambiando sus valores, agregando o eliminando elementos y realizando otras operaciones de edición según el tipo de objeto.
Análisis de Datos: Puedes realizar análisis de datos utilizando funciones y paquetes disponibles en RStudio. Puedes realizar estadísticas descriptivas, regresiones, gráficos y más.
Gestión de Objetos: Puedes eliminar objetos para liberar
memoria utilizando la función rm(), guardar objetos en
archivos, cargar objetos desde archivos y organizar tu espacio de
trabajo.
Programación Orientada a Objetos: R también admite programación orientada a objetos a través de sistemas de clases como S3, S4 y R6. Puedes crear objetos basados en clases y utilizar métodos asociados.
Visualización de Datos: RStudio proporciona capacidades de visualización de datos, lo que significa que puedes crear gráficos y visualizaciones de tus objetos de datos para comprender mejor los patrones y las relaciones.
Depuración y Profiling: RStudio también ofrece herramientas de depuración y profiling que te permiten encontrar y corregir errores en tu código y optimizar su rendimiento.
La manipulación de objetos en RStudio es fundamental para el análisis de datos y la programación en R. RStudio proporciona un entorno amigable y poderoso para realizar estas tareas de manera efectiva.
1. Clases: En R, las clases son definidas a través de la programación orientada a objetos. Puedes crear clases utilizando el sistema de clases en R, por ejemplo, con la función setClass().
Ejemplo de definición de una clase:
setClass("Persona", slots = c(nombre = "character", edad = "numeric"))2. Objetos: Los objetos en R son instancias de clases. Puedes crear objetos utilizando la función new().
Ejemplo de creación de un objeto:
persona1 <- new("Persona", nombre = "Juan", edad = 25)3. Matrices, Arreglos y Vectores: R es un lenguaje altamente especializado en estadísticas y análisis de datos. Los vectores son una estructura de datos fundamental en R. Las matrices y arreglos son estructuras bidimensionales y multidimensionales, respectivamente.
-vectores Creación de un vector numérico:
mi_vector <- c(1, 2, 3, 4, 5)
print(mi_vector)## [1] 1 2 3 4 5Creación de un vector de caracteres:
nombres <- c("Juan", "María", "Luis")
print(nombres)## [1] "Juan" "María" "Luis"-Matrices Creación de una matriz de números:
matriz_numeros <- matrix(c(1, 2, 3, 4, 5, 6), nrow = 2, ncol = 3)
print(matriz_numeros)## [,1] [,2] [,3]
## [1,] 1 3 5
## [2,] 2 4 6Acceso a elementos de una matriz:
elemento <- matriz_numeros[2, 3]
print(elemento)## [1] 6-Arreglos Creación de un arreglo (3D) de números:
mi_arreglo <- array(1:24, dim = c(2, 3, 4))
print(mi_arreglo)## , , 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 24Acceso a elementos de un arreglo:
elemento <- mi_arreglo[1, 2, 3]
print(elemento)## [1] 15La indentación en R se utiliza principalmente para mejorar la legibilidad del código. Aunque R no es tan estricto con la indentación como algunos otros lenguajes, se recomienda usarla para organizar el código de manera más clara. Por ejemplo, puedes usar espacios o tabulaciones para indentar el código dentro de bloques, como en funciones o bucles.
Ejemplo de indentación en una función en R:
mi_funcion <- function() {
for (i in 1:3) {
print(i)
}
}R utiliza expresiones condicionales similares a Python, pero con algunas diferencias sintácticas. Algunos ejemplos son:
d.1. if-else:
# Definimos un número
numero <- 5
# Verificamos si el número es positivo
if (numero > 0) {
print("El número es positivo.")
} else {
print("El número no es positivo.")
}## [1] "El número es positivo."d.2. if-else if-else:
if (condicion1) { # Código si condicion1 es verdadera } else if (condicion2) { # Código si condicion2 es verdadera } else { # Código si ninguna de las condiciones anteriores es verdadera }
# Definimos una puntuación
puntuacion <- 75
# Evaluamos la puntuación y asignamos una categoría
if (puntuacion >= 90) {
categoria <- "Excelente"
} else if (puntuacion >= 80) {
categoria <- "Bueno"
} else if (puntuacion >= 70) {
categoria <- "Aceptable"
} else {
categoria <- "Insuficiente"
}
# Mostramos la categoría
print(paste("La puntuación", puntuacion, "se clasifica como", categoria))## [1] "La puntuación 75 se clasifica como Aceptable"d.3. Operadores lógicos (or, and, not):
Operador or (||): if (condicion1 || condicion2) { # Se ejecuta si condicion1 es verdadera o condicion2 es verdadera }
# Ejemplo con operador or (||)
condicion1 <- TRUE
condicion2 <- FALSE
if (condicion1 || condicion2) {
print("Al menos una de las condiciones es verdadera.")
} else {
print("Ninguna de las condiciones es verdadera.")
}## [1] "Al menos una de las condiciones es verdadera."Operador and (&&): if (condicion1 && condicion2) { # Se ejecuta si condicion1 es verdadera y condicion2 es verdadera }
# Ejemplo con operador and (&&)
condicion1 <- TRUE
condicion2 <- FALSE
if (condicion1 && condicion2) {
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."Operador not (!): if (!condicion) { # Se ejecuta si condicion es falsa }
# Ejemplo con operador not (!)
condicion <- FALSE
if (!condicion) {
print("La condición es falsa, por lo que se ejecuta el bloque if.")
}## [1] "La condición es falsa, por lo que se ejecuta el bloque if."Un bucle for es una estructura de control que permite ejecutar un bloque de código de manera repetida para un rango específico de valores. Es como tener una lista y seguir instrucciones para cada elemento en esa lista.
Estructura básica:
for (variable in secuencia) { # Código a ejecutar en cada iteración }
##variable es una etiqueta que toma un valor de la secuencia en cada iteración. ##secuencia es una serie de elementos sobre la que queremos iterar (por ejemplo, números del 1 al 10).
Ejemplo:
Supongamos que queremos imprimir los primeros 5 números naturales. Podemos hacerlo así:
for (i in 1:5) {
print(paste("Número:", i))
}## [1] "Número: 1"
## [1] "Número: 2"
## [1] "Número: 3"
## [1] "Número: 4"
## [1] "Número: 5"En este caso, i toma valores de la secuencia del 1 al 5 en cada iteración, y se imprime un mensaje que incluye ese número.
Un bucle while es una estructura de control que permite ejecutar un bloque de código mientras se cumple una condición. Es útil cuando no sabemos cuántas veces queremos hacer algo, pero sabemos cuándo queremos detenernos.
Estructura básica:
while (condición) { # Código a ejecutar mientras la condición sea verdadera # Es importante actualizar la condición dentro del bloque de código }
##condición es una afirmación que debe ser verdadera para que el bucle se repita. Si la condición es falsa, el bucle se detiene.
Ejemplo:
Supongamos que queremos calcular la suma de los primeros 10 números naturales. Podemos hacerlo así:
sum_total <- 0
i <- 1
while (i <= 10) {
sum_total <- sum_total + i
i <- i + 1
}
print(paste("La suma de los primeros 10 números naturales es:", sum_total))## [1] "La suma de los primeros 10 números naturales es: 55"En este caso, repetimos la adición mientras i sea menor o igual a 10. En cada iteración, sumamos el valor de i a nuestra suma total y luego aumentamos i en 1.
De manera resumida, en este lenguaje los bucles son estructuras de control de flujo que permiten repetir un bloque de código un determinado o indeterminado número de veces. Esencialmente existen dos tipos de bucles: “for” y “while”, en este caso no mencionamos al “if”, “else”, “repeat”, “break” y “next”, ya que lo mencionaremos en las estructuras de control al igual que a los dos primeros
Vamos a obtener el cuadrado de cada uno de los elementos en un vector numérico del 1 al 6, que representa las caras de un dado y Comprobamos que la operación ha sido realizada a cada elemento de nuestro objeto usando la función “print”.
dado <- 1:6
for(cara in dado) {
print(cara ^ 2)
}## [1] 1
## [1] 4
## [1] 9
## [1] 16
## [1] 25
## [1] 36Si deseamos asignar los resultados de un bucle “for” a un objeto, usamos índices y rehusamos la función anterior:
mi_vector <- NULL
for(cara in dado) {
mi_vector[cara] <- cara ^ 2
}
mi_vector## [1] 1 4 9 16 25 36Tomaremos un número al azar del 1 al 10, y lo sumará a “valor”. Segundo, le sumará 1 a “conteo” cada que esto ocurra, de esta manera sabremos cuántas iteraciones ocurrieron para llegar a un valor que no sea menor a 50 para asi poder mostrar los resultados y comprobar si son asignados a los objetos “valor” y “conteo”
conteo <- 0
valor <- 0
while(valor < 50) {
valor <- valor + sample(x = 1:10, size = 1)
conteo <- conteo + 1
}
valor## [1] 54conteo## [1] 8Si intentamos ejecutar un “while” para el que la condición nunca es igual a TRUE, este no realizará ninguna operación.
conteo <- 0
while("dado" == "ficha") {
conteo <- conteo + 1
}
conteo## [1] 0Las declaraciones o estructuras de controles nos permiten manejar de manera eficiente nuestro código, estableciendo condicionales a los mismos. Nos ayuda a determinar la lógica y el orden en que ocurren las operaciones, en especial al definir funciones.
Como se mencionó anteriormente, ya mencionamos los bucles, ahora procedemos a ejecutar ejemplos e donde se haga uso del “if”, “else”, “repeat”, “break” y “next”.
El “if” (si) es usado cuando deseamos que una operación se ejecute únicamente cuando una condición se cumple.
El “else” (de otro modo) es usado para indicarle a R qué hacer en caso de la condición de un if no se cumpla.
###Ejemplo del “if” y “else”:
Al usar “if” con “else” es la manera de decir que:
SI esta condición es es cierta, ENTONCES haz estas operaciones, DE OTRO MODO haz estas otras operaciones.
if(8 > 9) {
"Verdadero"
} else {
"Falso"
}## [1] "Falso"Si queremos definir una función que calcule el promedio de calificaciones de un estudiante y, dependiendo de la calificación calculada, nos devuelva un mensaje específico, procedemos a ejecutar lo siguiente:
Primero: Definimos una función para calcular promedio.
promedio <- function(calificaciones) {
mean(calificaciones)
}
promedio(c(5, 8, 6, 10, 7))## [1] 7.2Segundo: Si asumimos que un estudiante necesita obtener 6 o más de promedio para aprobar, podemos decir que:
SI el promedio de un estudiante es igual o mayor a 6, ENTONCES mostrar “Aprobado”, DE OTRO MODO, mostrar “Reprobado”.
Aplicamso esta lógica, obtenemos:
promedio <- function(calificaciones) {
media <- mean(calificaciones)
if(media >= 6) {
print("Aprobado")
} else {
print("Reprobado")
}
}
promedio(c(5, 8, 6, 10, 7))## [1] "Aprobado"Tercero: Por último haremos uso de la función paste0() para pegar el promedio de calificaciones, como texto, con el resultado de “Aprobado” o “Reprobado”. Esta función acepta como argumentos cadenas de texto y las pega (concatena) entre sí, devolviendo como resultado una nueva cadena.
promedio <- function(calificaciones) {
media <- mean(calificaciones)
texto <- paste0("Calificación: ", media, ", ")
if(media >= 6) {
print(paste0(texto, "aprobado"))
} else {
print(paste0(texto, "reprobado"))
}
}
promedio(c(5, 8, 6, 10, 7))## [1] "Calificación: 7.2, aprobado"Ambas realizan una operación específica cuando aparecen en nuestro código.
“break” nos permite interrumpir un bucle, mientras que “next” nos deja avanzar a la siguiente iteración del bucle, “saltándose” la actual. Ambas funcionan para “for” y “while”.
Al interrumpir un “for” cuando i es igual a 7, aunque aún queden 3 elementos en el objeto.
for(i in 1:10) {
if(i == 7) {
break
}
print(i)
}## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5
## [1] 6Si interrumpimos un “while” antes de se cumpla la condición de que numero sea mayor a 7, en cuanto este tiene el valor de 12.
numero <- 20
while(numero > 7) {
if(numero == 12) {
break
}
numero <- numero - 1
}
numero## [1] 12Cuando “saltarnos” una iteración en un bucle. Cuando la condición se cumple, esa iteración es omitida.
for(i in 1:10) {
if(i == 5) {
next
}
print(i)
}## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 6
## [1] 7
## [1] 8
## [1] 9
## [1] 10Este es un bucle que se llevará a cabo el número de veces que especifiquemos, usando un break para detenerse. repeat asegura que las operaciones que contiene sean iteradas al menos en una ocasión.
Si queremos usar “repeat”, lo haremos cuando este sume +2 a la variable “valor” hasta que este sea igual a 8, entonces se detendrá.
valor <- 0
mi_vector <- NULL
repeat{
valor <- valor + 2
if(valor == 8) {
break
}
}
valor## [1] 8En resumen, la interfaz de estructura de control y bucle del lenguaje de programación R proporciona a los programadores una amplia gama de herramientas para gestionar el flujo de ejecución de sus programas y realizar tareas repetitivas de manera eficiente. R también proporciona bucles y funciones de flujo de control como if-else que permiten a los programadores crear fácilmente algoritmos complejos y realizar operaciones condicionales.
La ventaja de R es su orientación hacia la estadística y el análisis de datos, lo que se puede ver en la capacidad de aplicar bucles y estructuras de control a marcos de datos y vectores de forma natural. Facilita el manejo de datos y el procesamiento eficiente, lo cual es esencial para el análisis de datos y las estadísticas.
Sin embargo, se debe tener cuidado al utilizar bucles en R porque el lenguaje está optimizado para operaciones vectoriales y el uso excesivo de bucles puede provocar un rendimiento deficiente. En cambio, se recomiendan técnicas de programación funcional y operaciones vectoriales para aprovechar al máximo las capacidades de R.
En conclusión, R ofrece una poderosa combinación de bucles y estructuras de control que son esenciales para el análisis de datos y las estadísticas, pero los programadores deben conocer las mejores prácticas para escribir código eficiente y aprovechar al máximo las características del lenguaje.