Tipos de dados em R

Antes de começar a introdução e conhecer os vários tipos de dados em R, vamos configurar rapidinho o ambiente R tanto no Terminal quanto no Jupyter Notebook.

O comando a seguir é para macOS e vai instalar o R no seu terminal.

brew install r --build-from-source

Para verificar se a instalação deu certo, basta digitar R (maiúsculo) no terminal para entrar em uma sessão do R, como mostrado abaixo.

Para instalação em outros sistemas operacionais, confira este tutorial.

Agora vamos adicionar a linguagem R como kernel no Jupyter Notebook. Certifique-se de que o Jupyter Notebook já está instalado no seu sistema.

Abra o terminal, inicie uma sessão do R e rode os dois comandos abaixo para adicionar o kernel do R ao seu Jupyter Notebook.

install.packages('IRkernel')
IRkernel::installspec()

Depois que os dois comandos rodarem com sucesso, inicie o Jupyter pelo terminal e abra um notebook com o kernel R, como no exemplo:

Pronto! Você já pode escrever seu primeiro código em R no Jupyter Notebook.

Introdução

Para aproveitar o R ao máximo, é essencial conhecer e entender os vários tipos e estruturas de dados que existem na linguagem e como elas funcionam. Elas são fundamentais em praticamente todos os problemas e, especialmente, quando você trabalha com machine learning, área altamente centrada em dados.

Em uma linguagem de programação, geralmente usamos variáveis para armazenar informações, que podem ser inteiras, caracteres, ponto flutuante, booleanas etc. O tipo da variável depende do tipo de informação que ela guarda. Se recebe um inteiro, a variável tem tipo de dado int. Variáveis são apenas posições de memória reservadas onde valores são armazenados. Assim que você cria uma variável, um espaço de memória é reservado para ela.

Com base no tipo de dado da variável, o sistema operacional aloca uma certa quantidade de memória. Por exemplo, em R, uma variável que guarda um inteiro reserva 4 bytes de memória e 1 byte para um caractere.

Em linguagens como C, C++ e Java, variáveis são declaradas com um tipo de dado; porém, em Python e R, as variáveis são objetos. Objetos nada mais são do que estruturas de dados com alguns atributos e métodos aplicados a esses atributos.

Existem vários tipos de objetos/estruturas de dados em R que serão discutidos neste tutorial, como:

• Vetores

• Listas

• Matrizes

• Arranjos (arrays)

• Fatores

• Data frames

Antes, vamos entender alguns tipos básicos sobre os quais os objetos de R são construídos: numeric, integer, character, factor e logical.

• Numeric: números que têm casas decimais ou são frações têm tipo de dado numeric.

num <- 1.2
print(num)

[1] 1.2

Você pode verificar o tipo de dado de a usando a função class().

class(num)

'numeric'

• Integer: números que não possuem casas decimais têm tipo de dado integer. Para criar um integer explicitamente, use as.integer() passando a variável como argumento.

int <- as.integer(2.2)
print(int)

[1] 2

class(int)

'integer'

• Character: como o nome sugere, uma letra ou combinação de letras entre aspas é considerada tipo de dado character pelo R. Pode conter letras ou números.

char <- "datacamp"
print(char)

[1] "datacamp"

class(char)

'character'

char <- "12345"
print(char)

[1] "12345"

class(char)

'character'

• Logical: uma variável que pode assumir valores TRUE ou FALSE, como um booleano, é chamada de logical.

log_true <- TRUE
print(log_true)

[1] TRUE

class(log_true)

'logical'

log_false <- FALSE
print(log_false)

[1] FALSE

class(log_false)

'logical'

• Factor: tipo de dado usado para representar relações qualitativas, como cores, bom & ruim, avaliações de cursos ou filmes etc. São úteis em modelagem estatística.

Para isso, você usará a função c(), que retorna um vetor (unidimensional) combinando todos os elementos.

fac <- factor(c("good", "bad", "ugly","good", "bad", "ugly"))

print(fac)

[1] good bad  ugly good bad  ugly
Levels: bad good ugly

class(fac)

'factor'

O fator fac tem três níveis: good, bad e ugly, que podem ser verificados com a função levels; o tipo de cada nível é character.

levels(fac)

1. 'bad'
2. 'good'
3. 'ugly'

nlevels(fac)

3

class(levels(fac))

'character'

Antes de seguir, duas dicas rápidas que ajudam bastante:

• O R é case-sensitive. Todos os objetos definidos acima devem ser usados exatamente com a mesma grafia (maiúsculas/minúsculas), como no exemplo abaixo.

Num

Error in eval(expr, envir, enclos): object 'Num' not found
Traceback:

• No R, você pode listar todas as variáveis/objetos definidos no ambiente de trabalho com a função ls(), como mostrado abaixo.

ls()

1. 'char'
2. 'int'
3. 'num'

Listas

Diferente de vetores, uma lista pode conter elementos de vários tipos de dados e é frequentemente definida como uma coleção ordenada de valores. Ela pode conter vetores, funções, matrizes e até outra lista dentro dela (lista aninhada).

Listas em R são indexadas a partir de 1, ou seja, o índice começa em um.

Vamos entender listas com um exemplo rápido que terá três tipos de dados diferentes armazenados em uma única lista.

lis1 <- 1:5  # vetor integer
lis1

1. 1
2. 2
3. 3
4. 4
5. 5

lis2 <- factor(1:5)  # vetor factor
lis2

1. 1
2. 2
3. 3
4. 4
5. 5

lis3 <- letters[1:5]  # vetor character
lis3

1. 'a'
2. 'b'
3. 'c'
4. 'd'
5. 'e'

combined_list <- list(lis1, lis2, lis3)

combined_list

1. 1. 1
   2. 2
   3. 3
   4. 4
   5. 5
   1. 1
   2. 2
   3. 3
   4. 4
   5. 5
2. Níveis:

   1. '1'
   2. '2'
   3. '3'
   4. '4'
   5. '5'
   1. 'a'
   2. 'b'
   3. 'c'
   4. 'd'
   5. 'e'

Vamos acessar cada vetor da lista separadamente. Para isso, use dois colchetes, já que os três vetores estão no mesmo nível dentro da lista. python combined_list[[1]]

1. 1
2. 2
3. 3
4. 4
5. 5

python combined_list[[2]]

1. 1
2. 2
3. 3
4. 4
5. 5

combined_list[[3]]

1. 'a'
2. 'b'
3. 'c'
4. 'd'
5. 'e'

Agora, vamos acessar o quinto elemento do terceiro vetor, que é a letra e.

combined_list[[3]][5]

'e'

Por fim, vamos “achatar” a lista. Um ponto importante: como a combined_list combina tipos character e numeric, o tipo character tem precedência e o tipo de dado da lista achatada passa a ser character.

flat_list <- unlist(combined_list)

class(flat_list)

'character'

flat_list

1. '1'
2. '2'
3. '3'
4. '4'
5. '5'
6. '1'
7. '2'
8. '3'
9. '4'
10. '5'
11. 'a'
12. 'b'
13. 'c'
14. 'd'
15. 'e'

length(flat_list)

15

Vetores

Vetores são objetos usados para armazenar múltiplos valores do mesmo tipo de dado. Um vetor não pode misturar integer e character. Por exemplo, se você quer guardar as notas finais de 100 alunos, em vez de criar 100 variáveis diferentes, crie um vetor de tamanho 100 que armazenará todas as notas.

Você cria um vetor com a função c(), que combina os elementos e retorna um array unidimensional.

Vamos criar um vetor marks com dados de cinco alunos do tipo numeric.

marks <- c(88,65,90,40,65)

class(marks)

'numeric'

Vamos verificar o comprimento do vetor, que deve retornar o número de elementos.

length(marks)

5

Agora, vamos acessar um elemento específico pelo índice.

marks[4]

40

marks[5]

65

marks[6] # retorna NA porque não existe sexto elemento no vetor

<NA>

• Slicing: assim como em Python, o conceito de slicing também se aplica em R.

  Vamos acessar os elementos do segundo ao quinto usando slicing.

marks[2:5]

1. 65
2. 90
3. 40
4. 65

Agora vamos criar um vetor character, de forma semelhante ao numeric.

char_vector <- c("a", "b", "c")
print(char_vector)

[1] "a" "b" "c"

class(char_vector)

'character'

length(char_vector)

3

char_vector[1:3]

1. 'a'
2. 'b'
3. 'c'

Se criarmos um vetor com valores numéricos e de texto, os numéricos serão convertidos para tipo character.

char_num_vec <- c(1,2, "a")

char_num_vec

1. '1'
2. '2'
3. 'a'

class(char_num_vec)

'character'

Vamos criar um vetor com 1024 valores numéricos usando slicing.

vec <- c(1:1024)

Agora acesse o elemento do meio e o último. Para isso, use a função length.

vec[length(vec)]

1024

vec[length(vec)/2]

512

• Como criar um vetor de números ímpares?

Para criar um vetor de ímpares, use a função seq, que recebe três parâmetros: início, fim e passo.

seq(1,10, by = 2)

1. 1
2. 3
3. 5
4. 7
5. 9

Matriz

Assim como um vetor, uma matriz armazena informações do mesmo tipo de dado. Porém, diferente dos vetores, matrizes guardam informação bidimensional.

A sintaxe para definir uma matriz é:

M <- matrix(vector, nrow=r, ncol=c, byrow=FALSE, dimnames=list(char_vector_rownames, char_vector_colnames))

byrow=TRUE indica que a matriz deve ser preenchida por linhas. byrow=FALSE indica preenchimento por colunas (padrão).

Vamos definir rapidamente uma matriz M de formato 2×3.

M = matrix( c('AI','ML','DL','Tensorflow','Pytorch','Keras'), nrow = 2, ncol = 3, byrow = TRUE)
print(M)

     [,1]         [,2]      [,3]   
[1,] "AI"         "ML"      "DL"   
[2,] "Tensorflow" "Pytorch" "Keras"

Vamos usar slicing para buscar elementos por linha e coluna.

M[1:2,1:2] # a primeira dimensão seleciona as duas linhas; a segunda, os elementos da 1ª e 2ª coluna

Data frame

Diferente de uma matriz, data frames são uma forma mais geral de matriz. Eles contêm dados em formato tabular. Em um data frame, as colunas podem ter tipos de dados diferentes. A primeira coluna pode ser character, a segunda integer e a terceira logical.

As variáveis/recursos ficam em colunas, também chamadas de header, enquanto as observações ficam nas linhas, com o primeiro elemento sendo o nome da linha seguido dos dados, chamados de data rows.

Você cria um data frame com a função data.frame().

Data frames são amplamente usados para ler arquivos CSV e de texto. E não só para leitura: você também pode usá-los em problemas de machine learning, especialmente com dados numéricos. Eles são úteis para entender os dados, fazer wrangling, plotar e visualizar.

Vamos criar um dataset de exemplo e aprender algumas funções específicas de data frame.

dataset <- data.frame(
   Person = c("Aditya", "Ayush","Akshay"),
   Age = c(26, 26, 27),
   Weight = c(81,85, 90),
   Height = c(6,5.8,6.2),
   Salary = c(50000, 80000, 100000)
)

print(dataset)

  Person Age Weight Height Salary
1 Aditya  26     81    6.0  5e+04
2  Ayush  26     85    5.8  8e+04
3 Akshay  27     90    6.2  1e+05

class(dataset)

'data.frame'

nrow(dataset) # número de linhas do data frame dataset

3

ncol(dataset) # número de colunas do data frame dataset

5

df1 = rbind(dataset, dataset) # row bind: anexa os argumentos por linhas

df1

df2 = cbind(dataset, dataset) # column bind: anexa os argumentos por colunas

df2

Vamos ver a função head, muito útil quando você tem milhões de registros e quer olhar só as primeiras linhas. Da mesma forma, a função tail mostra as últimas linhas dos dados.

head(df1,3) # aqui serão impressas apenas três linhas

str(dataset) # retorna a classe/tipo de dado individual de cada coluna

'data.frame':    3 obs. of  5 variables:
 $ Person: Factor w/ 3 levels "Aditya","Akshay",..: 1 3 2
 $ Age   : num  26 26 27
 $ Weight: num  81 85 90
 $ Height: num  6 5.8 6.2
 $ Salary: num  5e+04 8e+04 1e+05

Agora vamos ver a função summary(), ótima para entender as estatísticas do seu dataset. Como abaixo, ela divide os dados em três quartis, o que ajuda a ter uma noção da distribuição. Também mostra se há valores ausentes.

summary(dataset)

    Person       Age            Weight          Height        Salary      
 Aditya:1   Min.   :26.00   Min.   :81.00   Min.   :5.8   Min.   : 50000  
 Akshay:1   1st Qu.:26.00   1st Qu.:83.00   1st Qu.:5.9   1st Qu.: 65000  
 Ayush :1   Median :26.00   Median :85.00   Median :6.0   Median : 80000  
            Mean   :26.33   Mean   :85.33   Mean   :6.0   Mean   : 76667  
            3rd Qu.:26.50   3rd Qu.:87.50   3rd Qu.:6.1   3rd Qu.: 90000  
            Max.   :27.00   Max.   :90.00   Max.   :6.2   Max.   :100000  

Conclusão

Parabéns por concluir o tutorial!

Este conteúdo é um ótimo ponto de partida para quem quer aprender a linguagem R. Como exercício, explore mais funções auxiliares relacionadas a cada tipo de dado.

Ainda há muito sobre R para descobrirmos: condicionais e controle de fluxo, utilitários em R e, o mais empolgante, machine learning com R. Tudo isso será abordado em futuros tutoriais — fique de olho!

Se tiver qualquer dúvida sobre este tutorial, use a área de comentários abaixo.

Se quiser aprender mais sobre R, faça o curso Intermediate R da DataCamp e confira o tutorial Introdução a data frames em R.