Instructivo R

Instructivo R
FAE-USACH
1
Agenda
Introducción a R
1. ¿Qué es R y cómo comenzar a usarlo?
2. Tipos de datos
3. Examinar tipos de datos
4. Estucturas de datos
5. Asignación de nombres a objetos R
6. Tranformación de tipos de estructuras de datos y clases
7. Importar datos
8. Operadores lógicos
9. Sub-seleccionar
10. Funciones preestablecidas para análisis estadístico
11. Gráficos
2
Agenda
Introducción a R
2. Tipos de datos
7. Importar datos
9. Sub-seleccionar
11. Gráficos
3
¿Qué es R y cómo comenzar a usarlo?
Caracteríticas y dónde se obtiene
Es un software libre para análisis estadístico basado en el lenguaje S.

Por esta razón, R se asocia comúnmente a S-Plus.
Principales Características
 Es gratis.
 Ofrece muchas funciones incorporadas. Sin embargo, al basarse en un lenguaje de

programación, también posee la gran ventaja de permitir crear funciones a medida.
 Existe una amplia gama de paquetes R que agrupan un conjunto de funciones

asociadas a un tema específico.
 Es parte de un proyecto colaborativo, lo que fomenta la incorporación de nuevas

funciones compartidas por sus usuarios a nivel mundial.
 Es integrable con distintas bases de datos.
 Es elevadamente flexible.
 Incorpora los últimos avances en distintos campos de la ciencia rápidamente.

4
Bájalo en: http://www.R-project.org Tiempo total de instalación: menos de 10 min.
R y R Studio
Interfaz gráfica de usuario (GUI) original Interfaz gráfica de usuario (GUI) adaptada
Ambiente de trabajo
Código
Resultados numéricos
Resultados gráficos
• Los códigos y sus resultados son • Los códigos y sus resultados son
mostrados en la misma ventana. mostrados en secciones
distintas.
• Los gráficos se muestran en • Los gráficos se muestran en
ventanas independientes. ventanas independientes,
generando un registro histórico
de sus vistas.
• Para lectura eficiente requiere una
estructura muy definida y mucho • Código fácilmente editable.
orden en el código. • Muestra el ambiente de trabajo.
Baja R Studio en:

http://www.rstudio.com/products/rstudio/download/
5
Directorio de trabajo
Una vez que R Studio está instalado, lo primero es abrir un nuevo archivo de trabajo. Ir a menu,
archivo nuevo y elegir “R Script.”
Luego, se puede encontrar el directorio donde R Studio se está ejecutando.
Para ejecutar el
Obtener el directorio comando, selecciona lo
getwd() que quieres ejecutar y
luego presiona:
[1] "C:/Usuarios/NombreDelEquipo/Documentos" Ctrl+R / +enter
Si se quiere cambiar el directorio, se puede cambiar a uno nuevo de la siguiente manera:
Cambiar el directorio
setwd("D:/Javier/USACH/Curso R")
getwd()
[1] "D:/Javier/USACH/Curso R"
6
R como calculadora
Para comenzar a usarlo, ejecutemos R Studio:
Para ejecutar el
Cálculos comando, selecciona lo
que quieres ejecutar y
2+2; 3^2 luego presiona:
Ctrl+R / +enter
Resultados
[1] 4
[1] 9
7
R como calculadora
Cálculos
2+2; 3^2
[1] 4
[1] 9
Cálculos: Operadores
3^2*4/2-3; 4*3^2/2-3; -3+4*3^2/2
[1] 15
[1] 15
[1] 15
Las operaciones matemáticas son aplicadas en el siguiente orden:

1ro: ^
2do: * y /
3ro: + y -
8
Guardar y mostrar objetos
Almacenamiento de Objetos
Usar el símbolo <- como el operador de asignación

MiPrimerX <- 1 # Nada es impreso.
El símbolo # es usado par hacer comentarios. Cualquier cosa a la derecha de # en la

línea de comando es ignorada.
MiPrimerX # Impresión automática
[1] 1
Después de escribir un objeto, R lo mostrará (impresión automática) a

menos que esté dentro de una función ( o programas largos).
La impresión explícita es útil cuando es necesario imprimir objetos explícitamente

sin importar el contexto.
print(MiPrimerX) # Impresión explícita
[1] 1
9
Una práctica común es almacenar objetos:
Usar el símbolo <- como el operador de asignación

x <- -10:10 # Nada es impreso
x
[1] -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10
… y luego usar esos objetos para crear otros

y <- x^2
y
[1] 100 81 64 49 36 25 16 9 4 1 0 1 4 9 16 25 36 49 64 81 100
10
Luego los objetos almacenados se pueden usar:
plot(x, y, main = "Ejemplo de una función cuadrática",xlab="Valores de X",ylab="y=x^2",type="l")
11
¿Dónde encontramos los objetos que vamos creando en una sesión de R?
Identificar y borrar objetos
Expresión, asignación, uso de memoria, inspección de objetos y eliminación.
Mostrar objetos (variables y funciones)

ls()
[1] “MiPrimerX ” “x“ ”y”
Borrar objetos
rm(y)
objects()
[1] “MiPrimerX ” “x”
12
Agenda
Introducción a R
2. Tipos de datos
7. Importar datos
9. Sub-seleccionar
11. Gráficos
13
Tipos de datos
• character: a, hello.
• double: 1+e13
Nota: Se almacenan números reales de doble precisión, mantisa y exponente.
• integer: 10L.
Nota: agregar 'L' después de cualquier número entero almacena el número como un
entero (32 bits), que es más barato que el doble (53 bits) en términos de memoria.
• numeric (real o decimal): -1, 7, 20.5.

Nota: Idéntico a 'double', incluye 'integer’.
• logical: TRUE, FALSE
• complex: 2+3i
Nota: Números complejos con partes reales e imaginarias.
14
Tipos de datos
Números
La opción predeterminada es almacenar números como objetos numéricos
(números reales de doble precisión).
Números “1” y “2” parecen “integers”. Sin embargo, estos están almacenados
como objetos numéricos (“1.00” o “2.00”)
Recuerde agregar el sufijo L si desea almacenar un número entero.
Casos especiales:
Inf: Infinito
NaN: valor indefinido (No número) Usualmente se confunde con NA que indica
valores perdidos.
Inf and NaN
1/Inf; 1/0; 2/0; 0/0
[1] 0
Estos son todos numéricos , [1] Inf
incluso el NaN! [1] Inf
[1] NaN
15
Agenda
Introducción a R
2. Tipos de datos

7. Importar datos
9. Sub-seleccionar
11. Gráficos
16
Examinar tipos de datos
Primero guardemos 3 objetos distintos para después analizar sus tipos:
Creación de 3 objetos: x, y, z
x <- “una palabra o muchas" # Podemos guardar frases (por ejemplo: tweets)
y <- 10 # Guardar solamente 1 número
z <- 1:10 # Guardar una secuencia de números, desde el 1 al 10 en este ejemplo
Dado un objeto, podemos conultar el tipo de dato que está contenido en él. Las
funciones más usadas para hacer esto son:
• class(): Muestra el tipo de objeto a “alto nivel”.
• typeof(): Muestra el tipo de objeto a “bajo nivel”.
• length(): Muestra la candidad de elementos en el objeto.
• attributes(): Muestra los meta datos asociados al objeto cuando ellos son un
poco más “complejos” que un vector. Por lo tanto, no siempre disponible.
17
Examinar tipos de datos: x
Examinar tipos de datos: x

class (x)
[1] "character"
typeof(x)
[1] "character"
length(x)
[1] 1
attributes(x)
[1] NULL
18
Examinar tipos de datos: y
Examinar tipos de datos: y

class (y)
[1] “numeric"
typeof(y)
[1] “double"
length(y)
[1] 1
attributes(y)
[1] NULL
19
Examinar tipos de datos: z
Examinando tipos de datos: z

class (z)
[1] "integer"
typeof(z)
[1] "integer"
length(z)
[1] 10
attributes(z)
[1] NULL
20
Examinar tipos de datos
Ahora sabemos cómo responder la pregunta:
¿Cuál es el tipo de datos contenido en el objeto?
También podemos responder preguntas más específicas, como por ejemplo:
¿El tipo de datos contenido en el objeto es “integer”?
Para esto podemos usar la función is.dt() para probar el tipo de datos dt y
tendremos como resultado TRUE o FALSE. Por ejemplo, ¿cuál es “TRUE”?:
• is.character(x)
• is.numeric(x)
• is.double(x)
• is.integer(x)
21
Agenda
Introducción a R
2. Tipos de datos
7. Importar datos
9. Sub-seleccionar
11. Gráficos
22
Estructura de Datos
Definición de estructura de datos:

La forma específica en la cual los datos son almacenados y organizados.
Tipos de estructuras:
• Vector: Estructura de datos unidimensional donde todos sus elementos son del mismo tipo de datos.
• Factor: Puede ser considerado como un tipo de Vector. Cada elemento debe ser uno de un conjunto
fijo de valores, llamados niveles del factor.
• Matrix: Estructura de datos bidimensional donde todos sus elementos son del mismo tipo.
• Array: Estructura de datos Multidimensional. Puede ser entendida como una colección de matrices.
• Data frame: Bidimensional. Cada columna contiene valores del mismo tipo de datos. Sin embargo,
diferentes columnas pueden tener diferentes tipos de datos. Todas las columnas deben tener la mismo
longitud.
• List: Multidimensional. Es la estructura de datos más compleja. Cada componente de una lista puede
23
puede ser de cualquier tipo de estructura de datos.
Estructura de Datos
Vectores
Creando un vector: vector_x

vector_x <-c(1,3,5,7,9)
vector_x
[1] 1 3 5 7 9
Clase y tipo de datos: vector_x

class(vector_x); typeof(vector_x)
[1] "numeric"
[1] "double"
24
Estructura de Datos
Vectores
Creación de vectores
25
Estructura de Datos
Vectores
^ Primero
*y/ Segundo
+y- Tercero
26
Estructura de Datos
Vectores
Otros tipos de vectores: Además de Numéricos, existen de Caracteres, Lógicos y Factores.
Más adelante veremos cómo ordenar

los niveles de un factor. 27
Estructura de Datos
Vectores
28
Estructura de Datos
Vector: Variables
Variables pueden ser consideradas como vectores de un solo elemento
Crear una variable y multiplicar una variable por un vector
variable_x <- 2; vector_x; variable_x; variable_x * vector_x
[1] 1 3 5 7 9
[1] 2
[1] 2 6 10 14 18
Precaución: Vectores de diferentes longitudes pueden ser multiplicados….
Multiplicando dos vectores de diferentes longitudes
variable_x <- c(2,3); variable_x; vector_x; variable_x * vector_x
[[1] 2 3
[1] 1 3 5 7 9
[1] 2 9 10 21 18
Warning message:
In variable_x * vector_x :
longer object length is not a multiple of shorter object length
29
Estructura de Datos
Factor (no ordenado)
Creando un factor: factor_x

factor_x <-as.factor(c(“alto","medio",“bajo",“bajo"))
factor_x
[1] alto medio bajo bajo
Levels: alto bajo medio
¿ Los niveles siguen un orden?

Clases y tipos de datos: factor_x
class(factor_x); typeof(factor_x); attributes(factor_x)
[1] "factor"
[1] "integer"
$levels
[1] “alto" “bajo" "medio"
$class
[1] "factor"
30
Estructura de Datos
Examinando niveles: factor_x

levels(factor_x)
[1] “alto" “bajo" "medio"
¿Es posible establecer un orden específico?
Estableciendo un nuevo orden: factor_x_ord

factor_x_ord<-factor(factor_x,levels(factor_x)[c(2,3,1)])
attributes(factor_x_ord); as.integer(factor_x_ord)
$levels
[1] “bajo" "medio" “alto"
$class
[1] "factor"
[1] 3 2 1 1
31
Estructura de Datos
Otra manera de establecer un orden específico…
Crear un Factor y establecer el orden de los niveles (visualización).

f<-factor(c(“alto","medio",“bajo","bajo"), levels=c("bajo","medio",“alto")); f;
str(f)
Levels: bajo medio alto
Factor w/ 3 levels "bajo","medio",..: 3 2 1 1
IMPORTANTE:
Estas son algunas formas de especificar el orden de visualización solamente. No
estamos configurando "alto" más alto que "medio“ realmente, solo estamos
indicando que "bajo" debería mostrarse primero, "medio" segundo y "alto" tercero.
1. ¿Cómo podemos establecer explícitamente el orden de las categorías en términos

de sus valores?, o en otras palabras,
2. ¿Cómo establecer (bajo <medio <alto) en lugar de solo (bajo medio alto)?
32
Estructura de Datos
Factor ordenado
Crear un Factor y establecer el orden de los niveles (valores).

f<-factor(c(“alto","medio","bajo","bajo"), levels=c("bajo","medio",“alto"), ordered
= TRUE); f; str(f)
Levels: bajo < medio < alto
Ord.factor w/ 3 levels "bajo"<"medio"<..: 3 2 1 1
Formalmente hay dos tipos de valores categóricos en R (nominales y ordinales):
- Factor (niveles sin orden)

- Factor ordenado (niveles ordenados)
Informalmente, el primero (Factor) puede ser dividido en dos, a pesar de que sus
niveles estén aún desordenados:
- Visualización sin orden

- Visualización ordenada
33
Estructura de Datos
Matrices
Crear una Matriz: mi_mat_c

mi_mat_c <- matrix(1:9, nrow = 3, ncol = 3)
mi_mat_c
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
Clase y tipo de dato: mi_mat_c

class(mi_mat_c); typeof(mi_mat_c); length(mi_mat_c); attributes(mi_mat_c)
[1] "matrix" # Note que este es un nuevo
[1] "integer" tipo de clase para nosotros
[1] 9
$dim
[1] 3 3
34
Estructura de Datos
Matrices
Creando una Matriz: mi_mat_r

mi_mat_r <- matrix(1:9, nrow = 3, ncol = 3, byrow=T)
mi_mat_r
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
[3,] 7 8 9
¿ Qué es lo diferente aquí?
35
Estructura de Datos
Arrays
Arrays: Son un conjunto de datos indexados por uno o más subíndices.
Creación de arrays
Creando una Matriz: array_x

array_x <- array(1:5, dim=c(2, 3, 2))
array_x
,,1
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 1
,,2
[,1] [,2] [,3]
[1,] 2 4 1
[2,] 3 5 2
36
Estructura de Datos
Arrays
Clase y tipo de datos: array_x

class(array_x); typeof(array_x); length(array_x); attributes(array_x)
[1] "array"
[1] "integer"
[1] 12
$dim
[1] 2 3 2
37
Estructura de Datos
Data Frames
Creando un data frame: mi_df

mi_df<-data.frame("Ranking"= c(3,1,4,2), “Edad"= c(24,25,23,28), "Nombre"=
c("Juan","Dominga","Pedro","María"))
mi_df
Ranking Edad Nombre
1 3 24 Juan
2 1 25 Dominga
3 4 23 Pedro
4 2 28 María
38
Estructura de Datos
Data Frames
Clase y tipo de datos: mi_df

class(mi_df); typeof(mi_df); length(mi_df); attributes(mi_df)
[1] "data.frame"
[1] "list"
[1] 3
$names
[1] "Ranking" “Edad" "Nombre"
$class
[1] "data.frame"
$row.names
[1] 1 2 3 4
Para cambiar el nombre de las filas se puede usar:

row.names(mi_df)<-c(“Persona1","Persona2","Persona3","Persona4")
39
Estructura de Datos
Listas
Creación de una lista: mat_array_df_list

mat_array_df_list<-list(mi_mat_c,mi_mat_r,array_x,mi_df)
mat_array_df_list
Output omitido. Este muestra objetos en una lista, el cual ya ha sido mostrado en slides
anteriores.
Clase y tipo de datos: mat_array_df_list

class(mat_array_df_list); typeof(mat_array_df_list); length(mat_array_df_list);
attributes(mat_array_df_list)
[1] "list"
[1] "list"
[1] 4
NULL
40
Agenda
Introducción a R
2. Tipos de datos

7. Importar datos
9. Sub-seleccionar
11. Gráficos
41
Asignación de nombres a objetos de R
Vectores
Nombres: Vectores
vector_x<-c(1,3,5,7,9); vector_x; names(vector_x)
[1] 1 3 5 7 9
NULL
names(vector_x) <- c(“ABC", “CDE", “EFG", “GHI", “IJK"); vector_x
ABC CDE EFG GHI IJK
1 3 5 7 9
names(vector_x)
“ABC" “CDE" “EFG" “GHI" “IJK"
42
Matrices
Nombres: Matrices
mi_mat_r<-matrix(1:9, nrow = 3, ncol = 3, byrow=T); mi_mat_r;
dimnames(mi_mat_r)
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
[3,] 7 8 9
NULL
dimnames(mi_mat_r) <- list(c("a", "b", "c"), c("d", "e", "f")); mi_mat_r
d e f
a 1 2 3
b 4 5 6
c 7 8 9
dimnames(mi_mat_r)
[[1]]
[1] "a" "b" "c"
[[2]]
[1] "d" "e" "f"
43
Matrices
Una alternativa es establecer los nombres para las filas y columnas separadamente.
Nombres: Matrices (2)

rownames(mi_mat_r) <- c("g", "h", "i"); colnames(mi_mat_r) <- c("j", "k", "l");
mi_mat_r
j k l
g 1 2 3
h 4 5 6
i 7 8 9
dimnames(mi_mat_r)
[[1]]
[1] "g" "h" "i"
[[2]]
[1] "j" "k" "l"
44
Data frame
Nombres: Data Frame
mi_df <- data.frame("Ranking"= c(3,1,4,2), “Edad"= c(24,25,23,28), "Nombre"=
c("Juan","Dominga","Pedro","María")); mi_df; names(mi_df)
Ranking Edad Nombre
1 3 24 Juan
2 1 25 Dominga
3 4 23 Pedro
4 2 28 María
[1] "Ranking" “Edad" "Nombre"
names(mi_df)<-c(“Posición",“Años",“PrimerNombre"); mi_df; names(mi_df)
Posición Años PrimerNombre
1 3 24 Juan
2 1 25 Dominga
3 4 23 Pedro
4 2 28 María
[1] “Posición" ”Años" ”PrimerNombre"
Para cambiar el nombre de las filas use:
45
row.names(mi_df)<-c(“Persona1","Persona2","Persona3","Persona4")
Listas
Nombres de Listas (1/2): Primero, miremos la lista mat_array_df_list
Nombres: Listas
mat_array_df_list; names(mat_array_df_list)
[[1]] [[3]]
[1,] [,2] [,3] , , 1
[1,] 1 4 7 [,1] [,2] [,3]
[2,] 2 5 8 [1,] 1 3 5
[3,] 3 6 9 [2,] 2 4 1
, , 2
[[2]] [,1] [,2] [,3]
[1,] [,2] [,3] [1] 2 4 1
[1,] 1 2 3 [2,] 3 5 2
[2,] 4 5 6
[3,] 7 8 9 [[4]]
Ranking Edad Nombre
Persona1 3 24 Juan
Persona2 1 25 Dominga
Persona3 4 23 Pedro
Persona4 2 28 María
NULL 46
Listas
Nombres de Listas (2/2): Luego, asignemos nombres a mat_array_df_list
Nombres: Listas
names(mat_array_df_list) <-c (“mi_mat_c”, “mi_mat_r”, “array_x”, “mi_df”);
mat_array_df_list; names(mat_array_df_list)
$mi_mat_c $array_x
[1,] [,2] [,3] , , 1
[1,] 1 4 7 [,1] [,2] [,3]
[2,] 2 5 8 [1,] 1 3 5
[3,] 3 6 9 [2,] 2 4 1
, , 2
$mi_mat_r [,1] [,2] [,3]
[1,] [,2] [,3] [1] 2 4 1
[1,] 1 2 3 [2,] 3 5 2
[2,] 4 5 6
[3,] 7 8 9 $mi_df
Ranking Edad Nombre
Persona1 3 24 Juan
Persona3 4 23 Pedro
[1] “mi_mat_c" “mi_mat_r" “array x” “mi_df” 47
Comando clave según tipo de objeto
Nombres:
La asignación de nombres a objetos en R es bastante intuitiva
Objeto Definir nombres de Definir nombres Definir nombres

element/sub-objeto columna filas
vector names()
matriz colnames() rownames()
data frame names() row. names()
lista names()
48
Agenda
Introducción a R
2. Tipos de datos

7. Importar datos
9. Sub-seleccionar
11. Gráficos
49
Conversión de Data Structure
Supongamos que tenemos:

- Dos vectores: x e y
- Una matriz: mi_mat
- Un data frame: mi_df
a un vector largo a matriz a data frame
desde vector c,(x,y) cbind(x,y) data.frame (x,y)

rbind(x,y)
desde matriz as.vector(mi_mat) as.data.frame(mi_mat)
desde data frame as.matrix(mi_df)
50
Transformar de tipos de datos
Se puede usar as.dt(x) para transformar x desde el tipo de datos dt (si es que está
disponible), ejemplo: as.double(x), as.integer(x):
x_int <- -6:6; x_int; class(x_int)
[1] -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6
[1] “integer”
x_num <- as.numeric(x_int); x_num; class(x_num)
[1] -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6
[1] “numeric”
x_log <- as.logical(x_int); x_log; class(x_log)
[1] TRUE TRUE TRUE TRUE TRUE TRUE FALSE TRUE TRUE TRUE TRUE TRUE TRUE
[1] “logical”
x_cha <- as.character(x_int); x_cha; class(x_cha)
[1] “-6” “-5” “-4” “-3” “-2” “-1” “0” “1” “2” “3” “4” “5” “6”
[1] “character”
x_int2 <- as.integer(x_cha); x_int2; class(x_int2) #Regresar a “integer” desde “character”
[1] -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6
51
[1] “integer”
Mezclando datos: Transformación implícita
Cuando diferentes clases de objetos R se mezclan en un vector, R impone una

transformación implícita.
x <- c(1,2, “a”) ; x; class(x)

[1] “1” “2” “a”
[1] “character”
x <- c(1,2, TRUE, FALSE, TRUE) ; x; class (x)
[1] 1 2 1 0 1
[1] “numeric”
x <- c(1, TRUE, “a”) ; x; class(x)
[1] “1” “TRUE” “a”
[1] “character”
x <- c(1, TRUE, 0); x; class(x)
[1] 1 1 0
[1] “numeric”
52
Vectores con valores perdidos
Valores perdidos se denotan como NA o NaN

Creando un vector con NA
x <-c(1, 2, NA, 4)
is.na(x) # consulta si es que hay valores NA
[1] FALSE FALSE TRUE FALSE
is.nan(x) # consulta si es que hay valores NaN
[1] FALSE FALSE FALSE FALSE
¿Qué pasa si hacemos el mismo ejercicio con NaN en vez de NA?
Creando un vector con NaN
x <-c(1, 2, NaN, 4)
is.na(x) # 1 NA
is.nan(x) # 1 NaN
Un valor NaN es también un valor NA pero un valor NA no es un valor NaN.
Por lo tanto, is.na() identifica ambos NA y NaN. 53
Vectores con valores perdidos
¿Qué pasa con los valores NULL?

Null representa objetos nulos en R
Creando un vector con valores perdidos y nulos

x <- c(1,2, NaN, 4, NA, 6, NULL) # 7 entradas
is.na(x) # 6 respuestas de las cuales 2 son NA
[1] FALSE FALSE TRUE FALSE TRUE FALSE
is.nan(x) # 6 respuestas, 1 NaN
[1] FALSE FALSE TRUE FALSE FALSE FALSE
Veamos los elementos de x y encontremos el número de elementos que tiene.

x; length(x)
[1] 1 2 Nan 4 NA 6
[1] 6
Mientras NaN y NA son valores aceptados en un vector, NULL no.
54
Agenda
Introducción a R
2. Tipos de datos
7. Importar datos
9. Sub-seleccionar
11. Gráficos
55
Directorio de trabajo
(Recordatorio)
R almacena todo en un “Directorio de Trabajo” (wd: Working Directory). Si este directorio de trabajo no es
especificado, R asume uno por defecto.
Para identificar y modificar el directorio de trabajo, hagamos lo siguiente:
R usa / en vez de \
56
Importar datos
En tu Directorio de Trabajo crea el archivo Datos_Ejemplo01.txt que contenga lo siguiente:

Es importante que la última línea esté vacía, de lo contrario habrá un error de importación.
Línea vacía
57
Importar datos
Una forma de importar datos, es hacerlo desde el conocimiento del usuario. Por ejemplo, al consultarle por su
nombre:
58
Importar datos: archivos csv
Además se pueden importar datos desde un archivo csv siempre y cuando estén perfectamente formateados:
myDataName<- read.csv(“Directorio/ArchivodeDatos.csv”)
Los datos contenidos en archivos *.csv generalmente están separados por coma. Sin embargo, algunas veces
pueden estar separados por “punto y coma”.
ConsumoCombustibleUK.csv
datoCombustibles_csv <- read.csv(“D:/......ConsumoCombustibleUK.csv”, nrows=10); head(datoCombustibles_csv, 4)
Transporte.ModoTransp.Combustible.Vehiculo.Año.Consumo
1 Sí;Calle;Bencina;Autos y taxis;2000;20.2
2 Sí;Calle;Bencina;Vans livianas;2000;1.0
3 Sí;Calle;Bencina;Motos y Scooters;2000;0.2
4 Sí;Calle;Diesel;Autos y taxis;2000;4.2
datoCombustibles_csv <- read.csv(“D:/......ConsumoCombustibleUK.csv” ,sep=“;”, nrows=10);
head(datoCombustibles_csv, 4)
Transporte ModoTransp Combustible Vehiculo Año Consumo
1 Sí Calle Bencina Autos y taxis 2000 20.2
2 Sí Calle Bencina Vans livianas 2000 1.0
3 Sí Calle Bencina Motos y Scooters 2000 0.2
4 Sí Calle Diesel Autos y taxis 2000 4.2
59
Nota: Reemplazar “D:/……” por el directorio del archivo.
Importar datos: archivos csv
Y finalmente:
datoCombustibles_csv <- read.csv(“D:/......ConsumoCombustibleUK.csv” ,sep=“;”);
dim(datoCombustibles_csv)
[1] 224 6
Nota: R no nos avisa cuando creamos un objeto con un mismo nombre de otro
objeto.
En este ejemplo hemos creado “datoCombustibles_csv” tres veces y sólo hay un
objeto llamado “datoCombustibles_csv” en R , que corresponde al último creado.
60
Importar datos: archivos txt
El archivo que nosotros queremos importar está separado por tabulaciones :

datoCombustibles_txt <- read.table(“D:/......ConsumoCombustibleUK.txt”, nrows=10);
head(datoCombustibles_txt,4)
Warning messages:
1: In read.table(“D:/......ConsumoCombustibleUK.txt” , : line 1 appears to contain embedded nulls
V1
1 ÿbT Dependiendo de la versión en que
el archivo de texto está guardado,
2 \n el mensaje de error cambia
3 Y
4 R
Si usamos “sep=‘\t’ ” como una opción por ejemplo:
datoCombustibles_txt <- read.table(“D:/......ConsumoCombustibleUK.txt” , sep=‘\t’ ,nrows=10);

head(datoCombustibles_txt,4)
Obtendremos los mismo resultados que en el recuadro de arriba.

Generalmente, este es un problema de codificación, el cual en este caso fue generado
automáticamente cuando guardamos el archivo .txt desde MS Excel.
61
Cuando el archivo que queremos importar esta codificado en UTF-16 se puede usar lo siguiente:
datoCombustibles_txt <- read.table(“D:/......ConsumoCombustibleUK.txt” ,sep=‘\t’ ,fileEncoding
=“UTF-16LE”); head(datoCombustibles_txt,4);
dim(datoCombustibles_txt)
V1 V2 V3 V4 V5 V6
1 Transporte ModoTransp Combustible Vehiculo Año Consumo
[1] 225 6
La codificación UTF-16 no es común cuando se trabaja con con algunas herramientas en Windows.
Aún sigue algo mal…
Nota: Reemplazar “D:/……” por el directorio del archivo

62
Cuando el archivo que queremos importar esta codificado en UTF-16 se puede usar lo siguiente:
datoCombustibles_txt <- read.table(“D:/......ConsumoCombustibleUK.txt” ,sep=‘\t’ ,fileEncoding
=“UTF-16LE”,header=TRUE); head(datoCombustibles_txt,4);
dim(datoCombustibles_txt)
[1] 224 6
Nota: Reemplazar “D:/……” por el directorio del archivo

63
Importar datos: xlsx files
El enfoque más común es convertir cuanlquier archivo que contenga el set de datos en csv o txt
file y después imprtarlo desde R. Sin embargo, otros formatos son soportados por diferentes
paquetes:
Consideremos un set de datos en un archivo Excel. Primero, hay que instalar y cargar el paquete
‘readxl’ usando:
install.packages(“readxl”) ; library(readxl)
datoCombustibles_excel <- read_excel(“D:/......ConsumoCombustibleUK.xlsx” ,n_max=10) ;
head(datoCombustibles_excel) ; dim(datoCombustibles_excel) ; class(datoCombustibles_excel) # Tibble. Similar al
formato de data frame.
# A tibble: 6 x 6
<chr> <chr> <chr> <chr> <dbl> <dbl>
5 Sí Calle Diesel Vans livianas 2000 3.60
6 Sí Calle Diesel Vehiculos de carga pesada 2000 6.27
[1] 10 6
[1] “tbl_df” “tbl” “data.frame”
Nota: Reemplazar “D:/……” por el directorio del archivo. 64
Importar datos: xlsx files
Un Tibble es una versión extendida de un data frame.
Trabajaremos con data frames, por lo tanto necesitamos hacer una transformación:
datoCombustibles_excel <- read_excel(“D:/......ConsumoCombustibleUK.xlsx”) ;
datoCombustibles_excel<-as.data.frame(datoCombustibles_excel) ; head(datoCombustibles_excel) ;
dim(datoCombustibles_excel) ; class(datoCombustibles_excel)

5 Sí Calle Diesel Vans livianas 2000 3.60
6 Sí Calle Diesel Vehiculos de carga pesada 2000 6.27
[1] 224 6
[1] “data.frame”
65
Importar datos: xlsx files usando read.table()
También es posible ir al archivo Excel, copiar la tabla a ser usada en R y luego usar la función
read.table(file = "clipboard", header=TRUE)
Hay que tener presente la forma en que R usa lo separadores de decimales y miles para configurarlo de la
misma manera en Excel antes de copiar.
Importar datos desde R usando read.table()

1ro.- En Excel, seleccionar y copiar la tabla a usar en R.
2do.- En R, escribir:
usdclpDia <- read.table(file = "clipboard", header=TRUE)
head(usdclpDia,4)
AMD PrecioDia
1 AAAAMMDD1 530.55
2 AAAAMMDD2 536.80
3 AAAAMMDD3 541.55
4 AAAAMMDD4 536.00
En ocasiones es necesario usar la opción sep=“t” ó sep=“\t”, entre otras.
Por ejemplo,
read.table(file = "clipboard“, sep=“t”, header=TRUE)
66
read.table(file = "clipboard“, sep=“\t”, header=TRUE)
Agenda
Introducción a R
2. Tipos de datos
7. Importar datos
9. Sub-seleccionar
11. Gráficos
67
Operadores lógicos
Para vectores, R usa operadores lógicos para cada elemento.

Operadores lógicos:==
1:3==1:3; 1:3==c(1,3,3)
[1] TRUE TRUE TRUE
[1] TRUE FALSE TRUE
Operadores lógicos: &

1:3==1:3 & 1:3==1:3;
1:3==1:3 & 1:3==c(1,3,3)
[1] TRUE TRUE TRUE
[1] TRUE FALSE TRUE
Operadores lógicos: &&

1:3==1:3 && 1:3==1:3;
1:3==1:3 && 1:3==c(1,3,3)
[1] TRUE
[1] TRUE
Precaución: R evalúa de izquierda a derecha para examinar sólo el primer elemento de cada vector
cuando usa &&.
68
Por lo tanto, hay que usar le operador lógico “&” a menos que realmente se necesite &&.
Operadores lógicos
Operadores lógicos: |, ||
Igual que para el caso &:
c(T,F,T) | c(T,F,T)
c(T,F,T) || c(T,F,T)
[1] TRUE FALSE TRUE
[1] TRUE
c(T,F,T) | c(F,F,T)
c(T,F,T) || c(F,F,T)
[1] TRUE FALSE TRUE
[1] TRUE
c(F,F,T) | c(F,F,T)
c(F,F,T) || c(F,F,T)
[1] FALSE FALSE TRUE
[1] FALSE
Precaución: R evalúa de izquierda a derecha para examinar sólo el primer elemento de cada vector
cuando usa ||.
Por lo tanto, hay que usar el operador lógico “|” a menos que realmente se necesite ||. 69
Agenda
Introducción a R
2. Tipos de datos
7. Importar datos
9. Sub-seleccionar
11. Gráficos
70
Sub-seleccionar
Hay tres tipos de operadores con los cuales se puede seleccionar un subset particular
de elementos de un objeto R
Operador Selecciona ¿El tipo de estructura

del resultado es igual
al original?
[posición] Uno o múltiples elementos Sí
[[posción]] Elementos de una lista o data frame No necesariamente
$nombreObjeto Elemento de una lista o data frame usando el No necesariamente
nombre literal del elemento
Ejemplos:
miVector[2] : Devuelve el segundo valor de miVector.
miLista[[3]] : Devuelve el tercer objeto de la lista miLista.
miDataFrame$nombrePrimeraColumna : Devuelve la primera columna de miDataFrame.

71
Sub-seleccionar un vector
Hay tres tipos de operadores con los cuales se puede seleccionar un subset particular de
elementos de objetos de R
Subseleccionando un vector También se puede usar una secuencia de

elementos:
x <- c("a", "b", "c", "d", "e", "f")
x[1]; x[2] x[1:3]; x[2:4]
[1] "a" [1] "a" "b" "c"
[1] "b" [1] "b" "c" "d"
Seleccionar el segundo, tercero y quinto elemento:

x[c(2,3,5)]
[1] "b“ "c“ "e"
x[c(2,3,5)][2:3] # Selecciona 2 valores específicos desde la selección previa
[1] "c" "e"
Y de nuevo:
x[c(2,3,5)][2:3][2] # Selecciona el segundo elemento desde la selección previa
[1] "e"
72
Sub-seleccionar un vector
Subseleccionar un vector:
Operadores lógicos
x[x>"c"]; x[-(1:3)]
[1] "d" "e" "f"
[1] "d“ "e" "f"
x[x>"c" & x<"f"]
[1] "d“ "e" También podemos hacer referencia a otro
vector:
x[x!=c("a", "b", "f")]
[1] "c" "d" "e" Subseleccionar un vector basado en otro:
Operadores lógicos.
y<-(-3:3)[-4]^2; y
x[y>2]
[1] 9 4 1 1 4 9
[1] "a" "b" "e“ "f"
73
Sub-seleccionar una Matriz
Subseleccionar una Matriz

mi_mat_r<-matrix(1:9, nrow = 3, ncol = 3,
byrow=T); mi_mat_r
mi_mat_r[3,1]; mi_mat_r[1,3]
[,1] [,2] [,3] Subseleccionar una Matriz: Filas

[1,] 1 2 3
mi_mat_r[3,]; mi_mat_r[1:2,]; mi_mat_r[c(1,3),]
[2,] 4 5 6
[3,] 7 8 9 [1] 7 8 9
[1] 7 [,1] [,2] [,3]

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

[1,] 1 2 3
[2,] 7 8 9
74
Subseleccionar una Matriz: Filas

mi_mat_r[3,]
# Note que R bota o no
[1] 7 8 9 considera las dimensiones
También se puede mantener la estructura de la matriz:
Subseleccionar manteniendo la estructura

mi_mat_r[3, , drop=FALSE]
[,1] [,2] [,3] # Note que R mantiene el
[1] 7 8 9 orden de las dimensiones
Ejercicios:
1) Seleccione la tercera columna
2) Seleccione la primera y la segunda columna
3) Seleccione la primera y tercera columna
75
Subseleccionar el “i-ésimo” elemento

mi_mat_r; mi_mat_r[8]
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
[3,] 7 8 9
[1] 6
Si usamos mi_mat_r[8, ] la respuesta es “Error in mi_mat_r[8, ] : subscript out of bounds”. Por

esta razón es importante la coma.
Operadores lógicos
mi_mat_r>1 ; mi_mat_r[mi_mat_r>1]
[,1] [,2] [,3]
[1,] FALSE TRUE TRUE
[2,] TRUE TRUE TRUE
[3,] TRUE TRUE TRUE ¿Por qué no
2 3 4 5 6 7 8 9?
[1] 4 7 2 5 8 3 6 9
76
Sub-seleccionar un Data Frame
Subseleccionar un data frame

mi_df; mi_df[1,1]; mi_df[1,] ; mi_df[“Persona4",]
Persona1 3 24 Juan
Persona3 4 23 Pedro
[1] 3

Persona1 3 24 Juan

mi_df[,2]; mi_df[c(2,4),1:2]
[1] 24 25 23 28
Posición Años
Persona2 1 25
Persona4 2 28 77
Sub-seleccionar un Data Frame
Subseleccionar una data frame como un vector:

mi_df$Años
[1] 24 25 23 28
Después de usar el operador $, se puede tratar el resultado como un vector:
Seleccionar un elemento de un vector en particular:

mi_df$Años[3]
[1] 23
78
Sub-seleccionar una lista
names(mat_array_df_list); mat_array_df_list[[2]]; mat_array_df_list[["mi_mat_r"]]

[1] "mi_mat_c" "mi_mat_r" "array_x" "mi_df"
[,1] [,2] [,3]

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

[1,] 1 2 3
[2,] 4 5 6
[3,] 7 8 9
Después de usar el operador “[[”, se puede extraer otro subconjunto:
mat_array_df_list[["mi_mat_r"]][2,3]
[1] 6
También es posible usar el operador “$” en vez de “[[“:
mat_array_df_list$mi_mat_r[2,3]
[1] 6 79
Sub-seleccionar con la función ‘subset()’
Subseleccionar con la función “subset()”

subset(mi_df,mi_df$Años<25)
Persona1 3 24 Juan
Persona3 4 23 Pedro
El mismo resultado obtenido con:

mi_df[mi_df$Años<25,]
80
Sub-seleccionar con la función ‘which()’
Subseleccionar con la función “which()”

which(mi_df$Años<25)
bajo25 <- which(mi_df$Años<25)
mi_df[bajo25,]
[1] 1 3
Persona1 3 24 Juan
Persona3 4 23 Pedro
81
Agenda
Introducción a R
2. Tipos de datos
7. Importar datos
9. Sub-seleccionar
10.Funciones preestablecidas para análisis estadístico

11. Gráficos
82
Funciones incoporadas para estadísticas descriptivas
¿Qué son las funciones?
Una función de R es un objeto que ejecuta un set de instrucciones con un propósito específico, por
ejemplo:
- Devolución de información.
- Procesamiento de datos
- Transformación objetos
- Realizar analisis
La estructura más general de la línea de comando para usar una función es:
Por ejemplo, sum(1:4) usa una secuencia de integers consecutivos de 1 a 4 como objetos y devuelve 10.
Este no requiere argumentos adicionales.
Algunas veces las funciones permiten/ necesitan más especificaciones para trabajar. Estas son llamados
“argumentos”. Es común usar objetos en la función como un argumento especial. De hecho algunas
funciones trabajan sólo con argumentos. Por ejemplo:
En este caso, la función seq() necesita al menos un argumento para trabajar. Si no se da ninguna
83
especificación entonces las opciones de default son consideradas.
¿Qué son las funciones?
Usualmente el usuario quiere guardar los resultados de un función, entonces:
En esta sección, nos enfocaremos en las funciones incorporadas. Estas son funciones que no
requieren ser instaladas usando un paquete.
Consideremos el siguiente ejemplo de una llamada a una función:
Funciones incorporadas:
x <- c(1,2,3,4)
length(x)
[1] 4
Primera línea: Usamos la función “c()”, la cual combina 4 argumentos dentro de un vector y lo
asignamos al objeto x.
Segunda línea: Usamos la función “length()”, la cual calculó y devolvió el largo de un vector.
Nota: El resultado de la función length(x) no fue asignado a ningún objeto. Por lo tanto, el
resultado es mostrado en la pantalla y no es guardado. 84
Funciones generales
Considera las siguientes variables:

x <- 1:4
y <- 3:6
length(x) – Contador, devuelve el número de elementos en un vector.

length(x)
[1] 4
append(x,y) – Agrega elementos a un vector

append(x,y)
[1] 1 2 3 4 3 4 5 6
85
Funciones generales
cbind(x,y) – combina vectores por columnas rbind(x,y) – combina vectores por filas
cbind(x,y) rbind(x,y)
x y [,1] [,2] [,3] [,4]
[1,] 1 3 X 1 2 3 4
[2,] 2 4 Y 3 4 5 6
[3,] 3 5
[4,] 4 6
identical(x,y) – Prueba si dos objetos son exactamente iguales

identical(x,y); identical(x+2,y); identical(x+2L,y)
[1] FALSE
[1] FALSE
[1] TRUE
Class(x) es “integer”, pero class(x+2) es númerico. Identical (x,y) no sólo prueba si los valores de
los elementos de dos vectores son lo mismo, sino también su clase. Solución: usa x+2L para
obtener un “integer”. 86
Funciones generales
unique(x) – remueve duplicados de un vector.
unique(append(x,y))
[1] 1 2 3 4 5 6
seq(x,y,n) – secuencia de x a y, espaciado por n unidades.

seq(0,3,0.5)
[1] 0.0 0.5 1.0 1.5 2.0 2.5 3.0
rep(x,n) – repite el número x, n veces.

rep(5,3); rep(1:5,3); rep(1:5,each=3)
[1] 5 5 5
[1] 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5
[1] 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5
cut(x,breaks=n o breaks=vector con puntos de corte) – divide al vector x en un factor con n variables.
cut(0:5,2)
[1] (-0.005,2.5] (-0.005,2.5] (-0.005,2.5] (2.5,5] (2.5,5] (2.5,5]
Levels: (-0.005,2.5] (2.5,5]
Cuando breaks=n, el rango de los datos es dividido en n partes de igual longitud y entonces los
límites exteriores son movidos en un 0,1% del rango para asegurar que ambos valores extremos
estén dentro de los intervalos. 87
Funciones generales
Recuerda los siguiente:

Repeticiones. sort(x) – ordena el vector x.
rep(1:5,3) sort(rep(1:5,3), decreasing = FALSE)
[1] 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 [1] 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5
rev(x) – elementos de x en orden inverso.

rev(sort(rep(1:5,3), decreasing = FALSE)) # Same as sort(rep(1:5,3),decreasing=TRUE)
[1] 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1
rank(x) – ranking de elementos de x promediando empates.

rank(rep(1:5,3))
[1] 2 5 8 11 14 2 5 8 11 14 2 5 8 11 14
order(x) – lista la posición de una versión rankeada de x sin empates

order(rep(1:5,3),decreasing = FALSE)
[1] 1 6 11 2 7 12 3 8 13 4 9 14 5 10 15 88
Funciones de texto
tolower(),toupper() – convierte una cadena de caracteres a minúscula/mayúscula:

tolower(“Funciones Incorporadas”); toupper(“Funciones Incorporadas”)
[1] “funciones incorporadas”
[1] “FUNCIONES INCORPORADAS”
month.abb or month.name – nombre de meses abreviados y completos.

month.abb; month.name
[1] “Jan” “Feb” “Mar” “Apr” “May” “Jun” “Jul” “Aug” “Sep” “Oct” “Nov” “Dec”
[1] “January” “February” “March” “April” “May” “June” “July” “August” “September”
“October” “November” “December”
letters – letras basadas en el abecedario inglés.

letters; letters[1:26]
[1] “a” “b” “c” “d” “e” “f” “g” “h” “i” “j” “k” “l” “m” “n” “o” “p” “q” “r” “s” “t” “u” “v”
“w” “x” “y” “z” 89
Funciones de texto
substr(x,start,stop) – captura subcadenas grep(pattern,x) – busca por
de caracteres en vectores de caracteres. patrón en vector x.
substr(“Funciones Incorporadas”,11,22) grep(“A”, c(“b”, “a”, “c”));
grep(“A”, c(“b”, “A”, “c”))
[1] “Incorporadas”
integer(0)
[1] 2
sub(pattern,replacement,x) – busca por patron en vector x y lo reemplaza con replacement.

sub(“A”, “AAA”, c(“abc”, “bac”, “cba”)); sub(“A”, “AAA”, c(“abc”, “bac”, “cbA”))
[1] “abc” “bac” “cba”
[1] “abc” “bac” “cbAAA”
strsplit(x,y) – busca por y en vector x y divide.

strsplit(“Funciones Incorporadas”, “ “)
[1] “Inbuilt” “Function”
paste(x,y,...,sep) – concatena x, y, and … usando sep para separar.

paste(“Funciones”, “Incorporadas”,sep=“-”)
90
[1] “Funciones-Incorporadas”
Funciones de sistema
Las funciones getwd() y setwd() devuelve y establece el directorio de trabajo respectivamente
como lo vimos anteriormente.
ls() – lista de objetos en el ambiente actual.
ls()
[1] “x” “y”
rm() – remueve un objeto del ambiente actual.
ls(); rm(x); ls()
[1] “x” “y”
[1] “y”
Sys.time() – captura la fecha y hora exacta en el momento en que es ejecutado.
Sys.time()
[1] “YYYY-MM-DD HH:MM:SS CLST”
Sys.Date() – captura la fecha en el momento en que es ejecutado.
Sys.Date()
[1] “YYYY-MM-DD” 91
Funciones de fechas
format(Sys.Date(), “%d/%m/%Y”) – Transformar el formato de fecha.

format(Sys.Date(), “%d/%m/%Y”)
[1] “DD/MM/YYYY”
as.Date() – Transforma texto o número a fecha.

as.Date(“2020-1-30”); as.Date(10,origin=“2020-1-30”)
[1] “2020-01-30”
[1] “2020-02-09”
as.Date(“2020/01/30”); as.Date(“30/01/2020”)
[1] “2020-01-30”
[1] “0030-01-02”
as.Date(“30/01/2020”, “%d/%m/%Y”)
[1] “2020-01-30”
92
Funciones de fechas
Algunos meses son expresados usando letras en vez de números.

as.Date(“30JAN2020”, “%d%b%Y”)
lct <- Sys.getlocale(“LC_TIME”); Sys.setlocale(“LC_TIME”, “C”)
as.Date(“30JAN2020”, “%d%b%Y”)
as.Date(“30/Jan/2020”, “%d/%b/%Y”)
[1] NA
[1] “C”
[1] “2020-01-30”
[1] “2020-01-30”
Si la función as.Date() no funciona, entonces intenta configurar el nombre de la configuración

regional “C” como se describe arriba. La configuración regional describe aspectos de
internacionalización del programa. Inicialmente, la mayoría de los aspectos de R son configurados
como “C” (el cual es el lenguaje predeterminado y refleja el uso norteamericano)
93
Funciones de fechas
strftime(date,infoOfInterest) – Captura
información de interés a cerca de una fecha:
día, mes, año, etc.
strftime(“2020-01-30 10:50:55”,”%S”);
strftime(“2020-01-30 10:50:55”,”%M”);
strftime(“2020-01-30 10:50:55”,”%H”);
strftime(“2020-01-30 10:50:55”,”%d”);
strftime(“2020-01-30 10:50:55”,”%m”);
strftime(“2020-01-30 10:50:55”,”%y”);
strftime(“2020-01-30 10:50:552,”%Y”)
[1] “55” difftime(end.time,init.time,units=“secs”) –
[1] “50” Calcula las diferencias entre dos fechas en
[1] “10” segundos, días, etc.
[1] “30”
[1] “01” difftime(“2020-12-31”,”2020-06-01”,units=“days”)
[1] “20”
[1] Time difference of 213.0417 days
[1] “2020”
94
Funciones Matemáticas
95
Funciones de Estadísticas descriptivas
96
Agenda
Introducción a R
2. Tipos de datos
7. Importar datos
9. Sub-seleccionar
11.Gráficos
97
Gráficos
Simulación de una base de datos
Ejecute este código y vea qué es lo que obtiene:
set.seed(123)
zona<-factor(sample(c("Z1","Z2","Z3"),1000,replace=TRUE,prob=c(0.5,0.3,0.2)))
noche<-as.factor((runif(1000,0,1)>0.5)*1)
dia<-factor(sample(c("L","M","Mi","J","V","S","D"),1000,
replace=TRUE,prob=c(0.20,0.15,0.10,0.15,0.20,0.10,0.10)))
dia<-factor(dia,levels=c("L","M","Mi","J","V","S","D"))
medioDePago<-factor(sample(c("Efectivo","Tarjeta","Otro"),1000,replace=TRUE,
prob=c(0.4,0.4,0.2)))
ingreso_combust<-round(rgamma(1000,12,1)+2,1)
ingreso_otros<- -5+ingreso_combust*0.1+
rnorm(1000,3,10)*ifelse(ingreso_combust>20,1,
ifelse(ingreso_combust>15,0.7,
ifelse(ingreso_combust>10,0.5,0.4)))
ingreso_otros[ingreso_otros<0]<-0
length(ingreso_otros[ingreso_otros==0])
98
Gráficos
hist(ingreso_combust+ingreso_otros)
99
Gráficos
hist(ingreso_combust+ingreso_otros,
main="Histograma del total de ingreso
por transacción",
xlab="Ingreso Total",
col="lightblue",
border=4,
breaks=15)
100
Gráficos
¿Qué cambia respecto del anterior?
por transacción",
col="lightblue",
border=4,
breaks=15,
freq=FALSE)
101
Gráficos
por transacción",
col="lightblue",
border=4,
breaks=15,
freq=FALSE)
lines(density(ingreso_combust+ingreso_otros,bw=2),
col="darkblue",lwd=3,lty=2)
Use lines(denstity(…)) sobre un histograma que muestre frecuencias. ¿Funciona? 102

Gráficos
plot(ingreso_combust,ingreso_otros)
103
Gráficos
plot(ingreso_combust,ingreso_otros,
main="Gráfico de dispersión de
dos fuentes de ingreso",
xlab="Combustible", ylab="Otros")
104
Gráficos
xlab=“Combustible",ylab="Otros", col=noche)
legend("topright",c("dia","noche"),
col=noche, pch=c(1,1))
105
Gráficos
xlab=“Combustible",
ylab="Otros", col=noche,
pch=as.numeric(medioDePago))
col=noche, pch=c(1,1))
legend("topleft",c("Efectivo","Tarjeta","Otro"),
pch=1:length(levels(medioDePago)))
106
Gráficos
ingresoPositivo_Otros <- which(ingreso_otros>0)

plot(ingreso_combust[ingresoPositivo_Otros],
ingreso_otros[ingresoPositivo_Otros],
dos fuentes de ingreso
\n (Combustible y Otros)",
xlab="Combustible", ylab="Otros",
col=noche, pch=as.numeric(medioDePago))
col=noche,pch=c(1,1))
pch=1:length(levels(medioDePago)))
107
Gráficos
No olvidar que todas las opciones (colores, figuras) deben estar vinculadas al mismo conjunto
de observaciones.
ingresoPositivo_Otros <- which(ingreso_otros>0)

plot(ingreso_combust[ingresoPositivo_Otros],
ingreso_otros[ingresoPositivo_Otros],
dos fuentes de ingreso
\n (Combustible y Otros)",
xlab="Combustible", ylab="Otros",
col=noche[ingresoPositivo_Otros],
pch=as.numeric(medioDePago[ingresoPositivo_Otros]))
col=noche,pch=c(1,1))
pch=1:length(levels(medioDePago))) 108
Gráficos
plot(table(dia), type="o")
109
Gráficos
plot(table(dia), type="o", pch=22, axes=FALSE,

xlab="", ylab="", main="Cantidad de ventas
por zona")
axis(1, at=1:7, lab=c("Lun", "Mar", "Mie",
"Jue", "Vie", "Sab", "Dom"))
axis(2,las=1,at=25*0:max(table(dia)))
box()
lines(table(dia[which(zona=="Z1")]), type="o", pch=22,lty=2,col="blue")
lines(table(dia[which(zona=="Z2")]), type="o", pch=23,lty=2,col="red")
lines(table(dia[which(zona=="Z3")]), type="o", pch=24,lty=2,col="green")
legend(3.5,220, c("Total", levels(zona)), cex=0.8, col=c("black", "blue", "red", "green"),
pch=21:24, lty=c(1,2,2,2), bty="n", horiz = T)
110
Gráficos
barplot(table(dia))
111
Gráficos
barplot(table(dia),axes=FALSE,
names.arg=c("Lun", "Mar", "Mie",
"Jue", "Vie", "Sab", "Dom"),
main="Cantidad de ventas",
border="red", col="darkblue")
axis(2, las=1, at=25*0:max(table(dia)))
112
Gráficos
barplot(table(zona,dia),axes=FALSE,
names.arg=c("Lun", "Mar", "Mie", "Jue",
"Vie", "Sab", "Dom"),
main="Cantidad de ventas por zona",
border="red",col=heat.colors(3))
axis(2, las=1, at=25*0:max(table(zona,dia)))
legend(7.5, 220, levels(zona), cex=0.8,
fill=heat.colors(3),bty="n")
113
Gráficos
mp<-barplot(table(zona,dia),axes=FALSE,
names.arg=c("Lun", "Mar", "Mie",
"Jue", "Vie", "Sab", "Dom"),
text(mp,10,paste(round(table(zona,dia)/
matrix(rep(colSums(table(zona,dia)),3),
ncol=7,byrow=T)*100)[1,],"%",sep=""))
legend(7.5, 220, levels(zona), cex=0.8, fill=heat.colors(3), bty="n")
114
Gráficos
mp<-barplot(table(zona,dia),axes=FALSE,
names.arg=c("Lun", "Mar", "Mie", "Jue",
text(mp,(table(zona,dia)/2)[1,],
paste(round(prop.table(table(zona,dia),2)*100)[1,],"%",sep=""))
text(mp,table(zona,dia)[1,]+(table(zona,dia)/2)[2,],
text(mp,table(zona,dia)[1,] +table(zona,dia)[2,]+(table(zona,dia)/2)[3,],
legend(7.5,220,levels(zona),cex=0.8, fill=heat.colors(3),bty="n")
115
Gráficos
mp<-barplot(prop.table(table(zona,dia),2)*100,
axes=FALSE, names.arg=c("Lun", "Mar",
"Mie", "Jue", "Vie", "Sab", "Dom"),
main="Distribución de ventas por zona",
border="red", col=heat.colors(3))
axis(2, las=1, at=25*0:100)
text(mp,(prop.table(table(zona,dia),2)/2)[1,]
*100,paste(round(prop.table(table(zona,dia),2)*100)[1,],"%",sep=""))
text(mp,(prop.table(table(zona,dia),2)[1,]+(prop.table(table(zona,dia),2)/2)[2,])
text(mp,(prop.table(table(zona,dia),2)[1,]+prop.table(table(zona,dia),2)[2,]
+(prop.table(table(zona,dia),2)/2)[3,])
legend(3, 116, levels(zona), cex=0.8, fill=heat.colors(3),bty="n",horiz =T, xpd=TRUE) 116
Gráficos
barplot(table(dia,zona),axes=FALSE,
names.arg=c("Z1", "Z2", "Z3"),
main="Cantidad de ventas por día",
axis(2, las=1, at=100*0:max(table(dia,zona)))
legend(3, 490, c("Lun", "Mar", "Mie", "Jue",
cex=0.8, fill=heat.colors(7), bty="n")
117
Gráficos
barplot(table(dia,zona),axes=FALSE,
names.arg=c("Z1", "Z2", "Z3"),
main="Cantidad de ventas por dia",
border="red",col=heat.colors(7),
beside = TRUE)
axis(2, las=1, at=20*0:max(table(dia,zona)))
legend(18, 110, c("Lun", "Mar", "Mie", "Jue",
cex=0.8, fill=heat.colors(7),bty="n")
118
Gráficos
boxplot(ingreso_combust ~ zona,
main="Gráfico de cajas para
Ingreso por Combustible")
119
Gráficos
Algunos tipos
¿Cuál es cual? plot(valoresx,xcuad,type="l") plot(valoresx,xcuad,type="p")
valoresx <- -5:5 plot(valoresx,xcuad,type="b") plot(valoresx,xcuad,type="s")
xcuad <- valoresx^2 plot(valoresx,xcuad,type="h") plot(valoresx,xcuad,type="n")
120
Gráficos
Algunos tipos
¿Cuál es cual? plot(valoresx,xcuad,type="l") plot(valoresx,xcuad,type="p")
valoresx <- -5:5 plot(valoresx,xcuad,type="b") plot(valoresx,xcuad,type="s")
xcuad <- valoresx^2 plot(valoresx,xcuad,type="h") plot(valoresx,xcuad,type="n")
Lines Points Both
Steps Hi-Density None
121
Gráficos
Edición
Los principales ajustes de formato sobre un gráfico son los siguientes:
plot(valoresx, xcuad, type="b",

main="Este es el título",
cex.main=3,
sub="Este es el subtítulo",
xlab="Nombre del eje x",
ylab="Nombre del eje y",
xlim=c(-10,10),
col.main="brown",
col="blue",
lty=2,
pch=2,
lwd=5,
cex=1.2)
122
Gráficos
Edición
Los tipos de puntos o marcadores son:
123
Gráficos
Edición
Editando los ejes.
plot(valoresx,xcuad,axes=FALSE)
axis(side=1,pos=0,at=c(-5,0,5))
axis(side=2,pos=0,at=c(0,5,10,15,20,25),labels=c("","5","10","15","20","25"),las=1) # ¿Qué
hace el comando las?
box()
124
Gráficos
Segmentos
### Crea un gráfico vacío
plot(c(-2, 2), c(-2, 2), type = "n", xlab="", ylab="")
### Dibuja dos segmentos

segments(x0 = -1.5, y0 = 0, x1 = -0.5, y1 = -2)
segments( -0.5, -2.0, 2, 2)
125
Gráficos
Múltiples
par(mfrow=c(1,2))
plot(mtcars$wt,mtcars$mpg)
plot(valoresx,xcuad,type="b")
par(mfrow=c(1,1))
126
Gráficos
Guadar en formato jpg ó pdf
Este código genera un archivo jpg y otro pdf con la imagen del gráfico construido.
Para revisar más gráficos, ejecutar

el comando example(plot)
127

Instructivo R

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Instructivo R

Cargado por

Copyright:

Formatos disponibles

Instructivo R

Es un software libre para análisis estadístico basado en el lenguaje S.

 Ofrece muchas funciones incorporadas. Sin embargo, al basarse en un lenguaje de

 Existe una amplia gama de paquetes R que agrupan un conjunto de funciones

 Es parte de un proyecto colaborativo, lo que fomenta la incorporación de nuevas

 Es integrable con distintas bases de datos.

 Incorpora los últimos avances en distintos campos de la ciencia rápidamente.

Baja R Studio en:

Las operaciones matemáticas son aplicadas en el siguiente orden:

Usar el símbolo <- como el operador de asignación

El símbolo # es usado par hacer comentarios. Cualquier cosa a la derecha de # en la

Después de escribir un objeto, R lo mostrará (impresión automática) a

La impresión explícita es útil cuando es necesario imprimir objetos explícitamente

Usar el símbolo <- como el operador de asignación

… y luego usar esos objetos para crear otros

plot(x, y, main = "Ejemplo de una función cuadrática",xlab="Valores de X",ylab="y=x^2",type="l")

Mostrar objetos (variables y funciones)

• numeric (real o decimal): -1, 7, 20.5.

• logical: TRUE, FALSE

3. Examinar tipos de datos

Primero guardemos 3 objetos distintos para después analizar sus tipos:

Examinar tipos de datos: x

Examinar tipos de datos: y

Examinando tipos de datos: z

Ahora sabemos cómo responder la pregunta:

¿Cuál es el tipo de datos contenido en el objeto?

También podemos responder preguntas más específicas, como por ejemplo:

¿El tipo de datos contenido en el objeto es “integer”?

Definición de estructura de datos:

Creando un vector: vector_x

Clase y tipo de datos: vector_x

Más adelante veremos cómo ordenar

Creando un factor: factor_x

¿ Los niveles siguen un orden?

Examinando niveles: factor_x

[1] “alto" “bajo" "medio"

¿Es posible establecer un orden específico?

Estableciendo un nuevo orden: factor_x_ord

Crear un Factor y establecer el orden de los niveles (visualización).

1. ¿Cómo podemos establecer explícitamente el orden de las categorías en términos

Crear un Factor y establecer el orden de los niveles (valores).

Formalmente hay dos tipos de valores categóricos en R (nominales y ordinales):

- Factor (niveles sin orden)

- Visualización sin orden

Crear una Matriz: mi_mat_c

Clase y tipo de dato: mi_mat_c

Creando una Matriz: mi_mat_r

¿ Qué es lo diferente aquí?

Creando una Matriz: array_x

Clase y tipo de datos: array_x

Creando un data frame: mi_df

Clase y tipo de datos: mi_df

Para cambiar el nombre de las filas se puede usar:

Creación de una lista: mat_array_df_list

Clase y tipo de datos: mat_array_df_list

5. Asignación de nombres a objetos R

Nombres: Matrices (2)

Objeto Definir nombres de Definir nombres Definir nombres

matriz colnames() rownames()

data frame names() row. names()

6. Tranformación de tipos de estructuras de datos y clases

Supongamos que tenemos:

a un vector largo a matriz a data frame

desde vector c,(x,y) cbind(x,y) data.frame (x,y)