Los operadores de asignación en R permiten asignar datos a un objeto para almacenar los datos.
<- asignación izquierda
= Asignación izquierda ( menos recomendado en R) y
asignación de argumentos
Para ejecutar una línea o bloque de código se puede realizar desde el
teclado presionando CTRL + ENTER o con el ícono
Run en parte superior derecha de la ventana de
Script.
En términos genéricos todos los elementos que maneja R son objetos: un valor numérico, un vector, una función, una base de datos, un gráfico, etc. Para realizar un uso eficiente de R es preciso entender y aprender a manipular bien las distintas clases de objetos que maneja el programa.
R utiliza, de hecho, programación orientada a objetos. Ello significa que una misma función hace cosas distintas según la clase del objeto que recibe como argumento, pudiendo incluso no hacer nada (o producir un error) si se le pasan argumentos de una clase inadecuada.
Los diferentes objetos dependen principalmente de cómo están compuestos, es decir qué tipo de variable se está utilizando.
Si es un número, el tipo es “numérico”.
x <- 3
y = 3
s = 8.7
Una palabra, es un caracter.
m = "vector"
Si es una conjuntos de datos, ya sean numéricos y/o caracteres, ese conjunto es un vector. Que se llama “atómico” si es numérico únicamente. Por ejemplo:
altura = c(1.8,1.9,1.7,1.68,1.72,1.57)
especie = c("mora","alamo","fresno","fresno","mora","alamo")
Para generar una tabla con los objetos creados utilizamos la función cbind
datos = cbind (especie,altura); datos
## especie altura
## [1,] "mora" "1.8"
## [2,] "alamo" "1.9"
## [3,] "fresno" "1.7"
## [4,] "fresno" "1.68"
## [5,] "mora" "1.72"
## [6,] "alamo" "1.57"
A medida que se ingresan los objetos, R los va asignando a Values en
su memoria. De ésta manera, se va llevando un registro de los objetos
creados. Cuando queremos observar lo que contienen dichos objetos
debemos llamarlos. Lo podemos realizar de diferentes maneras: corriendo
sólo el nombre del objeto; si es una tabla con la sentencia
View() o print() definiendo como argumento el
objeto a observar; o si queremos verlo al generarlo, para evitar una
linea en el script, se coloca el nombre del objeto a continuación de una
sentencia separandoló por “;”.
Para que no tome los valores de cada columna como datos aislados,
debemos determinar que la tabla es un data.frame, es decir, que es una
base de datos (relaciona datos categórico y/o numéricos). Primero,
debemos conocer si el objeto es una data.frame (o un número, un
caracter, etc) preguntando con la función is.data.frame(),
respondiendo la función por TRUE o FALSE. Para cambiar el estado de un
objeto a otro, se utiliza la función as.data.frame(). En
nuestro ejemplo, todos los valores aparecen como caracteres.
is.data.frame(datos)
## [1] FALSE
datos=data.frame(datos)
is.character(datos$especie)
## [1] TRUE
is.character(datos$altura)
## [1] TRUE
is.numeric(datos$altura)
## [1] FALSE
datos$altura =as.numeric(datos$altura)
is.numeric(datos$altura)
## [1] TRUE
Se utiliza el operador $ para seleccionar una variable de una tabla de datos
datos$altura
## [1] 1.80 1.90 1.70 1.68 1.72 1.57
Hay varias funciones que pueden imprimir el tipo de dato de un objeto
de R. Estas incluyen: typeof, mode,
storage.mode, classy `str.
Estructura del objeto
str(5)
## num 5
str(altura)
## num [1:6] 1.8 1.9 1.7 1.68 1.72 1.57
R distingue entre mayúsculas y minúsculas, por lo tanto el objeto datos es diferente al objeto Datos.
Hay algunas reglas a la hora de nombrar variables. Puedes usar letras, números, puntos y guiones bajos en el nombre de la variable, pero los guiones bajos no pueden ser el primer caracter del nombre de la variable.
También hay palabras reservadas que no se pueden usar, como TRUE,
FALSE, NULL, entre otras. Puedes ver la lista completa de palabras
reservadas escribiendo help(Reserved) o
?Reserveden la consola de comandos.
Un paquete de R es una biblioteca de funciones que se han desarrollado para cubrir algunas necesidades o métodos científicos específicos que no están implementados en las funciones de R base. Las funciones que R proporciona de manera predeterminada son limitadas, por lo que es posible que te preguntes cómo instalar nuevos paquetes en R.
Hay diferentes formas de instalación:
install.packages("nombre", dependencies=TRUE)
Para utilizar una libreria debemos llamarla mediante
library
library(readxl)
Si son pocos datos: Introducir los datos directamente en la consola de R.
Si son muchos datos: Podemos utilizar casi cualquier soporte:
El lenguaje de programación R permite cargar archivos TXT. La función
más básica para ello es la función read.table. Importar
archivos TXT en R rara vez necesita más argumentos de los especificados
a continuación. Aun así, si resultan de interés conocer todos los
argumentos, se encuentran en la documentación de la función read.table o
llamando a la ayuda de la función con ?read.table. Esta
sintaxis básica afecta a casi todos los archivos de datos TXT.
read.table(file, #Archivo de datos TXT indicado como string o ruta completa al archivo
header = FALSE, #Si se muestra el encabezado (TRUE) o no (FALSE)
sep = "", #Separador de las columnas del archivo
dec = ".") #Caracter utilizado para separar decimales de los números en el archivo
Si el archivo objetivo se llama mi_archivo.txt y que
está guardado en el directorio de trabajo, puede lleerse con el
siguiente código:
data <- read.table(file = "mi_archivo.txt", header = TRUE)
head(data)
Pero si el archivo se encuentra en otro directorio se debe indicar la ruta de acceso al mismo.
data <- read.table(file = "C:/Mi_ruta/mi_archivo.txt", header = TRUE)
Es habitual encontrar conjuntos de datos en formato CSV (valores
separados por comas). Este tipo de almacenamiento de datos es una
solución ligera para la mayoría de los casos. La lectura de este tipo de
datos se importan con las funciones read.csv y
read.csv2. La sintaxis básica de las funciones con los
argumentos más comunes se encuentra a continuación. Para obtener
detalles adicionales, recuerda escribir ?read.csv o
?read.csv2.
Por defecto coma (,) como separador y punto (.) como separador decimal
read.csv(file, #Nombre del archivo o ruta completa del archivo
header = TRUE, #Leer el encabezado (TRUE o FALSE)
sep = ",", #Separador de los valores
dec = ".", #Punto decimal
...) #Argumentos adicionales
Por defecto punto y coma (;) como separador y coma (,) como separador decimal
read.csv2(file,
header = TRUE,
sep = ";",
dec = ","
...)
Otra manera es importar desde el archivo en el directorio, de esta manera el RStudio plantea el script para llamar a estos archivos.
Para trabajar con datos de Excel en R deberás usar un paquete readxl. Hay varias opciones, pero los mejores paquetes para leer archivos de Excel podrían ser openxlsx y readxl.
Si estás usando RStudio puedes ir a File → Import Dataset → From Excel…. Luego, selecciona tu archivo de Excel dándole a Browse… y personaliza la salida (el nombre de la variable, la hoja, el rango de celdas, …). También puedes ver una vista previa del código que se ejecutará de fondo.
El paquete readxl forma parte del paquete tidyverse, creado por Hadley Wickham (científico jefe en RStudio) y su equipo.
install.packages("readxl")
library(readxl)
Obtener la ruta de un archivo XLSX de ejemplo del
paquete
ruta_archivo <- readxl_example(“clippy.xlsx”)
# Comprobar los nombres de las hojas del archivo
excel_sheets(ruta_archivo) # "list-column" "two-row-header"
La función genérica del paquete para leer archivos de Excel en R es la función read_excel, que ‘adivina’ el tipo de archivo (XLS o XLSX) según la extensión del archivo y el archivo en sí, en ese orden.
read_excel(ruta_archivo)
El argumento sheet permite especificar la hoja que quieres cargar, pasando su nombre o el número correspondiente de la pestaña. Ten en cuenta que, por defecto, la función carga la primera hoja de Excel.
Seleccionamos la otra hoja del Excel
read_excel(ruta_archivo, sheet = "two-row-header")
read_excel(ruta_archivo, sheet = 2) # Equivalente
R y sus paquetes tienen bases de datos para practicar las diferentes sentencias. Vamos a tomar la base “iris” para comenzar a trabajar la parte estadística.
Un paso crucial cuando se trabaja con datos es convertir los datos originales (por lo general sin formato adecuado para el análisis) en un formato apropiado para trabajar. Aprenderás a clasificar, ordenar, crear subconjuntos y dividir los datos.
Ordenar datos en el lenguaje de programación R se puede lograr de varias maneras, dependiendo de cómo quieras ordenarlos.
La función order en R
La función order devuelve una permutación del orden de los elementos de un vector. La sintaxis con descripciones resumidas de los argumentos es la siguiente:
order(x, # Secuencia de vectores de la misma longitud
decreasing = FALSE, # Ordenar en orden creciente (FALSE o TRUE)
na.last = TRUE, # Poner valores NA al final (TRUE o FALSE)
method = c("auto", "shell", "radix")) # Método usado.
sort.list(x, # Vector
decreasing = FALSE,
partial = NULL, # Vector de índices para ordenado parcial
na.last = TRUE,
method = c("auto", "shell", "quick", "radix"))
Crear subconjuntos de datos en R se puede lograr de diferentes maneras, dependiendo de los datos con los que estés trabajando. En general, puedes crear un subconjunto:
Usando corchetes [ ].
Usando el signo $ si los elementos del objeto tienen nombres.
Con funciones, como el comando
subset, para obtener subconjuntos basados en condiciones
lógicas.
datos[,1] # selecciona la primera columna del conjunto datos
## [1] "mora" "alamo" "fresno" "fresno" "mora" "alamo"
datos[3,] # selecciona el tercer registro del conjunto datos
## especie altura
## 3 fresno 1.7
El lenguaje de programación R permite al usuario crear sus propias funciones. Es necesario conocer ciertos conceptos cómo escribir funciones en R, cómo es la sintaxis, los argumentos, la salida, cómo utilizar la función return y cómo hacer un uso correcto de los parámetros opcionales, adicionales y los argumentos predeterminados.
Las funciones base de R no siempre cubren todas nuestras necesidades. Para escribir una función en R, primero necesitamos saber cómo es la sintaxis del comando function. La sintaxis básica de una función de R es la siguiente.
nombre_funcion <- function(arg1, arg2, ... ) {
# Código
}
De la función se deduce que: - arg1, arg2, … son los argumentos de entrada. - #Código representa el código a ser ejecutado dentro de la función para obtener la salida desada.
La salida de la función puede ser un número, una lista, un data.frame, un gráfico, un mensaje o cualquier objeto que queramos. También podemos asignarle a la salida alguna clase, pero hablaremos sobre ello en un artículo específico sobre las clases S3. Ésto último es especialmente interesante a la hora de escribir funciones para paquetes de R.
En R no es necesario declarar las variables utilizadas dentro de una función. La regla llamada “ámbito lexicográfico” se usa para decidir si un objeto es local a una función o global. Considera el siguiente ejemplo:
fun <- function() {
print(x)
}
x <- 1
fun() # 1
## [1] 1
La variable x no se define dentro de fun, por lo que R buscará x dentro del ámbito “circundante” e imprimirá su valor. Si x se usa como el nombre de un objeto dentro de la función, el valor de x en el entorno global (fuera de la función) no cambia.
x <- 1
fun2 <- function() {
x <- 2
print(x)
}
fun2() # 2
## [1] 2
x #1
## [1] 1
Para cambiar el valor global de una variable dentro de una función, puedes usar el operador de doble asignación (<<-).
x <- 1
y <- 3
fun3 <- function() {
x <- 2
y <<- 5
print(paste(x, y))
}
fun3() # 2 5
## [1] "2 5"
x # 1 (el valor no cambió)
## [1] 1
y # 5 (el valor cambió)
## [1] 5
Ejemplo: Lanzando un dado La siguiente función simula n (por defecto n = 100) lanzamientos de un dado. La función devuelve la tabla de frecuencias y el gráfico correspondiente.
dado <- function(n = 100){
lanzamientos <- sample(1:6, n, rep = T)
frecuencias <- table(lanzamientos)/n
barplot(frecuencias, main = "")
abline(h = 1/6, col = "red", lwd = 2)
return(frecuencias)
}
Se puede ver los resultados de simulación ejecutando la función.
par(mfcol = c(1, 3))
dado(100)
## lanzamientos
## 1 2 3 4 5 6
## 0.21 0.11 0.18 0.15 0.17 0.18
dado(500)
## lanzamientos
## 1 2 3 4 5 6
## 0.134 0.170 0.162 0.212 0.168 0.154
dado(100000)
## lanzamientos
## 1 2 3 4 5 6
## 0.16792 0.16552 0.16590 0.16761 0.16725 0.16580
Como se observa, a medida que aumentamos n estamos más cerca del valor teórico 1/6 = 0.1667.