Universidad Juárez Autónoma de Tabasco División Académica de Ciencias Biológicas Manual Práctico de Estadística con R y RStudio
Adolfo Alan Sánchez Vázquez
Guía de instalación de R y RStudio
Para utilizar este manual, primero debes saber cómo instalar dos programas: R y RStudio. R es un lenguaje y entorno de programación para el análisis de datos y gráficos, mientras que RStudio es una interfaz gráfica que facilita el uso de R. Aunque usaremos principalmente RStudio, es esencial entender que este es solo una interfaz para R. Por lo tanto, primero instalaremos R, que es el motor que ejecutará nuestros análisis, y luego instalaremos RStudio, que nos permitirá interactuar con R de una manera más amigable y visual.
Para instalar R ve al sitio https://cran.r-project.org/ en la cual se accede a la descarga de los instaladores del programa para diferentes sistemas operativos.
1) R Para Windows:
- Selección la opción Download R for Windows
- Tendrás una nueva ventana donde deberás seleccionar Instalo R for the first time
- Ahora tendrás una pantalla similar a esta, donde podrás descargar la versión vigente de R para Windows, dando clic en Download R-4.4.0 for Windows ( el número de versión es muy probable que haya cambiado para cuando leas este manual).
- Una vez descargado es preciso que ubiques el archivo en la carpeta donde haya sido descargado, has doble clic sobre el mismo para ejecutarlo y sigue las instrucciones de instalación. Se recomienda instalar la configuración predeterminada
2) R para macOS
- Selecciona la opción de instalación según el tipo de Mac con el que cuentas:
->For Apple silicon (M1-3) Macs:
R-4.3.3-arm64.pkg
SHA1-hash: 37dc051e0a241eeef8e8207b2710067767781e6c
(ca. 92MB, notarized and signed)-> For older Intel Macs:
R-4.3.3-x86_64.pkg
SHA1-hash: cbff7e4657eb67d3a35f4c74772680aa3c6b8d4b
(ca. 94MB, notarized and signed)Abre el archivo descargado (generalmente un archivo .pkg).
Sigue las instrucciones del instalador.
Acepta los términos del acuerdo de licencia del software
Has clic en instalar. Es posible que necesites ingresar el nombre de usuario y la contraseña de administrador para continuar.
Si tienes macOS Catalina o posterior, puede que necesites habilitar R en la terminal. Puedes hacerlo ejecutando el siguiente comando en la terminal: sudo R CMD javareconf
Para instalar RStudio ve al sitio https://posit.co/download/rstudio-desktop/ en esa misma página te permite ver en primer instancia el apartado de Instalación de RStudio para para Windows:
Pero si despliegas la página hacia abajo podrás ver el resto de los instaladores para otros sistemas operativos:
1) Instalación en Windows:
Haz clic en el enlace 2: Install RStudio de la página, “DOWNLOAD RSTUDIO DESKTOP FOR WINDOWS”.
Se abrirá la misma ventana pero te indica la descarga del archivo RStudio-2023.12.1-402 ( o el que se encuentre vigente al momento de instalar)
Ejecuta el archivo descargado ( clic en Abrir)
Sigue las siguientes instrucciones del instalador:
Bienvenida: Selecciona el idioma y haz clic en “Next” (Siguiente).
Acuerdo de licencia: Lee el acuerdo de licencia y, si estás de acuerdo, selecciona “I accept the agreement” (Acepto el acuerdo) y luego haz clic en “Next” (Siguiente).
Opciones de instalación: Elige las opciones de instalación deseadas y haz clic en “Next” (Siguiente).
Ubicación de instalación: Selecciona la ubicación donde deseas instalar RStudio y haz clic en “Install” (Instalar).
Progreso de la instalación: Espera a que la instalación se complete.
Finalización de la instalación: Haz clic en “Finish” (Finalizar) para completar la instalación.
Estos pasos pueden variar ligeramente según la versión específica de RStudio que estés instalando y el sistema operativo que estés utilizando.
2) Instalación en macOS
Abre el archivo descargado (generalmente un archivo .dmg).
Arrastra el ícono de RStudio a la carpeta de Aplicaciones.
Asegúrate de tener instalado R previamente.
3) Instalación en Linux:
Descarga el archivo .deb o .rpm según tu distribución.
Instala el archivo descargado usando el gestor de paquetes de tu distribución. Por ejemplo, en Ubuntu, puedes instalar el archivo .deb con el comando sudo dpkg -i rstudio-x.yy.zzzzz-amd64.deb (reemplaza rstudio-x.yy.zzzzz-amd64.deb con el nombre de tu archivo).
Una vez descargado, RStudio puede ejecutarse buscando el icono:
Deberá estar disponible en buscando en la barra de herramientas o en Programas instalados.
Primera parte
1. Introducciòn
El presente manual ha sido elaborado como una guía para el análisis de datos utilizando el sistema R para computación estadística. El objetivo principal es proporcionar descripciones concisas y claras sobre cómo realizar diversos análisis estadísticos utilizando R. Cada capítulo está dedicado a un análisis específico o a un conjunto de datos particular, con el fin de brindar una guía práctica y detallada para estudiantes de ingeniería ambiental y biología.
En este manual, se ofrece una introducción gradual al entorno de software estadístico R, junto con una variedad de análisis estadísticos comunes. Se abordarán temas como la instalación de R y RStudio, conceptos básicos de programación en R, manipulación de datos, estadística descriptiva, probabilidades, distribuciones de probabilidad, pruebas de hipótesis, análisis de varianza, regresión lineal simple y múltiple, entre otros.
Es importante destacar que este manual no pretende ser un texto exhaustivo sobre R, sino más bien una herramienta práctica y accesible para aquellos que deseen realizar análisis estadísticos utilizando este software. Se espera que al finalizar el manual, los estudiantes puedan comprender y aplicar de manera efectiva los conceptos y técnicas estadísticas presentadas, en el contexto de sus estudios y proyectos en ingeniería ambiental y biología.
Además, para complementar el contenido teórico presentado en este manual, los scripts correspondientes a los análisis estadísticos de cada tema estarán disponibles en un sitio web de Rpubs. En este sitio, los estudiantes podrán acceder a los scripts para su aprendizaje, revisión y adaptación a nuevos ejercicios o ejemplos. Esta herramienta adicional busca facilitar la comprensión y aplicación práctica de los conceptos estadísticos presentados, permitiendo a los usuarios explorar y experimentar con los análisis estadísticos en un entorno interactivo y educativo.
1.1 ¿Por qué R?
R difiere de otros lenguajes de programación en su origen. No fue concebido por ingenieros o desarrolladores de software; en cambio, fue creado por estadísticos con el propósito de ser un entorno interactivo destinado al análisis de datos.La interactividad se presenta como una característica fundamental en el ámbito de la ciencia de datos, ya que, como se comprenderá rápidamente, la capacidad para explorar los datos de manera eficiente se convierte en una necesidad para alcanzar el éxito en este campo. A pesar de estas diferencias, al igual que en otros lenguajes de programación, es posible almacenar el trabajo realizado en forma de scripts que pueden ejecutarse con facilidad en cualquier momento. Estos scripts desempeñan un papel crucial al servir como un registro detallado del análisis llevado a cabo, facilitando así la reproducibilidad del trabajo. Para aquellos que son programadores experimentados, es importante no esperar que R siga las convenciones a las que están acostumbrados, ya que esto podría generar cierta decepción. No obstante, con paciencia, se puede llegar a valorar la destacada capacidad de R en el ámbito del análisis de datos y, en particular, en la visualización de datos.
Otras características atractivas de R abarcan:
-R es una herramienta de acceso gratuito y de código abierto.
-Se ejecuta eficientemente en todas las plataformas principales, tales como Windows, Mac OS y UNIX/Linux.
-La transferencia de scripts y objetos de datos entre plataformas es un proceso sin complicaciones.
-Se destaca por contar con una comunidad considerable, en constante crecimiento y altamente activa de usuarios de R, lo que conlleva a una abundancia de recursos para el aprendizaje y la consulta de dudas.
-La facilidad para que otros contribuyan con extensiones posibilita a los desarrolladores compartir implementaciones de nuevas metodologías en ciencia de datos. Este aspecto proporciona a los usuarios de R acceso temprano a los métodos más recientes y a herramientas desarrolladas para diversas disciplinas, incluyendo las relacionadas con la División Académica de Ciencias Biológicas.
1.2 La consola de R
El análisis interactivo de datos se realiza comúnmente en la consola de R, donde los comandos se ejecutan a medida que los escribes. Existen diversas formas de acceder a la consola de R, y una de ellas consiste en iniciar simplemente R en tu computadora. La apariencia de la consola es similar a la siguiente:
Un ejemplo muy sencillo y práctico para usar la consola es calcular el 15% de $250.00 pesos:
< \(0.15 * 250\)
<\(37.5\)
1.3 Scripts
Una destacada característica de R es la capacidad de preservar tu labor en forma de scripts, los cuales puedes modificar y almacenar mediante un editor de texto. Incluso, el entorno de desarrollo RStudio proporciona un editor con numerosas funcionalidades específicas de R, así como una consola para ejecutar tu código y otros paneles prácticos, incluyendo uno destinado a la visualización de las gráficas generadas en el script.
2. RStudio
RStudio es un entorno de desarrollo integrado (IDE) diseñado para trabajar con el lenguaje de programación R. Proporciona una interfaz gráfica y herramientas que facilitan el desarrollo, la ejecución y la visualización de código en R. RStudio presenta diversas funciones fundamentales, entre las cuales se incluyen un Editor de Script que posibilita la redacción y edición de scripts de R con herramientas como resaltado de sintaxis y autocompletado. La Consola de R proporciona una interfaz interactiva para ejecutar comandos de R directamente y observar los resultados.
El Explorador de Objetos muestra los distintos objetos presentes en el entorno de trabajo, como conjuntos de datos y variables, facilitando así la exploración y comprensión de los datos. Además, ofrece paneles dedicados para visualizar gráficos generados en R y acceder a la documentación y ayuda del lenguaje.
RStudio también cuenta con herramientas de Control de Versiones, permitiendo la integración con sistemas como Git. Asimismo, brinda soporte para Proyectos, simplificando la organización y gestión de proyectos de análisis de datos.
2.1. Los paneles
Cuando inicias RStudio por primera vez, verás tres paneles. El panel izquierdo muestra la consola de R. A la derecha, el panel superior incluye pestañas como Entorno e Historial, mientras que el panel inferior muestra cinco pestañas: Archivo, Gráficos, Paquetes, Ayuda y Visor (estas pestañas pueden cambiar en nuevas versiones). Puedes hacer clic en cada pestaña para moverte entre las diferentes funciones.
Para comenzar un nuevo script, puedes hacer clic en el Menú File, después se despliega un submenú New File y seleccionas R Script
Esta acción abrirá un panel nuevo a la
izquierda, y es aquí donde se comienza a escribir el script.
2.2. Teclas especiales (atajos)
Muchas de las acciones que normalmente realizamos con el ratón pueden llevarse a cabo utilizando combinaciones de teclas en su lugar. A estas alternativas de acciones mediante teclado se les denomina atajos de teclado. Por ejemplo, recién explicamos cómo emplear el ratón para comenzar un nuevo script, pero también tienes la opción de utilizar un atajo de teclado: Ctrl+Shift+N en Windows y Command+Shift+N en Mac.
A pesar de que en este manual mostramos con frecuencia el uso del ratón, es altamente recomendable que memorices los atajos de teclado para las operaciones que realices con mayor frecuencia. RStudio proporciona un útil resumen con los comandos más utilizados, el cual puedes obtener directamente desde RStudio.
2.3. Ejecutando Comandos y editando scripts
Existen muchos editores diseñados específicamente para la codificación. Estos son útiles porque añaden automáticamente color e indentación1 para que el código sea más legible. RStudio es uno de estos editores y fue desarrollado específicamente para R. Una de las principales ventajas que ofrece RStudio sobre otros editores es que podemos probar nuestro código fácilmente mientras editamos nuestros scripts. A continuación, mostramos un ejemplo.
1Estilo de colocación, separación y color del código fuente.
Primero, se debe abrir un nuevo script como se hizo anteriormente. El siguiente paso es darle un nombre al script. Esto se puede hacer guardando el nuevo script sin nombre actual a través del editor. Para hacerlo, se debe hacer clic en el ícono de guardar o utilizar el atajo de teclado Ctrl+S en Windows y Command+S en Mac.
Cuando se guarda el documento por primera vez, RStudio pedirá un nombre. Es recomendable usar un nombre descriptivo, con letras minúsculas, sin espacios, y con guiones para separar palabras, seguido por el sufijo .R. Este script se llamará “mi primer-script-en.R”.
Ahora nos preparamos para editar
nuestro primer script. Las primeras líneas de código en un script de R
se utilizan para cargar o “llamar” las bibliotecas que se utilizarán.
Una función práctica de RStudio es que, al escribir
library( ), se autocompleta con las bibliotecas que tenemos
instaladas. Observa cómo se completa automáticamente al escribir
library(ti):
Otra observación relevante es que al
escribir library( , el segundo paréntesis se añade automáticamente. Esto
resulta útil para evitar uno de los errores más comunes en la
programación: olvidar cerrar un paréntesis.
Ahora, se puede proseguir con la redacción del código. A modo de ejemplo, se creará un gráfico tipo histograma basado en el conjunto de datos “airquality”, que viene incluido (preinstalado) en R y contiene información sobre la calidad del aire en Nueva York. Una vez concluida la redacción del código necesario para generar este gráfico, se puede probar ejecutando el código. Para ello, se debe hacer clic en el botón “Ejecutar” en la esquina superior derecha del panel de edición. También se puede emplear el atajo de teclado Ctrl+Shift+Enter en Windows o Command+Shift+Return en Mac.
Tras ejecutar el código, lo verás
reflejado en la consola de R y, en este caso, el gráfico generado
aparecerá en la consola de gráficos. Observa que la consola de gráficos
cuenta con una interfaz útil que te permite retroceder y avanzar entre
diferentes gráficos, hacer zoom en el gráfico o guardar los gráficos
como archivos.
2.4. Opciones Globales
RStudio permite modificar su apariencia y funcionalidad. Para cambiar las opciones globales, se debe hacer clic en Tools y luego en Global Options. A modo de ejemplo, se mostrará cómo realizar un cambio altamente recomendado: cambiar la opción Save workspace to a .RData on exit a Never y desmarcar Restore .RData into workspace at startup.
Por defecto, cuando se sale de R, este guarda todos los objetos creados en un archivo llamado .RData, de manera que al reiniciar la sesión en la misma carpeta, estos objetos se carguen. Sin embargo, esto puede causar confusión, especialmente al compartir código con colegas que no tienen este archivo .RData. Para evitar estos problemas, se recomienda ajustar las configuraciones generales de la siguiente manera:
2.5. Instalando R Packages
La funcionalidad básica que obtienes después de instalar R por primera vez se conoce como “R base”. Sin embargo, esta es solo una pequeña parte de lo que R puede ofrecer. La verdadera versatilidad y potencial adicional provienen de los complementos desarrollados por terceros, y hay cientos de ellos disponibles en lugares como CRAN y otros repositorios, como GitHub.
Dado que no todos necesitan todas las funciones adicionales, R organiza estas capacidades en “paquetes”. Instalar estos paquetes es muy sencillo desde R. Por ejemplo, si deseas instalar el paquete dslabs, utilizado para compartir conjuntos de datos y código relacionado con este libro, solo necesitas escribir:
Install.packages(“dslabs”)
Otra opción es ir a la pestaña Tools y seleccionar Install Packages.
Posteriormente, se puede cargar el paquete en las sesiones de R
utilizando la función Library:
library(dslabs)
Conforme avances en el manual, observaras que cargamos paquetes sin haberlos instalado previamente. La razón es, que una vez que instalas un paquete, permanece instalado y solo requiere cargarse con library. El paquete permanece cargado hasta que cierres la sesión de R. Si al cargar un paquete recibes un mensaje de error, es muy probable que se resuelva instalando primero el paquete.
En una misma instrucción puedes instalar más de un paquete a la vez:
install.packages(“dslabs”, “tidyverse”)
Hay algunos paquetes que instalan varios paquetes a la vez. Esto sucede porque un paquete tiene dependencias o utiliza funciones de otros paquetes. Entonces, cuando cargas un paquete con library, tambien cargas sus dependencias. Una vez instalados los paquetes de R ya no necesitas instalarlos nuevamente, a menos que cambies a una versión nueva de R. No olvides que los paquetes se instalan en R no en RStudio.
Tip: Crea un script que contenga la lista de todos los paquetes necesarios para tu trabajo, si por alguna razón necesitas realizar una instalación nueva de R, puedes reinstalar todos los paquetes ejecutando el script donde los tienes listados.
3. Básicos de programación en R
En su función más básica, R se puede emplear como una calculadora de escritorio sencilla. En esta sección, exploraremos cómo utilizar el software para realizar cálculos aritméticos y cómo guardar los resultados para su uso posterior en otras operaciones. Posteriormente, te introducirás en el mundo de los vectores, que te brindan la capacidad de manejar múltiples valores simultáneamente. Los vectores representan una herramienta fundamental en R, ya que gran parte de la funcionalidad del software fue diseñada teniendo en cuenta las operaciones con vectores. Te familiarizarás con algunas formas comunes y prácticas de manipular vectores, aprovechando el enfoque orientado a vectores de R.
3.1. Numéricos, aritmética, asignación y vectores
En R, rigen las reglas matemáticas estándar que siguen el orden usual de izquierda a derecha en las operaciones: paréntesis, exponentes, multiplicación, división, suma y resta (Jerarquía de operadores). Aquí tienes unos ejemplos:
Y como se verían en el escritorio de RStudio:
Tip
: Recuerda que por cada linea de código tienes que dar click en el botón
Run, para que puedas ver en la consola (panel inferior izquierdo) los
resultados de cada una de las operaciones ejecutadas.
Puedes encontrar la raíz cuadrada de cualquier número positivo con la función sqrt. Simplemente asigna el número deseado a x, como se muestra aquí:
Y como se vería en el entorno de RStudio
Al utilizar R, es común encontrarse
con la necesidad de convertir una fórmula aritmética compleja en código
para su evaluación, especialmente al replicar cálculos de libros de
texto o artículos de investigación. Los ejemplos a continuación
presentan un cálculo expresado matemáticamente, seguido de su
implementación en R.
Quedando en RStudio de la siguiente manera:
3.2. Logaritmos y exponenciales
Es muy común encontrar información donde se requiera aplicar una transformación logarítmica a determinados datos. Este proceso implica reescalar los números según el logaritmo. Cuando se proporciona un número específico, denotado como \(x\), y un valor llamado base, el logaritmo calcula la potencia a la que debes elevar la base para obtener \(x\). Por ejemplo, si \(x = 243\) y la base es 3 (expresado matemáticamente como \(log_3 243\)), el resultado es 5, ya que \(3^5=243\) . En R, la transformación logarítmica se realiza mediante la función log. Debes proporcionar a log el número que deseas transformar, asignado a \(x\), y la base, asignada a base, de la siguiente manera:
Recuerda siempre que los valores de x y la base siempre deben ser positivos, que el logaritmo de \(x=1\) siempre es 0 independientemente de la base.
Existe un tipo particular de transformación logarítmica comúnmente utilizada en matemáticas llamada logaritmo natural, que fija la base en un número matemático especial, el número de Euler. Este se representa convencionalmente como e y es aproximadamente igual a \(2.718\). El número de Euler da origen a la función exponencial, definida como e elevado a la potencia de x, donde x puede ser cualquier número (negativo, cero o positivo). La función exponencial, \(f(x) = e^x\), se escribe a menudo como \(exp(x)\) y representa la inversa del logaritmo natural, de manera que
\(exp(loge(x)) = loge(exp(x)) = x.\)
El comando R para la función exponencial es exp:
$ exp(x=3)$
Ejercicios:
Utilizando R, verifica que \(3 \cdot a + \frac{27}{2.5^2 - 2.82}\) es igual a 20.345 cuando a=1.8
¿Cuál de las siguientes expresiones eleva al cuadrado -3 y le suma 1 al resultado?
- \((-3)^2 +1\)
- \(-3^2 + 1\)
- \((-3)^{2+1}\)
- \(-3^{2+1}\)
Utilizando R, ¿cómo calcularías la raíz cuadrada de la tercera parte del promedio de los números 18.2, 13, 14.44, 13.7 y 16.6?
Encuentra el logaritmo natural de (0.7)
Calcula la transformación exponencial de tu respuesta en (D).
3.3. Asignación de Objetos
R sigue el paradigma de la programación orientada a objetos, donde cada comando genera un objeto que debe ser “nombrado” utilizando (<-) para permanecer en la memoria, y su nombre debe ser “invocado” para mostrarse en la pantalla. Básicamente, esto implica almacenar algún elemento o resultado bajo un nombre específico para facilitar el acceso posterior, evitando tener que volver a escribir ese cálculo. En este manual, utilizaremos los términos “asignar” y “almacenar” de manera intercambiable. Es importante señalar que algunos libros o manuales se refieren a un objeto almacenado como una “variable” debido a la capacidad de sobrescribir fácilmente ese objeto y cambiarlo por algo diferente, lo que implica que su representación puede variar a lo largo de un proyecto o script. No obstante, en este manual emplearé el término “objeto” de manera consistente, ya que abordaremos las variables en una sección posterior como un concepto estadístico claramente diferenciado.
# El símbolo # sirve para comentariar o desactivar el espacio a la derecha
# Nos sirve para poner notas o aclaraciones en cada linea de código
# El comando más básico: Asignar crea objetos.
# Puede usarse = en su reemplazo o -> para asignar el nombre al final.
# Para unificar el estilo de todas las rutinas usa <-
n <- 37
n #escribir el nombre de un objeto es “invocarlo”
# al usar de nuevo el mismo nombre el objeto anterior se pierde
n <- 46 + 12
n
# los caracteres categóricos necesitan ser ingresados con comillas
letra <- "A"
letraEn el entorno de RStudio quedaría de la siguiente manera:
Ejercicios
Crea un objeto que almacene el valor de \(3^2×4^{1⁄8}\)
Sobrescribe tu objeto del inciso A dividiéndolo entre \(3.66\). Imprime el resultado en la consola
Crea un nuevo objeto con el valor de \(-4.1×10^{-13}\)
Imprime de manera directa en la consola el resultado de multiplicar el inciso B por el C
3.4. Vectores
En el contexto de programación y ciencias de la computación, un vector se refiere a una estructura de datos que almacena elementos de manera secuencial. A diferencia del concepto matemático, en este contexto, no implica necesariamente magnitud y dirección.
Un vector en programación puede ser una colección de elementos homogéneos, es decir, del mismo tipo, como números, caracteres o cualquier otro tipo de dato. La idea fundamental es que estos elementos están dispuestos en una secuencia, y cada elemento puede ser accedido mediante un índice. Cuentan con una serie de características como son:
Secuencialidad: Los elementos se almacenan en una secuencia ordenada.
Acceso por índice: Cada elemento en el vector tiene un índice asociado que se utiliza para acceder a ese elemento específico. Los índices suelen comenzar desde 0 o 1, dependiendo del lenguaje de programación.
Homogeneidad: Todos los elementos en un vector son del mismo tipo de dato.
Los vectores son fundamentales para trabajar con conjuntos de datos, realizar cálculos y aplicar operaciones a cada elemento.
Para R los vectores son fundamentales para manejar múltiples elementos. Desde el punto de vista numérico, un vector es una colección de observaciones o mediciones relacionadas con una sola variable, por ejemplo, las temperaturas diarias de un lugar específico durante un mes o las concentraciones de dióxido de carbono en diferentes lugares a lo largo del tiempo.
# ejemplos de vectores
temperaturas <- c(25.3, 26.8, 24.5, 23.2, 25.9, 27.5, 28.1, 26.7, 25.4, 24.8, 23.6, 25.2, 26.6, 27.3, 26.9, 24.7, 23.9, 25.1, 27.0, 28.5, 26.4, 25.7, 24.2, 23.8, 25.6, 27.2, 28.0, 26.3, 25.0, 24.4, 23.5, 25.8)
co2_concentraciones <- c(402.1, 404.5, 406.2, 403.8, 405.7, 408.0, 407.3, 403.2, 404.8, 406.5, 408.2, 405.6, 404.1, 407.8, 409.2, 406.7, 404.9, 408.5, 410.0, 407.4, 405.3, 409.1, 411.2, 408.8, 406.4, 404.3, 407.0, 412.1, 410.5, 408.7, 405.9, 404.0)Este es un enunciado de asignación que hace uso de la función
c( ), la cual en este contexto tiene la capacidad de
aceptar un número variable de argumentos vectoriales. Su resultado es un
vector obtenido al concatenar sus argumentos de principio a fin. Si un
número aparece solo en una expresión, se interpreta como un vector de
longitud uno. Es importante notar que el operador de asignación
(<-) está compuesto por los caracteres <
(“menos que”) y - (“menos”) que aparecen estrictamente uno
al lado del otro y apuntan al objeto que recibirá el valor de la
expresión. En la mayoría de los contextos, el operador =
puede ser utilizado como una alternativa válida.
3.4.1. Creación de un vector
Crea los siguientes vectores de la siguiente manera:
También puedes vectores de caracteres, recuerda que debes usar las comillas dobles para denotar la entrada de datos tipo carácter en lugar de nombres de variables
También puedes usar comillas sencillas o individuales
Tip: Recuerda no confundir la comilla simple con la comilla invertida.
Ahora bien, que si escribes el código de la siguiente manera:
Recibirás un mensaje de error porque las variables Tabasco, Veracruz y Campeche no están definidas. Sino usas comillas, R buscará variables con esos nombres y al no encontrarlas te devuelve un error.
En el entorno de R quedaría de la siguiente manera:
Algunas ocasiones es de mucha utilidad ponerles nombre a las entradas de un vector. Siguiendo con el ejemplo anterior, le asignaríamos códigos a los Estados de la República, usando sus nombres para conectar ambos.
# estados de la republica y su código
estadosmx <- c(Tabasco = 030, Veracruz = 031, Campeche = 012)
estadosmxEl objeto estadosmx sigue siendo un vector numérico.
Verifícalo con la instrucción class(estadosmx)
3.4.2. Secuencia, repetición, búsqueda y longitud
R ofrece diversas herramientas para generar secuencias de números.
Por ejemplo, al escribir 1:30, obtenemos el vector
c(1, 2, ..., 29, 30). El operador de dos puntos tiene una
alta prioridad en las expresiones, por lo que, al escribir
2*1:15, generamos el vector
c(2, 4, ..., 28, 30). Si definimos n <- 10,
podemos comparar las secuencias 1:n-1 y 1:(n-1).
La construcción 40:1 se emplea para generar una
secuencia en orden inverso.
La función seq() es la más facil para generar
secuencias. Consta de cinco argumentos, y solo algunos de ellos se
pueden especificar en cada ejecución. Los dos primeros argumentos, si se
proporcionan, indican el inicio y el final de la secuencia. Si estos son
los únicos dos argumentos dados, el resultado es equivalente al operador
de dos puntos, es decir, seq(2,10) es igual al vector
2:10.
Los argumentos de seq() y de muchas otras funciones en R
también se pueden proporcionar mediante nombres, en cuyo caso el orden
en que aparecen no afecta. Los dos primeros argumentos pueden
denominarse from=value y to=value; por
ejemplo, seq(1,30), seq(from=1, to=30), y
seq(to=30, from=1) son equivalentes a 1:30.
Los dos argumentos siguientes de seq() pueden llamarse
by=value y length=value, especificando el
tamaño del paso y la longitud de la secuencia, respectivamente. Si no se
proporciona ninguno de estos, se asume el valor predeterminado
by=1.
Escribe el siguiente código:
El resultado sería un vector que va de -7 a 7 en saltos de 0.2.
Ahora bien. La siguiente instrucción te generan el mismo vector que el anterior:
En R quedaría de la siguiente manera:
Repeticiones con
rep()
Como ya vimos, las secuencias son extremadamente útiles, pero algunas
veces solo queremos repetir cierto valor. Esto lo puedes hacer usando la
función rep().
# Repetición utilizando la función rep()
Repeticion1 <- rep(x=1,times=4)
Repeticion1
Repeticion2 <- rep(x=c(3,62,8.3),times=3)
Repeticion2
Repeticion3 <- rep(x=c(3,62,8.3),each=2)
Repeticion3
Repeticion4 <- rep(x=c(3,62,8.3),times=3,each=2)
Repeticion4En RStudio quedaría de la siguiente manera:
Ordenar un vector
Clasificar un vector en orden ascendente o descendente según sus
elementos es otra tarea sencilla que se presenta en las actividades
diarias. La función convenientemente denominada sort()
realiza exactamente esa operación.
La función sort() es bastante directa. Debes
proporcionar un vector como argumento x a la función y, como segundo
argumento, “decreasing” indica el orden en el que deseas realizar la
clasificación. Este argumento utiliza un tipo de valor que aún no has
encontrado: uno de los valiosos valores lógicos.
Un valor lógico se puede definir únicamente como uno de dos valores
específicos y distinguidos por mayúsculas: TRUE o
FALSE. En términos generales, los valores lógicos se
emplean para señalar el cumplimiento o la falta de cumplimiento de
ciertas condiciones, constituyendo una parte esencial de todos los
lenguajes de programación. En relación con la función sort,
puedes establecer decreasing=FALSE para ordenar de menor a
mayor, y decreasing=TRUE para ordenar de mayor a menor.
# Ordenando vectores utilizando la función sort()
Ordenamiento1 <- sort(x=c(2.5,-1,-10,3.44),decreasing=FALSE)
Ordenamiento1
Ordenamiento2 <- sort(x=c(2.5,-1,-10,3.44),decreasing=TRUE)
Ordenamiento2
Secuencia <- seq(from=4.3,to=5.5,length.out=8)
Secuencia
Ordenamiento4 <- sort(x=Secuencia,decreasing=TRUE)
Ordenamiento4
Ordenamiento5 <- sort(x=c(Secuencia,Ordenamiento4),decreasing=FALSE)
Ordenamiento5En RStudio quedaría de la siguiente manera:
Ejercicios
Crea y almacena una secuencia de valores desde 8 hasta -16, avanzando en pasos de 0.4
Sobrescribe el objeto del apartado (a) utilizando la misma secuencia con el orden invertido.
Crea y almacena un vector que contenga, en cualquier configuración, lo siguiente:
- Una secuencia de enteros desde 3 hasta 18 (inclusive)
- Tres repeticiones del valor 8.5
- El número -3
3.4.3. Selección y extracción de elementos
Para acceder a elementos específicos de un vector, utilizamos corchetes cuadrados. En los vectores previamente definidos, podemos recuperar el segundo elemento escribiendo el nombre del vector seguido de la posición deseada entre corchetes. Es importante destacar que los corchetes cuadrados permiten la manipulación y recuperación de elementos específicos dentro de un vector en función de su posición.
Retomamos el ejemplo # estados de la república y la última instrucción te permitirá extraer el valor que está en la segunda posición del vector:
También puedes obtener más de dos valores utilizando un vector de múltiples entradas:
Las secuencias vistas en un apartado anterior son particularmente útiles si queremos acceder, por ejemplo, a los dos primeros elementos:
En RStudio quedaría de la siguiente manera:
3.5. Matrices y Arreglos
En el ámbito de la programación y las matemáticas computacionales, las matrices y los arreglos son estructuras de datos fundamentales que permiten organizar y manipular conjuntos de datos de manera eficiente. Ambos conceptos son esenciales para realizar operaciones avanzadas en disciplinas como la estadística, la inteligencia artificial y el análisis de datos.
Una matriz es una estructura bidimensional compuesta por filas y columnas, que puede contener números, variables u otros elementos. Cada elemento de la matriz está identificado por dos índices: uno que indica la fila y otro que indica la columna. Por ejemplo, una matriz A podría representarse como:
Donde \(A_2,_3\) representa el elemento en la segunda fila y tercera columna (en este caso, 6).
Los arreglos son estructuras más generales que pueden tener más de dos dimensiones. A diferencia de las matrices bidimensionales, los arreglos pueden tener cualquier número de dimensiones, lo que los hace más versátiles para representar datos complejos. Por ejemplo, un arreglo tridimensional B podría expresarse como:
En este caso, \(B_2,_1,_2\) representa el elemento en la segunda matriz, primera fila y segunda columna (en este caso, 10).
3.5.1. Definición de una matriz
Una matriz se describe como A de \(m\) × \(n\), lo que significa que tiene exactamente m filas y n columnas. Lo que se traduce en un total de mn entradas. Donde cada entrada tiene un lugar único \(a_i,_j\) determinada por su fila específica \((i = 1,2,...,m)\) y columna \((j = 1,2,...,n)\).
Expresaríamos lo anterior de la siguiente manera:
Vamos con los primeros ejemplos:
# matrices
A <- matrix(data=c(-7,10, 250,0,79), nrow=2, ncol=2)
A
Matriz1 <- matrix(1:20, 5, 4)
Matriz1En RStudio quedaría de la siguiente manera:
Puedes acceder a posiciones específicas en una matriz utilizando corchetes cuadrados ([). Si deseas la segunda fila y la tercera columna, usas:
Si quieres todos los valores de la segunda fila, dejas vacío el espacio de la columna:
Al igual que lo anterior, si quieres todos los valores de la primera columna, dejas vacio el espacio de la fila:
También puedes acceder a más de una columna o más de una fila, el resultado será una nueva matriz.
Si tienes varios vectores de longitud igual, puedes construir
rápidamente una matriz al unir estos vectores utilizando las funciones:
rbind () y cbind (). Puedes tratar cada vector
como una fila (usando el comando rbind) o tratar cada
vector como una columna (usando el comando cbind).
Puedes crear dos vectores con los elementos 1:3 y 4:6 para
reconstruir la matriz 2 × 3 usando rbind de la siguiente
manera:
La misma matriz podría construirse de la siguiente manera, utilizando
cbind:
En RStudio quedaría de la siguiente manera:
Como podrás observar, rbind ha combinado los vectores en forma de dos filas en una matriz, donde el orden de las filas de arriba hacia abajo coincide con el orden de los vectores proporcionados a rbind.
La función dim() nos retorna la dimensión, o sea, el
número de columnas y renglones de la matriz o arreglo
# función dim
ladimension <- rbind(c(1,3,4),5:3,c(100,20,90),11:13)
ladimension
dim(ladimension)
nrow(ladimension)
ncol(ladimension)
dim (ladimension)[2]En RStudio quedaría de la siguiente manera:
Ejecuta el siguiente ejemplo en tu proyecto de RStudio
# función dim
ladimension2 <- array(1:20, dim=c(4,5)) # Genera un arreglo de 4 por 5.
ladimension2
i <- array(c(1:3,3:1), dim=c(3,2)) # i es una matriz de 3 x 2
i
ladimension2[i] # extrae esos elementos
ladimension2[i] <- 0 # reemplaza esos elementos por ceros
ladimension2Debe de quedar en Rstudio de la siguiente manera:
3.5.2. Selección
La extracción y selección de elementos de matrices en R se parece mucho a la extracción de elementos de vectores. La única complejidad radica en que ahora hay una dimensión adicional. Aún se utiliza el operador de corchetes cuadrados [ ], pero ahora debe realizarse con una posición específica de fila y columna, proporcionadas estrictamente en el orden [fila, columna].
# selección de elementos de una matriz
A <- matrix((c(12, 34.5, 078, 32.4, 87, 54.6, 12, 7.90, 17.1), nrow=3, ncol=3)Le decimos a R que nos traiga el elemento contenido en la tercera fila y la segunda columna:
En RStudio quedaría de la siguiente manera:
3.5.3. Operaciones y algebra con matrices
Las matrices en R pueden ser utilizadas desde dos perspectivas distintas. En primer lugar, sirven como una herramienta computacional en programación para almacenar y operar con resultados. En segundo lugar, pueden emplearse por sus propiedades matemáticas en cálculos pertinentes, como la multiplicación de matrices para expresar ecuaciones de modelos de regresión. Es esencial señalar esta distinción ya que el comportamiento matemático de las matrices no siempre coincide con el comportamiento más genérico asociado al manejo de datos. Se proporcionará una breve descripción de algunas matrices especiales, así como de las operaciones matemáticas más comunes con matrices y la funcionalidad correspondiente en R.
3.5.3.1. Suma y resta de matrices
Se dice que dos matrices son compatibles cuando tienen el mismo tamaño, esto es, que tienen el mismo número de filas y columnas. Cuando se cumple esta condición, entonces los elementos correspondientes pueden sumarse o restarse entre sí, según la operación.
# suma y resta de matrices
Matriz1 <- cbind(c(2,5,2),c(6,1,4))
Matriz1
Matriz2 <- cbind(c(-2,3,6),c(8.1,8.2,-9.8))
Matriz2
Matriz1-Matriz2 # Resta de matrices
Matriz1+Matriz2 # Suma de matricesEn RStudio quedaría de la siguiente manera:
3.5.3.2. Multiplicación de matrices
Al trabajar con matrices, encontramos dos tipos de multiplicación: la multiplicación escalar y la multiplicación de matrices. La multiplicación escalar implica multiplicar una matriz por un solo número. La multiplicación de matrices implica multiplicar una matriz por otra matriz.
Para multiplicar dos matrices, es necesario que el número de columnas de la primera matriz sea igual al número de filas de la segunda matriz. La matriz resultante tendrá el mismo número de filas que la primera matriz y el mismo número de columnas que la segunda.
# multiplicación de matrices
Matriz1 <- rbind(c(2,5,2),c(6,1,4))
dim(Matriz1)
Matriz2 <- cbind(c(4,2,7),c(-6,3,9))
dim(Matriz2)
## confirmado que las matrices se pueden multiplicar, entonces
Matriz1 %*% Matriz2La multiplicación de matrices no es conmutativa utilizando las mismas dos matrices. Cambiar el orden de la multiplicación te proporciona un resultado completamente diferente. Agrega la siguiente instrucción a tu script:
En Rstudio los resultados deben verse de la siguiente manera:
Un valor escalar se refiere a un solo valor (univariado) que cuando es multiplicado por cualquier matriz , obtenemos una matriz en la que cada elemento de la matriz se ha multiplicado por el valor escalar.
# multiplicación escalar de matrices
Matriz1 <- rbind(c(5,2,5),c(7,2,3))
dim(Matriz1)
x <- 3
x * Matriz1En RStudio quedaría de la siguiente manera:
3.5.3.3. Matriz transpuesta
La matriz transpuesta de una matriz \(A\) se obtiene al intercambiar sus filas por columnas. En otras palabras, si A tiene dimensiones \(m × n\), la matriz transpuesta, denotada como \(A^T\), tendrá dimensiones \(n × m\), y sus elementos serán los mismos que los de A, pero reflejados respecto a su diagonal principal.
En R la función es t( ) y es muy facil de usar
En RStudio quedaría de la siguiente manera:
3.5.3.4. Matriz identidad
La matriz identidad, denotada como \(I_n\), es una matriz cuadrada de tamaño \(n×n\) que tiene 1 \((unos)\) en su diagonal principal y \(0 (ceros)\) en el resto de sus elementos. Es decir, para cada \(i-ésima\) fila y \(j-ésima\) columna de \(I_n\), el elemento en la posición \(i,j\) es igual a \(1\) si \(i = j\) y \(0\) si \(i ≠ j\). La matriz identidad es única en el sentido de que cualquier otra matriz cuadrada que la multiplique, ya sea desde la izquierda o la derecha, dará como resultado la misma matriz. Además, la multiplicación de cualquier matriz por la matriz identidad no altera la matriz original.
En Rstudio quedaría de la siguiente manera:
Tip:
Usando diag( ), puedes crear fácilmente una matriz
identidad de cualquier dimensión. El comportamiento de diag
depende del argumento que le proporcionas: si es una matriz, recuperará
los elementos diagonales; si es un solo número entero positivo, como en
este caso, generará la matriz identidad correspondiente a esa
dimensión
3.5.4. Arreglos multidimensionales
Los arreglos multidimensionales son estructuras de datos en programación que permiten almacenar elementos en múltiples dimensiones, organizados en forma de una tabla o matriz con filas y columnas. Los arreglos multidimensionales pueden tener más de una dimensión, lo que significa que se pueden representar como matrices tridimensionales, cuatridimensionales y así sucesivamente. Cada dimensión adicional agrega una capa adicional de índices para acceder a elementos específicos dentro del arreglo. Este tipo de estructuras son útiles cuando se trabaja con conjuntos de datos complejos que requieren una organización en varias dimensiones para su representación eficiente.
Para construir estas estructuras de datos, R emplea la función
array y detalla los elementos individuales en el argumento
data como un vector. Posteriormente, especifica las
dimensiones utilizando el argumento dim como otro vector
cuya longitud coincida con el número de dimensiones. Es importante
señalar que la función array llena las entradas de cada
capa con los elementos en data de manera estricta en
columnas, comenzando con la primera capa.
En RStudio quedaría de la siguiente manera:
Esto crea un array con la misma dimensión, donde cada una de las dos
capas forma una matriz de 4 × 3. Al igual que con una matriz única, la
multiplicación de los tamaños de las dimensiones del array resulta en el
número total de elementos. A medida que incrementas la dimensionalidad,
el vector dim debe extenderse correspondientemente. Como
ejemplo, un array de cuatro dimensiones es el siguiente nivel y puede
concebirse como bloques de arrays tridimensionales. Imaginemos que
disponemos de un array de cuatro dimensiones compuesto por tres copias
de AM, el array tridimensional definido anteriormente. Este nuevo array
se puede almacenar en R de la siguiente manera (nuevamente, el array se
llena en columnas):
En Rstudio quedaría de la siguiente manera:
3.6. Valores no numéricos
En R, los valores no numéricos, como texto, factores y variables categóricas, son esenciales para trabajar con conjuntos de datos diversos. Además, los valores lógicos en R, que solo pueden ser TRUE o FALSE, desempeñan un papel crucial. Estos valores lógicos representan conceptos de sí/no, uno/cero, satisfecho/no satisfecho, y tienen múltiples aplicaciones, como indicar si se cumple una condición o si un parámetro debe estar activado o desactivado.
3.6.1. Valores lógicos Verdadero/Falso
En el lenguaje de programación R, los valores lógicos se expresan de
manera completa como TRUE y FALSE, pero con frecuencia se abrevian como
T o F. Esta versión abreviada no afecta la ejecución del código; por
ejemplo, utilizar decremento = T es equivalente a
decremento = TRUE en la función de ordenación. Sin embargo,
es recomendable no crear objetos con nombres T o F si deseas aprovechar
esta conveniencia. Asignar valores lógicos a un objeto sigue el mismo
procedimiento que asignar valores numéricos.
En RStudio quedaría de la siguiente manera:
Lo anterior nos dice que cualquier objeto puede tomar el valor de TRUE o FALSE.
Dentro del ámbito de la programación en R, es fundamental destacar que los vectores pueden ser llenados con valores lógicos de manera directa. Asimismo, este mismo principio se extiende a la creación de matrices y otros arreglos con dimensiones superiores. Al aplicar este concepto de manera más general, podemos construir estructuras de datos que involucren valores lógicos sin depender de nombres específicos de variables.
# Verdadero o falso para vectores
vec1 <- c(T,F,F,F,T,F,T,T,T,F,T,F)
vec1
length(x=vec1)
# verdadero o falso para matrices
Matriz1 <- matrix(data=vec1,nrow=3,ncol=4,byrow=var1)En RStudio quedaría de la siguiente manera:
3.6.2. Operadores relacionales
En el contexto del lenguaje de programación R, los “Operadores Relacionales” se utilizan para establecer relaciones entre valores, permitiendo la realización de comparaciones entre dos elementos y obteniendo un resultado lógico. Estas herramientas son fundamentales en programación, ya que posibilitan la evaluación de expresiones para determinar su veracidad o falsedad.
los operadores relacionales comunes son:
• Igual a (==): Comprueba si dos valores son iguales.
• ¡No igual a (!=): Verifica si dos valores no son iguales.
• Mayor que (>): Evalúa si el primer valor es mayor que el segundo.
• Menor que (<): Indica si el primer valor es menor que el segundo.
• Mayor o igual que (>=): Comprueba si el primer valor es mayor o igual al segundo.
• Menor o igual que (<=): Verifica si el primer valor es menor o igual al segundo.
# Operadores Relacionales
5 == 5 # Resultado: TRUE
5 != 3 # Resultado: TRUE
8 > 3 # Resultado: TRUE
2 < 7 # Resultado: TRUE
5 >= 5 # Resultado: TRUE
4 <= 6 # Resultado: TRUE
## tambien se utilizan en estructuras condicionales, aunque el tema lo veremos más adelante
if (5 > 3) {
print("La condición es verdadera.")
} else {
print("La condición es falsa.")
}
Otro ejemplo, donde se comparan dos vectores utilizando un operador relacional:
# Operadores Relacionales con vectores
var1 <- c(3,2,1,4,1,2,1,-1,0,3)
var2 <- c(4,1,2,1,1,0,0,3,0,4)
length(x = var1) == length(x = var2)En RStudio quedaría de la siguiente manera:
3.6.3. Operadores lógicos
La utilidad fundamental de los valores lógicos se manifiesta al examinar la satisfacción de múltiples condiciones. En diversos escenarios, se busca realizar operaciones específicas solo tras haberse cumplido distintas condiciones. Los operadores lógicos, diseñados para contrastar dos objetos con valores TRUE o FALSE, se basan en las afirmaciones de AND y OR. Es relevante destacar que tanto AND como OR presentan variantes “única” y “elemento a elemento”.
Aquí te presento una tabla básica de algunos operadores lógicos en R, su interpretación y los resultados que producen:
| Operador | Interpretación | Resultado |
|---|---|---|
| & | AND (elemento a elemento) | Verdadero si ambos operandos son verdaderos |
| (TRUE & TRUE es TRUE) | ||
| && | AND (comparación única) | Verdadero si ambos operandos son verdaderos |
| (TRUE && TRUE es TRUE) | ||
| | | OR (elemento a elemento) | Verdadero si al menos uno de los operandos es verdadero |
| (TRUE | TRUE es TRUE) | ||
| (TRUE | FALSE es TRUE) | ||
| (FALSE | TRUE es TRUE) | ||
| (FALSE | FALSE es FALSE) | ||
| || | OR (comparación única) | Verdadero si al menos uno de los operandos es verdadero |
| (TRUE || TRUE es TRUE) | ||
| (TRUE || FALSE es TRUE) | ||
| (FALSE || TRUE es TRUE) | ||
| (FALSE || FALSE es FALSE) | ||
| ! | NOT | Niega el valor, convierte TRUE en FALSE y viceversa |
| (!TRUE is FALSE, !FALSE is TRUE |
# Operadores lógicos
# Utilizando el operador &
TRUE & TRUE # Resultado: TRUE
TRUE & FALSE # Resultado: FALSE
FALSE & TRUE # Resultado: FALSE
FALSE & FALSE # Resultado: FALSE
# Utilizando el operador &&
TRUE && TRUE # Resultado: TRUE
TRUE && FALSE # Resultado: FALSE
FALSE && TRUE # Resultado: FALSE
FALSE && FALSE # Resultado: FALSE
# Utilizando el operador |
TRUE | TRUE # Resultado: TRUE
TRUE | FALSE # Resultado: TRUE
FALSE | TRUE # Resultado: TRUE
FALSE | FALSE # Resultado: FALSE
# Utilizando el operador ||
TRUE || TRUE # Resultado: TRUE
TRUE || FALSE # Resultado: TRUE
FALSE || TRUE # Resultado: TRUE
FALSE || FALSE # Resultado: FALSE
# Utilizando el operador !
!TRUE # Resultado: FALSE
!FALSE # Resultado: TRUE
Aquí tienes unos ejemplos más:
# Operadores lógicos
# Supongamos dos números
numero1 <- 5
numero2 <- 8
# Utilizando el operador &
resultado_and <- numero1 > 0 & numero2 < 10
print(resultado_and) # Resultado: TRUE
# Supongamos dos números
numero1 <- 15
numero2 <- 3
# Utilizando el operador |
resultado_or <- numero1 > 10 | numero2 < 5
print(resultado_or) # Resultado: TRUEEn RStudio quedaría de la siguiente manera:
3.6.4. Caracteres
3.6.4.1. Cadenas de texto
En programación, una cadena de texto o “string” es una secuencia de caracteres. Estos caracteres pueden incluir letras, números, espacios y otros caracteres especiales. Las cadenas de texto se utilizan para representar y manipular texto en programas de computadora. En R, las cadenas de texto se utilizan a menudo para especificar ubicaciones de carpetas u opciones de software, para proporcionar un argumento a una función, y para anotar objetos almacenados, proporcionar salidas de texto o ayudar a aclarar gráficos y visualizaciones. De manera sencilla, también se pueden utilizar para definir diferentes grupos que componen una variable categórica.
En R se crean las cadenas de texto utilizando comillas simples \((')\) o dobles \((")\). Por ejemplo:
# Cadenas de Texto o String
cadenasimple <- ‘ mi primera cadena de texto ’
cadenadoble <- “ mi primera cadena de texto “En R, la cadena de texto también se le considera como una entidad
única. En otras palabras, “cadenasimple” tambien es un vector de
longitud 1 porque R cuenta únicamente el número total de cadenas
distintas en lugar de contar palabras o caracteres individuales. Si
deseas contar el número de caracteres individuales, puedes emplear la
función nchar.
En RStudio quedaría de la siguiente manera:
3.6.4.2. Concatenación
Concatenar se refiere a la unión o combinación de dos o más cadenas de texto en un solo conjunto continuo. Técnicamente hablando, concatenar implica crear una nueva cadena de caracteres a partir de la secuencia de caracteres originales, una después de la otra.
En R, hay dos funciones principales, cat y
paste, que se utilizan para unir cadenas de texto. La
distinción principal entre ellas radica en cómo manejan la salida. La
función cat muestra directamente su salida en la consola
sin devolver nada formalmente. Por otro lado, paste
concatena las cadenas y devuelve la cadena final como un objeto R que
puede ser utilizado en funciones adicionales o de manera secundaria, más
allá de simplemente mostrarla en la consola.
# Concatenar
# Concatenando Cadenas de Texto
especie <- "Panda Gigante"
poblacion <- 1864
# Imprimir directamente en la consola
cat("La población de", especie, "en peligro de extinción es de aproximadamente", poblacion, "individuos.")
# Ejemplos usando la funcion paste
tipos_arboles <- c("Pino", "Roble", "Cedro")
# Concatenar y devolver como objeto de R
tipos_arboles_concatenados <- paste(tipos_arboles, collapse=", ")
tipos_arboles_concatenadosEn RStudio quedaría de la siguiente manera:
3.6.5. Factores
Los factores son una estructura de datos utilizada para representar variables categóricas o de tipo ordinal. Un factor en R es esencialmente un vector que puede contener un conjunto finito de niveles o categorías diferentes. Se emplea cuando los datos tienen una naturaleza discreta y pueden clasificarse en un número predefinido de categorías o niveles.
Los factores son útiles para representar variables en contextos ambientales o biológicos, como la clasificación de especies en un estudio de biodiversidad, los diferentes tipos de hábitats en un ecosistema o las categorías de riesgo ambiental en un análisis de impacto ambiental. Al utilizar factores, se facilita el análisis estadístico y la manipulación de datos categóricos, ya que R puede reconocer y tratar estos factores de manera específica.
Además, los factores en R tienen la capacidad de asignar niveles específicos a las categorías, lo que puede ser útil para mantener un orden lógico en variables ordinales. Los factores son una herramienta esencial en estadística y análisis de datos cuando se trabaja con variables categóricas, especialmente en el ámbito ambiental o biológico.
3.6.5.1. Identificando categorías
Imaginemos que llevamos a cabo un estudio de biodiversidad en el estado de Tabasco, en el sur de México. Contamos con una lista de especies locales clasificadas en diferentes niveles de amenaza. Podemos utilizar factores para representar el estado de conservación de cada especie, asignando niveles como “No Evaluado,” “Preocupación Menor,” “Vulnerable,” y “En Peligro de Extinción.”
# Concatenar
# Factores y categorias
# Concatenando Cadenas de Texto
# Factores y categorías
# Crear un vector de especies locales en Tabasco
especies_tabasco <- c("Tapir", "Jaguar", "Manatí", "Tucán", "Quetzal", "Mono Araña")
# Crear un factor para representar el estado de conservación
estado_conservacion_tabasco <- factor(c("Preocupación Menor", "En Peligro de Extinción", "Vulnerable", "No Evaluado", "Vulnerable", "En Peligro de Extinción"),
levels = c("No Evaluado", "Preocupación Menor", "Vulnerable", "En Peligro de Extinción"),
ordered = TRUE)
# Imprimir el factor
estado_conservacion_tabascoEn RStudio quedaría de la siguiente manera:
Otro ejemplo: supongamos que estamos realizando un análisis de impacto ambiental y clasificamos diferentes proyectos según su impacto ambiental. Podemos utilizar factores para representar las categorías de impacto ambiental, como “Bajo,” “Moderado,” y “Alto.”
# Concatenar
# Factores y categorías
# Concatenando Cadenas de Texto
# Factores y categorías
# Crear un vector de proyectos
proyectos <- c("Parque Eólico", "Construcción de Carretera", "Reciclaje de Residuos", "Ampliación de Planta Industrial")
# Crear un factor para representar el impacto ambiental
impacto_ambiental <- factor(c("Moderado", "Alto", "Bajo", "Moderado"),
levels = c("Bajo", "Moderado", "Alto"),
ordered = TRUE)
# Imprimir el factor
print(impacto_ambiental)En RStudio quedaría de la siguiente manera:
3.7. Listas y dataframe
Los vectores y las matrices se caracterizan por su simplicidad y limitación en cuanto al almacenamiento de datos de tipos diferentes. En contraste, las listas son mucho más flexibles, ya que tienen la capacidad de almacenar cualquier tipo de dato u objeto de R. Por otro lado, los dataframe emergen como una herramienta especialmente útil cuando se trabaja con conjuntos de datos tabulares, permitiendo el almacenamiento de diferentes tipos de datos en forma de columnas.
3.7.1. Lista de objetos
La lista se destaca como una estructura de datos altamente versátil, capaz de agrupar diversos elementos y estructuras de R en combinaciones flexibles. Un solo conjunto puede incluir una matriz numérica, un array lógico, una cadena de caracteres y un objeto de tipo factor. Incluso, es posible tener una lista como componente dentro de otra lista. En este apartado, exploraremos cómo crear, modificar y acceder a los componentes de estas estructuras flexibles.
Construir una lista sigue un proceso similar al de crear un vector.
Se proporcionan los elementos que se desean incluir a la función
list, separándolos por comas.
# Listas
# Listas y Dataframes
variable <- list(matrix(data=1:4,nrow=2,ncol=2),c(T,F,T,T),"hola")
variableEn “variable” , se almacena una matriz numérica de 2 × 2, un vector
lógico y una cadena de caracteres y estos se imprimen en el orden en que
se suministraron a la función list.
En RStudio quedaría de la siguiente manera:
Ahora bien, veamos estos dos ejemplos más:
El primero, crea una lista llamada “datos_ambientales” que contiene información sobre la temperatura, humedad y precipitación, así como una etiqueta para indicar la estación.
El segundo, crea una lista llamada datos_biologicos que contiene información sobre diferentes especies, su población y su hábitat.
# Crear una lista con datos ambientales
datos_ambientales <- list(
temperatura = c(23.5, 24.0, 22.8, 25.2, 23.9),
humedad = c(65, 70, 62, 68, 75),
precipitacion = c(0.2, 0.0, 0.5, 0.8, 0.3),
estacion = "Verano"
)
# Imprimir la lista
datos_ambientales
# Crear una lista con datos biológicos
datos_biologicos <- list(
especies = c("Rana verde", "Mariposa monarca", "Pino blanco", "León africano"),
poblacion = c(120, 5000, 150, 30),
habitat = c("Selva tropical", "Pradera", "Bosque boreal", "Sabana")
)En RStudio quedaría de la siguiente manera:
3.7.2. Listas anidadas
Como se mencionó anteriormente, en R, un miembro de una lista puede ser, a su vez, otra lista. Al anidar listas de esta manera, es esencial estar al tanto de la profundidad de cada miembro para facilitar futuras operaciones de subconjunto o extracción. Es importante destacar que puedes agregar componentes a cualquier lista existente utilizando el operador “$” seguido de un nuevo nombre.
# Crear una lista anidada con datos ambientales
# Crear una lista principal
lista_principal <- list()
# Agregar componentes a la lista principal
lista_principal$temperaturas <- c(25, 28, 24, 26)
lista_principal$precipitaciones <- c(10, 15, 5, 20)
# Crear una lista secundaria
lista_secundaria <- list()
# Agregar componentes a la lista secundaria
lista_secundaria$ubicacion <- "Bosque tropical"
lista_secundaria$especies <- c("Pino", "Roble", "Cedro")
# Anidar la lista secundaria dentro de la lista principal
lista_principal$detalles <- lista_secundaria
# Mostrar la lista principal
lista_principalEn RStudio quedaría de la siguiente manera:
Otro ejemplo :
# Crear una lista principal
animales_lista <- list()
# Agregar componentes a la lista principal
animales_lista$vertebrados <- c("Perro", "Gato", "León")
animales_lista$invertebrados <- c("Araña", "Caracol", "Mariposa")
# Crear una lista secundaria
mamiferos_lista <- list()
# Agregar componentes a la lista secundaria
mamiferos_lista$orden <- c("Carnívoro", "Herbívoro", "Omnívoro")
mamiferos_lista$habitat <- "Bosque"
# Anidar la lista secundaria dentro de la lista principal
animales_lista$mamiferos <- mamiferos_lista
# Mostrar la lista principal
animales_listaEn RStudio quedaría de la siguiente manera:
3.7.3 Dataframes
Para generar un dataframe desde el principio, se emplea la función
data.frame. Proporcionas tus datos agrupados por variables,
utilizando vectores de igual longitud, de manera similar a la
construcción de una lista (como se explicó en la sección anterior).
Ilustremos esto con un ejemplo:
# Dataframe
midataframe <- data.frame(alumnos=c("Juan","Lois","Meg","Chris","Stewie"), edad=c(15,20,17,34,17),
sexo=factor(c("M","F","F","M","M")))Tip:para que ves el contenido del dataframe en forma de tabla, da clic en el panel Environment , en el objeto midataframe que está junto a una flecha azul.
En RStudio se vería de la siguiente manera:
3.7.3.1 Subdiviendo filas de un dataframe con filter()
Con una estructura bidimensional, los dataframes pueden ser
subconjuntos mediante la notación de matriz
[filas, columnas]. Utiliza vectores para subconjuntos
múltiples de filas/columnas. Omitir filas o columnas especifica todas
las filas y columnas, respectivamente.
# Utiliza data.frame() para crear un dataframe con datos de especies de árboles
especies_arboles_tabasco <- data.frame(especie=c("Ceiba", "Caoba", "Tule"),
altura=c(25, 30, 15),
afectada_por_plaga=c(FALSE, TRUE, FALSE))
especies_arboles_tabasco[3, 2]
# Primeras dos filas de la columna altura
especies_arboles_tabasco[1:2, "altura"]
# Todas las filas de la columna afectada_por_plaga
especies_arboles_tabasco[, "afectada_por_plaga"]En R quedaría de la siguiente manera:
3.7.3.2 Subdividiendo variables (columnas) de un dataframe
Con el ejemplo anterior, subdividimos en columnas (variables)
# Utiliza dataframe() para crear un dataframe con datos de especies de árboles
especies_arboles_tabasco <- data.frame(especie=c("Ceiba", "Caoba", "Tule"),
altura=c(25, 30, 15),
afectada_por_plaga=c(FALSE, TRUE, FALSE))
# subdividir en columnas
# Extrae las primeras dos filas y las columnas "especie" y "altura"
subset_df <- especies_arboles_tabasco[1:2, c("especie", "altura")]
# Muestra el nuevo dataframe resultante
subset_dfEn RStudio quedaría de la siguiente manera:
3.7.3.3 Agregando nuevas variables al dataframe
Para incorporar variables a los dataframe, simplemente decláralas columnas del dataframe al crearlo. Es importante señalar que intentar agregar una columna con una longitud incorrecta provocará un error.
# Crear un dataframe con especies de árboles en Tabasco
arboles_tabasco <- data.frame(
especie = c("Ceiba pentandra", "Tabebuia rosea", "Bursera simaruba"),
familia = c("Malvaceae", "Bignoniaceae", "Burseraceae"),
altura_promedio = c(30, 25, 20),
diametro_promedio = c(50, 30, 40)
)
# Mostrar el dataframe original
print("Dataframe original:")
arboles_tabasco
# Agregar nuevas variables al dataframe
arboles_tabasco$ubicacion <- c("Selva", "Bosque tropical", "Manglar")
arboles_tabasco$edad_aproximada <- c(50, 30, 40)
# Mostrar el dataframe actualizado
print("\nDataframe con nuevas variables:")
arboles_tabascoEn RStudio quedaría de la siguiente manera:
4. Valores especiales, clases y coerción
En R, además de los tipos de datos básicos como números y caracteres, existen valores especiales, clases y coerción que juegan un papel crucial en el manejo de datos y operaciones. Estos elementos permiten representar situaciones particulares, asignar propiedades a los objetos y convertir entre diferentes tipos de datos de manera eficiente. En este capítulo, exploraremos en detalle los valores especiales más comunes, las clases de objetos y cómo se lleva a cabo la coerción entre diferentes tipos de datos.
4.1 Algunos valores especiales
4.1.1. Infinito inf()
El valor Inf se utiliza para representar infinito. Puede
ser positivo (Inf) o negativo (-Inf). Se
utiliza, por ejemplo, cuando se divide un número finito por cero, lo que
resulta en un valor infinito.
4.1.2. NaN (Not a Number)
El valor NaN se utiliza para representar un resultado
que no es un número válido. Por ejemplo, cuando se realiza una operación
matemática que no tiene sentido, como intentar calcular la raíz cuadrada
de un número negativo, se obtiene NaN.
Imaginemos que estamos trabajando en un proyecto donde hay que medir el Oxígeno Disuelto (OD) de un cuerpo de agua cada día a una hora específica.
Si a la hora que se requiere hacer la medición el equipo falla y no
se logra tomar el dato, se puede representar como NaN,
indicando que no hay datos específicos para esta medición
específica.
Ahora, si por alguna razón hay un error en la medición o una
condición inusual donde el OD es extremadamente alto, se puede
representar con un Inf.
# Medición de Oxígeno Disuelto
# Datos de concentración de oxígeno disuelto en un cuerpo de agua
tiempo <- c(1, 2, 3, 4, 5) # Intervalos de tiempo (días)
concentracion <- c(8, 7, NaN, 9, Inf) # Concentración de oxígeno disuelto (mg/L)
# Imprimir los datos
for (i in 1:length(tiempo)) {
cat("Día:", tiempo[i], " - Concentración de oxígeno:", concentracion[i], "mg/L\n")
}En RStudio quedaría de la siguiente manera:
4.1.3 NA (Not Available)
El valor NA se utiliza para representar datos faltantes
o no disponibles. Por ejemplo, si tienes un vector con datos
incompletos, puedes usar NA para indicar los valores que faltan.
4.1.4 NULL
El valor NULL se utiliza para representar la ausencia de
un objeto. Se usa, por ejemplo, cuando eliminas un objeto o cuando una
función no devuelve ningún valor.
A diferencia de NA, NULL no es considerado
un valor faltante en R, sino más bien la ausencia de un valor o un
objeto.
El siguiente ejemplo nos dice que en una ciudad se recolectan datos de varias estaciones meteorológicas de forma diaria y se desean estudiar en RStudio.
El sensor de CO2 de una estación se encuentra dañado, por lo que, en este contexto, se puede usar NA para representar el dato faltante en las mediciones.
Por otro lado, se usa NULL para indicar la ausencia de un conjunto completo de mediciones. Por ejemplo, si una estación estuvo fuera de servicio por el periodo de tiempo a estudiar.
#6.1 Segundo ejercicio
# data frame simulado para representar los datos de varias estaciones meteorológicas
datos_meteorologicos <- data.frame(
estacion = c("Estacion1", "Estacion2", "Estacion3", "Estacion4"= NULL ),
temperatura = c(25, 22, 32), # Temperatura en grados Celsius
humedad = c(60, 80, 70), # Humedad relativa en %
co2 = c(NA, 852, 370), # Concentración de CO2 en ppm
precipitacion = c(0, 0.5, 0.7) # Precipitación en mm
#NULL indica que no se registró ningún datoEn RStudio quedaría de la siguiente manera:
Entender en qué momento usar NULL, NaN o
NA puede ser confuso, ya que los 3 representan un tipo de
“vacío”. Sin embargo, son de clases distintas, por lo que actuarán de
forma diferente en una lista, vectores o dataframes. Este tema se
profundiza en el siguiente capítulo, pero como resumen: NaN
es de clase numérica, NA es de clase lógica y
NULL es vacío.
4.2 Entendiendo tipos, clases y coerción
4.2.1. Atributos
Los atributos son metadatos asociados a los objetos que permiten almacenar información adicional sobre estos y se utilizan para proporcionar información relevante y cómo deben ser tratados. Los atributos de R son los siguientes:
• Nombres de filas y columnas: En matrices y dataframes, se pueden
asignar nombres a las filas y columnas utilizando los atributos
rownames() y colnames(), respectivamente.
Vamos a crear una matriz con numeración del uno al nueve, con tres filas y tres columnas. Luego, vamos a asignarle nombres a cada fila y columna.
# Ejemplo atributos
matriz <- matrix(1:9, nrow = 3, ncol = 3)
# Asignar nombres a las filas y columnas
rownames(matriz) <- c("Fila1", "Fila2", "Fila3")
colnames(matriz) <- c("Columna1", "Columna2", "Columna3")
print(matriz)En R quedaría de la siguiente manera:
• Clase de objeto: La clase de un objeto en R define su tipo y
comportamiento. Se puede verificar la clase de un objeto utilizando la
función class().
Crearemos un vector con solamente números y utilizaremos la función para saber de qué clase es.
• Dimensiones: En matrices y arrays, el atributo dim()
es utilizado para especificar y/o establecer las dimensiones del
objeto.
Ejemplo 3:
Supongamos que no conocemos las dimensiones de la matriz del primer
ejemplo, utilizaremos la función dim() para saberlo.
Además, vamos a convertir el vector del ejemplo 2 en una matriz.
# Ejemplo dimensiones
## P1
#Utilizamos la matriz anterior
matriz <- matrix(1:9, nrow = 3, ncol = 3)
dim(matriz) #Conoceremos sus dimensiones
## P2
#Utilizamos el vector del ejemplo anterior
vector <- c(1, 2, 3, 4, 5, 6)
# Lo convertiremos en una matriz de 2x3
dim(vector) <- c(2,3)
dim(vector) #comprobamosEn RStudio quedaría de la siguiente manera:
• Atributo de dimnames: En matrices y arrays, el atributo
dimnames() se usa para saber, especificar o eliminar tanto
los nombres de filas como los de columnas.
Ejemplo 4:
Crearemos una matriz, le asignaremos nombres a las columnas y filas, luego vamos a comprobar sus nombres para después, eliminarlos.
#### Ejempo dimnames
# Crear una matriz
matriz <- matrix(1:6, nrow = 2, ncol = 3)
print(matriz)
# Asignar nombres a las filas y columnas
dimnames(matriz) <- list(c("Fila1", "Fila2"), c("Columna1", "Columna2", "Columna3"))
print(matriz)
# Acceder a los nombres de filas y columnas
rownames <- dimnames(matriz)[[1]]
colnames <- dimnames(matriz)[[2]]
# Eliminar los nombres de filas y columnas
dimnames(matriz) <- list(NULL, NULL)
print(matriz)En RStudio quedaría de la siguiente manera:
• Atributos personalizados: Puedes definir y asignar tus propios atributos a un objeto en R utilizando la función attr().
Imaginemos que trabajando con datos de diferentes fuentes y queremos
mantener un registro de dónde provienen los datos. Crearemos un vector
de nombres y luego utilizamos attr() para asignar un
atributo “fuente” con el valor “base de datos externa” a la lista. Esto
nos permite mantener un registro de la fuente de los datos y facilita la
comprensión de dónde provienen los datos cuando se trabaja con ellos en
el futuro.
# Ejemplo atributo personalizado
# Crear un vector de nombres
nombres <- c("Juan", "María", "Pedro", "Ana")
# Asignar un atributo "fuente" a la lista
attr(nombres, "fuente") <- "base de datos externa"
# Verificar la fuente de los datos
fuente <- attr(nombres, "fuente")
print(fuente)
4.2.2. Clase de objetos
La clase de un objeto define su tipo y comportamiento. Es un concepto fundamental en la programación orientada a objetos, que permite definir cómo se comporta un objeto y qué operaciones se pueden realizar con él. Los objetos pueden tener una única clase o múltiples clases, lo que permite la flexibilidad en la definición de tipos de datos y operaciones.
- Definición JBJGCFT
las clases se definen utilizando la función setClass()
del paquete methods. Una clase en R especifica la
estructura y el comportamiento de un tipo de objeto. Define qué
atributos tiene el objeto (llamados “slots”) y qué funciones pueden ser
aplicadas a ese objeto (llamadas “métodos”).
- Creación de objetos en una clase
Una vez que has definido una clase en R, puedes crear objetos de esa
clase utilizando la función new(). Los objetos creados de
esta manera tendrán los atributos y el comportamiento definidos por la
clase.
- Métodos de clase
Los métodos en R son funciones que se aplican a objetos de una clase
específica. Los métodos se definen utilizando la función
setMethod(), que vincula una función con una clase y
especifica cómo esa función debe comportarse cuando se aplica a un
objeto de esa clase.
- Herencia de clases
La herencia de clases permite que una clase “hija” herede los atributos y métodos de una clase “padre”. Esto significa que la clase hija puede utilizar los mismos atributos y métodos que la clase padre, además de poder definir sus propios atributos y métodos adicionales.
Supongamos que estás desarrollando un sistema para administrar una
biblioteca y necesitas manejar información sobre los libros que se
encuentran en ella. Puedes definir una clase Libro para
representar los libros, con atributos como el título, el autor y el año
de publicación. Luego, puedes definir métodos para esta clase, como uno
para imprimir la información del libro:
### Ejemplo clase de objetos
# Definir la clase Libro
setClass("Libro",
slots = c(titulo = "character", autor = "character", año_publicacion = "numeric"))
# Crear un método para imprimir la información del libro
setMethod("show", "Libro",
function(object) {
cat("Título:", object@titulo, "\n")
cat("Autor:", object@autor, "\n")
cat("Año de publicación:", object@año_publicacion, "\n")
})
# Crear un objeto de la clase Libro
mi_libro <- new("Libro", titulo = "El señor de los anillos", autor = "J.R.R. Tolkien", año_publicacion = 1954)
# Imprimir la información del libro
print(mi_libro)En R quedaría de la siguiente manera:
Continuaremos usando el código del ejemplo anterior para poder crear
una clase LibroInfantil que heredará de la clase
Libro y agregaremos un nuevo slot
edad_recomendada. utilizando
contains = "Libro". Esto significa que
LibroInfantil tiene todos los slots y métodos de
Libro, además de su propio slot
edad_recomendada.
### Ejemplo 2 heredar
# Definir la clase LibroInfantil que hereda de Libro
setClass("LibroInfantil",
contains = "Libro",
slots = c(edad_recomendada = "numeric"))
# Crear un método para imprimir la información del libro infantil
setMethod("show", "LibroInfantil",
function(object) {
callNextMethod()
cat("Edad recomendada:", object@edad_recomendada, "\n")
})
# Crear un objeto de la clase LibroInfantil
mi_libro_infantil <- new("LibroInfantil",
titulo = "El principito",
autor = "Antoine de Saint-Exupéry",
año_publicacion = 1943,
edad_recomendada = 6)
# Imprimir la información del libro infantil
print(mi_libro_infantil)En RStudio quedaría de la siguiente manera:
4.2.3. Is-Dot
El operador “Is” en R, cuando se combina con un punto (.), se utiliza para verificar si un objeto pertenece a una clase específica o a una subclase de esa clase. Esto es útil para verificar la clase de un objeto y tomar decisiones en función de su tipo. También se puede utilizar para verificar si un objeto es de un tipo de dato específico, como un vector, una lista, una matriz, etc. Esto es útil para realizar comprobaciones de tipo más generales.
Verifiquemos si un objeto es una matriz o un vector.
### Ejemplo 1 is-dot
#crear un vector
x <- c(1, 2, 3)
#Verificar si es un vector o una matriz
is(x, "matrix")
is(x, "vector")En RStudio quedaría de la siguiente manera:
Veamos ahora una clase Persona y una subclase
Estudiante que hereda de Persona. Puedes usar
el operador is para verificar si un objeto es de la clase
Persona o Estudiante:
5. Archivos datasets
Un dataset en R es un conjunto de datos que generalmente se organiza en forma de tabla. Estos conjuntos de datos son fundamentales para realizar análisis de datos y aplicar distintos tipos de modelado estadístico o aprendizaje automático. En R, los conjuntos de datos pueden almacenarse en varios formatos, siendo los más comunes:
CSV (Comma-Separated Values): Un formato simple donde los datos están separados por comas. Es uno de los formatos más utilizados y es fácil de manejar.
Excel: Los archivos de Excel también pueden ser importados como conjuntos de datos en R. R tiene paquetes que permiten la lectura de archivos .xls o .xlsx.
Formatos Específicos: R también puede trabajar con formatos específicos como archivos .rds (R Data) o .rda (R Data Archive) que son formatos nativos de R.
Conjuntos de Datos Incorporados: R también incluye algunos conjuntos de datos directamente accesibles en su entorno de trabajo. Puedes cargarlos con comandos como data().
Especie Nombre Científico Población Temperatura
León Panthera leo 50 32.5
Elefante Loxodonta africana 20 28.0
Jirafa Giraffa camelopardalis30 30.2
Tigre Panthera tigris 15 33.8Ejemplo de datset separado por comas “,”
Especie,Nombre_Cientifico,Poblacion,Temperatura
Tucán,Tucanidae sp.,120,28.0
Quetzal,Pharomachrus mocinno,35,26.5
Jaguar,Panthera onca,15,31.2
Hormiga_Ata,Atta mexicana,5000,24.85.1 Lectura de datos de texto
5.1.1 Directorio de Trabajo
En R, la función setwd() se utiliza para establecer el
directorio de trabajo actual. El directorio de trabajo es la ubicación
en la cual R buscará y guardará archivos de forma predeterminada. Al
cambiar el directorio de trabajo, puedes facilitar el acceso a tus
archivos y evitar tener que proporcionar rutas de archivo completas cada
vez que cargas o guardas datos. La sintaxis básica de
setwd() es la siguiente:
setwd("/ruta/del/nuevo/directorio")Donde “/ruta/del/nuevo/directorio” es la ruta completa del directorio al que deseas cambiar.
Es importante destacar que las barras en la ruta deben estar en el formato correcto según el sistema operativo. En sistemas Windows, se utilizan barras invertidas (), mientras que en sistemas Unix/Linux se utilizan barras inclinadas (/). En R, generalmente puedes usar barras inclinadas independientemente del sistema operativo. El cambio de directorio de trabajo es útil cuando trabajas con conjuntos de datos y scripts almacenados en un directorio específico, ya que simplifica las operaciones de lectura y escritura de archivos.
# Establecer el directorio de trabajo
setwd("/ruta/del/nuevo/directorio")
# Verificar el nuevo directorio de trabajo
getwd()Una vez posicionado en el directorio de trabajo ( donde se encuentran ubicado los archivos o datasets), R te proporciona varias funciones relacionadas para leer datos almacenados en archivos.
Utiliza read.csv() para leer datos almacenados en
formato CSV y read.delim() para procesar datos de texto
delimitados por caracteres específicos, como tabuladores o espacios. Al
emplear read.delim(), es necesario especificar el
delimitador utilizando el argumento sep=. Ambas funciones
asumen que la primera fila del archivo de texto contiene los nombres de
las variables. En caso contrario, utiliza el argumento
header=FALSE. Estas funciones son comúnmente utilizadas
para la lectura de archivos almacenados en discos duros, memorias USB u
otros dispositivos de almacenamiento local.
# Establecer el directorio de trabajo
setwd("/ruta/del/nuevo/directorio")
# Verifica el nuevo directorio de trabajo
getwd()
# Lee un archivo CSV en el nuevo directorio
data_csv <- read.csv("archivo.csv")
# Visualiza los primeros registros del conjunto de datos
head(data_csv)
# Lee un archivo de texto delimitado por tabuladores en el nuevo directorio
data_tab <- read.delim("archivo.txt", sep="\t")
# Visualizar los primeros registros del conjunto de datos
head(data_tab)Tip: asegúrate de reemplazar “/ruta/del/nuevo/directorio” con la ruta completa del directorio al que deseas cambiar.
5.2 Exportar datos
Para exportar datos a un archivo .csv, utiliza la función write.csv() de la siguiente manera:
Si necesitas guardar múltiples objetos de tu sesión para su uso
posterior, puedes emplear la función save(). Esta función
crea un archivo binario .Rdata que puede cargarse más tarde con load().
Aquí hay un ejemplo:
# Guarda objetos en un archivo .Rdata
save(objeto1, objeto2, file = "/ruta/del/archivo.Rdata")
# Carga objetos desde el archivo .Rdata
load("/ruta/del/archivo.Rdata")Recuerda que las rutas de archivo proporcionadas no son reales y las debes reemplazar por rutas validas de tu directorio de trabajo
5.3 Paquetes para importar
En el contexto de la importación de datos, existen paquetes diseñados
específicamente para facilitar la lectura de diferentes formatos de
archivos, como Excel, Stata, SAS, SPSS y otros. Estos paquetes amplían
las capacidades básicas de R, ofreciendo funciones y métodos optimizados
para la importación y exportación de datos desde y hacia formatos
específicos. Los paquetes son: readxl: que facilita la
lectura de archivos de Excel, permitiendo a los usuarios importar datos
de hojas de cálculo directamente en R. haven: es útil para
trabajar con datos provenientes de software estadístico como Stata, SAS
y SPSS. readr: proporciona versiones actualizadas de funciones clásicas
de lectura de datos, como read.csv() y
read.delim(). Estas funciones están diseñadas con
estructuras de datos modernizadas para mejorar la eficiencia y la
flexibilidad.
# Instalar y cargar los paquetes
install.packages("readxl")
install.packages("haven")
library(readxl)
library(haven)
# Lee datos desde un archivo Excel (xlsx) con readxl
excel_data <- read_excel("ruta_del_archivo/excel_file.xlsx")
# Lee datos desde un archivo de Stata con haven
stata_data <- read_dta("ruta_del_archivo/stata_file.dta")
# Lee datos desde un archivo de SPSS con haven
spss_data <- read_sav("ruta_del_archivo/spss_file.sav")Recuerda de reemplazar “ruta_del_archivo/excel_file.xlsx”, “ruta_del_archivo/stata_file.dta”, y “ruta_del_archivo/spss_file.sav” con las rutas reales de tus archivos.
6 Condicionales y Bucles
Para avanzar en la creación de programas más sofisticados con R, resulta crucial dominar de manera efectiva el flujo y la secuencia de ejecución en tu código. Un enfoque fundamental para lograr esto implica condicionar la ejecución de secciones específicas del código según determinadas condiciones. Además, los bucles, que repiten bloques de código un número específico de veces, representan otro mecanismo crucial de control. Este apartado explora estas técnicas centrales de programación mediante el empleo de instrucciones if-else, bucles for y while, y otras estructuras de control.
6.1 Sentencia IF (Si)
La sentencia if permite condicionar la ejecución de
ciertas partes de un programa con base en evaluaciones lógicas. En
esencia, la sentencia if evalúa una expresión o condición
y, si esta es verdadera, ejecuta un bloque de código asociado. En caso
contrario, puede estar acompañada de una cláusula else, que
especifica el código a ejecutar cuando la condición es falsa. El uso de
la sentencia if proporciona un control preciso sobre el
flujo del programa, permitiendo realizar acciones específicas en función
de condiciones particulares.
La estructura del IF es la siguiente:
if (expr_1) expr_2 else expr_3
Donde expr_1 debe evaluarse como un único valor lógico y el resultado de toda la expresión se vuelve evidente. Los operadores de “cortocircuito” && y || se usan frecuentemente como parte de la condición en una instrucción if. A diferencia de & y |, que operan elemento a elemento en vectores, && y || se aplican a vectores de longitud uno, evaluando su segundo argumento solo cuando es necesario. Existe una versión vectorizada de la estructura if/else, la función ifelse. Esta tiene la forma ifelse(condición, a, b) y devuelve un vector de la misma longitud que la condición, con elementos a[i] si condition[i] es verdadero, y b[i] en caso contrario (a y b se reciclan según sea necesario).
# Sentencia if
# Definir una variable
edad <- 20
# Utilizar la sentencia if para realizar una comprobación
if (edad >= 18) {
print("Eres mayor de edad.")
} else {
print("Eres menor de edad.")
}
# Crear un vector de números
números <- c(5, 12, 8, 20, 3)
# Utilizar la sentencia if para comprobar cada elemento del vector
for (num in numeros) {
if (num %% 2 == 0) {
print(paste(num, "es un numero par."))
} else {
print(paste(num, "es un numero impar."))
}
}
# el código anterior recorre un vector de números y utiliza if para verificar si cada número es par o impar, imprimiendo el resultado correspondiente.En RStudio quedaría de la siguiente manera:
Otro ejemplo seria este:
# # Supongamos que tenemos datos de temperatura ambiental en grados Celsius en el estado de Tabasco
temperatura_tabasco <- 32
# Utilizamos la sentencia if para realizar una comprobación sobre la temperatura en Tabasco
if (temperatura_tabasco > 35) {
print("Hace mucho calor en Tabasco. Se recomienda tomar medidas para mantenerte fresco.")
} else if (temperatura_tabasco <= 35 && temperatura_tabasco > 25) {
print("La temperatura en Tabasco es agradable. Disfruta del clima característico de la región.")
} else {
print("Hace fresco en Tabasco. Aunque no es común, abrígate si es necesario.")
}En RStudio quedaría de la siguiente manera:
6.2 If anidados
Los ” if” anidados se refieren a la práctica de incluir
una declaración ” if” dentro de otra. Esto permite crear
una estructura de decisiones más compleja y específica. Cuando la
condición de un ” if” externo se cumple, se evalúa otra
condición interna, y así sucesivamente. Los ” if” anidados
son útiles cuando se necesitan múltiples evaluaciones lógicas para
determinar el flujo del programa. Cada nivel adicional de anidación
agrega una capa más de complejidad a la toma de decisiones en el
script.
# # # Ejemplo de if anidado
calificacion <- 7.5
if (calificacion >= 9.0) {
mensaje <- "Excelente"
} else {
if (calificacion >= 8.0) {
mensaje <- "Bueno"
} else {
if (calificacion >= 7.0) {
mensaje <- "Regular"
} else {
mensaje <- "Necesita mejorar"
}
}
}
cat("La calificación es:", mensaje)}En RStudio quedaría de la siguiente manera:
Otro ejemplo para clasificar los dias en función de la temperatura promedio en tres categorías: “Alta”, “Moderada” o “Baja”. Puedes modificar los parámetros según tus requerimientos académicos.
# Ejemplo de clasificación de temperaturas ambientales con vectores
temperaturas_max <- c(28, 32, 25, 22, 30)
temperaturas_min <- c(18, 20, 15, 12, 22)
temperaturas_promedio <- (temperaturas_max + temperaturas_min) / 2
clasificacion <- ifelse(temperaturas_promedio >= 28, "Alta",
ifelse(temperaturas_promedio >= 20, "Moderada", "Baja"))
# Mostrar resultados
resultados <- data.frame(Dia = 1:length(temperaturas_promedio), Temperatura_Promedio = temperaturas_promedio, Clasificacion = clasificacion)
print(resultados)En RStudio quedaría de la siguiente manera:
6.3 For (para)
Un mecanismo esencial en programación es el bucle, el cual repite una
parte definida de código, a menudo mientras aumenta un índice o
contador. Existen dos tipos de bucles: el bucle for repite
el código mientras recorre un vector, elemento por elemento; el bucle
while simplemente repite el código hasta que se cumple una
condición específica y se evalúa como FALSO.
En R, el bucle for es especialmente útil para iterar sobre elementos de una secuencia, como vectores o listas, y realizar operaciones específicas en cada iteración. Esta estructura proporciona un método eficiente para automatizar tareas repetitivas y realizar cálculos en grandes conjuntos de datos.
# Bucle for que recorre una secuencia del 1 al 5 y en cada iteración imprime el valor de la variable `ip`
for (i in 1:5) {
print(i)
}Otro ejemplo sería el de crear un vector de nombre
resultados de tamaño 10. Luego con el bucle for itera sobre
los números del 1 al 10. En cada iteración, calculamos el cuadrado del
número actual (i^2) y se almacena en la posición
correspondiente del vector resultados, para finalmente
imprimir el vector resultados para ver los cuadrados
calculados.
# Creamos un vector vacío para almacenar los resultados
# Bucle for para calcular el cuadrado de los primeros 10 números enteros
for (i in 1:10) {
resultados[i] <- i^2
}
# Imprimimos los resultados
print(resultados)Ambos ejemplos anteriores quedarían en RStudio de la siguiente manera:
Ahora veamos otro ejemplo, donde usamos el bucle for para recorrer
las longitudes de las hojas en el vector longitud_hojas y
sumarlas en la variable suma_longitudes. Luego, calculamos
el promedio dividiendo la suma total de las longitudes por la cantidad
de observaciones y finalmente imprimimos el resultado del promedio de
las longitudes de las hojas.
# Supongamos que tenemos un vector con la longitud de las hojas de una planta en diferentes días
longitud_hojas <- c(12, 14, 13, 15, 12)
# Inicializamos una variable para almacenar la suma de las longitudes de las hojas
suma_longitudes <- 0
# Bucle for para sumar todas las longitudes de las hojas
for (longitud in longitud_hojas) {
suma_longitudes <- suma_longitudes + longitud
}
# Calculamos el promedio de las longitudes de las hojas
promedio_longitudes <- suma_longitudes / length(longitud_hojas)
# Imprimimos el promedio de las longitudes de las hojas
print(paste("El promedio de las longitudes de las hojas es:", promedio_longitudes))En RStudio quedaría de la siguiente manera:
Veamos otro ejemplo, pero utilizando for e if para recorrer los pesos
de los peces almacenado en un vector de nombre pesos_peces.
Dentro del bucle, encontramos una estructura condicional if para
clasificar los peces en tres categorías según su peso. Los peces con un
peso de 0.5 kg o menos se consideran ligeros, los peces con un peso
mayor que 0.5 kg, pero igual o menor a 1 kg se consideran medios, y los
peces con un peso mayor que 1 kg se consideran pesados. Finalmente,
imprimimos los peces clasificados por categoría.
# Supongamos que tenemos un vector con los pesos de los peces en kilogramos
pesos_peces <- c(0.5, 0.8, 1.2, 0.3, 1.5, 0.9, 1.7)
# Creamos tres vectores vacíos para almacenar los peces en cada categoría
peces_ligeros <- c()
peces_medios <- c()
peces_pesados <- c()
# Bucle for para clasificar los peces según su peso
for (peso in pesos_peces) {
if (peso <= 0.5) {
peces_ligeros <- c(peces_ligeros, peso)
} else if (peso > 0.5 & peso <= 1) {
peces_medios <- c(peces_medios, peso)
} else {
peces_pesados <- c(peces_pesados, peso)
}
}
# Imprimimos los peces clasificados por categoría
print("Peces ligeros:")
print(peces_ligeros)
print("Peces medios:")
print(peces_medios)
print("Peces pesados:")
print(peces_pesados)en RStudio quedaría de la siguiente manera:
A continuación, utilizaremos un bucle for en matrices para analizar
datos de suelos contaminados por hidrocarburos. Nuestra matriz está
estructurada de manera que cada fila representa un sitio de muestreo,
mientras que cada columna indica la concentración de hidrocarburos en
diferentes muestras de suelo. Dentro del bucle for, evaluamos si alguna
de las muestras de suelo en el sitio de muestreo supera el umbral de 30
partes por millón (ppm). En caso afirmativo, clasificamos el sitio de
muestreo como contaminado y lo añadimos al vector
sitios_contaminados. Finalmente, presentamos los sitios de
muestreo que han sido identificados como contaminados.
# Supongamos que tenemos una matriz de datos de concentraciones de hidrocarburos en suelos
# Cada fila representa un sitio de muestreo y cada columna una muestra de suelo
concentraciones <- matrix(c(10, 15, 20, 25, 30, 35, 40, 45, 50), nrow = 3, byrow = TRUE)
# Creamos un vector para almacenar los sitios de muestreo contaminados
sitios_contaminados <- c()
# Bucle for para analizar cada sitio de muestreo
for (i in 1:nrow(concentraciones)) {
# Verificamos si alguna de las muestras en el sitio de muestreo tiene una concentración mayor a 30 ppm
if (any(concentraciones[i,] > 30)) {
# Si alguna muestra supera los 30 ppm, consideramos el sitio de muestreo como contaminado
sitios_contaminados <- c(sitios_contaminados, i)
}
}
# Imprimimos los sitios de muestreo contaminados
print("Sitios de muestreo contaminados:")
print(sitios_contaminados)En RStudio quedaría de la siguiente manera:
6.4 While (mientras)
El bucle while en R es una estructura de control que
permite repetir un bloque de código mientras se cumpla una condición
especificada. Esta condición se evalúa al inicio de cada iteración del
bucle. Si la condición es verdadera, el bloque de código se ejecuta; de
lo contrario, el bucle se detiene y la ejecución continúa con la
siguiente instrucción después del bucle. El bucle while es
útil cuando no se conoce de antemano cuántas veces se debe repetir el
código y se desea que la ejecución continúe mientras se cumpla una
condición específica. En este sentido, ofrece flexibilidad para
controlar el flujo de ejecución en función de las condiciones evaluadas.
El primer ejemplo sencillo del uso del while sería el siguiente: vamos a
imprimir los números del 1 al 5, ya que el bucle while se ejecutará
mientras el valor de contador sea menor o igual a 5. En cada iteración,
se imprime el valor actual del contador y luego se incrementa en 1. Una
vez que contador alcanza el valor de 6, la condición del bucle se vuelve
falsa y el bucle se detiene.
# Inicializamos una variable de contador
contador <- 1
# Definimos la condición para el bucle while
while (contador <= 5) {
# Imprimimos el valor del contador
print(paste("Iteración:", contador))
# Incrementamos el contador en 1 en cada iteración
contador <- contador + 1
}Otro ejemplo consistiría en : calcular la suma de los números del 1 al 10 utilizando un bucle while.
En cada iteración del bucle, se agrega el valor actual del contador a la suma y luego se incrementa el contador en 1. Una vez que el contador alcanza el valor de 11, el bucle se detiene y se imprime el resultado final de la suma.
# Definimos una variable para la suma y otra para el contador
suma <- 0
contador <- 1
# Definimos la condición para el bucle while
while (contador <= 10) {
# Sumamos el valor actual del contador a la suma
suma <- suma + contador
# Incrementamos el contador en 1 en cada iteración
contador <- contador + 1
}
# Imprimimos el resultado final de la suma
print(paste("La suma de los números del 1 al 10 es:", suma))Los dos ejemplo anteriores quedarían en RStudio de la siguiente manera:
A continuación, usaremos un vector para
concentraciones_bacterias utilizando un bucle while. En
cada iteración, verificamos si la concentración de bacterias en la
muestra actual es superior a 100 UFC/ml. Si es así, incrementamos el
contador muestras_contaminadas. Una vez completadas todas
las iteraciones, imprimimos el número total de muestras
contaminadas.
# Vector de concentraciones de bacterias contaminantes en UFC/mL
concentraciones_bacterias <- c(120, 90, 150, 80, 110, 130, 70, 200, 95)
# Contador para almacenar el número de muestras contaminadas
muestras_contaminadas <- 0
# Índice para iterar sobre las concentraciones
i <- 1
# Bucle while para verificar las concentraciones de bacterias
while (i <= length(concentraciones_bacterias)) {
if (concentraciones_bacterias[i] > 100) {
muestras_contaminadas <- muestras_contaminadas + 1
}
i <- i + 1
}
# Imprimir el número de muestras contaminadas
cat("El número de muestras contaminadas es:", muestras_contaminadas, "\n")En Rstudio quedaría de la siguiente manera:
Ahora bien, vamos a suponer que tenemos una matriz llamada
datos_tabasco que contiene datos ambientales recopilados en
diferentes sitios de muestreo. Cada fila de la matriz representa un
sitio de muestreo y cada columna representa una variable ambiental
específica, como temperatura, humedad, y concentración de contaminantes.
Queremos identificar el sitio de muestreo con la temperatura más alta y
su respectivo índice.
# Matriz de datos ambientales en Tabasco (temperatura en °C)
datos_tabasco <- matrix(c(30, 32, 31, 33, 29, 30, 32, 31, 32, 34), ncol = 2, byrow = TRUE)
# Inicializar variables para almacenar la temperatura máxima y su índice
temperatura_maxima <- -Inf
indice_maximo <- NULL
# Índice para iterar sobre las filas de la matriz
i <- 1
# Bucle while para encontrar la temperatura máxima y su índice
while (i <= nrow(datos_tabasco)) {
if (datos_tabasco[i, 1] > temperatura_maxima) {
temperatura_maxima <- datos_tabasco[i, 1]
indice_maximo <- i
}
i <- i + 1
}
# Imprimir la temperatura máxima y su índice
cat("La temperatura máxima en Tabasco es:", temperatura_maxima, "°C\n")
cat("Se registró en el sitio de muestreo", indice_maximo, "muestras contaminadas.", "\n")En RStudio quedaría de la siguiente manera:
6.5 Bucle implícito (apply)
El bucle implícito se refiere a la ejecución repetitiva de una
operación sobre los elementos de una estructura de datos sin necesidad
de utilizar un bucle explícito (como un bucle for o while). En lugar de
eso, se utiliza una función como apply() en R para aplicar
una función a cada elemento de una matriz, lista o vector. Esta función
toma la función que se desea aplicar y los datos sobre los cuales
aplicarla, realizando automáticamente la iteración y devolviendo los
resultados sin necesidad de escribir explícitamente un bucle de
repetición. Esto simplifica el código y hace que sea más eficiente y
legible.
Vamos con un ejemplo sencillo, imagina que tienes una matriz llamada
matriz_datos que contiene datos numéricos y quieres calcular la suma de
cada columna. Notaras que con apply( matriz_datos, 2, sum)
aplica la función sum() a cada columna.
# Crear una matriz de ejemplo
matriz_datos <- matrix(1:12, nrow = 3)
# Usar la función apply para sumar cada columna de la matriz
resultado <- apply(matriz_datos, 2, sum)
# Imprimir el resultado
print(resultado)El resultado de las suma de cada columna se almacenará en un vector.
Un segundo ejemplo es el siguiente: tienes una matriz llamada matriz_temp que contiene datos de temperatura registrados en diferentes horas del día, y queremos encontrar el valor máximo de temperatura registrado en cada hora. El script quedaría asi:
# Crear una matriz de ejemplo
matriz_temp <- matrix(c(25, 28, 30, 27, 29, 31, 26, 33, 32, 29, 30, 34), nrow = 4, byrow = TRUE)
# Utilizar la función apply para encontrar el máximo valor en cada columna
maximos_por_hora <- apply(matriz_temp, 2, max)
# Imprimir los máximos valores por hora
print(maximos_por_hora)Notaste que apply(matriz_temp, 2, max) aplica la función
max() a cada columna (margin = 2) de la matriz matriz_temp.
La función max() encuentra el valor máximo en cada columna
y devuelve un vector con los máximos valores registrados en cada hora
del día.
Los dos ejemplo anteriores quedarían asi en RStudio:
Aquí tienes un ejemplo más practico: tienes una matriz llamada
datos_flora que contiene los conteos de algunas especies de
flora registradas en tres áreas de conservación diferentes en Tabasco.
Queremos calcular la suma de los conteos de cada especie por separado en
cada área de conservación.
# Crear una matriz de ejemplo con los conteos de especies de flora
datos_flora <- matrix(c(20, 10, 15, 5, 8, 12, 6, 3, 9), nrow = 3, byrow = TRUE)
# Definir los nombres de las áreas de conservación y las especies de flora
nombres_areas <- c("Reserva La Encrucijada", "Reserva Los Chimalapas", "Reserva Pantanos de Centla")
especies_flora <- c("Ceiba pentandra", "Heliconia bihai", "Tabebuia rosea")
# Aplicar la función apply para calcular la suma de los conteos de cada especie de flora en cada área
suma_por_especie <- apply(datos_flora, 2, sum)
# Crear un dataframe con los resultados
resultados_flora <- data.frame(Especie = especies_flora, Area_de_Conservacion = rep(nombres_areas, each = length(especies_flora)), Suma_de_Conteos = suma_por_especie)
# Imprimir los resultados
print(resultados_flora)La función apply() calcula la suma de los conteos de
cada especie de flora por separado en cada área de conservación.
Finalmente, creamos un dataframe llamado resultados_flora
con los nombres de las especies de flora, el área de conservación y las
sumas de los conteos de cada especie por área, y luego imprimimos los
resultados.
Veamos primero el dataframe en RStudio, recuerda que debes hacer clic en el icono con un círculo azul y con la flecha en blanco para ver el contenido del dataframe.
Estarías viendo el contenido del
dataframe en el panel superior izquierdo de la siguiente manera:
Por último, los resultados del script se verían de la siguiente manera:
Un ejemplo más consiste en un conjunto de datos que contiene
información sobre los niveles de contaminantes en muestras de agua
tomadas en diferentes etapas del proceso de tratamiento de aguas
residuales de una planta de tratamiento. Queremos realizar varias
operaciones para analizar esos datos, entre ellas el promedio de cada
contaminante en cada etapa del proceso de tratamiento, para ellos usamos
la función sapply(). Esta función nos retorna los
resultados en forma de arreglo.
# Crear un conjunto de datos de ejemplo con los niveles de contaminantes en diferentes etapas del proceso de tratamiento de aguas residuales
datos_aguas_residuales <- data.frame(
Muestra = c(1, 2, 3, 4, 5),
Etapa = c("Crudo", "Pretratamiento", "Tratamiento primario", "Tratamiento secundario", "Desinfección"),
BOD5 = c(150, 120, 50, 20, 5), # Demanda Bioquímica de Oxígeno en 5 días (mg/L)
SS = c(200, 180, 120, 50, 10), # Sólidos Suspendidos (mg/L)
COD = c(300, 250, 150, 80, 20) # Demanda Química de Oxígeno (mg/L)
)
# Calcular el promedio de cada contaminante en cada etapa del proceso de tratamiento
promedio_contaminantes <- sapply(datos_aguas_residuales[,3:5], function(x) tapply(x, datos_aguas_residuales$Etapa, mean))
# Imprimir el promedio de cada contaminante en cada etapa del proceso de tratamiento
print(promedio_contaminantes)En RStudio quedaría de la siguiente manera:
La función tapply en R se utiliza para aplicar una función a subconjuntos de datos definidos por uno o más factores. Permite calcular estadísticas o realizar operaciones específicas en grupos de datos basados en las categorías definidas por los factores.
El siguiente es un ejemplo que utiliza datos de calidad del aire en
diferentes estaciones de monitoreo en el estado de Tabasco, México. La
función tapply calcula el promedio de los niveles de CO2
agrupados por estación de monitoreo. La función list() no
es necesaria en este caso ya que solo estamos agrupando por una
variable. Luego, mean() calcula el promedio de los niveles
de CO2 para cada estación ( aunque esta función la veremos más a detalle
en el siguiente capitulo.
# Crear un dataframe de ejemplo
calidad_aire <- data.frame(
Estacion = c(rep("Estacion1", 7), rep("Estacion2", 7), rep("Estacion3", 7)), # Estaciones de monitoreo
Dia = rep(1:7, 3), # Días de la semana
CO2_ppm = c(410, 415, 420, 418, 422, 419, 415, 415, 420, 425, 428, 423, 420, 422, 425, 410, 415, 420, 417, 421, 401)
# Niveles de CO2 en ppm
)
# Calcular el promedio de niveles de CO2 por estación usando tapply
promedio_CO2 <- tapply(calidad_aire$CO2_ppm, calidad_aire$Estacion, mean)
# Imprimir los resultados
print(promedio_CO2)En RStudio quedaría de la siguiente manera:
6.6 Otros mecanismos de control de flujo
En esta sección, exploraremos tres mecanismos adicionales de control de flujo en R: break, next y repeat. Estos mecanismos son herramientas poderosas que se utilizan en conjunto con los bucles y las instrucciones if para modificar el flujo de ejecución de un programa. Aprenderemos cómo y cuándo utilizar cada uno de estos mecanismos.
6.6.1 break
Se utiliza para interrumpir un bucle (for o
while) y salir inmediatamente de él. En el momento en que
se encuentra la declaración break dentro de un bucle, este
se detiene y la ejecución del programa continúa después del bucle. Tiene
utilidad cuando se cumple una condición específica y ya no es necesario
continuar con el bucle. El siguiente el bucle imprimirá los números del
1 al 4 y luego se detendrá cuando i sea igual a 5.
6.6.2 next
Esta declaración se utiliza para pasar a la próxima iteración del bucle sin ejecutar el código restante dentro del bucle para la iteración actual. Es útil cuando, por alguna razón, se desea omitir ciertas iteraciones del bucle. En el siguiente ejemplo, el bucle imprimirá solo los números impares del 1 al 9, ya que next se activa cuando i es par, omitiendo la impresión de números pares.
Los dos ejemplos anteriores en RStudio quedarían de la siguiente manera:
Veamos un siguiente ejemplo, donde se simula el crecimiento de peces
en varios estanques durante un período de tiempo determinado y demuestra
cómo se puede utilizar break para salir del bucle si se
encuentra una condición específica y next para pasar al
siguiente paso del bucle si se cumple otra condición. Ten en cuenta que
he simulado los datos de crecimiento de manera aleatoria para este
ejemplo. En una aplicación real, estos datos se calcularían o medirían
de acuerdo con las condiciones del cultivo de peces.
# Generación de datos simulados para el cultivo de peces
set.seed(123) # Semilla para reproducibilidad
# Supongamos que tenemos 10 estanques de peces y queremos simular su crecimiento durante 10 días
num_estanques <- 10
dias_simulacion <- 10
# Crear un dataframe para almacenar los datos de crecimiento de los peces en cada estanque
datos_peces <- data.frame(Estanque = rep(1:num_estanques, each = dias_simulacion),
Dia = rep(1:dias_simulacion, times = num_estanques),
Crecimiento = rnorm(num_estanques * dias_simulacion,
mean = 1, sd = 0.5))
# Simulación del cultivo de peces
for (i in 1:num_estanques) {
for (j in 1:dias_simulacion) {
# Supongamos que queremos detener el ciclo si el crecimiento de un estanque en un día es negativo
if (datos_peces$Crecimiento[(i - 1) * dias_simulacion + j] < 0) {
cat("El crecimiento en el estanque", i, "en el día", j, "fue negativo.\n")
break # Romper el bucle interno si el crecimiento es negativo
}
# Supongamos que queremos omitir los días en los que la tasa de crecimiento es menor a 0.5
if (datos_peces$Crecimiento[(i - 1) * dias_simulacion + j] < 0.5) {
cat("La tasa de crecimiento en el estanque", i, "en el día", j, "fue menor a 0.5. Saltando al siguiente día...\n")
next # Saltar al siguiente día si la tasa de crecimiento es menor a 0.5
}
# Aquí iría el resto del código relacionado con el cálculo del crecimiento de los peces
# Por simplicidad, solo mostramos un mensaje indicando que el crecimiento fue aceptable
cat("El crecimiento en el estanque", i, "en el día", j, "fue aceptable.\n")
}
}En RStudio quedaría de la siguiente manera:
7 Escribiendo Funciones (function)
La creación de una función facilita la reutilización de un conjunto de instrucciones sin tener que repetirlas una y otra vez. Además, permite que otros estudiantes, profesores, etc. aprovechen tus funciones para realizar los mismos cálculos en sus propios conjuntos de datos u objetos. Aprenderás a escribir tus propias funciones en R, así como a definir y utilizar argumentos, devolver resultados desde una función y especializar tus funciones de diversas maneras.
7.1 el comando function
En R, el comando function es fundamental para la creación de funciones personalizadas, lo que te permite escribir tu propio código para realizar tareas específicas de manera eficiente y reutilizable. Una función en R es un conjunto de instrucciones que realizan una tarea específica cuando se invoca.
Al usar el comando function, puedes definir tus propias
funciones, especificando los argumentos que toma la función, el cuerpo
de la función que contiene las instrucciones a ejecutar y,
opcionalmente, el valor de retorno. Esto te permite encapsular tus
algoritmos y procedimientos en funciones que pueden ser fácilmente
llamadas y utilizadas en diferentes partes de tu código.
En este tema vamos a ser más específicos, detallando primero que nada la sintaxis básica para definir una función en R:
nombre_de_la_funcion <- function(argumentos) {
# Cuerpo de la función
instrucciones
return(valor_de_retorno)
}Donde:
nombre_de_la_funcion es el nombre que le das a tu función.
argumentos son los parámetros que recibe la función (opcional).
instrucciones son las acciones que realiza la función.
valor_de_retorno es el resultado que devuelve la función (opcional).
Una vez que has definido una función, puedes llamarla simplemente escribiendo su nombre seguido de paréntesis, pasando los argumentos necesarios si los tiene. Esto ejecutará el código dentro de la función y devolverá el resultado, si es que hay uno.
En el siguiente ejemplo, la función area_circulo toma un argumento radio, que representa el radio del círculo. Dentro de la función, se calcula el área del círculo utilizando la fórmula matemática estándar \(π * radio^2\). Finalmente, el valor calculado del área se devuelve utilizando la declaración return(area).
Luego, se llama a la función area_circulo con un radio específico (en este caso, 5 unidades) y el resultado se almacena en la variable resultado. Finalmente, se imprime el resultado utilizando la función print.
# Definición de la función para calcular el área de un círculo
area_circulo <- function(radio) {
# Fórmula para calcular el área del círculo: π * radio^2
area <- pi * radio^2
return(area)
}
# Llamada a la función con un radio de 5 unidades
radio <- 5
resultado <- area_circulo(radio)
# Imprimir el resultado
print(paste("El área del círculo con radio", radio, "es:", resultado))En RStudio quedaría de la siguiente manera:
Veamos otro ejemplo poco más complejo, la función sumar_naturales toma un argumento n, que representa el número hasta el cual queremos sumar los números naturales. Utilizamos un bucle for para iterar sobre los primeros n números naturales y acumular su suma en la variable suma. Luego, devolvemos esta suma como resultado de la función.
Después de definir la función, llamamos a sumar_naturales con n = 10 y almacenamos el resultado en la variable resultado. Finalmente, se imprime el resultado en la consola.
# Definición de la función para calcular la suma de los primeros n números naturales
sumar_naturales <- function(n) {
# Inicializar la suma
suma <- 0
# Calcular la suma de los primeros n números naturales
for (i in 1:n) {
suma <- suma + i
}
# Devolver la suma calculada
return(suma)
}
# Llamada a la función con n = 10
n <- 10
resultado <- sumar_naturales(n)
# Imprimir el resultado
cat("La suma de los primeros", n, "números naturales es:", resultado)En RStudio quedaría de la siguiente manera:
Notaste en el script anterior el uso de return , esta función se usa para especificar el valor que una función debe devolver cuando se llama.
7.2 Argumentos
Los argumentos son elementos fundamentales en la definición y ejecución de funciones en R. Permiten a las funciones recibir datos de entrada y realizar operaciones específicas en base a esos datos. La forma en que R evalúa y maneja los argumentos es crucial para comprender cómo funcionan las funciones en este lenguaje de programación. Exploraremos en detalle cómo R trabaja con los argumentos, desde la asignación de valores predeterminados hasta el manejo de valores faltantes y la manipulación de argumentos adicionales a través de ellipses.
7.2.1 Evaluación perezosa (lazy evaluation)
Evaluación perezosa es un término clave en la programación, indicando que las expresiones se evalúan solo cuando se necesitan. En el contexto de las funciones de R, los argumentos se acceden y utilizan solo cuando se utilizan en el cuerpo de la función. En esta unidad aprenderás cómo las funciones de R manejan los argumentos durante la ejecución mediante un ejemplo práctico que consiste en :
Crear una función para buscar matrices en una lista y multiplicarlas por otra matriz especificada, devolviendo los resultados en una nueva lista. Si no se encuentran matrices o si no son adecuadas para la multiplicación, la función devolverá un mensaje de advertencia al usuario.
# Definir la función
multiplicar_matrices <- function(lista_matrices, matriz_multiplicadora) {
# Verificar si la lista contiene matrices
if (length(lista_matrices) == 0 || !all(sapply(lista_matrices, is.matrix))) {
# Si no hay matrices en la lista, devolver mensaje de advertencia
return("No se encontraron matrices en la lista.")
}
# Verificar si las matrices son adecuadas para la multiplicación
if (!all(sapply(lista_matrices, function(x) ncol(x) == nrow(matriz_multiplicadora)))) {
# Si las dimensiones no son adecuadas, devolver mensaje de advertencia
return("Las dimensiones de las matrices no son adecuadas para la multiplicación.")
}
# Multiplicar cada matriz por la matriz especificada
resultado <- lapply(lista_matrices, function(x) x %*% matriz_multiplicadora)
# Devolver el resultado
return(resultado)
}
# Ejemplo de uso de la función
# Crear una lista de matrices
lista_matrices <- list(matrix(1:4, nrow = 2), matrix(5:8, nrow = 2))
# Matriz multiplicadora
matriz_multiplicadora <- matrix(c(2, 0, 0, 2), nrow = 2)
# Llamar a la función
resultado <- multiplicar_matrices(lista_matrices, matriz_multiplicadora)
print(resultado)En RStudio quedaría de la siguiente manera:
7.2.2 Estableciendo valores predeterminados
Los valores predeterminados para funciones en R son los valores que se asignan automáticamente a los argumentos de una función si no se proporciona ningún valor al llamar a la función. Estos valores predeterminados se especifican al definir la función y permiten que la función se ejecute incluso si no se proporcionan todos los argumentos requeridos.
En el siguiente ejemplo la función mi_funcion tiene tres argumentos (a, b y c) con valores predeterminados (1, “default” y TRUE respectivamente). Puedes llamar a la función sin especificar ningún argumento, en cuyo caso se usarán los valores predeterminados, o puedes proporcionar valores diferentes para algunos o todos los argumentos al llamar a la función.
# Definir una función con valores predeterminados
mi_funcion <- function(a = 1, b = "default", c = TRUE) {
cat("El valor de a es:", a, "\n")
cat("El valor de b es:", b, "\n")
cat("El valor de c es:", c, "\n")
}
# Llamar a la función sin especificar argumentos
mi_funcion()
# Llamar a la función especificando algunos argumentos
mi_funcion(b = "nuevo_valor", c = FALSE)En RStudio quedaría de la siguiente manera:
7.2.3 Comprobación de valores perdidos ( o faltantes)
En R, la función missing() se utiliza
para verificar si un argumento específico ha sido proporcionado cuando
se llama a una función. Esta función toma como argumento el nombre del
parámetro que se desea verificar y devuelve
TRUE si el argumento correspondiente no ha
sido suministrado en la llamada a la función, y FALSE en
caso contrario.
La función missing() es útil para
evitar errores en el código cuando se espera que ciertos argumentos sean
obligatorios, pero pueden no ser proporcionados por el usuario al llamar
a la función. Al usar missing(), el código
puede tomar decisiones o realizar acciones alternativas según si un
argumento está presente o no.
Por ejemplo, si se tiene una función que requiere un argumento
x, se puede usar missing(x) dentro del cuerpo
de la función para verificar si x ha sido proporcionado por
el usuario al llamar a la función. Si
missing(x) devuelve TRUE,
significa que el argumento x no ha sido suministrado y se
pueden tomar acciones correspondientes, como asignar un valor
predeterminado o generar un mensaje de error. Si missing(x)
devuelve FALSE, significa que el argumento x
ha sido proporcionado y se puede proceder con el resto del código según
lo esperado.
# Definir una función que toma un argumento obligatorio 'x'
check_argument <- function(x) {
# Verificar si 'x' está presente
if (missing(x)) {
print("El argumento 'x' no fue proporcionado.")
} else {
print(paste("El valor de 'x' es:", x))
}
}
# Llamar a la función sin proporcionar 'x'
check_argument()
# Llamar a la función proporcionando 'x'
check_argument(5)En RStudio quedaría de la siguiente manera:
Veamos un ejemplo donde la función calcular_altura_promedio calcula la altura promedio de un conjunto de plantas. Si no se proporcionan datos de altura al llamar a la función, se imprime un mensaje indicando que no se proporcionaron datos. Si se proporcionan los datos de altura (en este caso, un vector de alturas de plantas), la función calcula y muestra la altura promedio de esas plantas.
# Definir una función para calcular la altura promedio de plantas
calcular_altura_promedio <- function(altura_plantas) {
if (missing(altura_plantas)) {
print("No se proporcionaron datos de altura de plantas.")
} else {
altura_promedio <- mean(altura_plantas)
print(paste("La altura promedio de las plantas es:", altura_promedio, "cm"))
}
}
# Crear un vector de datos de altura de plantas
altura_plantas <- c(15, 18, 14, 17, 20)
# Llamar a la función sin proporcionar datos
calcular_altura_promedio()
# Llamar a la función proporcionando el vector de altura de plantas
calcular_altura_promedio(altura_plantas)En RStudio quedaría de la siguiente manera:
7.2.4 Elipsis (Ellipses)
En R, la elipsis (o ellipses) es un símbolo representado por tres puntos consecutivos: …. Se utiliza en la definición de funciones para indicar que la función puede aceptar un número variable de argumentos. Esto significa que puedes pasar un número arbitrario de argumentos adicionales cuando llamas a la función, sin tener que especificarlos explícitamente en la definición de la función.
La elipsis permite que una función maneje una amplia gama de situaciones y datos sin necesidad de definir todos los posibles argumentos de antemano. Los argumentos adicionales que se pasan a través de la elipsis pueden ser utilizados dentro del cuerpo de la función o pueden ser pasados a otras funciones internamente.
Veamos un ejemplo para comprender mejor, la función
mi_funcion acepta un argumento x y
utiliza la elipsis para manejar argumentos adicionales. Cuando se llama
a la función con mi_funcion(3, “a”, 5, TRUE), imprime
los argumentos adicionales pasados (en este caso,
“a”,5yTRUE). Si no se pasan
argumentos adicionales, la función imprime un mensaje indicando que no
se pasaron argumentos adicionales.
mi_funcion <- function(x, ...) {
# Realiza alguna operación con el argumento 'x'
resultado <- x * 2
# Utiliza la elipsis para manejar argumentos adicionales
if (length(list(...)) > 0) {
cat("Argumentos adicionales pasados:", paste(..., collapse = ", "), "\n")
} else {
cat("No se pasaron argumentos adicionales.\n")
}
# Devuelve el resultado
return(resultado)
}
# Llama a la función con argumentos adicionales
mi_funcion(3, "a", 5, TRUE)En RStudio quedaría de la siguiente manera:
Otro ejemplo sería el siguiente: la función longitud_promedio_flores que calcula el promedio de las longitudes de las flores del sur de Tabasco utilizando datos simulados. Los datos simulados representan la longitud de las flores de tres especies diferentes: orquídeas, hibiscos y begonias. La función toma como argumento datos, que debe ser un dataframe que contenga al menos una columna llamada “longitud”.
# Definición de la función para calcular la longitud promedio de las flores
longitud_promedio_flores <- function(datos, ...) {
# Extraer la columna de longitud de las flores de los datos
longitudes <- datos$longitud
# Calcular el promedio de las longitudes de las flores
promedio <- mean(longitudes, ...)
# Imprimir el promedio calculado
cat("La longitud promedio de las flores es:", promedio, "cm\n")
# Devolver el promedio calculado
return(promedio)
}
# Crear datos simulados de longitud de flores
set.seed(123) # Fijar semilla para reproducibilidad
datos_tabasco <- data.frame(
especie = rep(c("Orquídea", "Hibisco", "Begonia"), each = 30),
longitud = c(rnorm(30, mean = 12, sd = 2), rnorm(30, mean = 10, sd = 1.5), rnorm(30, mean = 8, sd = 1))
)
# Llamar a la función para calcular el promedio de longitud de las flores
promedio_longitud_tabasco <- longitud_promedio_flores(datos_tabasco)En RStudio quedaría de la siguiente manera:
7.3 Funciones especializadas
En este capítulo exploraremos tres tipos de funciones definidas por el usuario que tienen usos especializados. Primero, las funciones auxiliares, las cuales están diseñadas para ser invocadas múltiples veces por otra función (incluso pueden ser definidas dentro del cuerpo de una función principal). Posteriormente, analizaremos las funciones desechables, las cuales pueden ser definidas directamente como argumentos en una llamada a otra función. Por último, las funciones recursivas, que se invocan a sí mismas.
7.3.1 Funciones de ayuda externas
Las funciones de ayuda externas en R, también conocidas como funciones auxiliares, son funciones diseñadas para ser utilizadas por otras funciones, ya sea dentro de un mismo script o en otros scripts. Estas funciones se crean para realizar tareas específicas que pueden ser requeridas repetidamente en un programa más grande, lo que ayuda a organizar y reutilizar el código de manera efectiva.
la función es_par es una función de ayuda externa que verifica si un número es par. La función analizar_numeros es la función principal que utiliza la función es_par para analizar una lista de números y contar cuántos de ellos son pares e impares.
# Función auxiliar para verificar si un número es par
es_par <- function(numero) {
if (numero %% 2 == 0) {
return(TRUE)
} else {
return(FALSE)
}
}
# Función principal que utiliza la función auxiliar para analizar una lista de números
analizar_numeros <- function(lista_numeros) {
pares <- 0
impares <- 0
for (numero in lista_numeros) {
if (es_par(numero)) {
pares <- pares + 1
} else {
impares <- impares + 1
}
}
cat("Cantidad de números pares:", pares, "\n")
cat("Cantidad de números impares:", impares, "\n")
}
# Lista de números de ejemplo
numeros <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
# Llamar a la función principal
analizar_numeros(numeros)En RStudio quedaría de la siguiente manera:
Ahora bien, el siguiente ejemplo crea una función auxiliar para determinar si un compuesto químico es degradado por un microorganismo específico, y luego utilizaremos esta función en una función principal para analizar una lista de compuestos químicos y determinar cuáles de ellos son degradados por el microorganismo:
# Función auxiliar para verificar si un compuesto químico es degradado por un microorganismo
es_degradable <- function(compuesto, microorganismo) {
# Aquí iría la lógica para determinar si el compuesto es degradable por el microorganismo
# En este ejemplo, simplemente retornamos un valor aleatorio para simular el resultado
return(sample(c(TRUE, FALSE), 1))
}
# Función principal que utiliza la función auxiliar para analizar una lista de compuestos químicos
analizar_compuestos <- function(lista_compuestos, microorganismo) {
degradables <- 0
no_degradables <- 0
for (compuesto in lista_compuestos) {
if (es_degradable(compuesto, microorganismo)) {
degradables <- degradables + 1
} else {
no_degradables <- no_degradables + 1
}
}
cat("Cantidad de compuestos degradables por el microorganismo:", degradables, "\n")
cat("Cantidad de compuestos no degradables por el microorganismo:", no_degradables, "\n")
}
# Lista de compuestos químicos de ejemplo
compuestos <- c("Benceno", "Tolueno", "Xileno", "Etilbenceno", "Nafthaleno")
# Microorganismo de ejemplo
microorganismo <- "Pseudomonas aeruginosa"
# Llamar a la función principal
analizar_compuestos(compuestos, microorganismo)En RStudio quedaría de la siguiente manera:
7.3.2 Funciones de ayuda interna
Las funciones de ayuda interna en R son funciones definidas dentro del cuerpo de otra función y se utilizan exclusivamente por esa función principal. Son útiles para dividir tareas complejas en partes más pequeñas y fáciles de manejar, lo que facilita la comprensión y mantenimiento del código. Estas funciones solo son visibles y accesibles dentro de la función principal en la que se definen, no pueden ser llamadas desde fuera de esa función ni modificar las variables locales de la función principal a menos que se pasen como argumentos.
Veamos un primer ejemplo donde la función calcular_area_exacta es una función de ayuda interna que calcula el área exacta de un círculo. Esta función interna solo se puede acceder y utilizar dentro de la función principal area_circulo, donde se define. La función principal area_circulo llama a la función interna para calcular el área exacta del círculo y luego redondea el resultado antes de devolverlo
# Función principal que calcula el área de un círculo y redondea el resultado
area_circulo <- function(radio) {
# Función interna para calcular el área exacta del círculo
calcular_area_exacta <- function(radio) {
return(pi * radio^2)
}
# Llamar a la función interna para calcular el área exacta
area_exacta <- calcular_area_exacta(radio)
# Redondear el resultado y devolverlo
return(round(area_exacta, 2))
}
# Calcular el área de un círculo con radio 5 utilizando la función principal
resultado <- area_circulo(5)
print(resultado)En Rstudio quedaría de la siguiente manera:
Ahora bien, en el siguiente ejemplo utilizaremos la función calcular_ica calcula un índice de calidad del agua basado en varios parámetros (pH, oxígeno disuelto, demanda química de oxígeno y demanda bioquímica de oxígeno). La función interna clasificar_calidad se utiliza para asignar una clasificación de calidad (Excelente, Buena, Aceptable, Mala) basada en el valor del índice calculado.
El script se vería de la siguiente manera:
# Función principal para calcular el índice de calidad del agua (ICA)
calcular_ica <- function(pH, oxigeno, demanda_quimica, demanda_bioquimica) {
# Función interna para clasificar la calidad del agua basada en el ICA
clasificar_calidad <- function(ica) {
if (ica >= 80) {
return("Excelente")
} else if (ica >= 60) {
return("Buena")
} else if (ica >= 40) {
return("Aceptable")
} else {
return("Mala")
}
}
# Cálculo del ICA
ica <- (pH * 0.1) + (oxigeno * 0.2) + (demanda_quimica * 0.3) + (demanda_bioquimica * 0.4)
# Clasificar la calidad del agua basada en el ICA
calidad <- clasificar_calidad(ica)
# Devolver el resultado
return(list(ica = ica, calidad = calidad))
}
# Ejemplo de uso
resultado <- calcular_ica(7.5, 8.2, 15, 20)
print(resultado)En RStudio quedaría de la siguiente manera:
7.3.3 Funciones descartables
Las funciones descartables en R, también conocidas como funciones anónimas, son funciones que se definen sin asignarles un nombre y se utilizan principalmente en situaciones en las que se necesita una función simple para una tarea específica que no se va a reutilizar. Estas funciones son útiles cuando se necesita pasar una función como argumento a otra función, como en el caso de apply, lapply o sapply ( vistos en capítulos anteriores). Al definir una función descartable, puedes escribir y ejecutar la función en el lugar donde se necesita, sin necesidad de asignarle un nombre ni almacenarla para uso posterior. Esto hace que el código sea más conciso y fácil de leer en casos donde una función simple es suficiente para la tarea en cuestión. Veamos un ejemplo:
# Ejemplo de función descartable para duplicar columnas de una matriz y luego ordenarlas
matriz <- matrix(1:9, nrow = 3)
print("Matriz original:")
print(matriz)
# Utilizando una función descartable con apply
nueva_matriz <- apply(matriz, 2, function(x) sort(c(x, x)))
print("Matriz con columnas duplicadas y ordenadas:")
print(nueva_matriz)En RStudio quedaría de la siguiente manera:
El siguiente ejemplo utiliza una función descartable (o anónima) para manipular datos de temperatura y humedad en el estado de Tabasco durante el año 2023. Se genera una matriz de datos simulados donde cada fila representa una fecha y cada columna corresponde a una medida (temperatura en grados Celsius y humedad en porcentaje). La función descartable se aplica a cada fila de la matriz para obtener un resumen de las condiciones climáticas de cada día, que incluye la temperatura y la humedad. Luego, se ordenan las filas de la matriz original según este resumen, lo que permite visualizar los datos climáticos ordenados por las condiciones resumidas de cada día.
# Ejemplo de función descartable para manipular datos de temperatura y humedad en Tabasco en 2023
# Generar datos de ejemplo
set.seed(123)
datos_climaticos_tabasco_2023 <- matrix(data = c(sample(20:40, 12, replace = TRUE), sample(50:90, 12, replace = TRUE)), nrow = 12, ncol = 2)
colnames(datos_climaticos_tabasco_2023) <- c("Temperatura (°C)", "Humedad (%)")
rownames(datos_climaticos_tabasco_2023) <- paste0("2023-01-", 1:12)
print("Datos originales:")
print(datos_climaticos_tabasco_2023)
# Función descartable para resumir las condiciones climáticas de cada día
resumen_clima <- apply(datos_climaticos_tabasco_2023, 1, function(x) paste("Temperatura:", x[1], "°C, Humedad:", x[2], "%"))
# Ordenar las filas según el resumen de condiciones climáticas
datos_climaticos_tabasco_2023_ordenados <- datos_climaticos_tabasco_2023[order(resumen_clima), ]
print("Datos ordenados según el resumen de condiciones climáticas:")
print(datos_climaticos_tabasco_2023_ordenados)En RStudio quedaría de la siguiente manera:
Observa en el script como la función permite realizar una tarea específica (resumir las condiciones climáticas de cada día) sin necesidad de definir una función con nombre en el entorno global. Esto hace que el código sea más conciso y fácil de entender, ya que la función se define y utiliza en el mismo contexto, sin necesidad de crear un objeto de función separado.
7.3.4 Funciones recursivas
Las funciones recursivas en R son aquellas que se llaman a sí mismas dentro de su propio cuerpo. Se utilizan para resolver problemas que pueden dividirse en casos más pequeños y similares al problema original. En cada llamada recursiva, el problema se reduce progresivamente hasta alcanzar un punto en el que ya no es necesario realizar más llamadas recursivas, este punto se conoce como “caso base”. El caso base es fundamental ya que evita que la recursión se convierta en un bucle infinito. Las funciones recursivas son útiles para abordar problemas complejos de manera más simple y elegante, especialmente aquellos que tienen una estructura recursiva inherente, como calcular factorial y la sucesión de Fibonacci. Estos ejemplos se describen en el siguiente script:
fibonacci <- function(n) {
if(n <= 1) {
return(n)
} else {
return(fibonacci(n - 1) + fibonacci(n - 2))
}
}
# Ejemplo de uso
n <- 10
resultado <- fibonacci(n)
cat("El término", n, "de la sucesión de Fibonacci es:", resultado, "\n")
factorial_recursivo <- function(n) {
if(n == 0 || n == 1) {
return(1)
} else {
return(n * factorial_recursivo(n - 1))
}
}
# Ejemplo de uso
n <- 5
resultado <- factorial_recursivo(n)En el script anterior la función Fibonacci calcula
el término n de la sucesión de Fibonacci de forma recursiva. Si n es
menor o igual a 1, se devuelve n directamente. De lo contrario, se llama
a la función fibonacci para n - 1 y n - 2 y se suma el resultado.
Finalmente, se imprime el término de Fibonacci calculado. Y por último
la función factorial_recursivo calcula el factorial de
n. Si n es 0 o 1, devuelve 1. De lo contrario, multiplica n por el
factorial de n - 1 (llamando a la función recursivamente) y devuelve el
resultado. Finalmente, se imprime el factorial calculado.
En RStudio quedaría de la siguiente manera:
