1 INTRODUÇÃO

O presente material é parte do Curso de Introdução ao R, ministrado entre os meses de janeiro e fevereiro de 2018 nas dependências do Tribunal de Contas do Estado da Paraíba. O curso foi promovido pela Escola de Contas Conselheiro Otacílio Silveira - ECOSIL e possui como objetivo capacitar seus servidores na Linguagem R, esta amplamente utilizada nos mais diversos campos de conhecimento.

2 O QUE É R?

O R é uma linguagem e ambiente voltados para estatística computacional e gráficos. Aberto e gratuito, é compatível com Windows, UNIX e MacOS. Atualmente o R se encontra em sua versão 3.4.3.

Apenas para evitar a confusão, o R pode se referir às duas coisas: ao software utilizado para executar o código escrito na linguagem R e à linguagem em si. Para mais informações, podemos visitar o site do Projeto R

2.1 Bibliografia indicada

  • R in a Nutshell: A Desktop Quick Reference (Adler 2012)
  • Learning R: A Step-by-Step Function Guide to Data Analysis (Cotton 2013)
  • R for Data Science: Import, Tidy, Transform, Visualize, and Model Data (Wickham and Grolemund 2016)
  • 25 Recipes for Getting Started with R (Teetor 2011a)
  • R Cookbook: Proven Recipes for Data Analysis, Statistics, and Graphics (Teetor 2011b)
  • The Essential R Reference (Gardener 2012)

2.2 Onde procurar ajuda?

2.3 Cursos indicados

2.4 Sites e blogs indicados

3 INICIANDO O USO DO R

3.1 Instalando o R

Para instalar o R, basta seguir os seguintes passos:

  • Visite um dos CRAN Mirros para fazer o download do software. Sugerimos: (https://vps.fmvz.usp.br/CRAN/);
  • Escolha a versão para o seu sistema operacional (Linux, Mac OS ou Windows);
  • Na página seguinte, escolha a versão base;
  • Baixe o arquivo disponível no link e instale!

3.2 Instalando o RStudio

O RStudio é um ambiente de interface gráfica para o R, ou melhor, um IDE (Integrated Development Environment). Atualmente o RStudio é considerado o melhor IDE para quem programa em R. Além de uma interface mais amigável, possui diversas funcionalidades que facilitam o aprendizado e a produtividade. O RStudio possui uma versão para desktop grátis e para baixar e instalar, basta seguir os seguintes passos:

  • Ir até a página de download do RStudio;
  • Clicar em download para a versão grátis;
  • Escolher o instalador de acordo com o seu sistema operacional (Windows, Mac OS, Linux);
  • Após o download, realizar a instalação.

Segue tabela com alguns atalhos do RStudio.

Operador Windows/Linux Mac
Executa a linha selecionada Ctrl+Enter Command + Enter
Comenta e descomenta linha Ctrl+Shift+C Command+Shift+C
Salva o documento Ctrl+S Command+S
Insere %>% (pipe) Ctrl+Shift+M Command+Shift+M
Vai para a primeira aba Ctrl+Shift+F11 Command+Shift+F11
Vai para a última aba Ctrl+Shift+F12 Command+Shift+F12
Vai para o final Ctrl+ ↓ Command+ ↓
Vai para o começo Ctrl+ ↑ Ctrl+ ↑
Ir para a linha Shift+Alt+G Command+Shift+Option+G

3.3 Preparando o ambiente de trabalho

Uma das primeiras coisas a se fazer, antes de começarmos a utilizar o RStudio, é definir o diretório de trabalho. Para verificar o diretório atual, podemos executar o comando getwd() no console.

Defina sua pasta de trabalho utilizando a função setwd(). Após isso, crie um novo script indo em File > New File > R Script. O R script será utilizado para organizar todos os comandos que você deseja executar. O R executa os comandos na sequência do seu script. Linhas iniciadas com # serão ignoradas.

3.4 Pedindo ajuda no R

O R possui um sistema de ajuda para auxilia-lo na busca de informações sobre funções e pacotes. Para pedir ajuda sobre determinada função, basta digitar ?seguido do nome da função. Por exemplo, vamos pedir ajuda sobre a função sum()(soma).

?sum

Se estiver utilizando o RStudio, você verá que a ajuda aparecerá na aba help.

Se você quiser ver exemplos da função, basta fazer:

example(sum)
## 
## sum> ## Pass a vector to sum, and it will add the elements together.
## sum> sum(1:5)
## [1] 15
## 
## sum> ## Pass several numbers to sum, and it also adds the elements.
## sum> sum(1, 2, 3, 4, 5)
## [1] 15
## 
## sum> ## In fact, you can pass vectors into several arguments, and everything gets added.
## sum> sum(1:2, 3:5)
## [1] 15
## 
## sum> ## If there are missing values, the sum is unknown, i.e., also missing, ....
## sum> sum(1:5, NA)
## [1] NA
## 
## sum> ## ... unless  we exclude missing values explicitly:
## sum> sum(1:5, NA, na.rm = TRUE)
## [1] 15

Você pode pedir ajuda sobre um tópico específico. Suponha que você deseja pesquisar sobre mapas, digite:

??maps

Você verá que uma série de tópicos relacionados serão exibidos na aba help.

4 OPERAÇÕES BÁSICA UTILIZANDO R

4.1 Principais operações aritméticas e lógicas com R

Antes de iniciarmos as primeiras operações com o R, é necessário conhecer os principais operadores aritméticos e lógicos. Segue tabela com os principais operadores e uma breve descrição de cada um.

Principais operadores aritméticos e lógicos
Operador Descrição
+ Operador de adição
- Operador de subtração
* Operador de multiplicação
/ Operador de divisão
: Operador de sequência
^ Operador exponencial
%% Operador de módulo
== Operador de igualdade
> Operador “maior que”
< Operador “menor que”
<= Operador “menor ou igual”
! Operador “Não”
& Operador lógico “E”
| Operador lógico “OU”

Conhecido tais operadores, podemos realizar nossas primeiras operações no console do R. Seguem alguns exemplos com os respectivos resultados.

#Exemplo de soma
347 + 328
## [1] 675
#Exemplo de subtração
567 - 345
## [1] 222
#Exemplo de multiplicação
457 * 32
## [1] 14624

4.2 Tipos numéricos

Recorrentemente lidamos com diferentes classes numéricas no R. Podemos nos deparar com números inteiros (integer), números decimais (numeric ou double) ou números complexos (complex). Para verificarmos a classe de um número, basta usarmos a função class()no número ou na variável que desejamos testar. Vejamos os exemplos a seguir:

class(3L) #Um número inteiro pode também ser representado acompanhado de um L
## [1] "integer"
class(3.435)
## [1] "numeric"
class(3 + 3i)
## [1] "complex"

NOTA: Para representar o infinito, o R utiliza Inf e -Inf. Faça o teste realizando a seguinte operação no console: 1 / 0

4.3 Operações lógicas

As operações lógicas são frequentemente utilizadas no R, principalmente nas funções de controle de fluxo. Diversas linguagens de programação utilizam a lógica booleana em que os valores lógicos podem ser TRUE ou FALSE. No R, além dos estados TRUE ou FALSE, há também um terceiro para indicar valor ausente (missing value) identificado por NA. Tais palavras são reservadas no R, o que indica que você não poderá criar variáveis com tais nomes. É importante destacar que o R é case sensitive, o que indica que existe a diferenciação entre letras maiúsculas e minúsculas. Portanto, quando formos representar os estados TRUE, FALSE ou NA, devemos escrever com todas as letras maiúsculas.

Também podemos representar TRUE e FALSE digitando apenas a primeira letra maiúscula. Faça os exemplos abaixo e analise os resultados do console.

3 > 5

48 != 10

TRUE == T

39 > 100

(30 > 10) & (4 < 3)

F == TRUE

TRUE + TRUE

FALSE / 2

NA + 3

TRUE + NA

class(TRUE)

NOTA: Devemos ter bastante cuidado com os valores ausentes (NA). Caso não haja o tratamento correto, tais valores podem interferir sensivelmente no código executado. Veremos isso com mais clareza ao longo do nosso curso.

4.4 Criando variáveis

Até então, realizamos algumas operações sem a necessidade de armazenar dados. No entanto, em operações mais complexas é praticamente impossível não utilizarmos variáveis. Com a criação de uma variável, podemos facilmente reusá-la ao longo de nosso código. Vejamos um exemplo.

x <- 3

x + 10
## [1] 13

No exemplo anterior, criamos uma variável x para armazenar o valor numérico 3. Ao realizarmos a operação x + 10, automaticamente o valor atribuído a x é recuperado. Para criarmos uma variável, utilizamos o símbolo <- ou =. No entanto, a notação <- é a mais utilizada e será a adotada ao longo do nosso curso. Faça o exemplo seguinte e analise os resultados.

x <- 25

x = 30

31 -> x

x <- x + 1

Os nomes das variáveis podem conter letras, números, pontos e sublinha (_), mas não podem iniciar com um número ou um ponto seguido de número.

NOTA: Por questão de estética e praticidade, é recomendável que você mantenha os nomes das variáveis apenas com letras minúsculas. As variáveis devem ter nomes curtos e revelar um pouco da informação que guarda. Isso facilitará a leitura do código!

Outra forma de criarmos variáveis é utilizando a função assign(), apesar de menos usual. Vejamos um exemplo a seguir.

assign("x", 99) #Note que é necessária a utilização de aspas para indicar o nome da variável

x
## [1] 99

4.5 Outras classes de variáveis

Além das classes numéricas e lógicas, podemos armazenar em uma variável dados em forma de texto (character) ou como fator (factor). A primeira forma é utilizada para armazenar qualquer dado texto, como o nome de uma pessoa. Já a segunda é geralmente utilizada para armazenar variáveis categóricas como, por exemplo, o sexo de uma pessoa. Seguem exemplo de criação de uma variável que irá armazenar um dado em texto.

nome <- "Antônio Santos"

nome
## [1] "Antônio Santos"

NOTA: Por questão didática, veremos como criar uma variável do tipo fator um pouco adiante, após conhecermos os vetores.

4.6 Listando e removendo variáveis

Para listar todas as variáveis criadas, usamos a função ls(). Digite a função no console e verifique as variáveis disponíveis no momento. Para remover uma variável, usamos a função rm() com o nome da variável que desejamos remover. Vamos atribuir 3 à uma variável de nome k1 e depois vamos removê-la do nosso ambiente.

k1 <- 3
rm(k1)

Sempre que começamos a executar um novo script, é recomendável limpar todas as variáveis carregadas, visando evitar conflitos e outros problemas. Basta utilizar o comando:

rm(list = ls())

5 VETORES

5.1 O que é um vetor?

Até então aprendemos a armazenar dados em variáveis. No entanto, muitas vezes precisamos armazenar uma sequência de dados. Suponhamos que você deseja armazenar as idades de uma turma de 30 alunos. Criar uma variável para cada um dos alunos nos parece um pouco sem sentido. É para isso que o R dispõe de alguns objetos capazes de lidar com grandes quantidades de dados de uma maneira mais inteligente.

O objeto que iremos conhecer agora se chama vetor. Na linguagem R, um vetor é uma sequência de dados de um mesmo tipo. Para criarmos um vetor no R a função utilizada é a c() e o processo é bastante simples. Vejamos um exemplo de criação de um vetor com os componentes {3, 23, 44} atribuído a uma variável y.

y <- c(3, 23, 44)

y
## [1]  3 23 44

Como já foi mencionado, os vetores armazenam dados de um mesmo tipo. Isso quer dizer que não podemos armazenar um dado numérico e um dado tipo texto (character) no mesmo vetor. Seguem alguns exemplos.

z <- c("João", "Paulo", "Pedro", "Francisco")

class(z)
## [1] "character"
k <- c(TRUE, FALSE, TRUE, TRUE)

class(k)
## [1] "logical"

Ao tentarmos criar um vetor com tipos de dados heterogêneos, o R converterá para character. O entendimento desse procedimento facilitará a detecção e a solução de alguns problemas no processo de manipulação e tratamento de dados.

k <- c(TRUE, 3, "Pedro")

class(k)
## [1] "character"

Agora que conhecemos um pouco de vetores, vamos criar uma variável tipo factor a partir de uma variável numérica. Suponha que você esteja diante de um conjunto de dados em que os gêneros feminino e masculino estejam representados pelos números 1 e 2, respectivamente. Podemos transformar essa informação em fator da seguinte forma:

genero <- c(1, 2, 1, 2)

genero <- factor(genero, levels = c(1, 2), labels = c("feminino", "masculino"))

genero
## [1] feminino  masculino feminino  masculino
## Levels: feminino masculino

Para mais detalhes, leia sobre a função factor().

5.2 Indexando vetores

Uma vez que aprendemos como criar vetores, chegou o momento de aprendermos a manipulá-los e a realizar algumas operações. Vamos começar criando um vetor com cinco elementos numéricos e depois realizar algumas operações.

#Criando o vetor e atribuindo à variavél de nome "v"
v <- c(20, 12, 35, 19, 60)

Uma vez que temos nosso vetor v, podemos recuperar todos os valores de uma só vez ou apenas um ou alguns componentes desejados. A posição inicial de um vetor no R possui valor 1 e segue da esquerda para a direita. Portanto, se quisermos obter o valor contido na posição 2 do nosso vetor v, usamos a seguinte notação: v[2]. Vejamos:

v[2]
## [1] 12

Podemos também selecionar um intervalo de componentes do vetor, o que é bastante útil e rápido. Se quisermos selecionar os dados das posições 2 a 4 do nosso vetor, basta fazermos:

v[2:4]
## [1] 12 35 19

Para exibirmos todos os componentes do vetor exceto o de uma determinada posição, utilizamos o sinal - ao indexar o nosso vetor. O exemplo seguinte selecionará todos os elementos do nosso vetor v, exceto o elemento da posição 4.

v[-4]
## [1] 20 12 35 60

Como um último exemplo, vamos indexar nosso vetor para que retorne apenas as posições 2 e 5. Isso pode ser feito facilmente da seguinte maneira:

v[c(2, 5)]
## [1] 12 60

NOTA: Há diferentes formas de indexarmos vetores e obtermos o mesmo resultado. Com o tempo, você vai descobrindo a forma mais usual e conveniente para chegar ao resultado desejado.

5.3 Operações matemáticas e lógicas com vetores

Além de indexar, devemos também conhecer como é que o R interpreta algumas operações quando utilizamos vetores. Com um vetor contendo dados numéricos, podemos realizar diversas operações. Seguem exemplos utilizando o vetor v criado no tópico anterior.

v
## [1] 20 12 35 19 60
v * 3
## [1]  60  36 105  57 180
v + 1
## [1] 21 13 36 20 61
v / 7
## [1] 2.857143 1.714286 5.000000 2.714286 8.571429

Podemos observar que ao realizarmos qualquer operação entre um vetor numérico e um número, a operação é realizada para cada um dos componentes do vetor, gerando um vetor resultado.

Podemos também somar dois vetores, desde que um deles seja de tamanho igual ou múltiplo do outro. O exemplo a seguir esclarece.

j <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

w <- c(11, 12, 13, 14, 15)
#Soma dos vetores j e w
j + w
##  [1] 12 14 16 18 20 17 19 21 23 25

Ao realizar uma operação lógica com um vetor obtemos como resultado um vetor lógico. Vejamos uma operação com o vetor w do exercício anterior.

w >= 13
## [1] FALSE FALSE  TRUE  TRUE  TRUE

Esse vetor resultado é importante para filtrarmos elementos do nosso vetor. Suponhamos que desejamos selecionar os elementos do vetor w que sejam maiores ou iguais a 13. Podemos fazer isso de uma maneira muito simples, utilizando a expressão w >= 13 como indexador do nosso vetor w. Se quisermos saber em quais posições do vetor se encontram os elementos que satisfazem à condição, podemos utilizar a função which(). Vejamos:

w[w >= 13]
## [1] 13 14 15
which(w >= 13)
## [1] 3 4 5

Diversas funções matemáticas e estatísticas podem ser facilmente aplicadas a vetores numéricos. Vejamos algumas funções importantes abaixo.

Função Descrição
sum() Retorna a soma
mean() Retorna a média
sd() Retorna o desvio padrão
median() Retorna a mediana
var() Retorna a variância
cor() Retorna a correlação entre dois vetores
min() Retorna o mínimo
max() Retorna o máximo
range() Retorna o mínimo e o máximo
summary() Retorna um sumário dos dados
quantile() Retorna os quantis do conjunto numérico

NOTA: Lembre-se que para ler sobre qualquer função no R basta digitarmos ? seguidos do nome da função no console.

Faça os exemplos seguintes e veja os resultados.

vetor1 <- c(1, 8, 11, 23.5, 12.8, 16, 25)

vetor2 <- c(10, 7.5, 10, 20.1, 24, 12, 25)

sum(vetor1)

mean(vetor2)

cor(vetor1, vetor2)

range(vetor1)

5.4 Sequências e números aleatórios

Sequências são importantes em várias operações, principalmente por economizar tempo. Uma forma simples de criar uma sequência é utilizando : e estabelecendo o início e o fim. Vejamos um exemplo de como criar uma sequência dos números de 1 a 20.

1:20
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20

É possível também que nossa sequência seja formada por um intervalo determinado por nós. Para isso, utilizamos a função seq(). Como exemplo, vamos criar uma sequência de 0 a 50 com um intervalo de 5.

seq(0, 50, 5)
##  [1]  0  5 10 15 20 25 30 35 40 45 50

Outras funções que frequentemente utilizamos no R são as que geram números aleatórias. Tais funções são bastante importantes nos processos de amostragem. As funções mais utilizadas para essa tarefa são: sample() e runif(). Vamos aos exemplos:

#Gerar 20 números inteiros no intervalo de 0 a 100 sem reposição
sample(0:100, 20)
##  [1] 82 90 47 68 87 12 72 31 44 42 60 45 93 11 46 58 25 26  5  9
#Gerar 20 valores entre 0 e 1 com reposição
sample(0:1, 20, replace = TRUE)
##  [1] 1 1 0 0 0 0 1 1 0 0 0 0 0 0 1 1 1 0 0 0
#Gerar 5 valores decimais entre 0 e 10
runif(5, 0, 10)
## [1] 3.3825195 6.7469271 8.1158721 8.4822125 0.3636028

Podemos gerar também valores aleatórios de variáveis do tipo character. Para isso, podemos utilizar a função sample() e definir um vetor de onde deverá ser selecionada a amostra. Como exemplo, podemos gerar 5 valores aleatórios entre as variáveis categóricas “masculino” e “feminino”. Observe que, como o número de valores gerados supera o conjunto de variáveis, devemos definir a possibilidade de repetição (replace = TRUE).

sample(c("masculino", "feminino"), 5, replace = TRUE)
## [1] "feminino"  "feminino"  "feminino"  "feminino"  "masculino"

Para gerarmos um determinado texto ou número repetidas vezes, podemos utilizar a função replicate().

replicate(5, "meu texto")
## [1] "meu texto" "meu texto" "meu texto" "meu texto" "meu texto"

5.5 Outras funções importantes para manipular vetores

A tabela seguinte apresenta algumas outras funções importantes para trabalharmos com vetores. É importante que você leia a documentação de cada função para evitar erros.

Função Descrição
paste() Concatena vetores
order() Retorna a ordem
length() Retorna o tamanho do vetor
names() Nomeia os elementos
cumsum() Retorna um vetor que é a soma cumulativa do vetor objeto
sort() Ordena um vetor
rev() Retorna o vetor em ordem decrescente
is.na() Retorna um vetor lógico com TRUE para valor ausente (NA)

6 EXERCÍCIOS

Tente responder as questões de 1 a 7 sem utilizar o R.

  1. Qual é o resultado da operação 11 > 3?

  2. Qual é o resultado da operação 13 + 4 * (5 + NA) ?

  3. Qual o resultado da operação (TRUE + FALSE + T)^2?

  4. Podemos realizar a operação 3nota <- 3.5 no R? Justifique a sua resposta.

  5. Sendo u <- c("A", 3), qual a classe do vetor u?

  6. Sendo j <- seq(1, 10, 3), qual será o valor do terceiro componente do vetor j?

  7. Sendo z <- c(1, 3, 5, 12, 87, 21, 0, 12), como podemos selecionar apenas os componentes do vetor z maiores do que 20?

NOTA: Para executarmos os exercícios seguintes do nosso caso hipotético, precisamos carregar o objeto vetor01. Para isso, coloque o arquivo vetor.RData no mesmo diretório de trabalho que está utilizando (use o comando getwd() para conferir) e execute o comando load("vetor.RData") no console. Você visualizará o objeto vetor01 no Global Enviroment do RStudio.

  1. O vetor01possui 15.000 observações referentes às notas dos candidatos do concurso público para auxiliar administrativo da Prefeitura de São Longuinho. Os dados foram disponibilizados pela empresa organizadora do concurso. As notas variam de 0 a 10 e os candidatos que não realizaram a prova estão com NA nos respectivos campos.

De posse dos dados, você deve realizar as seguintes tarefas:

  1. Coloque o vetor01 em ordem decrescente das notas e salve o resultado no próprio vetor01(sobrescrever). Você deve manter todas as 15.000 observações ao ordenar o vetor;
  2. Calcule a média e a mediana das notas;
  3. Calcule o desvio padrão das notas;
  4. Calcule o percentual de faltosos;
  5. Calcule quantos candidatos obtiveram notas maiores do que 7.00 e menores do que 8.00;
  6. Selecione as 500 maiores notas do vetor01 e guarde o resultado em um vetor chamado vetor02;
  7. Remova os valores ausentes (NA) do vetor01e guarde o resultado no próprio vetor01.

7 MATRIZES

A ideia de matriz no R é similar a da matriz que conhecemos na matemática. Seus componentes são indexados pelo índice da linha e da coluna correspondente. Para o R, uma matriz é uma coleção de elementos de uma mesma classe arranjados em duas dimensões.

\[ A_{m,n} = \begin{pmatrix} a_{1,1} & a_{1,2} & \cdots & a_{1,n} \\ a_{2,1} & a_{2,2} & \cdots & a_{2,n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m,1} & a_{m,2} & \cdots & a_{m,n} \end{pmatrix} \]

7.1 Criando matrizes

O processo de criação de uma matriz no R é relativamente simples. No exemplo a seguir, vamos criar uma matriz com 100 elementos numéricos em sequência de 1 a 100. Nossa matriz terá 10 linhas e 10 colunas.

matriz01 <- matrix( 
            seq(1, 100), 
            ncol = 10,
            nrow = 10) 

matriz01
##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]    1   11   21   31   41   51   61   71   81    91
##  [2,]    2   12   22   32   42   52   62   72   82    92
##  [3,]    3   13   23   33   43   53   63   73   83    93
##  [4,]    4   14   24   34   44   54   64   74   84    94
##  [5,]    5   15   25   35   45   55   65   75   85    95
##  [6,]    6   16   26   36   46   56   66   76   86    96
##  [7,]    7   17   27   37   47   57   67   77   87    97
##  [8,]    8   18   28   38   48   58   68   78   88    98
##  [9,]    9   19   29   39   49   59   69   79   89    99
## [10,]   10   20   30   40   50   60   70   80   90   100

Percebemos que o R, por default, preenche a matriz por colunas e não por linhas. No entanto, podemos criar uma matriz preenchendo primeiro as linhas e depois as colunas. Para isso, basta definirmos o argumento byrow = TRUE. Vejamos o resultado do exemplo anterior com o preenchimento por linhas e depois por colunas.

matriz01 <- matrix( 
            seq(1, 100), 
            ncol = 10,
            nrow = 10,
            byrow = TRUE)

matriz01
##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]    1    2    3    4    5    6    7    8    9    10
##  [2,]   11   12   13   14   15   16   17   18   19    20
##  [3,]   21   22   23   24   25   26   27   28   29    30
##  [4,]   31   32   33   34   35   36   37   38   39    40
##  [5,]   41   42   43   44   45   46   47   48   49    50
##  [6,]   51   52   53   54   55   56   57   58   59    60
##  [7,]   61   62   63   64   65   66   67   68   69    70
##  [8,]   71   72   73   74   75   76   77   78   79    80
##  [9,]   81   82   83   84   85   86   87   88   89    90
## [10,]   91   92   93   94   95   96   97   98   99   100

NOTA: Utilizaremos nossa matriz01 em alguns exemplos a seguir.

Outro ponto que merece atenção é a regra de reciclagem dos dados utilizados para a criação da matriz. Execute o código abaixo e observe o que ocorre.

matriz02 <- matrix( 
            seq(1, 9), 
            ncol = 2,
            nrow = 5)
matriz02

As matrizes no R também podem guardar dados em texto (character). O exemplo a seguir mostra o armazenamento desse tipo de dado.

set.seed(2) #Define a semente para que o comando sample gere sempre o mesmo resultado.
matriz03 <- matrix( 
            sample(c("M", "F"), 100, replace = TRUE), 
            ncol = 10) 

#Observe que nesse exemplo não temos o parâmetro nrow, no entanto o resultado é o mesmo.
matriz03
##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,] "M"  "F"  "F"  "M"  "F"  "M"  "F"  "M"  "M"  "F"  
##  [2,] "F"  "M"  "M"  "M"  "M"  "M"  "F"  "M"  "F"  "M"  
##  [3,] "F"  "F"  "F"  "F"  "M"  "F"  "F"  "M"  "M"  "M"  
##  [4,] "M"  "M"  "M"  "F"  "M"  "F"  "M"  "M"  "M"  "F"  
##  [5,] "F"  "M"  "M"  "F"  "F"  "M"  "F"  "M"  "M"  "M"  
##  [6,] "F"  "F"  "M"  "F"  "F"  "F"  "M"  "F"  "F"  "M"  
##  [7,] "M"  "F"  "M"  "F"  "F"  "F"  "M"  "M"  "F"  "M"  
##  [8,] "F"  "M"  "M"  "M"  "M"  "F"  "M"  "F"  "M"  "M"  
##  [9,] "M"  "M"  "F"  "F"  "F"  "F"  "M"  "M"  "F"  "M"  
## [10,] "F"  "M"  "M"  "M"  "F"  "F"  "M"  "F"  "M"  "M"

7.2 Operações matemáticas com matrizes

As operações com matrizes numéricas seguem praticamente a mesma lógica dos vetores. Ao realizar qualquer operação com uma constante numérica, a operação é feita para todos os elementos da matriz.

matriz01 * 10
##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]   10   20   30   40   50   60   70   80   90   100
##  [2,]  110  120  130  140  150  160  170  180  190   200
##  [3,]  210  220  230  240  250  260  270  280  290   300
##  [4,]  310  320  330  340  350  360  370  380  390   400
##  [5,]  410  420  430  440  450  460  470  480  490   500
##  [6,]  510  520  530  540  550  560  570  580  590   600
##  [7,]  610  620  630  640  650  660  670  680  690   700
##  [8,]  710  720  730  740  750  760  770  780  790   800
##  [9,]  810  820  830  840  850  860  870  880  890   900
## [10,]  910  920  930  940  950  960  970  980  990  1000

Já funções como mean(), sum(), sd() funcionam também como ocorre com os vetores, ou seja, levam em consideração todos os elementos da matriz.

sum(matriz01)
## [1] 5050

Há uma série de funções úteis para trabalharmos com matrizes, seguem algumas:

Função Descrição
t() Retorna a matriz transposta
diag(k) Cria uma matriz identidade k x k
det() Calcula o determinante da matriz
diag() Retorna os elementos da diagonal principal
dim() Retorna a dimensão da matriz
ncol Retorna o número de colunas da matriz
nrow() Retorna o número de linhas da matriz
rowSums() Retorna a soma das linhas da matriz
rowMeans() Retorna a média das linhas das matriz
colSums() Retorna a soma das colunas da matriz
colMeans() Retorna a média das colunas da matriz

As operações matemáticas entre matrizes também são possíveis no R. No entanto, temos que observar a dimensão das matrizes envolvidas na operação. Considere as matrizes A e B abaixo. \[A = \begin{bmatrix} 3 & 8 & 11 \\[0.3em] 5 & 9 & 19 \\[0.3em] 6 & 21 & 11 \end{bmatrix} B = \begin{bmatrix} 34 & 1 & 76 \\[0.3em] 7 & 1 & 12 \\[0.3em] 21 & 6 & 10 \end{bmatrix}\]

Como exerício, crie as matrizes A e B no R e realize as seguintes operações:

  1. \(A + B\)
  2. \(A * B\)
  3. \(A - B\)
  4. \(B \div A\)

A operação de multiplicação entre matrizes no R tem suas peculiaridades. Se quisermos realizar a multiplicação matricial, devemos utilizar o operador %*%. Matematicamente o resultado será o seguinte:

\[ AB = \begin{bmatrix} \displaystyle\sum_{k=1}^{n} a_{ik}b_{kj} \end{bmatrix} \] Caso seja utilizado apenas o operador *, o resultado será o seguinte:

\[ A*B = \begin{bmatrix} a_{11} \times b_{11} & a_{12} \times b_{12} & a_{13} \times b_{13} \\[0.3em] a_{21} \times b_{21} & a_{22} \times b_{22} & a_{23} \times b_{23} \\[0.3em] a_{31} \times b_{31}& a_{32} \times b_{32} & a_{33} \times b_{33} \end{bmatrix} \]

7.3 Manipulando matrizes

Assim como nos vetores, podemos selecionar quaisquer elementos de uma matriz. A diferença é que, para selecionarmos um elemento em uma matriz, devemos informar em qual linha e coluna se encontra o dado que queremos. Digamos que o elemento que desejamos obter o valor se encontra na terceira linha da quarta coluna da nossa matriz01 , criada no item anterior. A solução é a seguinte:

matriz01[3, 4]
## [1] 24

Muitas vezes não desejamos extrair o dado de apenas um elemento, mas de uma linha ou de uma coluna inteira de uma matriz. Para selecionarmos uma linha da nossa matriz01, utilizamos o seguinte comando: matriz01[i, ]. Onde i é a posição da linha que desejamos selecionar. Vejamos como fazemos para selecionar a linha 4 da matriz01:

matriz01[4, ]
##  [1] 31 32 33 34 35 36 37 38 39 40

Para selecionar um intervalo de linhas, a lógica é semelhante a que utilizamos para intervalos de elementos em vetores. Segue exemplo:

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

Na seleção de colunas, o R funciona de maneira igual, bastando informar qual coluna, ou intervalo de colunas, que queremos fazer a seleção. Segue exemplo de seleção da coluna 5:

matriz01[ ,5]
##  [1]  5 15 25 35 45 55 65 75 85 95

Faça os exemplos abaixo e observe os resultados.

matriz01[2:4, ]

matriz01[1:3, 7:10]

matriz01[-3, ]

matriz01[-3, -c(3:6)]

mean(matriz01[8:10, 8])

summary(matriz01)

NOTA: Podemos observar que a lógica do R para matrizes é bem similar a de vetores.

7.4 Nomeando linhas e colunas de uma matriz

Para facilitar a utilização e leitura dos dados de uma matriz, às vezes é interessante nomear suas linhas e colunas. Como exemplo, suponha que você está diante de uma matriz das notas de matemática de uma turma durante o ano de 2017. Cada linha representa um aluno e cada coluna representa um bimestre. Os dados estão estruturados conforme segue.

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

Para deixar a leitura mais fácil, podemos nomear as linhas e colunas através das funções rownames() e colnames(), respectivamente. Segue exemplo:

colnames(notas) <- c("bim-1", "bim-2", "bim-3", "bim-4")
rownames(notas) <- c("João", "Pedro", "Amanda", "Fábio", "Fernanda", "Gustavo",
                     "Severino", "Paulo", "Laura", "Túlio")
notas
##          bim-1 bim-2 bim-3 bim-4
## João         5     7     5     6
## Pedro        9     7     4     6
## Amanda       6     7     4     5
## Fábio        6     7     4     7
## Fernanda     8    10     5     5
## Gustavo      8     9     9     6
## Severino     4     4     8    10
## Paulo        6     8    10     5
## Laura        8    10     7     8
## Túlio        8     5     9     5

Uma vez com nomes das linhas e colunas, podemos utilizar os mesmos para realizar filtros em nossa matriz. Para exibir apenas as notas da aluna Fernanda, fazemos:

notas["Fernanda", ]
## bim-1 bim-2 bim-3 bim-4 
##     8    10     5     5

O procedimento para seleção das colunas segue a mesma lógica.

7.5 Unindo matrizes

A união de matrizes é bastante importante para formarmos um conjunto de dados maior a partir de dados menores. Essa união pode ocorrer de duas formas: por linhas e por colunas. Para unirmos duas matrizes através das colunas, utilizamos a função cbind(). Já para fazer a união através das linhas, usamos a função rbind().

Vamos continuar os exemplos com nossa matriz notas. No entanto, considere que, durante o ano de 2017, dois alunos foram transferidos da escola e suas notas de matemática nos dois primeiros bimestres estão armazenadas na matriz notas_transf. Vamos aos dados:

notas_transf
##            bim-1 bim-2 bim-3 bim-4
## Dimas          6     8    NA    NA
## Alessandra     8     9    NA    NA

Para consolidar os dados, precisamos unir as matrizes notas e notas_transf por linhas. Para executar tal tarefa, vamos usar a função rbind().

rbind(notas, notas_transf)
##            bim-1 bim-2 bim-3 bim-4
## João           5     7     5     6
## Pedro          9     7     4     6
## Amanda         6     7     4     5
## Fábio          6     7     4     7
## Fernanda       8    10     5     5
## Gustavo        8     9     9     6
## Severino       4     4     8    10
## Paulo          6     8    10     5
## Laura          8    10     7     8
## Túlio          8     5     9     5
## Dimas          6     8    NA    NA
## Alessandra     8     9    NA    NA

Para unirmos duas matrizes por colunas, o procedimento é similar. Porém, temos que observar que para unir matrizes através das colunas, devemos ter o mesmo número de linhas em todas as matrizes que desejamos unir. A lógica se aplica também à união por linhas, ou seja, as matrizes envolvidas devem ter o mesmo número de colunas.

8 EXERCÍCIOS

Tente resolver as questões de 1 a 5 sem utilizar o R.

  1. Podemos construir no R uma matriz com dados numéricos e texto? Se sim, qual o tipo de dado dessa matriz?

  2. O que ocorre se definirmos o argumento byrow = TRUE na construção de uma matriz?

  3. Para construir uma matriz com 25 elementos organizados em 5 linhas e 5 colunas, precisamos necessariamente definir os argumentos ncol = e nrow =da função matrix()? Por que?

  4. Considere o seguinte comando:

m <- matrix(
  c(1, 2, 3),
  nrow = 2
)

Qual o valor do elemento da segunda linha da segunda coluna (\(m_{22}\))?

  1. Considerando a matriz m do item anterior, qual o resultado, no R, da seguintes operações:
    • 3 * m
    • m + m
    • m > 2
    • sum[m == 3]

NOTA: Para resolvermos os exercícios seguintes, precisamos carregar a nossa base (chuvas.RData). Utilize o seguinte comando: load("chuvas.RData"). (Não se esqueça de colocar o arquivo em seu diretório de trabalho)

  1. A matriz chuvas possui dados (em mm) sobre precipitações em 100 municípios do Brasil, durante um período de 30 dias. Os municípios estão representados em códigos através das linhas e os dias através das colunas. Diante de tais dados, resolva as seguintes questões:
  1. Qual a média do volume diário de chuvas do período observado?
  2. Qual município teve o maior volume de chuvas considerando os 30 dias observados?
  3. Considerando o volume de todos os municípios observados, em qual dia menos choveu?
  4. Qual o volume de chuvas do município 81 (mun_81) nos primeiros 10 dias observados?
  5. Qual o volume total de chuvas nos primeiros 15 dias observados? Esse volume foi maior ou menor do que os 15 dias seguintes?
  6. Crie uma nova coluna (coluna 31 da matriz) com dados das somas de cada uma das linhas e guarde na variável chuvas_somas. Nomeie essa nova coluna de “soma”.
  7. Crie uma nova matriz com dados de todos municípios, porém com dados apenas dos 15 primeiros dias observados. Guarde o resultado em uma variável chamada chuvas_15dias.

9 DATA FRAMES E TIBBLES

9.1 O que é um Data Frame?

Em síntese, data frames são tabelas de dados. Em seu formato, são bem parecidos com as matrizes, no entanto, possuem algumas diferenças significativas. Podemos idealizar os data frames como sendo matrizes em que cada coluna pode armazenar um tipo de dado diferente. Logo, estamos lidando com um objeto bem mais versátil do que as matrizes e os vetores. Vejamos na prática!

Observe a tabela a seguir. Ela possui dados hipotéticos de seis universitários.

nome altura idade sexo peso fumante uf renda
João 1.80 22 masculino 78.3 sim PB 2
Pedro 1.77 21 masculino 82.1 não AL 5
Amanda 1.71 18 feminino 66.5 sim PE 10
Fábio 1.65 20 masculino 88.1 não PE 20
Fernanda 1.66 23 feminino 58.0 sim SP 10
Gustavo 1.63 19 masculino 75.4 não CE NA

Vamos criar um data frame no R com esses mesmos dados. A função que iremos usar é a data.frame(). Uma vez criado, iremos armazenar esses dados na variável df1.

df1 <- data.frame(
  nome = c("João", "Pedro", "Amanda", "Fábio", "Fernanda", "Gustavo"),
  altura = c(1.80, 1.77, 1.71, 1.65, 1.66, 1.63),
  idade = c(22, 21, 18, 20, 23, 19),
  sexo = c("masculino", "masculino", "feminino", "masculino", "feminino", "masculino"),
  peso = c(78.3, 82.1, 66.5, 88.1, 58, 75.4),
  fumante = c(TRUE, FALSE, FALSE, FALSE, TRUE, FALSE),
  uf = c("PB", "AL", "PE", "PE", "SP", "CE"),
  renda = c(2, 5, 10, 20, 10, NA)
)

O primeiro ponto a ser observado é que nosso data frame foi criado através de vários vetores. Cada um dos vetores possui um determinado tipo de dado. Vamos exibir o nosso data frame.

df1

Uma das funções básicas mais importantes para começarmos a trabalhar com data frames é a str(). Essa função dá uma visão clara da estrutura do nosso objeto, bem como informa os tipos de dados existentes.

str(df1)
## 'data.frame':    6 obs. of  8 variables:
##  $ nome   : Factor w/ 6 levels "Amanda","Fábio",..: 5 6 1 2 3 4
##  $ altura : num  1.8 1.77 1.71 1.65 1.66 1.63
##  $ idade  : num  22 21 18 20 23 19
##  $ sexo   : Factor w/ 2 levels "feminino","masculino": 2 2 1 2 1 2
##  $ peso   : num  78.3 82.1 66.5 88.1 58 75.4
##  $ fumante: logi  TRUE FALSE FALSE FALSE TRUE FALSE
##  $ uf     : Factor w/ 5 levels "AL","CE","PB",..: 3 1 4 4 5 2
##  $ renda  : num  2 5 10 20 10 NA

Analisando o resultado da função, podemos verificar que nosso data frame possui 6 observações e 8 variáveis. As observações e variáveis nada mais são do que nossas linhas e colunas, respectivamente. Uma outra informação importante é saber o tipo de dado que cada variável (coluna) apresenta. Podemos facilmente constatar que quatro das nossas variáveis são numéricas, três são fatores e uma lógica.

O RStudio possui uma maneira mais rápida e intuitiva para apresentar os mesmos dados.

Exibição do data frame no RStudio

Exibição do data frame no RStudio

9.2 Manipulando data frames

A manipulação de data frames é similar à manipulação de matrizes em muitos pontos. A seleção de elementos segue a mesma lógica. Vamos selecionar a terceira linha da segunda coluna do nosso objeto df1.

df1[3, 2]
## [1] 1.71

Podemos fazer, similar à operação com matrizes, a seleção de algumas colunas. Vamos selecionar apenas as colunas com dados de nome, sexo e uf.

df1[ ,c("nome", "sexo", "uf")]

Para extrairmos observações, a lógica é a mesma. Segue exemplo de seleção da primeira e da última linha de nosso data frame:

df1[c(1, 6), ]

Selecionar variáveis em um data frame é bastante simples usando a sintaxe: df$x. Onde df é o data frame e x a variável que desejamos selecionar. Para selecionar todos os dados contidos na variável altura, podemos fazer:

df1$altura
## [1] 1.80 1.77 1.71 1.65 1.66 1.63

Já para selecionar o quarto elemento da variável altura, podemos escrever:

df1$altura[4]
## [1] 1.65

NOTA: O RStudio auxilia bastante no trabalho com data frames. Ao digitarmos $ após o nome do nosso objeto, uma lista das variáveis irá aparecer para seleção. Além de economizar tempo, tal função reduz a ocorrência de erros.

Uma função bastante importante para selecionarmos dados conforme vários critérios e de forma mais intuitiva é a subset(). Ao trabalharmos com grandes data frames uma seleção mais intuitiva facilita a vida não só de quem está escrevendo o código como também a de quem irá ler o mesmo.

Suponha que desejamos dados apenas dos alunos com mais de 1.65 metros de altura e com mais de 20 anos de idade. A seleção pode ser feita facilmente da seguinte forma:

subset(df1, altura > 1.65 & idade > 20)

Leia sobre a função subset() e faça as seguintes seleções no df1:

  • Estudantes do sexo masculino e que sejam fumantes;
  • Estudantes que possuam peso acima de 60Kg;
  • Estudantes com peso abaixo de 80Kg ou com altura acima de 1.70m;
  • Selecione todas as observações das variáveis nome, altura, idade e peso (as demais colunas devem ser excluídas).
  • Estudantes que possuam altura acima 1.70m e abaixo de 1.80m.
subset(df1, renda > 2)

Outra função bastante útil para uma primeira análise dos dados é a função summary(), já vista em tópicos anteriores. Vamos aplicá-la em algumas variáveis do nosso objeto df1.

summary(subset(df1, select = c(peso, idade, sexo, renda)))
##       peso           idade              sexo       renda     
##  Min.   :58.00   Min.   :18.00   feminino :2   Min.   : 2.0  
##  1st Qu.:68.72   1st Qu.:19.25   masculino:4   1st Qu.: 5.0  
##  Median :76.85   Median :20.50                 Median :10.0  
##  Mean   :74.73   Mean   :20.50                 Mean   : 9.4  
##  3rd Qu.:81.15   3rd Qu.:21.75                 3rd Qu.:10.0  
##  Max.   :88.10   Max.   :23.00                 Max.   :20.0  
##                                                NA's   :1

Podemos ver que, usando poucos comandos, temos várias medidas estatísticas capazes de fornecer informações importantes sobre o nosso conjunto de dados, como a presença de NA em alguma das variáveis.

Outras funções como ncol(), nrow(), t(), dim() e colnames() funcionam com a mesma lógica que já vimos com as matrizes.

colnames(df1)
## [1] "nome"    "altura"  "idade"   "sexo"    "peso"    "fumante" "uf"     
## [8] "renda"

Um dos pacotes padrões do R é o datasets. Esse pacote possui uma série de objetos que podemos utilizar para testes. Um desses objetos é o airquality. Esse data frame possui 6 colunas e 153 linhas e é referente a medições de qualidade do ar em Nova Iorque realizadas entre maio e setembro de 1973. Digite airquality no console e veja os dados contidos no objeto.

Em muitas situações precisamos lidar com data frames com centenas de colunas e milhares de linhas. Exibir todos os dados apenas para fazer uma breve análise nos parece sem sentido, além de poluir desnecessariamente o console. Tanto é que o RStudio possui uma limitação para a exibição de linhas e colunas, exatamente por questões de desempenho e usabilidade. Para fazermos uma breve análise de como estão dispostos os dados em nosso data frame, utilizamos as funções head() e tail(). A primeira exibe as primeiras seis observações dos dados. Já a segunda, exibe as seis últimas. Veja exemplo aplicado ao data frame airquality.

head(airquality)
tail(airquality)

Tais funções nos dão um enorme ganho de produtividade.

Utilizando o data frame airquality, realize as seguintes operações:

  • Selecione as observações que possuem a variável Ozone com o valor NA;
  • Selecione as observações que estão com vento (Wind) acima da média dessa variável;
  • Selecione as observações do meses (Month) 5 e 9;
  • Selecione observações com temperatura (Temp) acima de 75, nos meses 7 e 8.
  • Ordene de forma decrescente pela variável Temp. (Dica: utilize a função `order())

9.3 Criando e modificando variáveis

O processo para criar novas variáveis (colunas) em data frames é igualmente simples a outras operações. Vimos que os dados do objeto airquality são referentes ao ano de 1973. Vamos criar um novo objeto chamado air_novo usando os dados originais do data frame airquality. Após isso, vamos criar uma nova coluna chamada ano, atribuir o valor 1973 e verificar como estão os dados com a função head().

air_novo <- airquality

air_novo$ano <- 1973

head(air_novo)

Podemos perceber que o valor 1973 foi aplicado a todas as linhas da coluna ano!

9.4 Transformando variáveis

Transformar variáveis em um data frame é uma tarefa igualmente simples à criação de uma nova coluna. Em nosso objeto air_novo, a variável Wind está em milhas por hora (mph). Sabendo que 1 mph é igual a 1,609 quilômetros por hora (kph), vamos transformar a nossa variável para que a velocidade do vento fique em kph.

air_novo$Wind <- air_novo$Wind * 1.609 #Veja que a operação é idêntica àquelas com vetores

head(air_novo)

A variável Temp do nosso data frame air_novo está em graus Fahrenheit (ºF). Sabendo que:

\[Celsius = \frac{Fahrenheit - 32}{1,8}\] tranforme a variável Temp de graus Fahrenheit (ºF) para graus Celsius (ºC) e depois use a função head() para conferir o resultado.

9.5 Convertendo tipos de variáveis

Frequentemente determinada variável não está com o tipo de dado que desejamos. Às vezes é necessário converter uma variável do tipo texto em fator, ou uma variável numérica em texto, por exemplo. Isso faz todo sentido quando queremos manter um padrão em diferentes data frames. Vejamos algumas funções importantes para realizar essa tarefa.

Função Descrição
as.character() Cria um objeto do tipo character
as.numeric() Cria um objeto do tipo numeric
as.factor() Cria um objeto do tipo factor
as.Date() Converte um objeto do tipo character para um objeto tipo Date

Veja um exemplo de conversão da variável ano (air_novo) de numeric para factor.

air_novo$ano <- as.factor(air_novo$ano)

class(air_novo$ano)
## [1] "factor"

Veja que nossa variável ano agora está em fator.

Vimos que em nosso data frame df1 todas as variáveis, que não são numéricas ou lógicas, estão como fator. Isso se deve especificamente ao fato do argumento stringsAsFactors estar, por padrão, com o valor TRUE. Logo, todo dado tipo texto será convertido para fator já na criação do nosso objeto. Crie um novo data frame com o argumento stringsAsFactors = FALSE e veja o que ocorre.

df2 <- data.frame(
  nome = c("João", "Pedro", "Amanda", "Fábio", "Fernanda", "Gustavo"),
  altura = c(1.80, 1.77, 1.71, 1.65, 1.66, 1.63),
  idade = c(22, 21, 18, 20, 23, 19),
  sexo = c("masculino", "masculino", "feminino", "masculino", "feminino", "masculino"),
  peso = c(78.3, 82.1, 66.5, 88.1, 58, 75.4),
  fumante = c(TRUE, FALSE, FALSE, FALSE, TRUE, FALSE),
  uf = c("PB", "AL", "PE", "PE", "SP", "CE"),
  renda = c(2, 5, 10, 20, 10, NA),
  stringsAsFactors = FALSE
)

9.6 O que é um tibble?

Tibbles são similares aos data frames, porém diferentes em dois aspectos: impressão e indexação

Na impressão no console, os tibbles apresentam apenas as dez primeiras linhas e todas as colunas que cabem na tela, tornando mais fácil o trabalho com grandes volumes de dados. Além disso, cada coluna apresenta o seu tipo, algo semelhante ao apresentado quando utilizamos a função str().

Veja um exemplo a seguir da impressão de um tibble no console.

library(nycflights13)
flights #Tais dados fazem parte do pacote nycflights13
## # A tibble: 336,776 x 19
##     year month   day dep_time sched_dep_time dep_delay arr_time
##    <int> <int> <int>    <int>          <int>     <dbl>    <int>
##  1  2013     1     1      517            515      2.00      830
##  2  2013     1     1      533            529      4.00      850
##  3  2013     1     1      542            540      2.00      923
##  4  2013     1     1      544            545     -1.00     1004
##  5  2013     1     1      554            600     -6.00      812
##  6  2013     1     1      554            558     -4.00      740
##  7  2013     1     1      555            600     -5.00      913
##  8  2013     1     1      557            600     -3.00      709
##  9  2013     1     1      557            600     -3.00      838
## 10  2013     1     1      558            600     -2.00      753
## # ... with 336,766 more rows, and 12 more variables: sched_arr_time <int>,
## #   arr_delay <dbl>, carrier <chr>, flight <int>, tailnum <chr>,
## #   origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>, hour <dbl>,
## #   minute <dbl>, time_hour <dttm>

A segunda diferença, não menos importante, é a forma de indexação. Para indexar um tibble devemos utilizar o nome completo da variável que desejamos. Caso contrário, ocorrerá um erro.

NOTA: Vimos que, nos data frames, podemos indexar uma variável usando $ e digitando apenas a primeira letra da variável que desejamos.

Ainda sobre a indexação, sempre que indexarmos um tibble usando [, o resultado será outro tibble. Usando [[ o resultados será um vetor.

flights[10]
## # A tibble: 336,776 x 1
##    carrier
##    <chr>  
##  1 UA     
##  2 UA     
##  3 AA     
##  4 B6     
##  5 DL     
##  6 UA     
##  7 B6     
##  8 EV     
##  9 B6     
## 10 AA     
## # ... with 336,766 more rows

10 EXERCÍCIOS

  1. Qual a diferença entre uma matriz e um data frame no R?
  2. Os data frames podem ser indexados com a mesma sintaxe utilizada para matrizes?
  3. Qual função básica que utilizamos para verificar a estrutura dos dados de um data frame?

NOTA: Para resolvermos os exercícios seguintes, precisamos carregar a nossa base (science_df.RData). Utilize o seguinte comando: load("science_df.RData"). (Não se esqueça de colocar o arquivo em seu diretório de trabalho)

  1. Utilizando o data frame science_df, responda as seguintes questões:
    • Qual a dimensão do objeto science_df?
    • Existe alguma variável do tipo character? Se sim, qual ou quais são?
    • Qual a variável fator que possui o maior número de níveis (levels)?
    • Na variável PrivPub temos informações sobre o tipo da escola, se privada (private) ou pública (public). Qual a quantidade de escolas públicas e privadas, respectivamente?
    • Alguma variável possui valores ausentes (NA)? Se sim, qual ou quais são?
  2. Ainda com o data frame science_df, realize as seguintes modificações:
    • Exclua qualquer observação com valor NA em alguma das variáveis e salve o resultado em science_df (sobrescerver);
    • Altere o nome da coluna class para id_class e sobrescreva science_dfcom o resultado;
    • Selecione apenas participantes de escolas públicas (variável PrivPub) e sobrescreva science_dfcom o resultado;
    • Exclua a variável Class do data frame e sobrescreva science_df com o resultado;
    • Modifique a variável sex para character;
    • Modifique os valores da variável sex da seguinte forma: altere os valores “m” para “masculino” e os valores “f” para feminino. Sobrescreva os resultados em science_df.
  3. O que são tibbles e quais as diferenças quando comparados com data frames?

Após realizar o exercício 5, aplique a função head() no objeto science_df. O resultado deve ser o seguinte:

head(science_df)

11 LISTAS

11.1 O que é uma lista?

Em poucas palavras, uma lista no R pode ser entendida como um vetor capaz de armazenar elementos com diferentes tipos de dados. Logo, uma mesma lista pode armazenar um vetor, um data frame e uma matriz, por exemplo. Por esse motivo, as listas podem se apresentar de forma bem mais complexa do que os objetos que conhecemos até agora, uma vez que podem conter outras listas. Vamos à pratica!

Primeiro, vamos relembrar os objetos df1, matriz01 e notas, criados nos tópicos anteriores

df1
matriz01
##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]    1    2    3    4    5    6    7    8    9    10
##  [2,]   11   12   13   14   15   16   17   18   19    20
##  [3,]   21   22   23   24   25   26   27   28   29    30
##  [4,]   31   32   33   34   35   36   37   38   39    40
##  [5,]   41   42   43   44   45   46   47   48   49    50
##  [6,]   51   52   53   54   55   56   57   58   59    60
##  [7,]   61   62   63   64   65   66   67   68   69    70
##  [8,]   71   72   73   74   75   76   77   78   79    80
##  [9,]   81   82   83   84   85   86   87   88   89    90
## [10,]   91   92   93   94   95   96   97   98   99   100
v
## [1] 20 12 35 19 60

Veja que temos um data frame, uma matriz e um vetor, respectivamente.

Com esses três objetos, podemos criar uma lista. A função para criar listas no R é a list().

lista01 <- list(df1, matriz01, v)

Para visualizar a estrutura do nosso novo objeto, podemos também utilizar a função str().

str(lista01)
## List of 3
##  $ :'data.frame':    6 obs. of  8 variables:
##   ..$ nome   : Factor w/ 6 levels "Amanda","Fábio",..: 5 6 1 2 3 4
##   ..$ altura : num [1:6] 1.8 1.77 1.71 1.65 1.66 1.63
##   ..$ idade  : num [1:6] 22 21 18 20 23 19
##   ..$ sexo   : Factor w/ 2 levels "feminino","masculino": 2 2 1 2 1 2
##   ..$ peso   : num [1:6] 78.3 82.1 66.5 88.1 58 75.4
##   ..$ fumante: logi [1:6] TRUE FALSE FALSE FALSE TRUE FALSE
##   ..$ uf     : Factor w/ 5 levels "AL","CE","PB",..: 3 1 4 4 5 2
##   ..$ renda  : num [1:6] 2 5 10 20 10 NA
##  $ : int [1:10, 1:10] 1 11 21 31 41 51 61 71 81 91 ...
##  $ : num [1:5] 20 12 35 19 60

Podemos ter uma visão resumida dos três objetos que compõem nossa lista. Nesse ponto é importante lembrar que as listas no R não possuem dimensão e sim tamanho. Logo, a função ser utilizada para saber o tamanho de uma lista é a `length().

11.2 Manipulando listas

Para manipularmos listas no R, a sintaxe é similar a que utilizamos com vetores. Para nos referirmos aos elementos da lista, utilizamos [ ]. Veja exemplo a seguir.

lista01[3]
## [[1]]
## [1] 20 12 35 19 60

No entanto, na maioria dos casos, desejamos acessar o objeto guardado em determinada posição da nossa lista. Dessa forma, utilizamos [[ ]] para indexarmos. Digamos que você queira acessar o terceiro elemento do vetor v, armazenado na lista01. Sabendo que se trata de um vetor, basta fazer:

lista01[[3]][3]
## [1] 35

Como um segundo exemplo, vamos acessar a primeira linha do data frame df1, guardado na primeira posição da mesma lista.

lista01[[1]][1, ]

Assim como nos outros objetos que conhecemos até agora, podemos indexar uma lista através dos nomes de seus elementos. Isso torna o trabalho mais rápido quando temos que lidar com listas maiores. Para demonstrar o funcionamento, vamos criar uma lista02, com os mesmos elementos da lista01 , porém, nomeando os seus elementos. O data frame df1 será chamado de data_frame; a matriz01 será chamada de matriz; o vetor v será chamado de vetor.

lista02 <- list(data_frame = df1,
                matriz = matriz01, 
                vetor = v)

Vamos observar a estrutura da nossa lista02 agora:

str(lista02)
## List of 3
##  $ data_frame:'data.frame':  6 obs. of  8 variables:
##   ..$ nome   : Factor w/ 6 levels "Amanda","Fábio",..: 5 6 1 2 3 4
##   ..$ altura : num [1:6] 1.8 1.77 1.71 1.65 1.66 1.63
##   ..$ idade  : num [1:6] 22 21 18 20 23 19
##   ..$ sexo   : Factor w/ 2 levels "feminino","masculino": 2 2 1 2 1 2
##   ..$ peso   : num [1:6] 78.3 82.1 66.5 88.1 58 75.4
##   ..$ fumante: logi [1:6] TRUE FALSE FALSE FALSE TRUE FALSE
##   ..$ uf     : Factor w/ 5 levels "AL","CE","PB",..: 3 1 4 4 5 2
##   ..$ renda  : num [1:6] 2 5 10 20 10 NA
##  $ matriz    : int [1:10, 1:10] 1 11 21 31 41 51 61 71 81 91 ...
##  $ vetor     : num [1:5] 20 12 35 19 60

Para indexar o terceiro elemento da nossa lista (o vetor), o processo é bem mais simples e intuitivo. Basta digitarmos:

lista02$vetor
## [1] 20 12 35 19 60

Se desejar acessar a terceira linha da matriz guardada no segundo elemento da lista02, use:

lista02$matriz[3, ]
##  [1] 21 22 23 24 25 26 27 28 29 30

Bem mais simples, não?

NOTA: Para indexar uma lista, o R também permite usar a primeira letra do nome do elemento da lista. No entanto, recomendamos utilizar o nome completo, visando uma leitura mais fácil do código e evitar erros. Digite lista02$d no console e veja o que acontece.

11.3 Combinando e modificando listas

Começaremos a aprender a modificar listas no R fazendo exclusões de seus elementos. A forma mais simples de excluir elementos de uma lista é atribuindo NULL ao elemento que desejamos excluir. Vamos excluir o terceiro elemento da lista02.

lista02[[3]] <- NULL

length(lista02)
## [1] 2

Veja que, após atribuir NULL ao elemento 3 da lista, a lista passou a ter tamanho 2. Outra forma seria fazermos lista02[-3] e sobrescrever o objeto. É importante lembrar que, ao atribuir NULL a um ou mais elementos da lista, a lista é automaticamente modificada. Se quisessemos exibir todos os elementos exceto o terceiro, a forma mais prática é: lista02[-3].

Para combinarmos listas, o processo é similar à combinação de vetores. No exemplo seguinte, vamos criar duas listas e exibir a combinação das duas.

lista03 <- list(TRUE, "Tribunal", 20, pi)
lista04 <- list(FALSE, NULL, 45, "Contas")
c(lista03, lista04)
## [[1]]
## [1] TRUE
## 
## [[2]]
## [1] "Tribunal"
## 
## [[3]]
## [1] 20
## 
## [[4]]
## [1] 3.141593
## 
## [[5]]
## [1] FALSE
## 
## [[6]]
## NULL
## 
## [[7]]
## [1] 45
## 
## [[8]]
## [1] "Contas"

Outra função bastante útil para trabalharmos com listas é a unlist(). Essa função exibe os elementos da lista em forma de vetor. Vamos aplicá-la a lista04 e observar o resultado.

unlist(lista04)
## [1] "FALSE"  "45"     "Contas"

Existem diversas funções no R que podemos utilizar para aplicações mais avançadas com listas. Pacotes como o purrr trazem funções bastante úteis para manipular, sumarizar, modificar e combinar listas. No entanto, para o objetivo desse curso, as operações vistas até agora são suficientes.

12 INSTALANDO E CONHECENDO PACOTES DO R

12.1 O que é um pacote do R?

Até aqui utilizamos o que chamamos de Base R, ou seja, sintaxe e funções básicas do R usando apenas os pacotes padrões e pré-carregados. Ao digitar ?sum()no console, por exemplo, podemos ver que se trata de uma função do pacote {base}.

No entanto, um dos motivos que tem tornado o R bastante popular nos últimos anos foi o crescimento da sua comunidade de desenvolvedores e, consequentemente, de pacotes disponíveis para utilização. Atualmente o CRAN (Comprehensive R Archive Network) possui mais de 14 mil pacotes disponíveis, para as mais diversas aplicações. A utilização de alguns desses pacotes aumenta de forma acentuada a experiência com o R. Poderemos constatar que muitas das tarefas que vimos até então podem ser realizadas de forma mais simples, ágil e intuitiva utilizando funções específicas trazidas por determinados pacotes. Você inclusive pode fazer o seu próprio pacote!

Vamos então à resposta da questão: O que é um pacote?

Segundo Adler (Adler 2012):

Um pacote é um conjunto relacionado de funções, arquivos de ajuda e arquivos de dados que foram empacotados juntos. Pacotes em R são similares a módulos em Pearl, bibliotecas em C/C++ e classes em Java.

Para ver os pacotes carregados por padrão no R, use o comando seguinte:

getOption("defaultPackages")
## [1] "datasets"  "utils"     "grDevices" "graphics"  "stats"     "methods"

Se você deseja ver todos os pacotes disponíveis em sua biblioteca, utilize o comando library(). Para visualizar os pacotes carregados, use (.packages()).

12.2 Instalando pacotes no R

Uma vez que o repositório de pacotes está disponível na internet, o primeiro requisito para instalar pacotes no R é possuir uma conexão com a internet. Se você está usando o RStudio, instalar um pacote é bem simples, uma vez que já existe um repositório padrão. O segundo passo é saber o nome do pacote.

Você pode encontrar uma lista dos pacotes diponíveis no CRAN clicando aqui.

Vamos comecar instalando um dos pacotes mais famosos do R, o dplyr. Para instalar o citado pacote, basta fazer:

install.packages("dplyr")

Você visualizará o progresso de instalação no console.

Uma vez instalado, sempre que desejarmos utilizar uma função de um determinado pacote, devemos carregar o mesmo. Podemos fazer isso usando a função library(). Vamos carregar o pacote dplyr.

library(dplyr)

Utilize o comando (.packages()) para constatar que o pacote está carregado!

O carregamento de um pacote também pode ser feito através da função require()!

12.3 Descobrindo pacotes do R

Como já foi mencionado, o R possui milhares de pacotes disponíveis no CRAN. Não é raro pesquisarmos por alguma palavra-chave e encontrar dezenas, às vezes centenas, de resultados. O caminho mais fácil é ler um pouco sobre o que você deseja fazer no R para saber quais são as suas necessidades. Às vezes conseguimos fazer várias tarefas utilizando apenas um pacote; às vezes precisamos de bem mais. Tudo depende do problema que você deseja resolver! No entanto, há alguns pacotes já consolidados no R, com um número expressivo de downloads e de usuários. O site RDocumentation.org nos dá uma noção mais precisa sobre isso.

Podemos descobrir pacotes do R de várias formas, através de uma simples pesquisa no Google, de livros, sites especializados para desenvolvedores como StackOverflow e GitHub, blogs, cursos e etc.

Recentemente vários dos mais famosos pacotes do R foram reunidos em um único pacote chamado tidyverse (Para mais informações acesse tidyverse.org).

Pacote Breve descrição
dplyr Manipulação e transformação de dados
tidyr Manipulação e transformação de dados
readr Importação de vários tipos de arquivos (csv, tsv, fwf)
purrr Manipulação avançada de listas e vetores
ggplot2 Gráficos dos mais variados tipos
readxl Importação de planilhas excel (.xls, .xlsx)
lubridate Manipulação de dados em formato de data e/ou tempo
jsonlite Importação de dados em JSON
magrittr Provê a utilização de pipes (%>%)
xml2 Importação de dados em XML
rvest Utilizado para web scraping
heaven Leitura e escrita de arquivos SPSS, SAS e Stata
DBI Conexão a base de dados (MySQL, PostgresSQL, SQLite…)
data.table Leitura e escrita de grandes bases de dados
ggmap Mapas geográficos

Podemos ver a seguir um exemplo de aplicação do pacote ggmap.

mapa <- ggmap::get_map(location = "Brasil", zoom = 4, 
                language = "pt", maptype = "roadmap")
ggmap::ggmap(mapa)