Unidade 4 Estruturas de dados

4.1 Vetores

A estrutura mais básica do R é um vetor

  • Um vetor pode conter apenas objetos da mesma classe básica
  • Existe um outro objeto chamado lista, que é representado como um vetor, mas pode conter objetos de classes diferentes
  • Vetores vazios podem ser criados com a função vector().
  • O operador : é usado para gerar/representar uma sequência de números.
 x <- 1:20 
 x
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20

4.2 Criando Vetores

A função c() concatena os seus argumentos em um vetor.

 x <- c(0.5, 0.6)       ## numeric
 
 x <- c(TRUE, FALSE)    ## logical
 
 x <- c(T, F)           ## logical
 
 x <- c("a", "b", "c")  ## character
 
 x <- 9:29              ## integer
 
 x <- c(1+0i, 2+4i)     ## complex

Para a criação de um vetor vazio podemos usar a função vector()

 x <- vector("numeric", length = 10) 
 x
##  [1] 0 0 0 0 0 0 0 0 0 0

4.3 Misturando Objetos

Quando objetos diferente são misturados em um vetor, a coerção ajusta os tipos de modo que todos elementos mantenham sejam da mesma classe.

 y <- c(1.7, "a")   ## character
 y <- c(TRUE, 2)    ## numeric
 y <- c("a", TRUE)  ## character

4.4 Coerção explícita

Objetos de uma classe podem ser sua classe alterada usando as funções as.*()

 x <- 0:6
 class(x)          # "integer"
## [1] "integer"
 as.numeric(x)  
## [1] 0 1 2 3 4 5 6
 as.logical(x)     # FALSE ....
## [1] FALSE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE
 as.character(x)   # "0" "1" "2" "3" "4" "5" "6"
## [1] "0" "1" "2" "3" "4" "5" "6"

Coerções não permitidas geram NA (Não avaliado/Não disponível).

 x <- c("a", "b", "c")
 as.numeric(x)
## Warning: NAs introduzidos por coerção
## [1] NA NA NA
 as.logical(x)
## [1] NA NA NA
 as.complex(x)
## Warning: NAs introduzidos por coerção
## [1] NA NA NA

4.5 Atributos (Attributes)

Os objetos em possuem vários atributos:

-   nomes, dimnames
-   dimensão (e.g. matrizes, arrays)
-   classe
-   comprimento
-   outras atributos definidos pelo usuário/metadata

O nome dos atributos de um objeto pode ser acessado usando a função attributes().

4.6 Matrizes

Matrizes são vetores com duas ou mais dimensões. A dimensão é na verdade um vetor com dois valores inteiros (número de linhas, número d colunas). Uma característica importante é que todos os elementos de uma matriz são do mesmo tipo.

Use attributes para explorar a estrutura de um tipo de dados.

 m <- matrix(nrow = 2, ncol = 3) 
 m
##      [,1] [,2] [,3]
## [1,]   NA   NA   NA
## [2,]   NA   NA   NA
dim(m)
## [1] 2 3
attributes(m)
## $dim
## [1] 2 3

Matrizes normalmente são construídas por colunas, de modo que uma sequência de dados é lido como se estivesse se iniciando na posição superior esquerda, elemento na [linha,coluna] = [1,1], continuando até o último elemento da coluna, e assim por diante.

 m <- matrix(1:6, nrow = 2, ncol = 3)
 m
##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6

Contudo, as matrizes podem também ser criadas a partir de vetores, basta definir seus atributos d dimensão, como no exemplo abaixo:

 m <- 1:10 
 m
##  [1]  1  2  3  4  5  6  7  8  9 10
 dim(m) <- c(2, 5)
 m
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    3    5    7    9
## [2,]    2    4    6    8   10

4.7 cbind-ing and rbind-ing

Existem várias situações onde mais prático criar matrizes adicionando colunas as já existentes (column-binding) ou adicionando linhas (row-binding_) com cbind() and rbind().

 x <- 1:3
 y <- 10:12
 cbind(x, y)
##      x  y
## [1,] 1 10
## [2,] 2 11
## [3,] 3 12
 rbind(x, y) 
##   [,1] [,2] [,3]
## x    1    2    3
## y   10   11   12

4.8 Listas (list)

Listas é uma poderosa estrutura de dados. É utilizada de várias formas no contexto de R, muitas vezes passando desapercebida. Uma lista nada mais é que um vetor que pode conter elementos de diferentes classes.

x <- list(1,"a",TRUE, 1 + 4i ) 
x
## [[1]]
## [1] 1
## 
## [[2]]
## [1] "a"
## 
## [[3]]
## [1] TRUE
## 
## [[4]]
## [1] 1+4i
x[1]     # Primeiro classe da lista
## [[1]]
## [1] 1
x[[1]]   # Primeiro elemento da primeira classe da lista
## [1] 1

4.9 Fator (factor)

Fatores são usados para representar valores de variáveis categóricas. Esses fatores podem ser ordenados ou não-ordenados. Pode-se pensar nos fatores como sendo números inteiros, cada um representando uma categoria representado por um nome padrão (label).

  • Fatores são tratados de maneira distinta em algums modelos, como por exemplo regressão linear lm() e regressão linear generalizada glm()

  • Usar fatores com nomes é melhor do que usar números devido a legibilidade e transparências. Por exemplo, usar “Masculino” e “Feminino” descreve melhor os possiveis valores da variável categoria “Sexo” do que os valores 1 e 2.

x <- factor(c("yes", "yes", "no", "yes", "no")) 
x
## [1] yes yes no  yes no 
## Levels: no yes
table(x) 
## x
##  no yes 
##   2   3
unclass(x)  # retorna x sem os atributos da classe factor, ou seja, os níveis(levels)
## [1] 2 2 1 2 1
## attr(,"levels")
## [1] "no"  "yes"

A ordem dos níveis levels pode ser definida usando o argumento levels na função factor(). Isso pode ser importante em modelos lineares como a regressão linear já que o primeiro nível é usado como base.

 x <- factor(c("yes", "yes", "no", "yes", "no"),
              levels = c("yes", "no"))
 x
## [1] yes yes no  yes no 
## Levels: yes no

Usando a função attributes

attributes(x) #Aqui eu encontro o método "levels"
## $levels
## [1] "yes" "no" 
## 
## $class
## [1] "factor"
levels(x)
## [1] "yes" "no"

4.10 Valores ausentes (Missing Values)

“Missing values” são definidos por NA (non-available) or NaN (not a number) e não são permitidos em algumas operações matemática. Muito usado!!!!

Não substimen sua utilidade quando estivermos limpando e ajustando os dados.

  • is.na() é usado para testar objetos se eles são NA

  • is.nan() é usado para testar elementos se eles são NaN

  • NA possuem classe. Ou seja, existem inteiros NA, caracteres (character) NA e etc.

  • NaN é usado para representar resultados de operações matemáticas não definidas, como 0/0 ou infinito - ìnfinito.

  • O NaN é também NA mas o inverso não é verdadeiro

x <- c(1, 2, NA, 10, 3)
is.na(x)
## [1] FALSE FALSE  TRUE FALSE FALSE
is.nan(x)
## [1] FALSE FALSE FALSE FALSE FALSE
x <- c(1, 2, NaN, NA, 4)
is.na(x)
## [1] FALSE FALSE  TRUE  TRUE FALSE
is.nan(x)
## [1] FALSE FALSE  TRUE FALSE FALSE

4.11 Data Frames (Finalmente a cereja do bolo :))

Data frames é uma estrutura de dados usada para armazenar dados em tabela. A diferença para matriz é que em data frames cada coluna pode conter um tipo de vaiável. Ou seja, é simplesmente uma tabela

  • Pode ser visto como um caso especial de lista onde todos os elementos da lista possuem o mesmo comprimento.

  • Cada elemento da lista é na verdade uma coluna de uma tabela, e o comprimento de cada elemento da lista o número de linhas da tabela.

  • Diferente das matrizes, data frames podem armazenar diferentes classes de objetos, uma em cada coluna (como uma lista); Todos os elementos das matrizes são da mesma classe

  • Data frames possuem um atributo especial chamado row.names

  • Data frames é o formato normalmente utilizado na importação de dados, resultado das funções read.table() ou read.csv()

  • Pode ser convertido para matriz por meio da função data.matrix()

x <- data.frame(foo = 1:4, bar = c(T, T, F, F)) 
x
##   foo   bar
## 1   1  TRUE
## 2   2  TRUE
## 3   3 FALSE
## 4   4 FALSE
nrow(x)
## [1] 4
ncol(x)
## [1] 2

4.12 Nomes

Objetos em R podem ter nomes associados, o que torna os códigos mais fácil de serem lidos e compreendidos.

x <- 1:3
names(x)
## NULL
names(x) <- c("foo", "bar", "norf") 
x
##  foo  bar norf 
##    1    2    3
names(x)
## [1] "foo"  "bar"  "norf"

Listas também podem ter nomes associados

 x <- list(a = 1, b = 2, c = 3) 
 x
## $a
## [1] 1
## 
## $b
## [1] 2
## 
## $c
## [1] 3

E matrizes.

m <- matrix(1:4, nrow = 2, ncol = 2)
dimnames(m) <- list(c('a', 'b'), c('c', 'd')) 
m
##   c d
## a 1 3
## b 2 4

4.13 Sumário

Estruturas de Dados em R

  • classes básicas: numérica, lógica, caracter, inteiro, número complexo

  • vetores, listas

  • fatores

  • missing values

  • data frames

E finalmente, é importante entender como os nomes são associados aos objetos em R