In eyeguas/fundamentosr: Fundamentos de R (Tutoriales basicos en castellano)

library(learnr)
knitr::opts_chunk$set(echo = FALSE)

Introducción

knitr::include_graphics("images/intro.jpg")

El presente tutorial pretende ser un vehículo de aprendizaje interactivo para los novatos en el lenguaje R.

Ha sido desarrollado a través del paquete learnr que permite utilizar documentos RMarkdown para generar tutoriales interactivos.

Como se explica en la página de learnr, los tutoriales consisten en contenido (texto, figuras, ilustraciones, ecuaciones, vídeos, etc.) junto con componentes interactivos, como preguntas con múltiples opciones y fragmentos de código de R que los usuarios pueden editar y ejecutar directamente, para verificar y reforzar la comprensión.

Estos tutoriales conservan automáticamente el avance que un usuario realizó, por lo que si un estudiante trabaja en algunos ejercicios o preguntas y vuelve al tutorial más tarde, puede retomarlo exactamente donde lo dejó.

Este tutorial ha sido publicado como el paquete fundamentosr.

Objetivo de aprendizaje

El objetivo de aprendizaje del presente tutorial es el siguiente:

• Reconocer los tipos de datos atómicos en R.

Constantes, valores literales y variables

De manera análoga al uso de estos términos en lenguaje matemático, una constante es un objeto con nombre cuyo valor no podemos cambiar. En contraste, una variable es un objeto que puede cambiar de valor. Un valor literal es el que aparece tal cual en el código fuente (ejemplo, un número). Por tanto, podemos ver Una constante como un nombre significativo que ocupa el lugar de un literal y mantiene este mismo valor.

Realizamos a continuación la suma entre los literales dos y cuatro. Pulsa el botón Run Code para comprobar el resultado de la ejecución.

2+4

Veamos ahora un ejemplo de la presencia de constantes, valores literales y variables. En la siguiente expresión (área de un círculo), $\pi$ es una constante, $2$ es un valor literal, mientras que $area$ y $radio$ son variables.

$area={\pi}radio^2$

Las constantes y variables en R tienen nombres que nos permiten hacer referencia a ellas en operaciones.

Las constantes ya están establecidas por R, mientras que nosotros podemos crear variables, asignándoles valores a nombres. Si una variable mantiene el mismo valor durante todo el programa podríamos considerarla como una constante.

Asignaciones

Si una expresión se utiliza como una orden por sí misma, su valor se imprime y se pierde. En R usamos <- para hacer asignaciones proporcionando un valor a una determinada variable. De este modo, podemos asignar el valor $9$ a la variable $radio$ para poder reutilizarlo posteriormente.

radio<-9

Podemos comprobar como la propia asignación no produce respuesta alguna. Para mostrar el valor de la variable debemos hacerlo con print y englobando entre paréntesis la propia variable.

radio<-9
print(radio)

Prueba a cambiar el valor a asignar a la variable en el código anterior. Cámbialo a un número flotante: por ejemplo, $9,5$. Vuelve a ejecutar el código: Run Code.

El resultado que obtendrás será un error:

radio<-9,5
print(radio)

El símbolo separador que se utiliza para los flotantes en R es el punto (.). De ahí el error. Pulsa entonces Start Over y modifica el código nuevamente incluyendo ahora el flotante $9.5$. Tras ejecutar el código, la salida ahora será diferente:

radio<-9.5
print(radio)

En RStudio cuando realizamos una asignación, por ejemplo en la consola (Console), aparecen automáticamente en la pestaña Environment las variables creadas junto a su valor.

knitr::include_graphics("images/consola_variables.jpg")

knitr::include_graphics("images/environment_variables.jpg")

Comentarios

En R, tal y como ocurre con otros lenguajes de programación, existe la posibilidad de incluir comentarios en el código. Para ello se usa el símbolo de hashtag # al inicio de línea. De esta forma, toda línea que comience por # podrá incluir texto libre y no será ejecutada como código.

En el siguiente ejemplo, aparece código y texto libre como comentarios. Prueba inicialmente a ejecutar con Run Code. Tras comprobar que no tiene efecto alguno, prueba a eliminar el símbolo # de las líneas que contienen código y vuelve a ejecutar para comprobar que ahora sí tienen efecto.

#Asignación y visualización de contenido de variable
#area<-20
#print(area)

Si pruebas a eliminar el símbolo de comentario de la primera línea aparecerá el error correspondiente:

Asignación y visualización de contenido de variable
area<-20
print(area)

Nombres de variables

Los nombres de los objetos deben comenzar con una letra y solo pueden contener letras, números, _ y .. Es mejor que los nombres sean descriptivos. Es convencional hacer uso del símbolo _ para usar más de una palabra o comenzar la segunda palabra con mayúscula. Así mismo, se recomienda no usar la tilde.

quiz(
  question("¿Cuáles de los siguientes nombres de variables son correctos?",
           correct="¡Bien hecho!", allow_retry=TRUE,
    answer("``area circulo``", message="Hay un espacio en blanco en mitad del nombre ``area circulo``. No sería válido."),
    answer("``areaCirculo``", correct=TRUE),
    answer("``area_circulo``", correct = TRUE),
    answer("``#AreaCirculo``", message="El nombre de la variable ``#AreaCirculo`` comienza con el símbolo ``#``. No sería válido."),
    incorrect="Existen dos nombres de variable correctos."
  )
)

Para examinar un objeto (variable) podemos escribir directamente su nombre. Sin embargo, es de vital importancia que no haya errores ortotipográficos (typos) y comprobar la coincidencia de mayúsculas y minúsculas (no es lo mismo variable que Variable o que VARiable, por ejemplo). Se trata de un lenguaje case-sensitive.

mi_area<-20
mi_radio<-5
mi_area
mi_Radio

Si ejecutas el código anterior comprobarás que aparece un error: la variable mi_Radio no está definida, dado que la que sí lo está es mi_radio.

mi_radio<-5
mi_Radio

Cambia el nombre de la variable y vuelve a ejecutar el código para comprobar que funciona todo bien y se puede ver el contenido de las variables mi_area y mi_radio.

Tipos de datos en R

Todo lo que manipulamos a través de R son objetos. Los objetos más simples son de cinco tipos a los que se denomina tipos de datos atómicos. Son los siguientes:

• Numéricos
• numeric (números reales)
• integer (números enteros)
• complex (números complejos)
• Cadenas de caracteres
• character
• Lógicos
• logical

Los datos numéricos

Probablemente, el principal uso de R es la manipulación de datos numéricos. El lenguaje agrupa este tipo de datos en tres categorías: numeric (números reales), integer (números enteros) y complex (números complejos). Cuando se introduce algo que puede interpretar como un número, por defecto será tratado como un dato de tipo numeric, es decir, un número de tipo real, a no ser que explícitamente se indique un tratamiento diferente. Para conocer el tipo de datos asignado a una variable se usa class junto a la variable entre paréntesis.

edad<-33
peso<-69.5
edad
peso
class(edad)
class(peso)

Al ejecutar el código anterior podemos comprobar que ambas variables edad y peso son de tipo de datos numeric. En caso de querer considerar, por ejemplo, ambas variables como enteras (integer) haríamos uso de as.integer incluyendo entre paréntesis el valor correspondiente a la variable.

edad<-as.integer(33)
peso<-as.integer(69.5)
edad
peso
class(edad)
class(peso)

Al ejecutar el código anterior podemos comprobar que ahora ambas variables son tratadas como de tipo de datos entero. El efecto en la variable peso es que se ha eliminado la parte decimal. En caso de que queramos que directamente en la asignación se trate a un valor como entero debemos añadir al número la letra L al final.

edad<-33L
peso<-69.5L
edad
peso
class(edad)
class(peso)

En este caso, tras ejecutar el código, nos damos cuenta que si el número tiene formato de número entero (no tiene decimales) sí que es tratado como número entero (número asignado a variable edad). En caso contrario, es tratado de acuerdo a su formato (número real para el caso de la variable peso).

quiz(
  question("¿Cuáles de las siguientes variables son interpretadas por R como tipo de datos entero?",
           correct="¡Bien hecho!", allow_retry=TRUE,
    answer("``altura<-as.integer(177)``", correct=TRUE),
    answer("``hijos<-2L``", correct=TRUE),
    answer("``edad<-33``", message = "Aunque el valor ``33`` podemos interpretarlo como entero, R por defecto interpretará la variable ``edad`` como real a no ser que lo indiquemos explícitamente."),
    answer("``experiencia_profesional<-5.5``", message="La variable ``experiencia_profesional`` es un número real (tiene parte decimal)."),
    incorrect="Existen dos variables de tipo de datos entero."
  )
)

Los números complejos (complex) no los abordaremos por el momento.

Cadenas de caracteres

Una cadena de caracteres (string en inglés) es una secuencia ordenada de caracteres, con una longitud arbitraria (finita). Las cadenas de caracteres son secuencias de elementos (letras, números, espacio, signos o símbolos) que pertenecen a un cierto lenguaje formal o alfabeto: análogas a una frase o a una oración.

Una cadena suele ser representada entre comillas dobles ("hola"), mientras que un carácter de esa cadena se suele representar entre comillas simples ('h'). En R el caracter y la cadena de caracteres no son tipos de datos diferentes. Tanto el caracter como la cadena son tratados como character (no hay caracteres individuales sino cadenas de caracteres de un elemento).

Podemos crear una cadena utilizando comillas simples o dobles. A diferencia de otros lenguajes, no hay diferencias en su comportamiento. Es recomendable utilizar comillas dobles ", a menos que queramos crear una cadena que contenga múltiples comillas.

nombre<-"Luisa"
apellidos<-"Cobos"
direccion<-"Calle Rios, 39"
genero<-"F"
nombre
apellidos
direccion
genero
class(nombre)
class(apellidos)

Ejecuta el código anterior. Comprueba el tipo de datos indicado por class: character.Depués cambia las comillas dobles " por simples ' y las cadenas de caracteres de la siguiente forma:

• nombre: Luis,
• apellidos: Cobo,
• direccion: Calle Rio, 49,
• genero: M.

Comprueba que sigue funcionando. A continuación vamos a ver cómo insertar las comillas explícitamente dentro de una cadena de caracteres. La forma más sencilla sería rodeando la cadena de caracteres mediante comillas simples y usando las comillas dobles rodeando los caracteres necesarios dentro de la cadena.

futbolista1<-'Manuel Francisco dos Santos "Garrincha"'
futbolista2<-'Edson Arantes do Nascimento "Pelé"'
futbolista3<-'Leo "La Pulga" Messi'
futbolista4<-'Juan Sebastián "La Brujita" Verónº'
futbolista1
futbolista2
futbolista3
futbolista4

Como vemos, al examinar el contenido de una variable cadena de caracteres aparecen las comillas que la delimitan. En caso de aparecer comillas en el interior de la cadena son precedidas del símbolo \.

quiz(
  question("¿Cuáles de las siguientes variables de tipo cadena están definidas correctamente?",
           correct="¡Bien hecho!", allow_retry=TRUE,
    answer("``direccion1<-'Calle \"Ciudad de la Luz\", 4, 5º B'``", correct=TRUE),
    answer("``direccion2<-'Avenida de la Libertad, 102'``", correct=TRUE),
    answer("``direccion3<-'Plaza Mayor, 5\"``", message = "La cadena ``direccion3`` no está delimitada con el mismo tipo de comillas. Comienza con el símbolo ``'`` y acaba con el símbolo ``\"``."),
    answer("``direccion4<-Carretera del Ventorrillo, km 333``", message="La cadena ``direccion4`` no es correcta. Faltan los delimitadores de la cadena."),
    incorrect="Existen dos variables definidas correctamente."
  )
)

Tipo de datos lógico o booleano

El tipo de dato lógico o booleano (logic) es en computación aquel que puede representar valores de lógica binaria, esto es, dos valores, que normalmente representan verdadero o falso. En R, este tipo de datos toma los valores TRUE o FALSE (en mayúsculas). TRUE y FALSE pueden ser abreviados con T y F (en mayúsculas) respectivamente. No obstante, se recomienda utilizar la versión completa del valor.

casado<-TRUE
con_hijos<-FALSE
casado
con_hijos
class(casado)
class(con_hijos)

Ejecuta el código anterior. Sustituye las variables por la opción opuesta pero utilizando los valores abreviados T y F. Comprueba el resultado.

También podemos verificar si una variable determinada es de un tipo de datos específico: numeric, character o logical:

edad<-20
es_tipo_datos_numerico<-is.numeric(edad)
nombre<-"Beatriz"
es_tipo_datos_cadena<-is.character(nombre)
casada<-TRUE
es_tipo_datos_logico<-is.logical(casada)
es_tipo_datos_numerico
es_tipo_datos_cadena
es_tipo_datos_logico

Ejecuta el código anterior. Para saber si la variable edad es de tipo de datos numérico usamos is.numeric junto a la variable entre paréntesis. Para saber si la variable nombre es de tipo de datos cadena usamos is.character junto a la variable entre paréntesis. Finalmente, para saber si la variable casado es lógica usamos is.logical de la misma forma. El resultado es siempre de tipo lógico (logical) y se guarda respectivamente en las variables es_tipo_datos_numerico, es_tipo_datos_cadena y es_tipo_datos_logico.

Cambia el código anterior para que las tres variables es_tipo_datos_numerico, es_tipo_datos_cadena y es_tipo_datos_logico tengan valor FALSE. Basta con cambiar las variables contenidas dentro de is.numeric, is.character y también is.logical. Ten en cuenta que antes de preguntar por el valor de una variable, este valor debe haber sido asignado previamente. Por ello, cambia todas las asignaciones al principio del código.

edad<-20
nombre<-"Beatriz"
casada<-TRUE
es_tipo_datos_numerico<-is.numeric(nombre)
es_tipo_datos_cadena<-is.character(edad)
es_tipo_datos_logico<-is.logical(edad)
es_tipo_datos_numerico
es_tipo_datos_cadena
es_tipo_datos_logico

Si ejecutas este código puedes ver un ejemplo en el que todas las variables mencionadas tienen el valor FALSE.

Finalmente, vamos a realizar un ejercicio en el que vamos a intercambiar el valor de dos variables. Partiremos de una mujer casada y sin hijos y queremos convertirla en una mujer no casada y con hijos. Los estados estarán representados con las variables casada y con_hijos. Debemos intercambiar el valor de esas variables. Intenta llevarlo a cabo. No te preocupes si no obtienes la solución porque la proporcionaremos a continuación.

casada<-TRUE
con_hijos<-FALSE
#incluye aquí
#el código para
#intercambiar las variables
print("Casada:")
casada
print("Con hijos:")
con_hijos

Una de las soluciones que se puede ocurrir en una primera aproximación es asignar el valor de una variable a otra.

casada<-TRUE
con_hijos<-FALSE
casada<-con_hijos
con_hijos<-casada
print("Casada:")
casada
print("Con hijos:")
con_hijos

El problema de este código es que una vez que asigno el valor de la variable con_hijos a la variable casada se pierde el valor de la variable casada. Por tanto, en la siguiente asignación la variable con_hijos vuelve a tomar su valor original. Por tanto, ambas variables tendrían el valor FALSE. Esto se mantiene si cambio el orden de las asignaciones aunque, en ese caso, ambas tendrían el valor TRUE. Puedes comprobarlo modificando el código anterior.

La solución aparece haciendo uso de una variable auxiliar en la que se guarde el contenido de una de las variables para que no se pierda durante el intercambio.

casada<-TRUE
con_hijos<-FALSE
auxiliar<-casada
casada<-con_hijos
con_hijos<-auxiliar
print("Casada:")
casada
print("Con hijos:")
con_hijos

Conclusión

En este tutorial, has comprobado las características de cada tipo de datos simple en R y ejemplos de los datos que son modelados con cada uno de ellos.

Felicidades, has completado el tutorial de Tipos de datos simples en R. Puedes continuar con el siguiente tutorial: Operadores Aritméticos.

eyeguas/fundamentosr documentation built on March 31, 2021, 5:20 p.m.