Constantes y variables

De manera análoga al uso de estos términos en lenguaje matemático, una constante es un objeto cuyo valor no podemos cambiar, en contraste, una variable es un objeto que puede cambiar de valor.

$$A=\pi r^2$$

En R usamos <- para hacer asignaciones.

radio <- 3

Al crear una variable usemos nombres claros, no ambiguos y descriptivos.

Los nombres de las variables pueden incluir letras, números, puntos y guiones bajos. Deben empezar siempre con una letra o un punto y si empiezan con un punto, a este no puede seguirle un número.

Finalmente, cuando te encuentres con un renglón de código que inicia con un gato (hashtag), esto representa un comentario, es código que no se ejecutará, sólo se mostrará.

# Este es un comentario

Funciones (introducción básica)

Una función es una serie de operaciones a la que les hemos asignados un nombre. Las funciones aceptan argumentos, es decir, especificaciones sobre cómo deben funcionar.

Cuando llamamos una función, se realizan las operaciones que contiene, usando los argumentos que hemos establecido.

En R reconocemos a una función usando la notación: nombre_de_la_función(). Por ejemplo:

• mean()
• quantile()
• summary()
• density()
• c()

Al igual que con las variables, se recomienda que los nombres de las funciones sean claros, no ambiguos y descriptivos. Idealmente, el nombre de una función describe lo que hace.

Documentación

Las funciones de R base y aquellas que forman parte de paquete tienen un archivo de documentación.

Para obtener la documentación de una función, escribimos el ? antes de su nombre y lo ejecutamos. También podemos usar la función help(), con el nombre de la función.

?mean()

help("mean")

Directorio de trabajo

El directorio o carpeta de trabajo es el lugar en nuestra computadora en el que se encuentran los archivos con los que estamos trabajando en R. Este es el lugar donde R buscara archivos para importarlos y al que serán exportados, a menos que indiquemos otra cosa.

Puedes encontrar cuál es tu directorio de trabajo con la función getwd(). Sólo tienes que escribir la función en la consola y ejecutarla.

getwd()

## [1] "/cloud/project/CUADERNOS"

Puedes cambiar el directorio de trabajo usando la función setwd(), dando como argumento la ruta del directorio que quieres usar.

setwd("C:\otro_directorio")

Por último, si deseas conocer el contenido de tu directorio de trabajo, puedes ejecutar. la función list.files(), sin argumentos, que devolverá una lista con el nombre de los archivos de tu directorio de trabajo. La función list.dirs(), también sin argumentos` te dará una lista de los directorios dentro del directorio de trabajo.

Paquetes

Cada paquete es una colección de funciones diseñadas para atender una tarea específica. Por ejemplo, hay paquetes para trabajo visualización geoespacial, análisis psicométricos, mineria de datos, interacción con servicios de internet y muchas otras cosas más.

Estos paquetes se encuentran alojados en CRAN, así que pasan por un control riguroso antes de estar disponibles para su uso generalizado.

Podemos instalar paquetes usando la función install.packages(), dando como argumento el nombre del paquete que deseamos instalar, entre comillas.

Por ejemplo, para instalar el paquete readr, corremos lo siguiente.

install.packages("readr")

## Installing package into '/cloud/lib/x86_64-pc-linux-gnu-library/4.3'
## (as 'lib' is unspecified)

Una vez concluida la instalación de un paquete, podrás usar sus funciones con la función library(). Sólo tienes que llamar esta función usando como argument o el nombre del paquete que quieres utilizar

library(readr)

Cuando haces esto, R importa las funciones contenidas en el paquete al entorno de trabajo actual.

Scripts

Los scripts son documentos de texto con la extensión de archivo .R, por ejemplo `mi_script.R

Estos archivos son iguales a cualquier documentos de texto, pero R los puede leer y ejecutar el código que contienen.

Aunque R permite el uso interactivo, es recomendable que guardes tu código en un archivo .R, de esta manera puedes usarlo después y compartirlo con otras personas. En realidad, en proyectos complejos, es posible que sean necesarios mútiples scripts para distintos fines.`

Coerción

En R, los datos pueden ser coercionados, es decir, forzados, para transformarlos de un tipo a otro.

La coerción es muy importante. Cuando pedimos a R ejecutar una operación, intentará coercionar de manera implícita, sin avisarnos, los datos de su tipo original al tipo correcto que permita realizarla. Habrá ocasiones en las que R tenga éxito y la operación ocurra sin problemas, y otras en las que falle y obtengamos un error.

Lo anterior ocurre porque no todos los tipos de datos pueden ser transformados a los demás, para ello se sigue una regla general.

La coerción de tipos se realiza de los tipos de datos más restrictivos a los más flexibles.

Las coerciones ocurren en el siguiente orden.

lógico -> entero -> numérico -> cadena de texto (logical -> integer -> numeric -> character)

Las coerciones no pueden ocurrir en orden inverso. Podemos coercionar un dato de tipo entero a uno numérico, pero uno de cadena de texto a numérico.

Como los datos de tipo lógico sólo admiten dos valores (TRUE y FALSE), estos son los más restrictivos; mientras que los datos de cadena de texto, al admitir cualquier cantidad y combinación de caracteres, son los más flexibles.

Los factores son un caso particular para la coerción. Dado que son valores numéricos con etiquetas, pueden ser coercionados a tipo numérico y cadena de texto; y los datos numéricos y cadena de texto pueden ser coercionados a factor. Sin embargo, al coercionar un factor tipo numérico, perdemos sus niveles.

as.character(5)

## [1] "5"

as.numeric("cinco")

## Warning: NAs introduced by coercion

## [1] NA

as.factor(5)

## [1] 5
## Levels: 5

as.factor("cinco")

## [1] cinco
## Levels: cinco

factor_cinco <- as.factor("cinco")

factor_cinco

## [1] cinco
## Levels: cinco

as.character(factor_cinco)

## [1] "cinco"

as.numeric(factor_cinco)

## [1] 1

as.numeric(TRUE)

## [1] 1

as.numeric(FALSE)

## [1] 0

as.null(FALSE)

## NULL

as.null(457)

## NULL

as.null("palabra")

## NULL

Verificar el tipo de un dato

En ocasiones, tenemos datos pero no sabemos de simple vistazo de qué tipo son. Para esto casos, podemos usar la función class()

class() recibe como argumento un dato o vector y devuelve el nombre del tipo al que pertenece, en inglés.

Por ejemplo, verificamos el tipo de datos que son 3, “3” y TRUE.

class(3)

## [1] "numeric"

class("3")

## [1] "character"

class(TRUE)

## [1] "logical"

is.numeric(5)

## [1] TRUE

is.character(5)

## [1] FALSE

Operadores aritméticos

Como su nombre lo indica, este tipo de operador es usado para operaciones aritméticas.

En R tenemos los siguientes operadores aritméticos:

Es posible realizar operaciones aritméticas con datos de tipo entero y numérico.

Si escribes una operación aritmética en la consola de R y das Enter, esta se realiza y se devuelve su resultado.

15 * 3

## [1] 45

Cuando intentas realizar una operación aritmética con otro tipo de dato, R primero intentará coercionar ese dato a uno numérico. Si la coerción tiene éxito se realizará la operación normalmente, si falla, el resultado será un error.

Por ejemplo, 4 + “tres”

4 + "tres"

## Error in 4 + "tres": argumento no-numérico para operador binario

El mensaje “non-numeric argument for binary operator” aparece siempre que intentas realizar una operación aritmética con un argumento no numérico. Si te encuentras un un error que contiene este mensaje, es la primera pista para que identifiques donde ha ocurrido un problema.

Cualquier operación aritmética que intentemos con un dato NA, devolverá NA como resultado.

NA - 66

## [1] NA

21 * NA

## [1] NA

NA ^ 13

## [1] NA

4 %% 2

## [1] 0

5 %% 2

## [1] 1

Operadores relacionales

Los operadores lógicos son usados para hacer comparaciones y siempre devuelven como resultado TRUE o FALSE (verdadero o falso, respectivamente).

Es posible comparar cualquier tipo de dato sin que resulte en un error.

Sin embargo, al usar los operadores >, >= , < y <= con cadenas de texto, estos tienen un comportamiento especial.

Por ejemplo,

"casa" > "barco"

## [1] TRUE

Este resultado se debe a que se ha hecho una comparación por orden alfabético.

Cuando intentamos comparar factores, siempre obtendremos como resultado NA y una advertencia acerca de que estos operadores no son significativos para datos de tipo factor.

as.factor("casa") > "barco"

## Warning in Ops.factor(as.factor("casa"), "barco"): '>' not meaningful for
## factors

## [1] NA

Operadores lógicos

Los operadores lógicos son usados para operaciones de álgebra Booleana, es decir, para describir relaciones lógicas, expresadas como verdadero (TRUE) o falso (FALSO).

Estos operadores pueden ser usados con estos con datos de tipo numérico, lógico y complejo. Al igual que con los operadores relacionales, los operadores lógicos siempre devuelven TRUE o FALSE.

Para realizar operaciones lógicas, todos los valores numéricos y complejos distintos a 0 son coercionados a TRUE, mientras que 0 siempre es coercionado a FALSE.

Por ejemplo, 5 | 0 resulta en TRUE y 5 & FALSE resulta en FALSE. Podemos comprobar lo anterior con la función isTRUE().

5 | 0

## [1] TRUE

5 & 0

## [1] FALSE

isTRUE(0)

## [1] FALSE

isTRUE(5)

## [1] FALSE

Estos operadores se pueden combinar para expresar relaciones complejas.

!(FALSE | FALSE)

## [1] TRUE

Operadores de asignación

Este es probablemente el operador más importante de todos, pues nos permite asignar datos a variables.

En este ejemplo, asignamos valores a las variables estatura y peso.

estatura <- 1.73

peso <- 83

Llamamos a sus valores asignados

estatura

## [1] 1.73

peso

## [1] 83

Usamos los valores asignados para realizar operaciones.

peso / estatura ^ 2

## [1] 27.7323

Cambiamos el valor de una variable a uno nuevo y realizamos operaciones

peso <- 76

peso

## [1] 76

peso / estatura ^ 2

## [1] 25.39343

estatura <- 1.56

peso <- 48

peso / estatura ^ 2

## [1] 19.72387

Asignamos el resultado de una operación a una variable nueva.

bmi <- peso / estatura ^ 2

bmi

## [1] 19.72387

Orden de operaciones

En R, al igual que en matemáticas, las operaciones tienen un orden de evaluación definido.

El orden de operaciones incluye a las aritméticas, relacionales, lógicas y de asignación.

Si deseamos que una operación ocurra antes que otra, rompiendo este orden de evaluación, usamos paréntesis.

Vectores

Un vector es la estructura de datos más sencilla en R. Un vector es una colección de uno o más datos del mismo tipo.

Todos los vectores tienen tres propiedades:

• Tipo. Un vector tiene el mismo tipo que los datos que contiene. Si tenemos un vector que contiene datos de tipo numérico, el vector será también de tipo numérico. Los vectores son atómicos, pues sólo pueden contener datos de un sólo tipo, no es posible mezclar datos de tipos diferentes dentro de ellos.
• Largo. Es el número de elementos que contiene un vector. El largo es la única dimensión que tiene esta estructura de datos.
• Atributos. Los vectores pueden tener metadatos de muchos tipos, los cuales describen características de los datos que contienen. Todos ellos son incluidos en esta propiedad.

Cuando una estructura únicamente puede contener datos de un sólo tipo, como es el caso de los vectores, decimos que es homogénea, pero no implica que necesariamente sea atómica

Como los vectores son la estructura de datos más sencilla de R, datos simples como el número 3, son en realidad vectores. En este caso, un vector de tipo numérico y largo igual a 1.

3

## [1] 3

verificamos que el 3 es un vector con la función is.vector().

is.vector(3)

## [1] TRUE

Y usamos la función length() para conocer su largo.

length(3)

## [1] 1

Lo mismo ocurre con los demás tipos de datos, por ejemplo, con cadenas de texto y datos lógicos.

is.vector("tres")

## [1] TRUE

is.vector(TRUE)

## [1] TRUE

c(1, 2, 3, 5, 8, 13)

## [1]  1  2  3  5  8 13

c("arbol", "casa", "persona")

## [1] "arbol"   "casa"    "persona"

c(TRUE, TRUE, FALSE, FALSE, TRUE)

## [1]  TRUE  TRUE FALSE FALSE  TRUE

mi_vector <- c(TRUE, FALSE, TRUE)

mi_vector <- c(mi_vector, FALSE)

mi_vector

## [1]  TRUE FALSE  TRUE FALSE

mi_vector_1 <- c(1, 3, 5)
mi_vector_2 <- c(2, 4, 6)

mi_vector_3 <- c(mi_vector_1, mi_vector_2)

mi_vector_3

## [1] 1 3 5 2 4 6

mi_vector <- c(1, 2, 3)

class(mi_vector)

## [1] "numeric"

mi_vector_nuevo <- c(mi_vector, "a")

class(mi_vector_nuevo)

## [1] "character"

mi_vector_mezcla <- c(FALSE, 2, "tercero", 4.00)

class(mi_vector_mezcla)

## [1] "character"

1:10

##  [1]  1  2  3  4  5  6  7  8  9 10

10:1

##  [1] 10  9  8  7  6  5  4  3  2  1

-43:-30

##  [1] -43 -42 -41 -40 -39 -38 -37 -36 -35 -34 -33 -32 -31 -30

67.23:75

## [1] 67.23 68.23 69.23 70.23 71.23 72.23 73.23 74.23

-2.48:2

## [1] -2.48 -1.48 -0.48  0.52  1.52

seq(1,15,2)

## [1]  1  3  5  7  9 11 13 15

mi_vector <- c(2, 3, 6, 7, 8, 10, 11)

mi_vector + 2

## [1]  4  5  8  9 10 12 13

mi_vector * 2

## [1]  4  6 12 14 16 20 22

mi_vector %% 2

## [1] 0 1 0 1 0 0 1

mi_vector > 7

## [1] FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE

mi_vector < 7

## [1]  TRUE  TRUE  TRUE FALSE FALSE FALSE FALSE

mi_vector == 7

## [1] FALSE FALSE FALSE  TRUE FALSE FALSE FALSE

Matrices y arrays

Las matrices y arrays pueden ser descritas como vectores multidimensionales. Al igual que un vector, únicamente pueden contener datos de un sólo tipo, pero además de largo, tienen más dimensiones.

Los arrays, por su parte, pueden tener un número arbitrario de dimensiones. Pueden ser cubos, hipercubos y otras formas.

1:12

##  [1]  1  2  3  4  5  6  7  8  9 10 11 12

matrix(1:12)

##       [,1]
##  [1,]    1
##  [2,]    2
##  [3,]    3
##  [4,]    4
##  [5,]    5
##  [6,]    6
##  [7,]    7
##  [8,]    8
##  [9,]    9
## [10,]   10
## [11,]   11
## [12,]   12

matrix(1:12, nrow = 3, ncol = 4)

##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12

matrix(1:12, nrow = 4, ncol = 3)

##      [,1] [,2] [,3]
## [1,]    1    5    9
## [2,]    2    6   10
## [3,]    3    7   11
## [4,]    4    8   12

matrix(1:12, nrow = 3, ncol = 3)

## Warning in matrix(1:12, nrow = 3, ncol = 3): data length differs from size of
## matrix: [12 != 3 x 3]

##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9

matrix(1:12, nrow = 5, ncol = 4)

## Warning in matrix(1:12, nrow = 5, ncol = 4): data length [12] is not a
## sub-multiple or multiple of the number of rows [5]

##      [,1] [,2] [,3] [,4]
## [1,]    1    6   11    4
## [2,]    2    7   12    5
## [3,]    3    8    1    6
## [4,]    4    9    2    7
## [5,]    5   10    3    8

vector_1 <- 1:4
vector_2 <- 5:8
vector_3 <- 9:12
vector_4 <- 13:16

matriz <- rbind(vector_1, vector_2, vector_3, vector_4)

matriz

##          [,1] [,2] [,3] [,4]
## vector_1    1    2    3    4
## vector_2    5    6    7    8
## vector_3    9   10   11   12
## vector_4   13   14   15   16

matriz1 <- cbind(vector_1, vector_2, vector_3, vector_4)

matriz1

##      vector_1 vector_2 vector_3 vector_4
## [1,]        1        5        9       13
## [2,]        2        6       10       14
## [3,]        3        7       11       15
## [4,]        4        8       12       16

vector_1 <- 1:2
vector_2 <- 1:3
vector_3 <- 1:5

matriz_2 <- cbind(vector_1, vector_2, vector_3)

## Warning in cbind(vector_1, vector_2, vector_3): number of rows of result is not
## a multiple of vector length (arg 1)

matriz_2

##      vector_1 vector_2 vector_3
## [1,]        1        1        1
## [2,]        2        2        2
## [3,]        1        3        3
## [4,]        2        1        4
## [5,]        1        2        5

vector_1 <- c(NA, 1, 2)
vector_2 <- c(3,  4, NA)

matriz_3 <- rbind(vector_1, vector_2)

matriz

##          [,1] [,2] [,3] [,4]
## vector_1    1    2    3    4
## vector_2    5    6    7    8
## vector_3    9   10   11   12
## vector_4   13   14   15   16

mi_matriz <- matrix(1:10)

class(mi_matriz)

## [1] "matrix" "array"

mi_matriz <- matrix(1:12, nrow = 4, ncol = 3)
dim(mi_matriz)

## [1] 4 3

mi_vector <- 1:12

dim(mi_vector)

## NULL

mi_matriz <- matrix(1:9, nrow = 3, ncol = 3)

mi_matriz

##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9

mi_matriz + 1

##      [,1] [,2] [,3]
## [1,]    2    5    8
## [2,]    3    6    9
## [3,]    4    7   10

mi_matriz * 2

##      [,1] [,2] [,3]
## [1,]    2    8   14
## [2,]    4   10   16
## [3,]    6   12   18

mi_matriz ^ 3

##      [,1] [,2] [,3]
## [1,]    1   64  343
## [2,]    8  125  512
## [3,]   27  216  729

vector_1 <- c(NA, 2, 3)
vector_2 <- c(4, 5, NA)

matriz <- rbind(vector_1, vector_2)

matriz

##          [,1] [,2] [,3]
## vector_1   NA    2    3
## vector_2    4    5   NA

matriz / 2

##          [,1] [,2] [,3]
## vector_1   NA  1.0  1.5
## vector_2    2  2.5   NA

matriz <- matrix(1:6, nrow = 3)

matriz

##      [,1] [,2]
## [1,]    1    4
## [2,]    2    5
## [3,]    3    6

matriz_t <- t(matriz)

matriz_t

##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    4    5    6

Data frames

Los data frames son estructuras de datos de dos dimensiones (rectangulares) que pueden contener datos de diferentes tipos, por lo tanto, son heterogéneas. Esta estructura de datos es la más usada para realizar análisis de datos.

En términos generales, los renglones en un data frame representan casos, individuos u observaciones, mientras que las columnas representan atributos, rasgos o variables.

library(DT)
DT::datatable(iris) 

Para crear un data frame usamos la función data.frame(). Esta función nos pedirá un número de vectores igual al número de columnas que deseemos. Todos los vectores que proporcionemos deben tener el mismo largo.

Esto es muy importante: Un data frame está compuesto por vectores.

mi_df <- data.frame(
  "entero" = 1:4, 
  "factor" = c("a", "b", "c", "d"), 
  "numero" = c(1.2, 3.4, 4.5, 5.6),
  "cadena" = as.character(c("a", "b", "c", "d"))
)

mi_df

##   entero factor numero cadena
## 1      1      a    1.2      a
## 2      2      b    3.4      b
## 3      3      c    4.5      c
## 4      4      d    5.6      d

dim(mi_df)

## [1] 4 4

El largo de un data frame es igual a su número de columnas

length(mi_df)

## [1] 4

• names() nos permite ver los nombres de las columnas

names(mi_df)

## [1] "entero" "factor" "numero" "cadena"

• La clase de un data frame es data.frame

class(mi_df) 

## [1] "data.frame"

Si los vectores que usamos para construir el data frame no son del mismo largo, los datos no se reciclaran. Se nos devolverá un error

Creamos una matriz.

matriz <- matrix(1:12, ncol = 4)

Usamos as.data.frame() para coercionar una matriz a un data frame.

df <- as.data.frame(matriz)

Verificamos el resultado

class(df)

## [1] "data.frame"

df

##   V1 V2 V3 V4
## 1  1  4  7 10
## 2  2  5  8 11
## 3  3  6  9 12

Listas

Las listas, al igual que los vectores, son estructuras de datos unidimensionales, sólo tienen largo, pero a diferencia de los vectores cada uno de sus elementos puede ser de diferente tipo o incluso de diferente clase, por lo que son estructuras heterogéneas.

Para crear una lista se usa la función list(), que nos pedirá los elementos que deseamos incluir en nuestra lista. Para esta estructura, no importan las dimensiones o largo de los elementos que queramos incluir en ella.

Al igual que con un data frame, tenemos la opción de poner nombre a cada elemento de una lista.

mi_vector <- 1:10

mi_matriz <- matrix(1:4, nrow = 2)

mi_df     <- data.frame("num" = 1:3, "let" = c("a", "b", "c"))

mi_lista <- list("un_vector" = mi_vector, "una_matriz" = mi_matriz, "un_df" = mi_df)

mi_lista

## $un_vector
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## $una_matriz
##      [,1] [,2]
## [1,]    1    3
## [2,]    2    4
## 
## $un_df
##   num let
## 1   1   a
## 2   2   b
## 3   3   c

Creamos una lista que contiene otras listas.

lista_recursiva <- list("lista1" = mi_lista, "lista2" = mi_lista)

lista_recursiva

## $lista1
## $lista1$un_vector
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## $lista1$una_matriz
##      [,1] [,2]
## [1,]    1    3
## [2,]    2    4
## 
## $lista1$un_df
##   num let
## 1   1   a
## 2   2   b
## 3   3   c
## 
## 
## $lista2
## $lista2$un_vector
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## $lista2$una_matriz
##      [,1] [,2]
## [1,]    1    3
## [2,]    2    4
## 
## $lista2$un_df
##   num let
## 1   1   a
## 2   2   b
## 3   3   c

length(lista_recursiva)

## [1] 2

class(lista_recursiva)

## [1] "list"

Coerción

Al igual que con los datos, cuando intentamos hacer operaciones con una estructura de datos, R intenta coercionarla al tipo apropiado para poder llevarlas a cabo con éxito.

También podemos usar alguna de las funciones de la familia as() coercionar de un tipo de estructura de datos. A continuación se presentan las más comunes.

Datos precargados en R

R-base viene con muchos datos precargados; concretamente en el pkg de R-base llamado datasets. Además muchos packages contienen también conjuntos de datos. Para ver los datos que tenemos precargados y disponibles en R se usa la función data():

data()  

Funciones para importar/exportar datos de los siguientes formatos:

• Datos en formato texto (o tabulares)

  • CSV: .csv (comma separated values o , en castellano, datos separados por comas)
  • otros datos en formato texto

• Formatos de otros programas (software propietario)

  • EXCEL: .xls y .xlsx
  • SPSS: .sav y `.por
  • STATA: .dta
  • SAS: .sas

• Formatos propios de R

  • R objects: .RData o .rda
  • Serialized R objects: .rds

• Otros Formatos

  • JSON
  • XML