1.Datos_variables_y_objetos.knit

Una de las principales funciones de R es el manejo y análisis de una diversidad de datos. Para ello R los clasifica en tres principales grupos:

Numéricos
Lógicos
Caracteres

2.1 Datos numéricos

Existen dos principales tipos de datos nuéricos: los números enteros o integer con valores positivos o negativos y los números decimales o numeric con valores positivos o negativos:

Con los valores numéricos es posible realizar todo tipo de operaciones algebraicas:

3+4

## [1] 7

100-60

## [1] 40

9.7*6

## [1] 58.2

450/9

## [1] 50

2^5

## [1] 32

sqrt(121)

## [1] 11

log10(100)

## [1] 2

2.2 Datos lógicos

Son datos que toman el valor de una variable dicotómica, es decir con dos categorías: verdadero TRUE (T) o falso FALSE (F). También se le conoce como valores boleanos o logical. Siempre se esciben con letras MAYUSCULAS

TRUE

## [1] TRUE

## [1] TRUE

FALSE

## [1] FALSE

## [1] FALSE

2.3 Caracteres

Los caracteres o character representan texto que comprende letras, palabras, frases o enunciados. Para ingresar un caracter es importante inseratrlo entre comillas:

"W"

## [1] "W"

"Variable"

## [1] "Variable"

"Linea de codigo"

## [1] "Linea de codigo"

"Esta linea de codigo se escribe entre comillas"

## [1] "Esta linea de codigo se escribe entre comillas"

Una manera de verificar el tipo o la clase de los datos es empleando la función o comando class()

##La función class() para conocer el tipo de datos
class(3)

## [1] "numeric"

class(-5.4)

## [1] "numeric"

class(TRUE)

## [1] "logical"

class(FALSE)

## [1] "logical"

class("w")

## [1] "character"

class("Una cadena de caracteres")

## [1] "character"

Un caso especial son los datos faltantes, a los cuales se les asigna el nombre NA.

Una variable es un espacio en la memoria de la computadora en donde se almacenan datos de cualquier tipo. Para crear o declarar una variable se utilizan los siguientes signos de asignación:

numero <- 2
texto <- "Pablito clavo un clavito"
logico <- TRUE

numero = -1
texto = "Tres tristes tigres"
logico = FALSE

Las variables que declares se almacenan en el cuadrante 3 que corresponde al Entorno de variables.
Con las variables numéricas es posible realizar las operaciones algebraicas previamente mencionadas:

numero_1 <- 203
numero_2 <- 64

Una vez que declares una variable, es posible que realices operaciones algebraicas entre ellas. Además, es posible que verifiques el tipo de dato que almacena la variable y las concatenes:

galon <- 3.785
litros <- 5
conv <- litros/galon

class(galon)

## [1] "numeric"

class(litros)

## [1] "numeric"

class(conv)

## [1] "numeric"

Ejercicio 1
Visita la siguiente liga y resuelve el ejercicio

En R puedes manejar estructuras de datos más complejas. Esto es útil al momento de analizar tablas, matrices o listas de datos. Las principales estructures complejas de datos son:

Vectores
Matrices
Data frames
Listas

Tipo y estructuras de datos en R. Tomada de https://www.analytixlabs.co.in/blog/r-programming-language-basics/

4.1 Vectores

Los vectores son grupos de datos acomodados en una sola dimensión. Pueden ser descritos como una lista de datos numéricos, lógicos o de texto. Para crear un vector utiliza la función concatenar c() y dentro del parentesis coloca los datos separados por comas:

##vector con datos numéricos
c(1, 3, 5, 7, 9, 11)

## [1]  1  3  5  7  9 11

##datos lógicos
c(TRUE, TRUE, TRUE, FALSE, FALSE, FALSE)

## [1]  TRUE  TRUE  TRUE FALSE FALSE FALSE

##datos de texto
c("gato", "leon", "puma", "jaguar", "ocelote", "tigre")

## [1] "gato"    "leon"    "puma"    "jaguar"  "ocelote" "tigre"

Es posible declarar una variable que contenga datos dentro de un vector:

volumenes <- c(2.3, 4.5, 9.0, 10.6, 1.3)
volumenes

## [1]  2.3  4.5  9.0 10.6  1.3

escencias <- c("lavanda", "limon", "neroli", "gardenia", "bergamota", "vainilla")
escencias

## [1] "lavanda"   "limon"     "neroli"    "gardenia"  "bergamota" "vainilla"

visitas <- c(TRUE, FALSE, FALSE, TRUE, FALSE)
visitas

## [1]  TRUE FALSE FALSE  TRUE FALSE

4.2 Creación de vectores con secuencias o elementos repetidos

En R, es posible crear vectores con secuencias numéricas regulares que inicien en un número y finalicen en otro. La manera más sencilla de hacerlo es utilizando dos puntos que separen el primer y el último número de la secuencia:

##Generar una secuencia numérica que inicie en el número 1 y finalice en el número 70
1:70

##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
## [26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
## [51] 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70

num <- 1:70
num

##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
## [26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
## [51] 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70

En este caso, los elementos de la secuencia están separados por un solo valor. Si el intervalo de separación entre elementos se desea modificar, utilizar el comando seq():

##Generar una secuencia del 1 al 10 separanco cada cifra en intervalos de 0.5
seq(1, 10, 0.5)

##  [1]  1.0  1.5  2.0  2.5  3.0  3.5  4.0  4.5  5.0  5.5  6.0  6.5  7.0  7.5  8.0
## [16]  8.5  9.0  9.5 10.0

En ocasiones resulta útil generar dos secuencias que tengan diferente rango de valores o que el intervalo de separación entre cada cifra Para ello emplear comando sequence() con sus diversos argumentos:

##Generar dos secuencias. La primera del número 1 al 4 y la segunda del numero 1 al 5. Ambas secuencias están contenidas en el mismo vector
sequence(4:5)

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

##La opción from nos permite indicar la cifra con la cual inician las dos secuencias
sequence(4:5, from = 2)

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

##La opción by indica el número de valores separados netre cada elemento de la secuencia
sequence(4:5, by = 3)

## [1]  1  4  7 10  1  4  7 10 13

Finalmente, existe la posibilidad de generar vectores con elementos repetidos. Para ello se utiliza el comando rep().

##Generar un vector que repita 25 veces la letra a
rep("a", 25)

##  [1] "a" "a" "a" "a" "a" "a" "a" "a" "a" "a" "a" "a" "a" "a" "a" "a" "a" "a" "a"
## [20] "a" "a" "a" "a" "a" "a"

##Generar un vector que repita 50 veces la secuencia D1, D15, D40 y D100
rep(c("D1", "D15", "D40", "D100"), 50)

##   [1] "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15" 
##  [11] "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100"
##  [21] "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15" 
##  [31] "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100"
##  [41] "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15" 
##  [51] "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100"
##  [61] "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15" 
##  [71] "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100"
##  [81] "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15" 
##  [91] "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100"
## [101] "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15" 
## [111] "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100"
## [121] "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15" 
## [131] "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100"
## [141] "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15" 
## [151] "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100"
## [161] "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15" 
## [171] "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100"
## [181] "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15" 
## [191] "D40"  "D100" "D1"   "D15"  "D40"  "D100" "D1"   "D15"  "D40"  "D100"

##La opción each nos permite repetir cada elemento las veces que se indica, colocando de manera consecutiva las repeticiones
rep(c("D1", "D15", "D40", "D100"), each = 4)

##  [1] "D1"   "D1"   "D1"   "D1"   "D15"  "D15"  "D15"  "D15"  "D40"  "D40" 
## [11] "D40"  "D40"  "D100" "D100" "D100" "D100"

4.3 Propiedades de los vectores

Los vectores al ser listas de datos tienen asociadas ciertas propiedades que son útiles al momento de de analizar datos. Por ejemplo, la clase de datos que contiene se obtiene con la función class():

v1 <- seq(1, 19, 2)
v2 <- rep(c("a", "b", "c", "d"), 5)

class(v1)

## [1] "numeric"

class(v2)

## [1] "character"

El número de elementos que contiene el vector o longitud se obtiene con la function length():

length(v1)

## [1] 10

Las veces que se aparece un elemento en el vector, o proporción, se obtiene con la funcion table():

table(v1)

## v1
##  1  3  5  7  9 11 13 15 17 19 
##  1  1  1  1  1  1  1  1  1  1

table(v2)

## v2
## a b c d 
## 5 5 5 5

Cuando hay repetición de datos, aquellos denominados como unicos se obtienen con la función unique():

unique(v2)

## [1] "a" "b" "c" "d"

Para ordenar los elementos de un vector (numerico o de texto) se emplea la función sort():

sort(v1)

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

##Para ordenar de forma descendente, coloca la opción decreasing = T
sort(v1, decreasing = T)

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

4.4 Manipulación de vectores

Al trabajar con datos, resulta útil extraer elementos de un vector de acuerdo a su posición dentro del vector o a un criterio. A esta operación de extracción se le conoce como subset y analizaremos el primer caso. Los elementos dentro de un vector se encuentran numerados o indexados. Al número que hace referencia a la posición de los elementos se le conoce como índice. La numeración siempre comienza desde 1.
Para extraer elementos de un vector de acuerdo a su posición es necesario colocar entre corchetes [] la posición del elemento que queremos extraer:

##Crea un vector con n elementos
simpson <- c("Marge", "Homero", "Lisa", "Bart", "Maggie", "Ned", "Ines", "Skinner", "Krusty", "Magda")
##Extrae el cuarto elemento del vector
simpson[4]

## [1] "Bart"

##Extrae el séptimo elemento del vector
simpson[7]

## [1] "Ines"

Para extraer múltiples elementos de un vector, dentro de los corchetes se tiene que añadir los índices de los elementos a extraer dentro de un vector:

##Extrae el primer, tercer, cuarto y octavo elemento del vector
simpson[c(1, 3, 4, 8)]

## [1] "Marge"   "Lisa"    "Bart"    "Skinner"

Para extraer elementos con índices consecutivos basta con indicar el indice de incio y de fin separados por :

##Extrae del primer al quinto elemento del vector
simpson[1:5]

## [1] "Marge"  "Homero" "Lisa"   "Bart"   "Maggie"

##Extrae del tercer al sexto elemento del vector
simpson[3:6]

## [1] "Lisa"   "Bart"   "Maggie" "Ned"

Con respecto a la extracción de datos que cumplen un criterio, basta con escribir dentro de los corchetes el valor exacto que deseamos extraer empleando la siguiente sintaxis:

simpson[simpson == "Marge"]

## [1] "Marge"

El símbolo que acabamos de utilizar se le conoce como operador relacional y en R existen los siguientes: - Es igual ==

No es igual !=
Es mayor >
Es menor <
Es mayor o igual >=
Es menor o igual <=

El resultado de emplear un operador relacional será un valor o dato lógico. Cuando hacemos subseting de elementos de un vector utilizando este método, se seleccionarán aquellos datos que cumplan con la condición, es decir, sean TRUE

##Extrae los valores mayores a 5
v1[v1 > 5]

## [1]  7  9 11 13 15 17 19

##Extrae los valores menores a 17
v1[v1 < 17]

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

#Extrae los valores mayores o igual a 10
v1[v1 >= 10]

## [1] 11 13 15 17 19

##Extrae los valores menores a 12
v1[v1 <= 12]

## [1]  1  3  5  7  9 11

##Extrae los numeros distintos a 15
v1[v1 != 15]

## [1]  1  3  5  7  9 11 13 17 19

Cuando requerimos que se cumplan dos o más condiciones debemos emplear los operadores | O, & Y:

##Extrae los datos entre 10 y 15. Es decir, mayores a 10 y menores a 15
v1[v1 > 10 & v1 < 15]

## [1] 11 13

##Extrae los primeros y ultimos cinco valores
v1[v1 <= 5 | v1 >= 15]

## [1]  1  3  5 15 17 19

Ejercicio 2
Visita la siguiente liga y resuelve el ejercicio

Las matrices en R representan arreglos en dos dimensiones n y m,, que contienen datos de la misma clase y en donde: n es el número de filas y m de columnas.

Las matrices pueden verse como la unión de dos o más vectores que contienen datos de las distintas clases. Para crear una matriz corremos la función matrix() e indicando el número de filas y columnas con las opciones nrow y ncol, respectivamente:

##Crea una matriz con doce elementos consecutivos ordenados en una sola columna
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

##Separa los elementos en tres filas y cuatro columnas
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

##Separa los elementos filas y columnas sin que sean múltiplos del número de datos
matrix(1:12, nrow = 4, ncol = 5)

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

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

##La opción byrow permite acomodar los valores por fila y no por columna
matrix(1:12, nrow = 3, ncol = 4, byrow = T)

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

Las matrices también se pueden crear al juntar o concatenar varios vectores y empleando las funciones rbind() o cbind():

##Crea cuatro vectores
x <- c(1, 2, 3, 4, 5)
y <- c(6, 7, 8, 9, 10)
z <- c(11, 12, 13, 14, 15)
a <- c(16, 17, 18, 19, 20)

##Une los vectores como si fueran filas
rbind(x, y, z, a)

##   [,1] [,2] [,3] [,4] [,5]
## x    1    2    3    4    5
## y    6    7    8    9   10
## z   11   12   13   14   15
## a   16   17   18   19   20

##Une los vectores como si fueran columnas
cbind(x, y, z, a)

##      x  y  z  a
## [1,] 1  6 11 16
## [2,] 2  7 12 17
## [3,] 3  8 13 18
## [4,] 4  9 14 19
## [5,] 5 10 15 20

5.1 Propiedades de las matrices

Al igual que los vectores, las matrices presentan propiedades muy características que nos permitirán manipularlas. De manera análoga a la longitud de los vectores, las matrices tienen un numero de dimensiones (renglones y columnas) que podemos obtener con la función dim():

##Creamos una matriz
mi_matriz <- matrix(1:15, nrow = 5, ncol = 3)

##Obtenemos el número de dimensiones o filas y columnas de la matriz
dim(mi_matriz)

## [1] 5 3

También, es posible conocer la clase de la matriz usando la función class():

class(mi_matriz)

## [1] "matrix" "array"

Los nombres de las filas y columnas los obtenemos con las funciones rownames() y colnames()

##Obten el nombre de las filas y columnas de la matriz
rownames(mi_matriz)

## NULL

colnames(mi_matriz)

## NULL

En caso que la matriz no tenga asignados nombres de filas y columnas, estos pueden ser asignados usando las mismas funciones rownames() y colnames() de la siguiente manera:

##Asigna los nombres de las filas y columnas de la matriz
rownames(mi_matriz) <- c("fila1", "fila2", "fila3", "fila4", "fila5")
colnames(mi_matriz) <- c("columna1", "columna2", "columna3")

##Verifica el resultado
rownames(mi_matriz)

## [1] "fila1" "fila2" "fila3" "fila4" "fila5"

colnames(mi_matriz)

## [1] "columna1" "columna2" "columna3"

5.2 Manipulación de matrices

Al igual que los vectores, es posible extraer datos o hacer “subseting” en una matriz. Los datos a extraer pueden ser individuales, filas o columnas enteras. Para ello, usaremos el mismo procedimiento que con los vectores. En corchetes colocamos el índice de las filas seguido por el índice de las columnas y separados por comas:

##Extrae la primera fila de la matriz
mi_matriz[1, ]

## columna1 columna2 columna3 
##        1        6       11

##Extrae la segunda columna de la matriz
mi_matriz[, 2]

## fila1 fila2 fila3 fila4 fila5 
##     6     7     8     9    10

##Extrae el dato de la fila 4 columna 3
mi_matriz[4, 3]

## [1] 14

La extracción de datos contenidos en dos o más filas o columnas es similar a la extracción en vectores. Dentro de un vector, indica los índices de las filas o columnas que deseas extraer:

##Extrae los datos de las primeras tres filas
mi_matriz[c(1:3), ]

##       columna1 columna2 columna3
## fila1        1        6       11
## fila2        2        7       12
## fila3        3        8       13

##Extrae los datos de las últimas dos columnas
mi_matriz[, c(2, 3)]

##       columna2 columna3
## fila1        6       11
## fila2        7       12
## fila3        8       13
## fila4        9       14
## fila5       10       15

La extracción de elementos en una matriz se puede realizar por medio de los operadores relacionales. Veamos un ejemplo:

##Extrae los datos que tengan un valor menor o igual a 10
mi_matriz <= 10

##       columna1 columna2 columna3
## fila1     TRUE     TRUE    FALSE
## fila2     TRUE     TRUE    FALSE
## fila3     TRUE     TRUE    FALSE
## fila4     TRUE     TRUE    FALSE
## fila5     TRUE     TRUE    FALSE

mi_matriz[mi_matriz <= 10]

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

##Extrae los datos que sean mayores a 8
mi_matriz[mi_matriz > 8]

## [1]  9 10 11 12 13 14 15

Sin embargo, cuando queremos extraer datos de una matriz por fila o columna y además cumplan una condición, tendremos que usar la función which(). Esta función nos devuelve los índices de las filas o columnas que cumplen o no cierta condición:

##Obten los índices de los elementos (filas) de la columna 1 que sean distintos de tres usando la función which
which(mi_matriz[, 1] != 3)

## fila1 fila2 fila4 fila5 
##     1     2     4     5

##Obten los índices de los elementos (columnas) de la fila 1 que sean menores a 9
which(mi_matriz[1, ] < 9)

## columna1 columna2 
##        1        2

##Extrae los datos de la matriz original
mi_matriz[which(mi_matriz[, 1] != 3), 1]

## fila1 fila2 fila4 fila5 
##     1     2     4     5

mi_matriz[1, which(mi_matriz[1, ] < 9)]

## columna1 columna2 
##        1        6

Como lo habras notado la función which() nos devuelve resultados de manera contraria o encontrada. Es decir:

Cuando preguntas cuáles elementos de una columna cumplen o no una condición el resultado son índices de filas
Cuando preguntas cuáles elementos de una fila cumplen o no una condición el resultado son índices de columnas

En ocasiones, resulta útil transponer los datos en una matriz, es decir, convertir filas en columnas y viceversa. La función t() nos permite realizar dicha operación:

#V#isualiza la estructura original de la matriz
mi_matriz

##       columna1 columna2 columna3
## fila1        1        6       11
## fila2        2        7       12
## fila3        3        8       13
## fila4        4        9       14
## fila5        5       10       15

##Transpon la matriz
t(mi_matriz)

##          fila1 fila2 fila3 fila4 fila5
## columna1     1     2     3     4     5
## columna2     6     7     8     9    10
## columna3    11    12    13    14    15

Ejercicio 3
1. Genera una matriz con los números del 5 al 24 de 5 filas x 4 columnas
2. Asigna el nombre de las filas y de las columnas a la matriz. Las filas nombralas como f1, f2, f3, etcétera y las columnas como c1, c2, c3, …
3. Extrae los elementos de la fila 2 y después los de la columna 4

Los cuadros de datos o data frames son tablas que contienen datos distribuidos en dos dimensiones, es decir, en filas y en columnas. De manera similar a las matrices, los data frames pueden ser visualizados como una concatenación o conjunción de venctores. A diferencia de las matrices, los data frames pueden contener datos de diferente clase, por lo que son estructuras heterogéneas. Estrictamente, en un data frame los renglones representan individuos o casos y las columnas variables o rasgos.

Un data frame lo podemos entender como una versión más flexible, y por lo tanto más preferida, que una matriz. Por ello, cuando se importan tablas de datos a R, es preferible que se codifiquen como data frames.

Para crear un data frame corremos la función data.frame() y a manera de vector incluimos los nombres de las columnas. El número de elementos de cada vector debe de ser igual

data.frame(numero = c(1, 2, 3, 4), factor = c("a", "b", "c", "d"), decimal = c(1.1, 2.2, 3.3, 4.4), logico = c(T, F, F, T))

##   numero factor decimal logico
## 1      1      a     1.1   TRUE
## 2      2      b     2.2  FALSE
## 3      3      c     3.3  FALSE
## 4      4      d     4.4   TRUE

Si incumplimos con la condición anterior, el número de elementos de los vectores es distinto, entonces R nos imprimirá un error:

data.frame(numero = c(1, 2, 3, 4, 5), factor = c("a", "b", "c", "d"), decimal = c(1.1, 2.2, 3.3, 4.4), logico = c(T, F, F, T))

## Error in data.frame(numero = c(1, 2, 3, 4, 5), factor = c("a", "b", "c", : arguments imply differing number of rows: 5, 4

6.1 Propiedades de los data frames

Al igual que las matrices, los data frames presentan una clase particular, dimensiones, nombres de filas y columnas. Con las funciones class(), dim(), rownames() y colnames() se obtienen estos atributos:

##Crea un data frame y asignalo a una variable
mi_df <- data.frame(numero = c(1, 2, 3, 4), factor = c("a", "b", "c", "d"), decimal = c(1.1, 2.2, 3.3, 4.4), logico = c(T, F, F, T))

##Obten la clase, dimensiones y nombres de filas y columnas del data frame
class(mi_df)

## [1] "data.frame"

dim(mi_df)

## [1] 4 4

rownames(mi_df)

## [1] "1" "2" "3" "4"

colnames(mi_df)

## [1] "numero"  "factor"  "decimal" "logico"

Adicionalmente, los nombres de las columnas de un data frame se obtienen con la función names(). Recuerda que esta función solamente es exclusiva de los data frames:

##Obten el nombre de las columnas del data frame usando la función names
names(mi_df)

## [1] "numero"  "factor"  "decimal" "logico"

##Intenta correr la función names en una matriz
names(mi_matriz)

## NULL

De lo contrario, en una matriz la función names() nos devuelve un objeto nulo o vacío

6.2 Manipulación de los data frames

Manipular data frames resulta una operación común en el análisis de datos. Como se mencionó previamente, los data frames resultan ser estructuras preferidas sobre las matrices por la flexibilidad en su manipulación. Al igual que las matrices, es posible obtener todos los elementos de una fila o columna en particular utilizando corchetes:

##Obten la fila 1 del data frame
mi_df[1, ]

##   numero factor decimal logico
## 1      1      a     1.1   TRUE

##Obten la columna 3 del data frame
mi_df[, 3]

## [1] 1.1 2.2 3.3 4.4

Existe un método exclusivo de los data frames para seleccionar columnas y obtener sus elementos. Solo requerimos escribir el nombre del data frame y después agregar el signo $. Esto nos desplegará un menú con los nombres de las columnas. Seleccionamos el que deseamos y concluimos:

##Selecciona la columna correspondiente a factor
mi_df$factor

## [1] "a" "b" "c" "d"

##O a decimal
mi_df$decimal

## [1] 1.1 2.2 3.3 4.4

¿Cuál método se te facilitó más? … Emplea ese método

Si deseas seleccionar múltiples filas o columnas hazlo de forma similar a las matrices. Dentro de los corchetes agrega dentro de un vector los índices de filas o columnas que deseas seleccionar:

##Selecciona las dos primeras filas
mi_df[c(1, 2), ]

##   numero factor decimal logico
## 1      1      a     1.1   TRUE
## 2      2      b     2.2  FALSE

##Selecciona las últimas tres columnas
mi_df[, c(2:4)]

##   factor decimal logico
## 1      a     1.1   TRUE
## 2      b     2.2  FALSE
## 3      c     3.3  FALSE
## 4      d     4.4   TRUE

En ocasiones los data frame están compuestos por un número grande de datos. Las funciones head() y tail() permiten imprimir en la consola de R los primeros o los últimos 6 valores, respectivamente:

head(mi_df)

##   numero factor decimal logico
## 1      1      a     1.1   TRUE
## 2      2      b     2.2  FALSE
## 3      3      c     3.3  FALSE
## 4      4      d     4.4   TRUE

tail(mi_df)

##   numero factor decimal logico
## 1      1      a     1.1   TRUE
## 2      2      b     2.2  FALSE
## 3      3      c     3.3  FALSE
## 4      4      d     4.4   TRUE

La visualización de estos elementos puede modificarse a cualquier otro numero distinto de 6 de la siguiente manera head(, *numero de filas a imprimir*):

dim(lakers)

## [1] 34624    13

head(lakers, 30)

##        date opponent game_type  time period      etype team              player
## 1  20081028      POR      home 12:00      1  jump ball  OFF                    
## 2  20081028      POR      home 11:39      1       shot  LAL           Pau Gasol
## 3  20081028      POR      home 11:37      1    rebound  LAL Vladimir Radmanovic
## 4  20081028      POR      home 11:25      1       shot  LAL        Derek Fisher
## 5  20081028      POR      home 11:23      1    rebound  LAL           Pau Gasol
## 6  20081028      POR      home 11:22      1       shot  LAL           Pau Gasol
## 7  20081028      POR      home 11:22      1       foul  POR           Greg Oden
## 8  20081028      POR      home 11:22      1 free throw  LAL           Pau Gasol
## 9  20081028      POR      home 11:00      1       foul  LAL Vladimir Radmanovic
## 10 20081028      POR      home 10:53      1       shot  POR   LaMarcus Aldridge
## 11 20081028      POR      home 10:45      1       shot  LAL        Derek Fisher
## 12 20081028      POR      home 10:32      1       shot  POR   LaMarcus Aldridge
## 13 20081028      POR      home 10:31      1    rebound  LAL         Kobe Bryant
## 14 20081028      POR      home 10:21      1       shot  LAL           Pau Gasol
## 15 20081028      POR      home 10:04      1       shot  POR       Travis Outlaw
## 16 20081028      POR      home 09:50      1       shot  LAL        Andrew Bynum
## 17 20081028      POR      home 09:48      1    rebound  LAL         Kobe Bryant
## 18 20081028      POR      home 09:41      1       shot  LAL           Pau Gasol
## 19 20081028      POR      home 09:24      1       shot  POR         Brandon Roy
## 20 20081028      POR      home 09:21      1    rebound  POR           Greg Oden
## 21 20081028      POR      home 09:20      1       shot  POR           Greg Oden
## 22 20081028      POR      home 09:20      1    rebound  POR           Greg Oden
## 23 20081028      POR      home 09:20      1       foul  LAL        Andrew Bynum
## 24 20081028      POR      home 09:11      1       shot  POR           Greg Oden
## 25 20081028      POR      home 09:09      1    rebound  LAL Vladimir Radmanovic
## 26 20081028      POR      home 09:04      1       foul  POR         Steve Blake
## 27 20081028      POR      home 08:51      1       shot  LAL        Andrew Bynum
## 28 20081028      POR      home 08:50      1    rebound  POR       Travis Outlaw
## 29 20081028      POR      home 08:39      1       shot  POR         Brandon Roy
## 30 20081028      POR      home 08:38      1    rebound  LAL        Andrew Bynum
##    result points          type  x  y
## 1              0               NA NA
## 2  missed      0          hook 23 13
## 3              0           off NA NA
## 4  missed      0         layup 25  6
## 5              0           off NA NA
## 6    made      2          hook 25 10
## 7              0      shooting NA NA
## 8    made      1               NA NA
## 9              0      personal NA NA
## 10   made      2          jump 36 21
## 11   made      2   pullup jump 30 21
## 12 missed      0          jump 34 10
## 13             0           def NA NA
## 14   made      2          jump 15 17
## 15   made      2          jump 46  9
## 16 missed      0          jump 21 10
## 17             0           off NA NA
## 18   made      2          jump 39  9
## 19 missed      0 driving layup 25  6
## 20             0           off NA NA
## 21 missed      0         layup 25  6
## 22             0           off NA NA
## 23             0      personal NA NA
## 24 missed      0          jump 20  9
## 25             0           def NA NA
## 26             0      personal NA NA
## 27 missed      0          jump 26 12
## 28             0           def NA NA
## 29 missed      0          jump 36 18
## 30             0           def NA NA

tail(lakers, 30)

##           date opponent game_type  time period      etype team           player
## 34595 20090414      UTA      home 02:46      4    timeout  UTA                 
## 34596 20090414      UTA      home 02:46      4        sub  UTA                 
## 34597 20090414      UTA      home 02:46      4        sub  UTA                 
## 34598 20090414      UTA      home 02:46      4        sub  UTA                 
## 34599 20090414      UTA      home 02:32      4       shot  UTA      Kyle Korver
## 34600 20090414      UTA      home 02:31      4    rebound  UTA   Kyrylo Fesenko
## 34601 20090414      UTA      home 02:30      4       shot  UTA   Kyrylo Fesenko
## 34602 20090414      UTA      home 02:27      4       shot  UTA   Kyrylo Fesenko
## 34603 20090414      UTA      home 02:27      4    rebound  UTA   Kyrylo Fesenko
## 34604 20090414      UTA      home 02:12      4       shot  LAL    Jordan Farmar
## 34605 20090414      UTA      home 02:11      4    rebound  UTA      Kyle Korver
## 34606 20090414      UTA      home 02:06      4       foul  LAL    Jordan Farmar
## 34607 20090414      UTA      home 02:06      4 free throw  UTA   Kyrylo Fesenko
## 34608 20090414      UTA      home 02:06      4    rebound  UTA                 
## 34609 20090414      UTA      home 02:06      4 free throw  UTA   Kyrylo Fesenko
## 34610 20090414      UTA      home 01:52      4       shot  LAL     Andrew Bynum
## 34611 20090414      UTA      home 01:28      4       shot  UTA    Brevin Knight
## 34612 20090414      UTA      home 01:27      4    rebound  LAL      Josh Powell
## 34613 20090414      UTA      home 01:12      4       shot  LAL      Josh Powell
## 34614 20090414      UTA      home 01:09      4    rebound  UTA Andrei Kirilenko
## 34615 20090414      UTA      home 01:04      4   turnover  UTA Andrei Kirilenko
## 34616 20090414      UTA      home 00:54      4       foul  UTA   Kyrylo Fesenko
## 34617 20090414      UTA      home 00:54      4 free throw  LAL     Andrew Bynum
## 34618 20090414      UTA      home 00:54      4 free throw  LAL     Andrew Bynum
## 34619 20090414      UTA      home 00:42      4       foul  LAL      Luke Walton
## 34620 20090414      UTA      home 00:42      4 free throw  UTA      Kyle Korver
## 34621 20090414      UTA      home 00:42      4 free throw  UTA      Kyle Korver
## 34622 20090414      UTA      home 00:27      4   turnover  LAL     Andrew Bynum
## 34623 20090414      UTA      home 00:21      4       shot  UTA      Kyle Korver
## 34624 20090414      UTA      home 00:20      4    rebound  LAL      Luke Walton
##       result points      type  x  y
## 34595             0   regular NA NA
## 34596             0           NA NA
## 34597             0           NA NA
## 34598             0           NA NA
## 34599 missed      0      jump  5  7
## 34600             0       off NA NA
## 34601 missed      0     layup 25  6
## 34602   made      2 slam dunk 25  6
## 34603             0       off NA NA
## 34604 missed      0      jump 40  7
## 34605             0       def NA NA
## 34606             0  shooting NA NA
## 34607 missed      0           NA NA
## 34608             0           NA NA
## 34609   made      1           NA NA
## 34610   made      2      dunk 25  6
## 34611 missed      0       3pt 42 27
## 34612             0       def NA NA
## 34613 missed      0      dunk 25  6
## 34614             0       def NA NA
## 34615             0           NA NA
## 34616             0  shooting NA NA
## 34617   made      1           NA NA
## 34618   made      1           NA NA
## 34619             0  personal NA NA
## 34620   made      1           NA NA
## 34621   made      1           NA NA
## 34622             0           NA NA
## 34623 missed      0       3pt 41 25
## 34624             0       def NA NA

Para extraer datos que cumplan con un valor, la función subset() permitirá filtrar datos de un data frame de una manera más amigable. La sintaxis es:

subset(dataframe, Columna Condicion)

##Extrae los elementos que sean menores a 3 de la columna decimal
subset(mi_df, decimal < 3)

##   numero factor decimal logico
## 1      1      a     1.1   TRUE
## 2      2      b     2.2  FALSE

Los data frames al igual que las matrices se transponen usando la función t()

##Transpon el data frame
t(mi_df)

##         [,1]   [,2]    [,3]    [,4]  
## numero  "1"    "2"     "3"     "4"   
## factor  "a"    "b"     "c"     "d"   
## decimal "1.1"  "2.2"   "3.3"   "4.4" 
## logico  "TRUE" "FALSE" "FALSE" "TRUE"

En ocasiones requerimos adicionar nuevas columnas cuyos valores dependen de una operación en otra columna. Para adicionar nuevas columnas al data frame tendrás que asignar la nueva columna usando el símbolo de $ y escribiendo el nombre de la nueva columna:

##Agrega una nueva columna que sea igual al logaritmo base 10 de los valores de decimal
mi_df$logaritmo <- log(mi_df$decimal)
##Verifica el resultado
mi_df

##   numero factor decimal logico  logaritmo
## 1      1      a     1.1   TRUE 0.09531018
## 2      2      b     2.2  FALSE 0.78845736
## 3      3      c     3.3  FALSE 1.19392247
## 4      4      d     4.4   TRUE 1.48160454

Ejercicio 4
1. Emplea el data frame instalado por default llamado iris y visualizalo
2. Obten las dimensiones del data frame e indica cuantas filas y columnas contiene
3. Obten el nombre de las columnas del data frame y asignlas a un vector que se llame columnas_iris
4. Extrae las primeras 50 filas del data frame
5. Extrae las columnas con valores numericos
6. Obten el número de datos que pertencen a cada especie
7. Obten los datos exclusivos de la especie setosa

Las tablas de datos que se generan en un procesador de textos distinto a R requieren ser importadas ambiente de R. Cuando generes tablas hazlo desde excel o empleando un procesador de texto plano. Al generar las tablas ten en mente lo siguiente:

Evita usar nombres para las columnas con espacios en blanco o caracteres especiales (acentos, ñ, diéresis…)
Evita dejar celdas en blanco. Si no tienes los valores, llena la celda con NA
Guarda los archivos en formato .txt o .csv. Aunque R tiene una función para leer archivos .xls evita guardarlos en este formato
Al guardar las tablas especifica como quieres quieres que los valores se separen (por tabuladores, comas, espacios…)

Para leer una tabla de datos externa, R implementa varias funciones. La más común es read.table(). Leamos la tabla de datos que tenemos en nuestro directorio:

read.table(file = "./top50.txt", header = T, sep = "\t")

Las opciones son:

file: Es el directorio donde está ubicada la tabla. Para ello debes indicar la ruta usando .. y / hacia el archivo

header: Si la tabla tiene encabezado (nombres de columnas) entonces utiliza TRUE

sep: Es el tipo de separador de las columnas en los datos. Si los datos están separados por tabuladores usa \t, si están separados por comas usa ,

Cuando la tabla sea importada a R se hará en formato de data frame

2 Tipos de datos

2.1 Datos numéricos

2.2 Datos lógicos

2.3 Caracteres

3 Variables

4 Datos complejos