3 Primeros pasos

3.1 Instalar R

El programa para instalar el software R se puede descargar desde el sitio web de R: https://www.r-project.org/. En el sitio web de R, primero es necesario elegir un espejo CRAN (servidor desde el cual se debe descargar R, y desde el más cercano a su ubicación geográfica), luego descargue el archivo base. Los usuarios de Linux pueden preferir un sudo apt-get install r-base.

El software R se puede descargar de muchos servidores CRAN (Comprehensive R Archive Network) de todo el mundo. Estos servidores se llaman espejos. La elección del espejo es manual.

3.2 R como calculadora

Una vez que se inicia el programa, aparece una ventana cuya apariencia puede variar dependiendo de su sistema operativo (Figura 3.1). Esta ventana se llama consola.

$Captura de pantalla de la consola R en Windows.\label{fig:screenCapConsole}$

Figure 3.1: Captura de pantalla de la consola R en Windows.

La consola corresponde a la interfaz donde se interpretará el código, es decir, donde el código será transformado en lenguaje de máquina, ejecutado por la computadora y retransmitido en forma legible por humanos. Esto es análogo a lo que sucede en una calculadora (Figura 3.2). Así es como se usará R más adelante en esta sección.

A lo largo de este libro, los ejemplos del código R aparecerán sobre un fondo gris. Se pueden copiar y pegar directamente en la consola, aunque es mejor reproducir los ejemplos escribiéndolos en la consola (o más adelante en los scripts) para una mejor comprensión del manejo del programa R. El resultado de lo que se envía en la consola también aparecerá en un fondo gris con ## delante del código para hacer la distinción entre el código y el resultado del código.

$Captura de pantalla de la consola R al lado de la calculadora de Windows.\label{fig:screenCapConsoleCal}$

Figure 3.2: Captura de pantalla de la consola R al lado de la calculadora de Windows.

3.2.1 Los operadores aritméticos

5 + 5

## [1] 10

Si escribimos 5 + 5 en la consola y luego Enter, el resultado aparece precedido por el número [1] entre corchetes. Este número corresponde al número del resultado (en nuestro caso, solo hay un resultado, volveremos a este aspecto más adelante). También podemos observar en este ejemplo el uso de espacios antes y después del signo +. Estos espacios no son necesarios, pero permiten que el código sea más legible para los humanos (es decir, más agradable de leer tanto para nosotros como para las personas con las que queremos compartir nuestro código). Los operadores aritméticos disponibles en R se resumen en la tabla 3.1.

Table 3.1: Operadores aritméticos.
Label	Operador
adición	+
resta	-
multiplicación	*
división	/
potencia	^
módulo	%%
cociente decimal	%/%

Clásicamente, las multiplicaciones y divisiones tienen prioridad sobre las adiciones y sustracciones. Si es necesario, podemos usar paréntesis.

5 + 5 * 2

## [1] 15

(5 + 5) * 2

## [1] 20

(5 + 5) * (2 + 2)

## [1] 40

(5 + 5) * ((2 + 2) / 3)^2

## [1] 17.77778

El operador módulo corresponde al resto de la división euclidiana. Se usa en ciencias de la computación, por ejemplo, para saber si un número es par o impar (un número módulo 2 devolverá 1 si es impar y 0 si es par).

451 %% 2

## [1] 1

288 %% 2

## [1] 0

(5 + 5 * 2) %% 2

## [1] 1

((5 + 5) * 2) %% 2

## [1] 0

R también incorpora algunas constantes que incluyen pi. Además, el signo infinito está representado por Inf.

pi

## [1] 3.141593

pi * 5^2

## [1] 78.53982

1/0

## [1] Inf

El estilo del código es importante porque el código está destinado a ser leído por nosotros y por otras personas. Para tener un estilo legible, se recomienda colocar espacios antes y después de los operadores aritméticos, excepto “*”, “/” y “^”, aunque a veces es útil agregarlos como es el caso en nuestro ejemplos.

3.2.2 Los operadores comparativos

Sin embargo, R es mucho más que una simple calculadora porque permite otro tipo de operadores: operadores de comparación, para comparar los valores (Table 3.2).

Table 3.2: Operadores de comparación.
Label	Operador
más pequeño que	<
mayor que	>
más pequeño o igual a	<=
más grande o igual a	>=
igual a	==
diferente de	!=

Por ejemplo, si queremos saber si un numero es más grande que otro, podemos escribir:

5 > 3

## [1] TRUE

R devuelve TRUE si la comparación es verdadera y FALSE si la comparación es falsa.

5 > 3

## [1] TRUE

2 < 1.5

## [1] FALSE

2 <= 2

## [1] TRUE

3.2 >= 1.5

## [1] TRUE

Podemos combinar operadores aritméticos con operadores de comparación.

(5 + 8) > (3 * 45/2)

## [1] FALSE

En la comparación (5 + 8) > (3 * 45/2) no se necesitan paréntesis, pero permiten que el código sea más fácil de leer.

Un operador de comparación particular es igual a. Veremos en la siguiente sección que el signo = está reservado para otro uso: permite asignar un valor a un objeto. El operador de comparación igual a debe ser diferente, por eso R usa ==.

42 == 53

## [1] FALSE

58 == 58

## [1] TRUE

Otro operador particular es diferente de. Se usa con un signo de admiración seguido de igual, !=. Este operador permite obtener la respuesta opuesta a ==.

42 == 53

## [1] FALSE

42 != 53

## [1] TRUE

(3 + 2) != 5

## [1] FALSE

10/2 == 5

## [1] TRUE

R usa TRUE y FALSE, que también son valores que se pueden probar con operadores de comparación. Pero R también asigna un valor a TRUE y FALSE:

TRUE == TRUE

## [1] TRUE

TRUE > FALSE

## [1] TRUE

1 == TRUE

## [1] TRUE

0 == FALSE

## [1] TRUE

TRUE + 1

## [1] 2

FALSE + 1

## [1] 1

(FALSE + 1) == TRUE

## [1] TRUE

El valor de TRUE es 1 y el valor de FALSE es 0. Veremos más adelante cómo usar esta información en los próximos capítulos.

R es también un lenguaje relativamente permisivo, significa que admite cierta flexibilidad en la forma de escribir el código. Debatir sobre la idoneidad de esta flexibilidad está fuera del alcance de este libro, pero podemos encontrar en el código R en Internet o en otras obras el atajo T para TRUE y F for FALSE.

T == TRUE

## [1] TRUE

F == FALSE

## [1] TRUE

T == 1

## [1] TRUE

F == 0

## [1] TRUE

(F + 1) == TRUE

## [1] TRUE

Aunque esta forma de referirse a TRUE y FALSE por T y F está bastante extendida, en este libro siempre usaremos TRUE y FALSE para que el código sea más fácil de leer. Como mencionado anterioramente, el objetivo de un código no solo es ser funcional sino también fácil de leer y volver a leer.

3.2.3 Los operadores lógicos

Hay un último tipo de operador, los operadores lógicos. Estos son útiles para combinar operadores de comparación (Table 3.3).

Table 3.3: Operadores lógicos.
Label	Operador
no es	!
y	&
o	\|
o exclusivo	xor()

!TRUE

## [1] FALSE

!FALSE

## [1] TRUE

((3 + 2) == 5) & ((3 + 3) == 5)

## [1] FALSE

((3 + 2) == 5) & ((3 + 3) == 6)

## [1] TRUE

(3 < 5) & (5 < 5)

## [1] FALSE

(3 < 5) & (5 <= 5)

## [1] TRUE

El operador lógico xor() es o exclusivo. Es decir, uno de los dos argumentos de la función xor() debe ser verdadero, pero no ambos. Más adelante volveremos a las funciones y sus argumentos, pero recuerde que identificamos una función por sus paréntesis que contienen argumentos separados por comas.

xor((3 + 2) == 5, (3 + 3) == 6)

## [1] FALSE

xor((3 + 2) == 5, (3 + 2) == 6)

## [1] TRUE

xor((3 + 3) == 5, (3 + 2) == 6)

## [1] FALSE

xor((3 + 3) == 5, (3 + 3) == 6)

## [1] TRUE

Se recomienda que las comas , sean seguidas de un espacio para que el código sea más agradable de leer.

3.2.4 Ayuda a los operadores

El archivo de ayuda en inglés sobre operadores aritméticos se puede obtener con el comando ?'+'. El de los operadores de comparación con el comando ?'==' y el de los operadores lógicos con el comando ?'&'.

3.3 El concepto de objeto

Un aspecto importante de la programación con R, pero también la programación en general es la noción de objeto. Como se indica en la página web de wikipedia (https://ia.wikipedia.org/wiki/Objecto_(informatica)), en ciencias de la computación, un objeto es un contenedor, es decir, algo que contendrá información. La información contenida en un objeto puede ser muy diversa, pero por el momento contendremos en un objeto el número 5. Para hacer esto (y para reutilizarlo más adelante), debemos darle un nombre a nuestro objeto. En R, los nombres de los objetos no deben contener caracteres especiales como ^ $ ? | + () [] {}, entre otros. No deben comenzar con un número ni contener espacios. El nombre del objeto debe ser representativo de lo que contiene, sin ser demasiado corto ni demasiado largo. Imagine que nuestro número 5 corresponde al número de repeticiones de un experimento. Nos gustaría darle un nombre que se refiera a numero y repeticiones, que podríamos reducir a nbr y rep, respectivamente (nbr para number en ingles). Hay varias posibilidades que son bastante comunes bajo R:

la separación mediante guión bajo (underscore): nbr_rep
la separación mediante el carácter punto: nbr.rep
el uso de letras minúsculas: nbrrep
el estilo lowerCamelCase que consiste en una primera palabra en minúscula y la primera letra de las siguientes palabras con una letra mayúscula: nbrRep
el estilo UpperCamelCase donde cada palabra comienza con una letra mayúscula: NbrRep

Todas estas formas de nombrar un objeto son equivalentes. En este libro usaremos el estilo lowerCamelCase. En general, debemos evitar los nombres que son demasiado largos, como miNumeroDeRepeticionesDeMiExperimento o demasiado cortos como nR, y los nombres que no permiten identificar los contenidos como miVariable o miNumero, asi que nombres como a o b. El objetivo es de tener una idea de lo que hay en cada objeto en base a su nombre.

Hay diferentes maneras de definir un nombre para los objetos que crearemos con R. En este libro, utilizamos el estilo lowerCamelCase. Lo importante no es la elección del estilo, sino la consistencia en su elección. El objetivo es tener un código funcional, pero también un código que sea fácil y agradable de leer para nosotros y para los demás.

Ahora que hemos elegido un nombre para nuestro objeto, debemos crearlo y hacer que R entienda que nuestro objeto debe contener el número 5. Hay tres maneras de crear un objeto bajo R:

con <-
con =
o con ->

nbrRep <- 5
nbrRep = 5
5 -> nbrRep

En este libro siempre usaremos la forma <- para coherencia y también porque es la forma más común.

nbrRep <- 5

Acabamos de crear un objeto nbrRep y establecerlo con el valor 5. Este objeto ahora está disponible en nuestro entorno de computación y puede ser utilizado. Algunos ejemplos :

nbrRep + 2

## [1] 7

nbrRep * 5 - 45/56

## [1] 24.19643

pi * nbrRep^2

## [1] 78.53982

El valor asociado con nuestro objeto nbrRep se puede modificar de la misma manera que cuando se creó:

nbrRep <- 5
nbrRep + 2

## [1] 7

nbrRep <- 10
nbrRep + 2

## [1] 12

nbrRep <- 5 * 2 + 7/3
nbrRep + 2

## [1] 14.33333

El uso de objetos tiene sentido cuando tenemos operaciones complejas para realizar y hace que el código sea más agradable de leer y entender.

(5 + 9^2 - 1/18) / (32 * 45/8 + 3)

## [1] 0.4696418

termino01 <- 5 + 9^2 - 1/18
termino02 <- 32 * 45/8 + 3
termino01 / termino02

## [1] 0.4696418

3.4 Los scripts

R es un lenguaje de programación denominado lenguaje de scripting. Esto se refiere al hecho de que la mayoría de los usuarios escribirán pequeñas piezas de código en lugar de programas completos. R se puede usar como una simple calculadora, y en este caso no será necesario mantener un historial de las operaciones que se han realizado. Pero si las operaciones a implementar son largas y complejas, puede ser necesario e interesante guardar lo que se ha hecho para poder continuar más adelante. El archivo en el que se almacenarán las operaciones es lo que comúnmente se llama el script. Un script, por lo tanto, es un archivo que contiene una sucesión de información comprensible por R y que es posible ejecutar.

3.4.1 Crear un script y documentarlo

Para crear un nuevo script basta con abrir un documento vacío de texto, que será editado por un editor de texto como el bloc de notas en Windows o Mac OSX, o Gedit o incluso nano en Linux. Por convención, este archivo toma la extensión “.r” o “.R” (lo mas comun). Esta última convención se usará en este libro (“miArchivo.R”). Desde la interfaz gráfica de R, es posible crear un nuevo script en Mac OS y Windows a través de file, luego new script y save as. Al igual que el nombre de los objetos, el nombre del script es importante para que podamos identificar fácilmente su contenido. Por ejemplo, podríamos crear un archivo formRConceptsBase.R que contenga los objetos que acabamos de crear y los cálculos que hicimos. Pero incluso con nombres de objetos y archivos bien definidos, será difícil recordar el significado de este archivo sin la documentación que acompaña a este script. Para documentar un script utilizaremos comentarios. Los comentarios son elementos que R identificará como tales y no se ejecutarán. Para especificar a R que vamos a hacer un comentario, debemos usar el carácter octothorpe (corsé o numeral) #. Los comentarios se pueden insertar en una nueva línea o al final de la línea.

# creación objeto número de repeticiones
nbrRep <- 5 # Comentario de fin de línea

Todo lo que hay despues del simbolo numeral # no sera ejecutado. Significa que podriamos usar comentarios como ### o #comentario, aun que se recomienda hacer comentarios con un solo simbolo numeral seguido por un espacio y despues su comentario: # mi comentario.

Los comentarios también se pueden usar para hacer que una línea ya no se ejecute. En este caso no queremos ejecutar la secunda linea:

nbrRep <- 5
# nbrRep + 5

Para volver a la documentación del script, se recomienda comenzar cada uno de nuestros scripts con una breve descripción de su contenido, luego cuando el script sea extenso, estructurarlo en diferentes partes para facilitar su lectura.

# ------------------------------------------------------------
# Aquí hay un script para adquirir los conceptos básicos
# con R
# fecha de creación : 27/06/2018
# autor : François Rebaudo
# ------------------------------------------------------------

# [1] creación del objeto número de repeticiones
# ------------------------------------------------------------

nbrRep <- 5

# [2] cálculos simples
# ------------------------------------------------------------

pi * nbrRep^2

## [1] 78.53982

Para ir más allá en el estilo del código, una guía completa de recomendaciones está disponible en línea en el sitio web tidyverse (en ingles ; http://style.tidyverse.org/).

3.4.2 Ejecutar un script

Como tenemos un script, no trabajamos directamente en la consola. Pero solo la consola puede entender el código R y devolvernos los resultados que queremos obtener. Por ahora, la técnica más simple es copiar y pegar las líneas que queremos ejecutar desde nuestro script hasta la consola. A partir de ahora, ya no utilizaremos editores de texto como bloc de notas, sino editores especializados para la creación de scripts R. Sera es el objetivo del siguiente capítulo.

3.5 Conclusión

Felicitaciones, hemos llegado al final de este primer capítulo sobre la base de R. Sabemos:

Instalar R
Usar R como una calculadora
Crear objetos y utilisarlos para los calculos aritméticos, comparativos y logicos
Elejir nombres pertinentes para los objetos
Crear un nuevo script
Elejir un nombre pertinente para el archivo del script
Ejecutar el codigo de un script
Documentar los scripts con comentarios
Usar un estilo de código para que sea agradable de leer y facil de entender