Práctica 1. Introducción a R y RStudio

José R. Hilera, 07/09/2023 CC-BY

1. Introducción

Con esta práctica se pretende aprender a usar la herramienta RStudio, que permite crear proyectos para ejecutar comandos en lenguaje R para realizar cálculos y generar diagramas.

R es un lenguaje de programación con el que se pueden escribir comandos, también llamados órdenes, instrucciones o sentencias, que el ordenador ejecuta; para lo cual es necesario tener instalado un software denominado “R”, disponible para Windows, macOS o Linux.

Para que sea más cómodo crear y ejecutar grupos de comandos R, es recomendable usar una herramienta como RStudio. Se trata de un entorno de desarrollo integrado, que incluye un editor de comandos R, pero también otras utilidades como una consola de ejecución de comandos, un gestor de archivos del proyecto, una sección para visualizar gráficos, etc.

2. Instalación de R y RStudio

2.1 Instalación de R

Para que RStudio funcione, primero hay que instalar el software R, que se descarga desde cran.rediris.es.

En el caso de Windows, se selecciona “install R for the first time”.

Y se descarga la última versión disponible.

Es un archivo .exe, que una vez descargado hay que ejecutar para que se instale.

En todas las pantallas que aparezcan se selecciona el botón “Siguiente”.

2.2 Instalación de RStudio

Una vez instalado R, se puede instalar RStudio Desktop desde posit.co.

En el caso de Windows, descargamos el archivo .exe de la última versión y lo ejecutamos.

Seleccionamos el botón “Siguiente” en todas las ventanas.

Existe la opción de utilizar RStudio de forma online sin instalarlo en nuestro ordenador, usando un navegador web. Se trata de Posit Cloud, que ofrece una suscripción gratuita con algunas limitaciones.

2.3 Referencias sobre R y RStudio

Sobre R existen recomendaciones de manuales y documentos de consulta en el propio sitio web del proyecto R:

Sobre RStudio se recomiendan las siguientes referencias:

3. Descripción de RStudio

Para ejecutar RStudio, localizamos su icono en el escritorio de nuestro ordenador. No confundir con el icono de R.

Al abrir RStudio aparece una ventana con diferentes secciones.

Debemos crear un nuevo proyecto desde el menú principal de la parte superior de la ventana:

File > New Project

Y aparece una ventana en la que elegiremos New Directory > New Project.

Al elegir esta opción, se nos pide el nombre del directorio (carpeta) del ordenador en el que queremos que se guarde el proyecto. Con el botón “Browse” podemos navegar por el explorador de archivos del ordenador hasta la carpeta que queramos usar para que se cree una subcarpeta para el proyecto.

Por ejemplo, podríamos crear el proyecto en una carpeta P1 para esta práctica, dentro de la carpeta Estadística:

Si la carpeta Estadística no existe en el disco, se crea en el momento de seleccionar el botón “Create Project”. Y aparece en entorno de trabajo de RStudio.

Pueden verse tres secciones:

  1. Environment: Con las variables y otros recursos usados en el proyecto. De momento no hay nada.
  2. Files: Donde se ve el contenido de la carpeta (directorio) del proyecto. De momento sol hay un archivo llamado “R1.Rproj”.
  3. Console: En esta sección se pueden escribir directamente los comandos en lenguaje R. Podemos probar a escribir una operación matemática como: 34+62 y vemos que nos responde con el resultado de la suma.

Si queremos limpiar la consola, podemos seleccionar el icono con forma de brocha o cepillo.

3.1 Crear un archivo de texto para comandos en lenguaje R

En las prácticas no escribiremos comando u órdenes en lenguaje R directamente en la consola, sino que crearemos previamente un archivo de texto en el que escribiremos las órdenes, una en cada línea, así podemos guardar el trabajo en dicho archivo y recuperarlo en siguientes sesiones.

Para crear un archivo hay que seleccionar:

File > New File > R Script

Al hacerlo, lo que ocurre es que se crea una nueva sección encima de la consola, que es un editor de texto, en el que se abre el archivo recién creado, cuyo nombre inicial es “Untitled1”.

Para guardar este archivo de texto en la carpeta (directorio) del proyecto hay que seleccionar:

File > Save

Y se nos pide el nombre para el archivo, y escribimos por ejemplo “P1.R”. Los archivos de comandos en lenguaje R, deben tener como extensión “.R” al final del nombre.

Al hacer esto, en el editor ahora aparece el nombre del archivo. Y el propio archivo podemos verlo en la ventana File del proyecto.

Ya estamos en condiciones de empezar a escribir comandos R en el archivo de texto, uno por cada línea, por ejemplo, podemos escribir estas dos líneas:

34+62
5^2
    

En la primera línea hemos escrito un comando, orden o instrucción para sumar dos números y en la segunda para elevar 5 al cuadrado.

Para ejecutar cada línea hay que posicionar el cursor en esa línea y pulsar Ctrl+Intro en el teclado, o bien el botón “Run” que aparece en la parte superior derecha del editor. Y el resultado de la ejecución de esa línea debe aparecer en la consola. Si queremos ejecutar de una sola vez varias líneas del archivo de texto, debemos seleccionar todas, y pulsar Ctrl+Intro o bien el botón “Run”.

Delante de cada resultado aparece un número [1] que de momento podemos ignorar, será útil cuando los resultados de un mismo comando ocupen más de una línea, para poder identificar cada una de ellas.

4. Variables, operadores, comandos y funciones

Como en cualquier otro lenguaje de programación como Python, Java, C, JavaScript, etc., en R también se pueden crear variables, y usar operadores y funciones.

Las variables son contenedores de valores. A una variable le podemos asignar un valor, y en aquellos comandos en los que se use la variable, cuando se ejecute será sustituida por su valor.

Para asignar un valor a una variable podemos hacerlo de dos formas, con el operador <- o con el operador “=”. En esta práctica y en las siguientes usaremos siempre el operador “=”.

Por ejemplo, podemos crear una variable edad y asignarle un valor 12.

edad = 12

O bien:

edad <- 12

Y después usarla en una expresión como:

edad + 100

Para ejecutar estas órdenes desde el archivo de texto P1.R, se recuerda que hay que pulsar Ctrl+Intro en cada línea, y el resultado aparece en la consola.

Cuando creamos variables en un proyecto, aparecen en la sección “Environment”.

Puede observarse que al asignar un valor a una variable con edad=12, no aparece el resultado en la consola. Si queremos ver el resultado de la asignación en la consola, hay que encerrar la expresión entre paréntesis:

(edad=12)

Puede apreciarse que en un caso en la consola no se indica el valor 12 y en el otro sí, aunque en ambos casos el resultado ha sido el mismo, es decir se ha creado la variable en el proyecto, aparece en Environment y se puede usar a partir de ahora en el proyecto.

Si se utilizan números con decimales, hay que utilizar el punto “.” Para separar la parte entera de la decimal.

precio = 34.99

También se pueden asignar textos a las variables, en este caso deben encerrarse entre comillas dobles o simples.

nombre = "juan perez"

O bien:

nombre= 'juan perez'

También se pueden variables que almacenen valores lógicos o booleanos, que pueden ser TRUE o FALSE.

Por ejemplo:

respuesta = FALSE

Normalmente usamos nombres largos para las funciones, en ese caso se pueden usar símbolos como “_” o “.” en el nombre de la función, o una notación “camelcase”, es decir poner en mayúscula la primera letra de cada palabra. Lo habitual en r es usar el separador “.”. Por ejemplo, algunos nombres válidos podrían ser:

> totaldelafactura=25.99
> TotalDeLaFactura=25.99
> total_de_la_factura=25.99
> total.de.la.factura=25.99

4.2 Operadores

Se pueden utilizar operadores de diferente tipo, como aritméticos y de comparación, entre otros.

Principales operadores aritméticos en R
Operador Nombre Ejemplo (consola)
+
Suma
> 30+10
[1] 40
-
Resta
> 456.78-0.50
[1] 456.28
*
Multiplicación
> 100*3
[1] 300
/
División
> 56/5
[1] 11.2
%/%
División entera
> 56%/%5
[1] 11
%%
Resto de un división
> 56%%5
[1] 1
^
Potencia
> 5^3
[1] 125

Con los operadores de comparación se obtiene un resultado TRUE o FALSE.

Principales operadores de comparación en R
Operador Nombre Ejemplo (consola)
==
Igual
> 6==5
[1] FALSE
!=
Desigual
> 6!=5
[1] TRUE
>
Mayor
> 6>5
[1] TRUE
>=
Mayor o igual
> 6>=5
[1] TRUE
<
Menor
> 6<5
[1] FALSE
<=
Menor o igual
> 6<=5
[1] FALSE

4.3 Comandos y comentarios

Los comandos de R son similares a las órdenes, instrucciones o sentencias de otros lenguajes de programación.

Un grupo de comandos en un archivo “.R” se puede considerar un programa.

Los comandos se pueden separar con un salto de línea como ya hemos visto, pero también con punto y coma “;”. Por ejemplo:

34+64; 5^2

Los comandos se pueden agrupar encerrándolos entre llaves “{ }”. Por ejemplo:

{x=34+62; y=5^2}; {x+y}

En un archivo “.R” se pueden incluir comentarios usando el símbolo “#”. Todo lo que haya a la derecha del símbolo se considera un comentario y no se ejecuta.

# Ejemplo de suma
34+62

100-20  #Ejemplo de resta

4.4 Funciones

En los comandos se pueden usar funciones predefinidas (built-in) en el propio lenguaje o creadas por desarrolladores y disponibles en librerías que se pueden descargar de Internet.

Cuando se usa una función, el intérprete de R ejecuta las líneas de código que estableció el autor de la función. No necesitamos conocer dicho código, únicamente cuál es el objetivo de la función, los parámetros o argumentos que tenemos que pasar a la función y el tipo de resultado que debe devolver.

Por ejemplo, la función sqrt() calcula la raíz cuadrada de un número.

Ejemplo de función
Función sqrt(x)
Objetivo de la función Calcular la raíz cuadrada de un número
Parámetros o argumentos x: número real del que se quiere calcular la raíz cuadrada
Resultado La raíz cuadrada de x
Ejemplos
> sqrt(25)
[1] 5
> raiz.de.cincuenta=sqrt(50)
> raiz.de.cincuenta
[1] 7.071068              
                    

4.4.1 Funciones predefinidas

Algunas funciones predefinidas para cálculos aritméticos son las siguientes.

Ejemplos de funciones aritméticas predefinidas en R
Función Operación realizada Ejemplo
abs(x) Valor absoluto de x
> abs(-34)
[1] 34
exp(x) e^x
> exp(2)
[1] 7.389056
log(x) Logaritmo neperiano (base e) de x
> log(20)
[1] 2.995732
log10(x) Logaritmo natural (base 10) de x
> log10(20)
[1] 1.30103
sqrt(x) Raíz cuadrada de x
> sqrt(36)
[1] 6
factorial(x) x!
> factorial(4)
[1] 24
ceiling(x) Primer número entero mayor o igual que x
> ceiling(45)
[1] 45
> ceiling(45.3)
[1] 46
floor(x) Primer número entero menor o igual que x
> floor(45.3)
[1] 45
trunc(x) Parte entera de x
> trunc(3.5)
[1] 3
round(x, digits=n) Redondea x con n dígitos decimales
> 43/7
[1] 6.142857
> round(43/7, digits=3)
[1] 6.143
sin(x), cos(x), tan(x) Seno, coseno, tangente de x, con x expresado en radianes. NOTA: se puede usar la variable predefinida pi, que tiene el valor 3.141593
> sin(pi/2)
[1] 1

También existen funciones predefinidas para manejar texto (cadenas de caracteres o strings).

Ejemplos de funciones de texto predefinidas en R
Función Operación realizada Ejemplo
toupper(x) Convierte a mayúsculas todas las letras del texto contenido en x
> toupper ("Informática")
[1] "INFORMÁTICA"
tolower(x) Convierte a minúsculas todas las letras del texto contenido en x
> tolower ("SisTEMas")
[1] "sistemas"
paste(x, y, sep=..) Concatena el texto de x e y, dejando como texto entre ambos lo que se indique en el parámetro sep
> paste("Buenos","días",sep="")
[1] "Buenosdías"
> paste("Buenos","días",sep=" ")
[1] "Buenos días"
substr(x, start=.., stop=..) Extrae los caracteres de x desde la posición start hasta la posición stop
> substr("Informática", start=3, stop=7) 
[1] "formá"

Existen algunas otras funciones predefinidas básicas que pueden ser útiles, como las siguientes.

Ejemplos de otras funciones predefinidas en R
Función Operación realizada Ejemplo
help(“funcion”) Muestra la ayuda sobre la función indicada.
> help("log")
rm(x) Borra la variable x del proyecto
> x=5
> rm(x)
> x
Error: object 'x' not found
print (expresión) Imprime en la consola el resultado de la expresión. En general no es necesario usarla. El efecto es el mismo si escribimos sólo la expresión.
> x=5
> 4+x
[1] 9
> print(4+x)
[1] 9
install.packages ("paquete") Instala en nuestro ordenador el paquete de funciones llamado “paquete”
> install.packages("gtools")
library(libreria) Activa, para poder usarse en el proyecto actual, el paquete indicado
> library(gtools)
detach(“package:paquete”) Desactiva el paquete en el proyecto actual y ya no se puede usar > detach("package:gtools")
remove.packages(“paquete”) Elimina de nuestro ordenador el paquete de funciones llamado “paquete” > remove.packages("gtools")
getwd() Obtiene el directorio (carpeta) de trabajo del proyecto actual
> getwd()
[1] "C:/Estadistica/P1"
setwd ("directorio") Establece como directorio (carpeta) de trabajo el indicado como parámetro.
> setwd("C:/Estadistica/P1b")
> getwd()
[1] "C:/Estadistica/P1b"
source ("archivo.R") Ejecuta en el proyecto actual el código contenido en “archivo.R”. Si no se indica la ruta del archivo, se supone que está en el directorio de trabajo actual.
> source("c:\curso\ejemplo.R")
options(scipen = dígitos) Establece que aquellos resultados que tengan un número de dígitos inferior al indicado, se representen con notación fija, y no con notación científica que utiliza un formato de un valor multiplicado por 10 elevado a un exponente.
> options(scipen = 100)

4.4.2 Funciones importadas de librerías

Con las funciones install.package y luego library podemos importar librerías de funciones contenidas en paquetes públicos.

Existen miles de paquetes en r-project.org.

Por ejemplo, podemos descargar el paquete toOrdinal.

Según su documentación, este paquete ofrece una función para hacer conversiones de números cardinales a ordinales.

> install.packages("toOrdinal")
… Content type 'application/zip' length 33615 bytes (32 KB)
downloaded 32 KB
package ‘toOrdinal’ successfully unpacked and MD5 sums checked
The downloaded binary packages are in
C:\Users\JoseR\AppData\Local\
Temp\RtmpKitiHU\downloaded_packages

A continuación, se ejecuta library:

> library(toOrdinal)
toOrdinal 1.3-0.0 (2-18-2022).
For help: >help("toOrdinal") or visit https://centerforassessment.github.io/toOrdinal/

Y ya se puede usar:

> toOrdinal(55, language="English")
[1] "55th"
> toOrdinal(55, language="Spanish")
[1] "55.º"
> toOrdinal(55, language="French")
[1] "55e"

Si hemos instalado varios paquetes que tienen funciones con el mismo nombre, para diferenciarlas se puede poner delante de la función el nombre del paquete librería seguido de “::”. Por ejemplo:

> toOrdinal::toOrdinal(55, language="English")
[1] "55th"

El comando contrario a library, para eliminar un paquete del proyecto actual es detach:

> detach("package:toOrdinal")

Y el contrario a install.packages, para eliminar un paquete del ordenador es remove.packages:

> remove.packages("toOrdinal")
Removing package from ‘C:/Users/JoseR/AppData/Local/R/win-library/4.2’
(as ‘lib’ is unspecified)

4.4.3 Creación de funciones propias

Podemos crear nuestras propias funciones, para después usarlas en el proyecto en el que estemos trabajando o en otros proyectos.

Para crear una función se utiliza el siguiente comando:

nombre = function (parámetros) {
   Contenido de la función
}

Por ejemplo, podemos crear una función para sumar dos números.

sumar = function (x,y) {
  return(x+y)
}

Las funciones que hemos creado en el proyecto aparecen en la sección Environment > Functions.

A partir de ahora podemos usar nuestra función de la forma habitual. Algunos ejemplos de uso pueden ser:

> sumar(4,5)
[1] 9

> a=10
> sumar(30,a)
[1] 40

> z=4*sumar(5,5)
> z
[1] 40

Si queremos compartir nuestra función con otros desarrolladores, podemos guardar su código en un archivo “.R” y enviarlo a los posibles interesados, para que lo incorporen a su proyecto usando la función source(“archivo.R”).

5 Vectores

Los vectores son colecciones ordenadas de números, caracteres o valores lógicos. Se crean mediante la función predefinida c().

Por ejemplo, podemos crear las siguientes variables de tipo vector:

ejemplo = c(34.6, 100, 67.2, 55, -8.4, 0, 0.5)
personas = c("Ana", "Juan", "Elena")
respuestas = c(TRUE, FALSE, FALSE)

Para ver su valor escribimos el nombre de la variable en la consola:

> ejemplo
[1]  34.6 100.0  67.2  55.0  -8.4   0.0   0.5

> personas
[1] "Ana"   "Juan"  "Elena"

> respuestas
[1]  TRUE FALSE FALSE

Algunos operadores y funciones para usar con vectores son los siguientes.

Operadores y funciones con vectores en R
Operador o función Operación realizada Ejemplos
v = c(n1,n2,n3) Crea un vector con los elementos n1, n2, n3
> valores=c(45,32,1,-5,0)
> valores
[1] 45 32  1 -5  0
inicio:fin Crea un vector como secuencia de número comenzando por inicio hasta fin y sumando una unidad para obtener el siguiente elemento del vector. Se puede comenzar con un número decimal
> numeros = 4:10
> numeros
[1]  4  5  6  7  8  9 10

> num = 4.3:10
> num
[1] 4.3 5.3 6.3 7.3 8.3 9.3
sample(inicio:fin, n) Crea un vector de n números elegidos aleatoriamente entre los valores incio y fin. Se puede añadir el parámetro replace=TRUE para indicar que se admiten números repetidos > num = sample(1:10, 5)
> num
[1] 4 6 9 2 1
> num = sample(1:10, 5, replace=TRUE)
> num
[1] 4 1 7 3 7
v[i] Obtiene el valor del elemento que ocupa la posición “i” en el vector “v”
> valores=c(45,32,1,-5,0)
> segundo=valores[2]
> segundo
[1] 32
v[c(i,j,k)] Obtiene un vector con los elementos del vector “v” que están en las posiciones “i”, “j” y “k”
> valores=c(45,32,1,-5,0)
> otro=valores[c(2,4)]
> otro
[1] 32 -5
v[c(-i,-j,-k)] Obtiene un vector con todos los elementos del vector “v” menos los que están en las posiciones “i”, “j” y “k”
> valores=c(45,32,1,-5,0)
> sin=valores[c(-2,-4)]
> sin
[1] 45  1  0
v[i]=valor Modifica el elemento de la posición “i” del vector “v” por el valor indicado
> valores=c(45,32,1,-5,0)
> valores[2]=100
> valores
[1]  45 100   1  -5   0
v[condición] Obtiene un vector con los datos del vector v que cumplen la condición
> valores=c(45,32,1,-5,0)
> valores[valores<=1]
> valores
[1]  1  -5   0
length(v) Obtiene la longitud o número de elementos del vector “v”
> personas = c("Ana", "Juan")
> length(personas)
[1] 2
min(v) Obtiene el elemento del vector v con el menor valor
> valores=c(45,32,1,-5,0)
> min(valores)
[1] -5
max(v) Obtiene el elemento del vector v con el mayor valor
> valores=c(45,32,1,-5,0)
> max(valores)
[1] 45
sort(v) Obtiene un vector que es el vector “v” ordenado de menos a mayor. No modifica el contenido del vector “v”
> valores=c(45,32,1,-5,0)
> ordenado = sort(valores)
> ordenado
[1] -5  0  1 32 45
sum(v) Obtiene la suma de todos los elementos del vector v
> v=c(1,2,3,4)
> sum(v)
[1] 10
prod(v) Obtiene el producto de todos los elementos del vector v
> v=c(1,2,3,4)
> prod(v)
[1] 24
cumsum(v) Obtiene un vector en el que cada elemento es la suma acumulada hasta ese elemento en el vector v
> v=c(1,2,3,4)
> cumsum(v)
[1]  1  3  6 10
cumprod(v) Obtiene un vector en el que cada elemento es el producto acumulado hasta ese elemento en el vector v
> v=c(1,2,3,4)
> cumprod(v)
[1]  1  2  6 24
cummin(v) Obtiene un vector en el que cada elemento es el mínimo de los elementos hasta ese elemento en el vector v
> v=c(1,2,3,4)
> cummin(v)
[1] 1 1 1 1
cummax(v) Obtiene un vector en el que cada elemento es el máximo de los elementos hasta ese elemento en el vector v
> v=c(1,2,3,4)
> cummax(v)
[1] 1 2 3 4
diff(v) Obtiene un vector en el que cada elemento es la diferencia entre un elemento del vector v y el elemento anterior a aquel
> v=c(15, 20, 35, 100)
> diff(v)
[1] 5 15 65
rep(v, each=n) Obtiene un vector que es como el vector “v” pero repitiendo “n” veces casa uno de sus elementos
> repetido=rep(c(1,2,3),each=3)
> repetido
[1] 1 1 1 2 2 2 3 3 3
rep(v, times=n) Obtiene un vector que es como el vector “v” pero repitiendo su contenido “n”
> repe=rep(c(1,2,3),times=3)
> repe
[1] 1 2 3 1 2 3 1 2 3
rep(v, times=c(i,j,k)) Obtiene un vector que es como el vector “v” pero repitiendo su primer elemento i” veces, el segundo “j” veces y el tercero “k” veces
> repe2=rep(c(1,2,3),times=c(4,2,2))
> repe2
[1] 1 1 1 1 2 2 3 3
seq(from=n, to=m, by=s) Obtiene un vector con un elemento inicial “n” hasta un elemento final “m” incrementando cada uno un valor “s”
> seq(from=4,to=11,by=2)
[1]  4  6  8 10

> seq(from=4,to=7,by=0.7)
[1] 4.0 4.7 5.4 6.1 6.8
unique(v) Obtiene un vector como v pero dejando sólo una vez los elementos repetidos
> v=c(8,1,9,9,7,7,7)
> unique(v)
[1] 8 1 9 7
match(v1,v2) Obtiene un vector con las posiciones que los valores del vector v1 ocupan en el vector v2
> v1=c(8,1,9,9,7,7,7)
> v2=c(8,1,9,7)
> match(v1,v2)
[1] 1 2 3 3 4 4 4
tabulate(v) Obtiene un vector en el que cada valor indica el número de veces que aparece cada elemento diferente del vector v
> v=c(1,2,3,3,4,4,4)
> tabulate(v)
[1] 1 1 2 3
sample(v, n, replace=FALSE, prob=NULL) Obtiene un vector con una muestra aleatoria con n valores del vector v, con o sin reemplazamiento
> v=c(1,2,3,3,4,4,4)
> sample(v,3)   
[1] 4 2 4
    

Cuando se realizan operaciones aritméticas con vectores, estas operaciones se realizan elemento a elemento, como puede comprobarse en los siguientes ejemplos.

> x=c(10,20,30,40)
> y=c(1,2,3,4)

> 2*x
[1] 20 40 60 80

> x-10
[1]  0 10 20 30

> x^2
[1]  100  400  900 1600

> x+y
[1] 11 22 33 44

> x-y
[1]  9 18 27 36

> x*y
[1]  10  40  90 160

> x/y
[1] 10 10 10 10

En el caso de vectores de caracteres se puede usar la función paste() para combinar los elementos.

> nombres=c("Juan", "Ana")
> apellidos=c("Perez", "Garcia")

> paste(nombres,apellidos)
[1] "Juan Perez" "Ana Garcia"

> paste(nombres,apellidos,sep=",")
[1] "Juan,Perez" "Ana,Garcia"

También se pueden usar números, que se transforman a caracteres.

> paste(nombres, c(100,200))
[1] "Juan 100" "Ana 200"

6 Tablas (data.frame)

Las tablas son estructuras de datos con filas y columnas, en las que cada columna tiene un título o cabecera, y todos los elementos de una misma columna son del mismo tipo. Cada columna se trata como un vector.

Una tabla puede crearse con la función predefinida data.frame. Para crear un data.frame en R se utiliza la siguiente sintaxis:

tabla = data.frame (
  columna1 = vector1,
  columna2 = vector2,
  columna3 = vector3
)

Un ejemplo podría ser:

personas = data.frame (
  nombre = c("Juan", "Ana", "Elena", "Jose"),
  apellido = c("Perez", "Garcia", "Lopez", "Garcia"),
  edad = c(25,33,30,25)
)

Si visualizamos en la consola el valor de la variable personas:

> personas
  nombre apellido edad
1   Juan    Perez   25
2    Ana   Garcia   33
3  Elena    Lopez   30
4   Jose   Garcia   25

Se puede mostrar la tabla en RStudio con un formato más amigable usando la función View:

> View(personas)

Las columnas son realmente vectores, y se pueden obtener todos los datos de una columna de tres formas:

  1. Usando el nombre de la tabla, el símbolo “$” y el nombre de la columna.
    > años=personas$edad
    > años
    [1] 25 33 30 25
    
  2. Usando el nombre de la tabla y el nombre de la columna entre [[ ]].
    > años=personas[["edad"]]
    > años
    [1] 25 33 30 25
    
  3. Usando el nombre de la tabla y el número de la columna entre [ ].
    > años=personas[3]
    > años
      edad
    1   25
    2   33
    3   30
    4   25
    

En este tercer caso en la consola se muestra de otra forma, pero es un vector como en los casos anteriores.

NOTA: Es posible crear tablas usando la función data.table(), pero para ello hay que instalar el paquete data.table. Ambas funciones son similares, aunque data.table tiene algunas ventajas como la velocidad al procesar grandes volúmenes de datos. Para comenzar a trabajar con R, se suele recomendar primero usar data.frame. En este enlace se realiza una comparación entre data.frame y data.table.

Se puede acceder a una fila de una tabla con tabla[fila,].

> personas[2,]
  nombre apellido edad
2    Ana   Garcia   33

O a una celda, indicando fila y columna con tabla[fila,columna]:

> personas[2,3]
[1] 33

A partir de una tabla se puede obtener otra sólo con las filas que cumplan una condición con tabla[condición]. Por ejemplo, con las personas que se apelliden “Garcia”.

> personas.garcia = personas[personas$apellido=="Garcia",]
> personas.garcia
  nombre apellido edad
2    Ana   Garcia   33
4   Jose   Garcia   25

O por ejemplo con las personas que tengan más de 26 años.

> mayores = personas[personas$edad>26,]
> mayores
  nombre apellido edad
2    Ana   Garcia   33
3  Elena    Lopez   30

La condición se puede utilizar para obtener una muestra aleatoria de filas de la tabla, usando la función sample.

> muestra=personas[sample(nrow(personas), size=2),]
> muestra
  nombre apellido edad
  4   Jose   Garcia   25
  3  Elena    Lopez   30

Se puede modificar el valor de un dato en una tabla identificando su fila y columna: tabla[fila,columna].

> personas
    nombre apellido edad
1   Juan    Perez   25
2    Ana   Garcia   33
3  Elena    Lopez   30
4   Jose   Garcia   25
> personas[2,3]=34
> personas
    nombre apellido edad
1   Juan    Perez   25
2    Ana   Garcia   34
3  Elena    Lopez   30
4   Jose   Garcia   25

Se puede modificar una fila completa, mediante la notación tabla[fila,]=list(valores).

> personas[1,]=list("Pedro","Herrero",20)
> personas
  nombre apellido edad
1  Pedro  Herrero   20
2    Ana   Garcia   34
3  Elena    Lopez   30
4   Jose   Garcia   25

Se puede eliminar una fila mediante la notación tabla[-fila,].

> personas=personas[-2,]
> personas
    nombre apellido edad
1  Pedro  Herrero   20
3  Elena    Lopez   30
4   Jose   Garcia   25

Se puede añadir una nueva fila al final de un tabla usando la función rbind()

> personas=rbind(personas,list("María","Gutierrez", 40))
> personas
    nombre  apellido edad
1   Pedro   Herrero   20
3   Elena     Lopez   30
4    Jose    Garcia   25
5   María Gutierrez   40

Se puede eliminar una columna de una tabla usando la notación tabla[,-columna].

> personas
   nombre  apellido
1   Pedro   Herrero
3   Elena     Lopez
4    Jose    Garcia
5   María Gutierrez

Se puede añadir una nueva columna a la derecha de la tabla usando la función cbind().

> nota=c(6,10,5,9)
> personas=cbind(personas,nota)
> personas
    nombre  apellido nota
 1   Pedro   Herrero    6
 3   Elena     Lopez   10
 4    Jose    Garcia    5
 5   María Gutierrez    9

7 Archivos de datos

Cuando se utiliza R para realizar cálculos estadísticos, se suelen leer los datos desde el archivo en el que estén almacenados. Uno de los formatos que más se utiliza es CSV (Comma Separated Values). Un archivo csv puede generarse desde un programa de edición de hojas de cálculo, como Excel, LibreOffice, o Google Sheets.

En los siguientes sitios web podemos encontrar miles de archivos csv con datos reales:

En estas prácticas se usarán sólo archivos .csv.

Para leer el contenido de un archivo .csv y almacenarlo en una tabla de tipo data.frame se utiliza la función read.csv2().

tabla = read.csv2(“archivo.csv”)

Esta función considera que, en el archivo, las columnas se separan con “;” y los números con parte decimal usan el carácter “,” como separador. Si usáramos un archivo de datos generado en un ordenador configurado para idioma inglés, habría que utilizar la función read.csv(), que considera que las columnas están separadas por “,” y el separado de decimales usado en el archivo es “.”.

NOTA: Aunque en el archivo de datos el separador decimal sea “,”, una vez leídos los datos y cargados en la variable del proyecto de R, hay que usar en los comandos R el separador “.”, como se ha hecho en los apartados anteriores.

Para probar con un archivo de ejemplo, vamos a descargar el archivo futbol.csv que contiene datos sobre equipos de fútbol.

El archivo descargado hay que guardarlo en la carpeta del nuestro proyecto P1 de RStudio. Para recordar cuál es nuestra carpeta o directorio de trabajo (working directory) se puede usar la función getwd() de R.

> getwd()
[1] "C:/Estadistica/P1"

Cada uno habrá obtenido la ubicación de su proyecto, y es en esa carpeta donde hay que guardar el archivo descargado. Que debe aparecer en la sección Files de RStudio.

Una vez que lo tenemos en el espacio de trabajo, podemos cargar los datos en una variable usando la función data.frame.

> datos=read.csv2("futbol.csv")
> datos
   PRESUPUESTO VICTORIAS GOLES
1         34.6         8    34
2         37.1         7    34
3         37.6         9    46
4         41.0        11    36
5         42.0         9    36
6         42.7         6    29
7         46.6        11    37
8         49.4         5    34
9         52.6         9    28
10        56.5        13    47
11        62.5        14    55
12        71.3        17    50
13       100.9        17    59
14       103.4        10    50
15       119.8        NA    46
16       145.2        15    60
17       185.8        24    53
18          NA        26    67
19       382.7        24    85
20       468.5        25    67

Podemos comprobar que hay dos valores NA, porque esas celdas en el archivo estaban vacías, por no disponer de esos datos.

Para evitar problemas de procesamiento, podemos eliminar las filas de esos equipos, con la función na.omit.

> datos=na.omit(datos)
> datos
   PRESUPUESTO VICTORIAS GOLES
1         34.6         8    34
2         37.1         7    34
3         37.6         9    46
4         41.0        11    36
5         42.0         9    36
6         42.7         6    29
7         46.6        11    37
8         49.4         5    34
9         52.6         9    28
10        56.5        13    47
11        62.5        14    55
12        71.3        17    50
13       100.9        17    59
14       103.4        10    50
16       145.2        15    60
17       185.8        24    53
19       382.7        24    85
20       468.5        25    67

Si queremos cargar en un vector el número de goles marcados por cada equipo, podemos hacerlo con:

> goles=datos$GOLES
> goles
[1] 34 34 46 36 36 29 37 34 28 47 55 50 59 50 60 53 85 67

Ahora podemos usar cualquiera de las funciones vistas en los apartados anteriores. Por ejemplo, podemos consultar el máximo número de goles marcados por un equipo, el mínimo, o sumar el total de goles marcados por todos los equipos.

> max(goles)
[1] 85
> min(goles)
[1] 28
> sum(goles)
[1] 840

En las prácticas no vamos a generar archivos de datos, sólo procesar archivos ya existentes. No obstante, es algo sencillo que puede hacerse usando la función write.csv2.

Por ejemplo. Supongamos que ha habido un error en los goles del equipo 10 y en lugar de 47 goles ha marcado 48.

Podemos modificar el data.frame así:

> datos[10,3]=48
> datos
   PRESUPUESTO VICTORIAS GOLES
1         34.6         8    34
2         37.1         7    34
3         37.6         9    46
4         41.0        11    36
5         42.0         9    36
6         42.7         6    29
7         46.6        11    37
8         49.4         5    34
9         52.6         9    28
10        56.5        13    48
11        62.5        14    55
12        71.3        17    50
13       100.9        17    59
14       103.4        10    50
16       145.2        15    60
17       185.8        24    53
19       382.7        24    85
20       468.5        25    67

Y volver a guardar en el archivo con:

> write.csv2(datos,"futbolcambiado.csv")

Podemos comprobar en la sección Files de RStudio que aparece el nuevo archivo de datos en la carpeta de trabajo.

Si alguna vez queremos cambiar el directorio o carpeta de trabajo, podemos hacerlo con la función setwd.

> setwd("c:/Estadistica/P1b")

Para ello, antes debemos crear la carpeta indicada en el ordenador, pues en otro caso avisará de que no existe.

También se puede cambiar el directorio de trabajo desde la sección Session > Set Working Directory de RStudio.

8 Gráficos

Con R se pueden generar gráficos, que aparecen en la sección Plots de RStudio.

8.1 Función plot

La función plot(c(x1,x2,x3,..),c(y1,y,2,y3,..)) dibuja puntos en las coordenadas (x1,y1), (x2,y2), (x3,y3), ..

Ejemplo:

> plot(c(2,-5,6,0), c(5,7,-3,0))

Se pueden usar variables para las coordenadas y un parámetro type para indicar el aspecto del gráfico.

Ejemplos:

> v1=c(2,-5,6,0)
> v2=c(5,7,-3,0)
> plot(v1,v2,type="b")
> plot (v1, v2, type="l")

Se pueden manejar otros aspectos del gráfico, con los siguientes parámetros, ver ayuda en RStudio con help(”plot”):

Ejemplos:

> plot(v1,v2,type="b", main="Título del diagrama", sub="Subtítulo del diagrama", xlab="Etiqueta eje x", ylab="etiqueta eje y", col="red", lwd="3")

> plot(v1, v2, type="l", xlim = c(-10,10), ylim=c(-5,15), lty=2)

Se pueden dibujar funciones, si como segundo vector se pasa una función aplicada a los elementos del primer vector.

Ejemplos:

> x=-10:10
> plot(x, 3*x+2,type="l", main="Recta y=3x+2")

> x=-10:10
> plot(x, x^2, type="l", main="Parábola")

> x=-10:10
> plot(x,exp(x),type="l", main="Función exponencial")

8.2 Función curve

Se puede dibujar cualquier curva con la función curve (función(x), from=valor mínimo de x, to=valor máximo de x).

Ejemplo:

> curve(x^2, from=-10, to=10)

Se puede crear previamente la función usando function:

> mi.funcion = function (x) {x^2}
> curve(mi.funcion,from=-10, to=10)

8.3 Múltiples gráficos (función par)

La función par(mfrow=c(filas,columnas) divide la ventana Plots en filas y columnas, y los gráficos se dibujan según esa división.

Para volver a tener una ventana para un solo gráfico hay que ejecutar: par(mfrow=c(1,1)).

Ejemplo:

> par(mfrow=c(2,3))
> x=-10:10
> plot(x,3*x+2,type="l", main="Recta")
> plot(x,x^2,type="l", main="Parábola")
> plot(x,exp(x),type="l", main="Exponencial")
> plot(x,log(x),type="l", main="Logaritmo neperiano")
> plot(x,abs(x),type="l", main="Absoluto")
> plot(x,x^3,type="l", main="Función x^3")
> par(mfrow=c(1,1))

9 Ejercicios propuestos