Apostila Unidade 2 - Curso R

Capítulo 2
Aula 2 Básicos da Sintaxe do R
João Pedro Figueira Amorim Parga

Fundação João Pinheiro
11
12
Introdução
Este documento foi criado para ser uma referência inicial aos alunos do Curso de R da Fundação
João Pinheiro (FJP), como uma iniciativa do projeto de Transformação Digital da Diretoria de Es
tatística e Informações (DIREI). Em linhas gerais, este curso apresenta os conceitos fundamentais
da linguagem R e serve de guia para os primeiros passos na utilização do RStudio para a análise de
dados.
No primeiro capítulo, é feita uma breve recaptulação do R e sua história. No segundo, são apre
sentadas noções básicas de R, sobretudo seu uso por meio do RStudio, por exemplo: a utilização
do Console, como realizar operações matemáticas, como designar objetos, como executar coman
dos no R (introdução às funções), onde conseguir ajuda, as principais referências para a Ciência
de dados no R, como executar Scripts e o que são pacotes e como utilizálos. O terceiro capítulo,
por fim, concentrase no principal objeto do R: o vetor. São apresentados os conceitos básicos de
vetores, como criálos, utilizálos, seus tipos, suas propriedades, como selecionar seus elementos,
entre outros aspectos. O capítulo foca principalmente em vetores atômicos, por ser o mais básico
dos vetores, porém também são apresentados breves conceitos de vetores recursivos, isto é, listas.
Este documento foi criado no próprio RStudio, por meio do pacote rmarkdown, com base em diver
sas referências sobre a linguagem R, em especial os trabalhos de Wickham (2015a), Peng (2015),
Wickham e Grolemund (2017) e Long e Teetor (2019), assim como a documentação oficial da lin
guagem R (2019b).

Alameda das Acácias, 70, São Luiz, Belo Horizonte – MG
www.fjp.mg.gov.br
13
2.1 Recaptulação: História do R

Este capítulo apresenta uma breve revisão da história do R, de acordo com o trabalho de Peng
(2015).
• O que é R?
R é um dialeto de S.
S, por sua vez, é uma linguagem de computação desenvolvida nos anos 1970 como um ambiente de
análise estatística, criada com os objetivos de tornar análise de dados mais simples e descomplicada,
além de ser capaz de oferecer funcionalidades mais comumente associadas à uma linguagem de
programação.
• A Filosofia da linguagem S
A filosofia por trás da linguagem S ajuda a compreender o funcionamento e a estrutura do R. Em

linhas gerais, a linguagem foi feita para atender tanto os usuários casuais quanto os desenvolve
dores. Em sua criação, a linguagem foi concebida para que, à medida em que o conhecimento e a
sofisticação das necessidades dos usuários aumentassem, eles seriam capazes de encontrar e utilizar
as ferramentas mais comumemnte associadas a outras linguagens de programação. Assim, a lingua
gem [S] foi feita para se adequar à análise interativa de dados (i.e. baseada em simples comandos
em linhas) assim como ao desenvolvimento de programas mais longos (associados à linguagem de
programação tradicional).
2.1.1 R
Como dito, R corresponde a um dialeto do S. R é um software livre, o que representa uma de suas
principais características e permite o livre acesso ao código fonte do sistema a qualquer pessoa.
Isto, por sua vez, possibilita as diversas contribuições e melhorias ao seu funcionamento, isto é, o
desenvolvimento de novas funcionalidades por parte dos próprios usuários.
Em comparação a outros pacotes estatísticos, outra vantagem do R é sua capacidade de criar gráficos
com qualidade de publicação. O seu sistema base de gráficos permite o controle de praticamente
todos os aspectos destes objetos.
Atualmente, as semânticas das linguagens R e S não são tão semelhantes. Porém, a filosofia inicial
deste permanece naquele, isto é, a linguagem em R é útil para o manuseio interativo de dados, além
de ser robusta o suficiente para o desenvolvimento de novos instrumentos de análise. Isto permite
aos usuários, que incialmente aplicam as ferramentas existentes na análise de dados, desenvolverem
seus próprios instrumentos, que podem servir à toda comunidade do R.

www.fjp.mg.gov.br
14
Como resultado destes fatores, a comunidade de usuários de R é bastante ativa, com contribuições
de pessoas ao redor do mundo, que desenvolvem e ajudam outros indivíduos a resolverem seus
problemas.
2.1.2 O Sistema R
O sistema R pode ser divido em duas porções:
1. O sistema “base” do R, que pode ser baixado no Comprehensive R Archive Network (CRAN);
2. Todo o resto (incluindo os pacotes desenvolvidos por diversas fontes).
As funcionalidades do R e todas as tarefas que podem ser executadas a partir de seu sistema são
divididas em pacotes. O sistema “base” do R, incluído no download do programa no CRAN, contém
o pacote base, necessário para rodar o R e que abrange suas funções mais fundamentais, assim como
outros pacotes, que podem ser vistos aqui.
Contudo, dada a sua natureza de software livre, uma das principais vantagens do R é possibilitar
a expansão das funcionalidades originais de seu programa, a partir de intervenções dos usuários.
Estas intervenções se dão por meio de pacotes criados pelos próprios usuários e submetidos ao
CRAN (e em sites pessoais, que podem ser baixados por meios além do usual, comentado adiante).
2.1.3 RStudio
RStudio é um software de programação em R, caracterizado como um Ambiente de Desenvolvi

mento Integrado (Integrated Development Environment IDE, em inglês). Em síntese, ele repre
senta um ambiente em que não só os códigos escritos em R podem ser executados, como todos
os aspectos da programação nesta linguagem são contemplados, por exemplo: obtenção de ajuda,
plotagem de gráficos, gerenciamento de arquivos, visualização interativa de sistemas, etc. Como
destacado em Gillespie and Lovelace (2017), é altamente recomendável a utilização do RStudio
para a programação em R, dado que este programa é gratuito, encoraja boas práticas de programa
ção e, fundamentalmente, facilita bastante o uso de seus usuários, aumentando sua produtividade e
eficiência.
Este curso foi desenvolvido para o uso do RStudio, contando com várias de suas especificidades,
como atalhos para digitação, facilidade de visualização dos objetos, menus interativos, etc. Para
mais detalhes, consultar o site oficial do RStudio.

www.fjp.mg.gov.br
15
2.1.4 Considerações
Feita esta recaptulação do R e sua história, no capítulo seguinte são abordados os aspectos básicos
da sintaxe do R e do RStudio, como a inserção de comandos e funções para serem executados,
operadores matemáticos básicos, as referências de documentação da linguagem e como conseguir
ajuda, como utilizar pacotes, etc.

www.fjp.mg.gov.br
16
2.2 Introdução ao R e RStudio: noções básicas
2.2.1 Executando comandos: Console
Localizado no painel esquerdo do RStudio, o Console corresponde ao local de inserção de códigos

de comandos para serem executados, de visualização de seus resultados e de exibição de mensagens
do R.1 Ao inserir uma expressão no Console, ela é avaliada pelo R e o seu resultado é retornado no
próprio Console.
Figura 2.1: RStudio: Console
Abaixo, alguns caracteres importantes para o Console:
• > marca o início de uma linha;

• + marca a continuação de uma linha;
• # marca o início de um comentário, i.e., tudo ao lado direito de # (assim como o próprio #) não
será interpretado como código para ser avaliado pelo R e, consequentemente, será ignorado
pelo programa e não será executado;
1
Ao executar o R, no lugar do RStudio, o Console corresponde à única janela visível; o RStudio adiciona todas os outros
componentes para facilitar a utilização do R.

www.fjp.mg.gov.br
17
• ' e " (aspas) são caracteres utilizados para escrever elementos (strings) e objetos (vetores de
caracteres) que não são interpretados como números no R (ex.: 'palavra', 'Esta é uma
expressão', "2 é um número", etc);
• : cria sequências de valores;
• <- é o símbolo de designação de objetos.
Para executar um comando no Console, devemos digitálo e pressionar a tecla Enter.

Como primeiro exemplo, iremos executar uma operação de adição básica, escrevendo os números
que devem ser somados (no caso, 2 e 3), separados pelo operador de adição, +:
# Operação de adição
2 + 3
## [1] 5
O número entre colchetes ([1]) não faz parte do objeto em si, apenas revela que este é o primeiro
valor de seu resultado. Alguns comandos geram mais de um valor, de modo que seus resultados
podem encher mais de uma linha no Console. Veremos sobre isso no Capítulo seguinte, sobre
Objetos, especialmente ao criarmos vetores.
O R demanda que sejam inseridos elementos no Console até que uma expressão seja escrita por
completo. Se uma expressão incompleta for inserida, o sinal exibido no Console passa de > para
+, indicando que é necessário completála, ou seja, que você ainda não digitou tudo o que deveria.
Geralmente, isto significa que você esqueceu algum sinal, como fechar as expressões marcadas por
", ' ou ). Insira o caractere faltante ou clique em Esc para abortar a expressão e começar novamente.
Na expressão abaixo, utilizase a função max() para obter o valor máximo de um conjunto de
números contidos entre parênteses.
> max(1,2,3,4,5,5,6
+
Como pode ser visto, é necessário completar a expressão com o ) faltante:
# Completando uma expressão

max(1,2,3,4,5,5,6)
## [1] 6
Além disso, os sinais de operação devem ser escritos ao fim de uma linha, e não no começo.

www.fjp.mg.gov.br
18
> # Sinais de operação ao fim de cada linha

> 10 - 9 - 8 -
+ 7 -
+ 6 -
+ 5 - 4 - 3 - 2 -
+ 1
## [1] -35
2.2.1.1 Histórico de comandos
No Console, podemos acessar os comandos previamente executados na sessão presente do R. Di

gitando a seta para cima (↑) no Console, o histórico de comandos executados é disposto na linha
de inserção de códigos do própio Console. O histórico pode ser então navegado a partir das setas
para cima e para baixo (↑ e ↓). Para visualizar em uma pequena janela o histórico de comandos,
pressionar Ctrl + ↑ (navegando com as setas para cima e para baixo), como na figura abaixo.
Figura 2.2: Histórico de comandos Console
Além disso, no quadrante superior direito do RStudio (ao lado de Environment), o histórico de
comandos pode ser acessado pela aba History. O comando history() também acessa esta aba,
especificando a quantidade dos últimos comandos a serem exibidos entre partênteses. Exemplo:
exibir os últimos 10 comandos do histórico:
# Exibir os últimos 10 comandos do histórico

history(10)

www.fjp.mg.gov.br
19
Figura 2.3: Aba History Quadrante superior direito
2.2.2 Operações matemáticas básicas

Em sua forma mais básica, o R pode ser usado como uma simples calculadora, para realizar opera
ções aritméticas, como nos exemplos abaixo.
# Adição: +
5 + 5
## [1] 10
# Subtração: -
5 - 5
## [1] 0
# Multiplicação: *
(3 + 2) * 5
## [1] 25
# Exponenciação: ^ ou **
2 ^ 5
## [1] 32

www.fjp.mg.gov.br
20
2 ** 5
## [1] 32
# Divisão: /
20 / 8
## [1] 2.5
# Divisão inteira (fornece apenas a porção inteira do resultado da divisão): %/%

20 %/% 8
## [1] 2
# Resto da divisão (restante da divisão do número da esquerda pelo número da direita): %%

20 %% 8
## [1] 4
2.2.3 Designação de Objetos (Introdução à Objetos)
Um objeto (variável) é um dos conceitos mais importantes em linguagens de programação. Em R,

um objeto corresponde a um conjunto de dados, que podem ser organizados em tipos de estruturas
específicas. Simplificadamente, um objeto permite salvar dados, organizados em estruturas distin
tas (como valores, palavras, gráficos, imagens, funções, combinações destes elementos, etc) em um
elemento, que ficará contido no sistema e disponível para uso, quando necessário. Para se fazer
referência, e uso, de um objeto, utilizase seu nome, composto por símbolos (caracteres).2
Como destacado, o comando de designação de objetos é <-.3 A expressão de designação (de um
valor, por exemplo) a um objeto possui a seguinte estrutura:
nome_do_objeto <- valor_do_objeto
2
No R, contudo, estes símbolos também são objetos e podem ser manipulados da mesma forma que quaisquer outros.
Veremos isto em vetores de caracteres (do tipo Character).
3
O sinal = também pode ser utilizado na designação de um objeto, de modo que, na maior parte dos contextos (porém
não todos), estes sinais podem ser usados indiscriminadamente. Porém, o sinal = também é utilizado para passar
argumentos em uma função (explicado mais adiante), o que pode gerar confusões. Assim, é sugerida a utilização de
<-.

www.fjp.mg.gov.br
21
que pode ser interpretada como: “criase um objeto (no caso um vetor unitário de valor
valor_do_objeto) e a este objeto é atrubuído um nome (nome_do_objeto)”. Ao fazer isso, o
objeto “nome_do_objeto” será salvo no espaço de trabalho atual da memória do R (no painel
“Enviroment”, à direita da tela do RStudio), contendo o valor a ele atribuído pela expressão.
Dica: atalho para o símbolo <-:
• Alt + - : pressionar a tecla Alt juntamente com a tecla - (o sinal de menos).
Este comando gera <- com espaços imediatamente antes e depois do símbolo, o que facilita e agiliza
a digitação.
Dito isto, iremos começar com o básico: criar um objeto (x) e atribuir a ele um valor númerico
simples (o número 5):
# Atribuir o valor 5 ao objeto x

x <- 5
Com isto, o objeto será salvo no Environment. Para que o valor contido no objeto seja exibido,
simplesmente digite o seu nome.4
# Exibir o objeto criado no Console

x
## [1] 5
Ao escrever uma expressão de designação, para que o valor do objeto seja exibido no Console
juntamente com a expressão, escrevêla entre parênteses:
# Designar um valor a um objeto e exibí-lo simultaneamente

(y <- 10)
## [1] 10
O valor contido em um objeto pode ser modificado a qualquer momento. Simplesmente faça outra
operação de designação com o seu nome e um novo valor. Exemplo:
4
A função print() pode ser utilizada para este propósito, mas não é usual, já que é mais fácil simplesmente digitar o
nome do objeto. Geralmente, esta função é utilizada na criação de outras funções, quando há a necessidade explícita
de exibir o objeto.

www.fjp.mg.gov.br
22
# Modificar o valor de um objeto: simplesmente fazer outra operação de designação

x <- 3 ^ 2
x
## [1] 9
Assim, ao objeto x é designado um novo valor (3 ^ 2 = 9: 3 elevado a 2, igual a 9). O novo

valor é salvo na memória do R, o que, como sabemos, pode ser visto no Environment, à direita do
RStudio.
2.2.3.1 Como nomear um objeto
Os nomes dos objetos podem conter somente os seguintes caracteres:
• Letras
• Números (dígitos)
• _ (underline)
• . (ponto)
e não podem começar com:
• _ (underline)
• Número (dígito)
• . seguido de um dígito
Dica: dê nomes claros e descritivos aos objetos (ex.: microdados_pnad_2010, para uma base de
dados contendo os microdados da PNAD de 2010; vetor_anos_1990_2010, para um vetor que
contém os anos dentro do intervalo desejado, etc).
OBS.: a linguagem R é sensível a letras Maiúsculas e minúsculas. Assim, ao designar um objeto,
a forma com que o seu nome é escrito importa.
Objeto <- 10 ^ 2
Objeto
## [1] 100

www.fjp.mg.gov.br
23
objeto <- 2 + 2
objeto
## [1] 4
Como visto, Objeto e objeto contêm valores distintos e representam objetos distintos.
2.2.3.2 Utilizando objetos
Ao designar valores aos objetos, podemos utilizálos para diversos propósitos. Como exemplo,
supomos que desejamos contar a quantidade total de horas/aula deste curso e a quantidade de ho
ras/aula concluídas até o momento:
# Objetos contendo o total de horas/aula do curso e o montante concluído até o momento

horas_aula_total <- 32
horas_aula_concluidas <- 2
Ao criar estes objetos, podemos obter a quantidade de horas/aula restantes até a conclusão do curso:
# Obter a quantidade de horas/aula restantes

horas_aula_total - horas_aula_concluidas
## [1] 30
# Criar objeto contendo a quantidade de horas/aula restantes

(horas_aula_restantes <- horas_aula_total - horas_aula_concluidas)
## [1] 30
2.2.4 Funções (noções básicas)

Recaptulando: Toda vez que escrevemos algo no Console, o R irá avaliar a expressão digitada e
exibir o seu resultado, de acordo com o que foi escrito e o funcionamento da própria linguagem.
As operações matemáticas utilizadas até aqui (adição, subtração, etc) podem ser vistas como fun
ções, isto é, representam comandos que realizam uma tarefa específica de acordo com um código.
Simplificadamente, as funções no R possuem a seguinte estrutura:
nome_da_função(lista_de_argumentos)

www.fjp.mg.gov.br
24
Os argumentos identificam os dados que serão transformados e representam especificações que

modificam a maneira com que as funções são desempenhadas. Assim, “passamos” argumentos
nas funções (i.e., incluímos as especificações desejadas) para que possamos obter os resultados de
acordo com nossas necessidades. A lista_de_argumentos corresponde a uma lista, separada por
vírgulas (,) dos argumentos de uma função. Por exemplo:
exemplo_função(argumento1 = valor_argumento1, argumento2 = valor_argumento2)
Um argumento pode ser um símbolo, que contém um valor específico (ex.: argumento1 =
valor_argumento1) ou o argumento especial ‘...’, que pode conter qualquer número de
argumentos (geralmente, o argumento especial é encontrado em funções em que a quantidade de
argumentos que será passada é desconhecida). Algumas funções possuem valores padrões em seus
argumentos, ou seja, valores/atributos que serão “passados” na função se nenhum outro valor for
especificado (ex.: argumento1 = default). Usualmente, os valores padrão são os valores mais
comuns que especificam um argumento de uma função.
Em linhas gerais, os argumentos da funções se dividem em duas categorias:
1. Os dados (data), que especificam onde a função será executada;

2. Os argumentos suplementares, que especificam como a função será executada, i.e., seus de
talhes.
Por exemplo, a função log() (que será mencionada posteriormente) possui dois argumentos: x
representa os dados e base a base em que o logaritmo é computado.
Como mencionado anteriormente, o sistema base do R possui um conjunto de funções, capazes de
desempenhar as funcionalidades mais fundamentais da linguagem. Podemos, por exemplo, obter o
valor máximo de um conjunto de números, com a função max().
max(1, 2, 3, 10, 50, 100)
## [1] 100
OBS.:: Em grande parte das funções, os argumentos não precisam ser especificados por nome. Ou
seja, pode se utilizar uma função da seguinte maneira:
exemplo_função(valor1, valor2)
o que irá executar a função exemplo_função passando os valores valor1 e valor2 aos argumentos
argumento1 e argumento2, respectivamente. Para “passar” um argumento, respeitase a ordem
dos argumentos encontrados na documentação da função.
O exemplo abaixo contém uma função para inserir dados de uma planilha .csv no R, com e sem a
especificação de seu primeiro argumento, file =.

www.fjp.mg.gov.br
25
# Não especificar o argumento `file = `

read_csv("meu_arquivo_csv.csv")
# Especificar o argumento `file = `
read_csv(file = "meu_arquivo_csv.csv")
• Dica: especificar os argumentos das funções ajuda a compreensão do código para outros
usuários. Em um momento inicial, recomendase adotar esta prática.
2.2.5 Erros e ajuda: como e onde obter
A frustração é comum ao se começar a programar em R, em função do caminho natural para o

entendimento do funcionamento da linguagem e da atenção necessária aos detalhes requeridos para
fazer qualquer comando ser executado (WICKHAM, GROLEMUND (2017); LONG, TEETOR
(2019)). Assim, é preciso acostumarse com um pequenos percalços que irão aparecer no caminho.
Porém, estas dificuldades são inerentes ao processo de aprendizado, ou seja, acontecem à todos,
além de tenderem a diminuir: a única maneira de superálas é praticar.
Dito isto, existem alguns meios de conseguir uma melhor compreensão do funcionamento da lin
guagem, suas funções e como resolver os problemas que irão aparecer (quaisquer que sejam seus
níveis de complexidade). As tarefas e funcionalidades simples são relativamente fáceis quando se
sabe o que fazer, mas descobrir “o que fazer” pode ser enlouquecedor. Mencionamos, abaixo, os
guias internos ao RStudio e, em seguida, as principais referências externas e os meios de se obter
esclarecimentos sobre problemas intrínsecos ao aprendizado do R e sobre questões pontuais, que
irão aparecer à medida em que se usa a linguagem.
2.2.5.1 Ajuda Interna (RStudio): help e ?
A seção de ajuda interna ao RStudio pode ser acessada pelo comando help(). Com ele, pode se
consultar a definição e o funcionamento de uma função, por exemplo. Para isto, deve se escrever
help(nome_da_função)
no Console. No RStudio, este comando abre a aba Help, no painel direito inferior do programa.
Dica: O comando ? é um atalho para o comando help(). Digitar
? + nome_da_função
para obter a ajuda do R, igualmente à help(nome_da_função).
Exemplo: Obter a ajuda da função max()

www.fjp.mg.gov.br
26
# Usando `help()`
help(max)
## starting httpd help server ... done
# Usando `?`
?max
Dica: use o comando args() para obter os argumentos de uma função. Use example() para ver
os exemplos de uso de uma função encontrados na documentação do próprio R.
# Obter os argumentos da função `max()`

args(max)
## function (..., na.rm = FALSE)

## NULL
Como vemos, a função max() contém o argumento especial ‘...’, o que significa que podemos in
cluir uma quantidade qualquer de valores numéricos dentro de seus parênteses, para serem avaliados
(i.e., para se definir qual possui o maior valor).
# Ver o exemplo de aplicação da função `max()`

example(max)
2.2.5.2 Ajuda Externa: referências, documentação oficial e canais úteis
Além da ajuda interna, outras fontes de ajuda para introduzir e aprofundar os conhecimentos da
linguagem são a documentação oficial do R e referências produzidas por autores/usuários (livros
texto, cursos online, etc). Estes recursos servem de auxílio na solução de problemas do diaadia e
são extremamente úteis na consulta de dúvidas.
• Cursos e materiais
– Introduction to R Datacamp: curso introdutório ao R do Datacamp. Bom ponto de

partida, por ser gratuito e apresentar os conceitos e fundamentos na prática;
– CursoR: material de aprendizado online, gratuito e em português, de R;

www.fjp.mg.gov.br
27
– Manipulação e Visualização de Dados: material online, em português, feito por Wal

mes Marques Zeviani, professor do departamento de Estatística da UFPR, sobre ma
nipulação e visualização de dados, com enfoque no conjunto de pacotes tidyverse
(referência na Ciência de Dados com o R).
• Livrostexto
– R for Data Science: livro referência sobre a utilização de R para Ciência de Dados
(contendo os principais pacotes utilizados neste curso);
– R Programming for Data Science: livro sobre os fundamentos do R sob a perspectiva
da Ciência de Dados;
– R Cookbook: guia de “receitas” solução de problemas no R. Indicado para qualquer
usuário, já que o nível de dificuldade das tarefas aumenta ao longo do livro, começando
dos problemas mais básicos até os mais complexos;
– HandsOn Programming With R: guia prático para aprender a programar em R;
– R Graphics Cookbok: guia de receitas (semelhante ao R Cookbook) de gráficos no R;
– Efficient R Programming: guia avançado para tornar a programação e a escrita de có
digos em R mais eficiente;
– Advanced R: guia avançado para usuários de R entenderem melhor o funcionamento da
linguagem e escreverem códigos mais eficientes.
• Páginas oficiais
– R Language Definition: documentação e guia da linguagem do R. Bom para entender

as definições oficiais da linguagem;
– An Introduction to R: guia de introdução do R (para iniciantes, começar do Apêndice
A);
– Pacote tidyverse: página do conjunto de pacotes tidyverse, contendo exemplos,
aplicação das funcões, etc;
– Pacote ggplot2: página do pacote ggplot2, principal instrumento na criação de gráfi
cos no R.
• Cheatsheets (folhas de referência)
– RStudio Cheatsheets
• Canais de dúvida: Stackoverflow e outras fontes
Como usuário do R, é imperativo tornarse familiarizado com os recursos existentes na internet para
a solução de dúvidas. Por ser um software livre, uma das principais características do R é a interação
entre os seus usuários na comunidade. O canal mais utilizado de dúvidas é o Stackoverflow, uma

www.fjp.mg.gov.br
28
comunidade aberta de comunicação entre programadores. A comunidade do R neste canal é bastante

ativa, o que tornase um grande auxílio no aprendizado da linguagem.
Como consequência do tipo de linguagem (livre) e da expansão acelerada da comunidade nos últi
mos anos, observase que é muito improvável ser a primeira pessoa a vivenciar um problema/erro
ou ter dificuldade com alguma questão específica. Na maioria dos casos, outros usuários já viven
ciaram as mesmas dificuldades que você. Dado que a comunidade do R é bastante ativa, é comum
encontrar respostas para a maior parte das dúvidas, por mais simples ou específicas que elas sejam.
Assim, é essencial acostumarse a fazer buscas nos sites especializados (ex.: Stackoverflow) para
esclarecer as questões existentes.
O site RBloggers é outra boa fonte de referências sobre o R, organizado no formato de blog, com
posts dos usuários sobre questões pertinentes, boas práticas da utilização da linguagem, etc.
Como exemplo de como solucionar uma dúvida, iremos conferir os argumentos de uma função, a
partir do comando help(), e utilizála. Além disso, veremos como obter possíveis soluções para
um erro obtido no R ao executar um comando, a partir de uma busca de respostas na internet.
2.2.5.3 Exemplo ajuda interna: arredondar valores
Como exemplo de aprender a ler a documentação de uma função e utilizála, iremos arredondar
valores. Primeiramente, iremos partir da função round(). Assim, obter a ajuda interna do RStudio,
por meio do comando help().
# Abrir a janela de ajuda da função `round`

help(round)
O comando acima nos leva à página interna de ajuda de funções utilizadas para arredondar valores
númericos (Rounding of Numbers). São apresentadas as seguintes funções:
• ceiling(), que arredonda o valor desejado para cima;

• floor(), que arredonda o valor desejado para baixo;
• trunc(), que retorna apenas o número inteiro do valo desejado;
• round(), que arredonda e retorna o valor do primeiro argumento para a quantidade de casas
decimais desejadas;
• signif(), que arredonda e retorna o valor do primeiro argumento para a quantidade de dí
gitos desejados.
Pela descrição da função round(), vemos que ela arredonda os valores do primeiro argumento à
quantidade de casas decimais especificadas, sendo o padrão (default) igual a 0.5 Para ver os seus
argumentos, podemos utilizar o comando args(), como visto anteriormente.
5
“round rounds the values in its first argument to the specified number of decimal places (default 0).”.

www.fjp.mg.gov.br
29
# Ver os argumentos da função `round`

args(round)
## function (x, digits = 0)

## NULL
O argumento x indica o vetor numérico a ser arredondado. O argumento digits, para a função
round(), indica o número de casas decimais que será utilizada no resultado final.
Dito isto, podemos arredondar o número 3.1455.
# Arredondar 3.1455 com o argumento padrão (digits = 0)

round(3.1455)
## [1] 3
# Arredondar 3.1455 para duas casas decimais

round(3.1455, digits = 2)
## [1] 3.15
OBS.: Como visto, no R, as casas decimais dos números reais são especificadas por . (ponto), e
não por , (vírgula), como em português. Mais detalhes sobre isto, na seção Numéricos (Numeric),
no capítulo seguinte.
Além disso, nos detalhes da documentação da função (Details), vemos que ao arredondar o valor 5,
a função round() o faz em direção ao número par (even digit). Isto pode ser visto pelas aplicações
abaixo.
# arredondar valores `5`

round(0.5)
## [1] 0
round(1.5)
## [1] 2

www.fjp.mg.gov.br
30
round(4.115, digits = 2)
## [1] 4.12
Além disso, podese arredondar para potências de dez, especificadas no argumento ‘digits =’
como um número negativo. Por exemplo, round(x, digits = -2) arredonda para a centena
mais próxima.
# Arredondar para uma potência de dez

round(131, digits = -2)
## [1] 100
round(5.7, digits = -1)
## [1] 10
Podemos explorar o comportamento das outras funções (ceiling() e floor()) testando os resul
tados obtidos para os números 0.05, 1.1 e 1.5.
# Ceiling
ceiling(0.05)
## [1] 1
ceiling(1.5)
## [1] 2
ceiling(-1.1)
## [1] -1
# Floor
floor(0.05)
## [1] 0

www.fjp.mg.gov.br
31
floor(1.5)
## [1] 1
floor(-1.1)
## [1] -2
2.2.5.4 Exemplo ajuda externa: listar (ls()) e remover (rm()) objetos
• Listando objetos salvos (Environment)
Podemos verificar quais objetos estão salvos no Enviroment, utilizando a função ls().
# Listando objetos presentes no Environment
ls()
## [1] "carregar" "colorize" "def.chunk.hook"

## [4] "horas_aula_concluidas" "horas_aula_restantes" "horas_aula_total"
## [7] "objeto" "Objeto" "pacotes"
## [10] "x" "y"
• Removendo objetos salvos (Environment)
Por meio da função rm(), podemos remover objetos do Environment. Isto é importante para deixar
o espaço de trabalho mais organizado e “limpar” a memória do R, principalmente em um nova seção
de análise de dados, um projeto distinto, etc. Para remover um objeto, simplesmente incluir o seu
nome dentro dos argumentos da função rm():
# Remover os objetos 'objeto' e 'Objeto'
rm(objeto, Objeto)
# Verificar o resultado (Environment)

ls()
## [1] "carregar" "colorize" "def.chunk.hook"

## [4] "horas_aula_concluidas" "horas_aula_restantes" "horas_aula_total"
## [7] "pacotes" "x" "y"
Feito isto, supomos que, por descuido, tentemos remover novamente o objeto objeto do Environ
ment.

www.fjp.mg.gov.br
32
# Remover um objeto inexistente

rm(objeto)
Como visto, a seguinte mensagem será exibida no Console:
Figura 2.4: Mensagem de erro Console
A partir disso, além de consultar os guias e referências mencionadas anteriomente, é extremamente

comum solucionar os problemas encontrados no R a partir de buscas na internet, i.e., buscas no
Google. Para isto, podemos:
• Inserir a mensagem de erro exibida no Console a partir da execução do comando; ou
• Fazer uma pesquisa descrevendo o problema em questão. Por exemplo: ‘r how remove object
environment’, indicando que procuramos alguma página relativa ao R sobre como remover
objetos do Environment.
Seguindo a primeira opção e copiando literalmente a mensagem de erro do Console (Warning

message: In rm(objeto) : object 'objeto' not found), obtive os seguintes resultados:
A primeira página corresponde a uma questão submetida ao Stackoverflow, sobre o que a menesa
gem de erro "Error: object '<myvariable>' not found' significa (obtida a partir da apli
cação da função mean(), no caso), o que se assemelha ao erro encontrado a partir da aplicação da
função rm() em um objeto não encontrado pelo R.
No Stackoverflow, os usuários votam nas melhores respostas (mais explicativas, mais completas,
que resolvem o problema de uma maneira mais elegante, etc). É comum encontrar explicações
relativamente detalhadas para problemas aparentemente simples e comuns, como neste caso.

www.fjp.mg.gov.br
33
Figura 2.5: Mensagem de erro Resultado da busca no Google

www.fjp.mg.gov.br
34
Figura 2.6: Mensagem de erro Questão submetida ao Stackoverflow
A resposta mais votada para a questão exposta acima apresenta a razão do erro ter ocorrido (i.e., o
R não conseguiu encontrar a variável mencionada no comando) além de modos para checar se uma
variável existe (utilizando a função ls(), apresentada anteriomente, e outra, exists()), possíveis
razões para outros erros desta natureza, referências para consultas mais avançadas, na documentação
do R e no livro Advanced R (citado nas referências), entre outros aspectos.
Como visto, portanto, é fundamental acostumarse a buscar respostas na internet aos problemas
encontrados no R. Além disso, só tentando executar os códigos, implementar as funções, etc, que
aprendemos a utilizar a linguagem.
• Dica Removendo todos os objetos do Environment: A função rm() possui o argumento

list =, que consiste em um vetor de caracteres nomeando as variáveis que serão removidas.
Combinando a função ls(), que retorna um vetor de todas as variáveis salvas no Environ
ment atual, com rm(), podemos remover todos os objetos salvos na memória corrente do R,
utilizando o comando:
# Remover todos os itens do Environment atual

rm(list = ls())

www.fjp.mg.gov.br
35
Figura 2.7: Mensagem de erro Resposta mais votada no Stackoverflow
2.2.6 Scripts
Até o momento, aprendemos a executar os códigos do R no Console. Porém, quando temos um

conjunto de comandos relativamente longos ou utilizados com maior frequência, tornase laborioso
adotar esta forma de organização do fluxo de trabalho em função do retrabalho envolvido nesta
prática. Dito isto, a organização padrão de um fluxo de trabalho no R envolve a utilização de
Scripts.
Um Script é um arquivo que contém um conjunto de códigos e comandos que podem ser acessados
e excecutados facilmente, tornando o fluxo de trabalho no RStudio mais eficiente. Ao utilizar o
RStudio, os códigos contidos nos scripts podem ser executados individualmente ou em conjunto.
Para criar um script no RStudio, clicar em File → New File → R Script, como na imagem abaixo,
ou utilizar o atalho Ctrl + Shift + N.
Com isso, o quadrante esquerdo do RStudio será dividido verticalmente em dois: a parte superior
comporta o editor de scripts e a inferior o Console.

www.fjp.mg.gov.br
36
Figura 2.8: Criação de script no RStudio

www.fjp.mg.gov.br
37
Figura 2.9: RStudio: interface após criar um script
2.2.6.1 Executando comandos
Assim como no Console, o símbolo # marca o início de um comentário em um script. Tudo a sua
direita, portanto, será ignorado pelo R ao executar um comando. Se posicionarmos o cursor em
uma linha iniciada por um comentário, o R irá ignorála e executar a linha subsequente que contém
um código executável.
Diferentemente do Console, no Script, a tecla Enter não executa um comando, apenas quebra uma
linha (i.e., adiciona um parágrafo no Script). Isto é bastante útil para comandos ou funções longas,
que dependem de muitos argumentos, pois permite tornar o código mais legível para outros usuários
(afinal, os códigos não devem ser apenas avaliados e executados pelo computador, como também
entendidos pelos outros usuários que forem utilizálos).
A maneira mais eficiente de executar um comando individualmente é usar o atalho Ctrl + Enter,
que executa a linha ou seleção corrente. Para tanto, posicione o cursor em qualquer posição da
linha desejada e pressione o atalho (Ctrl + Enter). O mesmo pode ser atingido pelo ícone Run no
quadrante do Script.
Ao executar um comando do script, o comando e seu respectivo resultado serão exibidos no Console.
Se houver uma necessidade de exectuar um comando que se estende por várias linhas, você pode

www.fjp.mg.gov.br
38
Figura 2.10: Run: resultado após executar a linha 2 do Script
posicionar o cursor em apenas uma delas e pressionar Ctrl + Enter ou selecionar todas as linhas
e fazer o mesmo.
# Criar o objeto `z` (soma de 1, 2 e 3), em um comando que se estende por três linhas do script
z <- 1 +
2 +
3
z
## [1] 6
Para executar todos os comandos de um script, clicar no ícone Source ou digitar o atalho Ctrl +
Shift + S.
Para que os resultados de execução de um script inteiro sejam exibidos no Console, clicar na seta
ao lado de Source e clicar em Source with echo ou usar o atalho Ctrl + Shift + Enter.

www.fjp.mg.gov.br
39
Figura 2.11: Run: resultado após executar o comando das linhas 5, 6 e 7 do Script
2.2.6.2 Salvando um script
A grande vantagem de utilizar Scripts é salvar a forma com que se obtém os resultados desejados,
no lugar dos própios resultados. Ou seja, em muitas situações, é prático salvar o Script (contendo
os códigos necessários para realizar tarefas específicas) no lugar de salvar os objetos contidos no
Environment.
Para salvar um script, clicar em File → Save As…, escolhendo o diretório em que o arquivo será
guardado. Uma vez definido o local e escolhido o nome do script, clicar em File → Save ou utilizar
o atalho Ctrl + S para salvar o arquivo corrente. O script possui a extensão .R e pode ser aberto
por editores de texto padrão (Bloco de Notas/Notepad, Sublime Text, etc).
2.2.7 Pacotes
Como destacado anteriormente, o R possui um conjunto de funções incluídas na base de seu sis
tema, que são carregadas automaticamente no R/RStudio e que podem ser executadas sem nenhum
requerimento adicional. Contudo, uma das principais características do R é a interação entre os
usuários de sua comunidade. Assim, os próprios usuários podem desenvolver novas funções para
desempenhar diferentes funcionalidades no R e compartilhálas com outros pessoas. Os Pacotes

www.fjp.mg.gov.br
40
Figura 2.12: Source: Resultado após executar script inteiro
(Packages) correspondem às unidades fundamentais de compartilhamento de códigos e funções no

R (WICKHAM (2015b)). Um pacote reune códigos, isto é, funções que executam tarefas específi
cas, dados, documentação de seu funcionamento e testes para a sua execução.
No momento de escrita deste material (dezembro de 2019), existem mais de 15.000 pacotes dis
poníveis no CRAN. Esta grande variedade de pacotes representa uma das principais razões para
o sucesso do R nos anos recentes: é bastante provável que algum usuário já tenha enfrentado, e
solucionado, o mesmo problema que você. Desta forma, você pode obter enormes benefícios em
termos de eficiência (tempo, esforço, etc) ao utilizar o conjunto de funcionalidades desenvolvidas
por outros usuários para resolver os seus problemas.
2.2.7.1 Utilizando pacotes
A utilização básica de pacotes pode ser resumida em dois passos:6
1. Instalar os pacotes do CRAN: install.packages("nome_do_pacote");

6
Pacotes que ainda não foram submetidos ao CRAN, mas que foram publicados no GitHub, também podem ser instala
dos a partir de funções do pacote devtools. Para mais detalhes, constultar o item Installing a Package from GitHub,
do livro R Cookbook.

www.fjp.mg.gov.br
41
2. Carregar os pacotes na memória do R em cada sessão: library("nome_do_pacote").
Ao rodar o comando de instalação de pacotes (install.packages("nome_do_pacote")), o pa

cote será instalado na máquina, de modo que é necessário fazer este procedimento apenas uma vez
(com exceção de atualizações do pacote, que serão comentadas adiante). Contudo, no R, instalar
um pacote no computador não signfica que você terá acesso aos seus conteúdos (funções, documen
tação, base de dados, etc) em sua sessão corrente do R. Para isto, é necessário carregar o pacote
em cada sessão de uso do programa, ou seja, toda vez que o R for iniciado e se desejar utili
zar um pacote, é necessário carregálo na memória do programa para que seus contúdos se tornem
disponíveis para uso. Para carregar o pacote, utilizase a função library(), como especificado
acima.
Assim, como exemplo de instalação dos pacotes, iremos instalar e carregar o principal pacote de
manipulação, transformação e análise de dados do R: tidyverse. Simplificadamente, este pacote
corresponde a um agrupamento de diversos pacotes direcionados a funcionalidades e aplicações
específicas, como manipulação de carcteres (stringr), criação de gráficos (ggplot2), manipula
ção de base de dados (dplyr), etc. Para instalálo (e, consequentemente, todos os pacotes que o
compõem) e carregálo, usar os comandos mencionados anteriormente.
# Instalar o pacote `tidyverse`

install.packages("tidyverse")
# Carregar o pacote `tidyverse` na sessão atual da memória do R
library("tidyverse")
• ATENÇÃO: Ao instalar um pacote, pelo comando install.packages(), o seu nome deve

ser escrito como caractere (string), isto é, deve ser acompanhado de um par de " ou '.
Para carregar o pacote, com o comando library(), isto não é necessário, mas pode ser feito
também, sem diferenças. Recomendase, em um momento inicial, escrever ambos com " ou
', para não gerar problemas.
2.2.7.2 Identificando pacotes instalados na máquina e carregados na sessão
• Pacotes instalados
Para visualizar os pacotes instalados na máquina, utilizase as funções library() e installed.packages(),

com diferentes níveis de detalhes. A função library() (sem argumentos) dispõe uma lista com o
nome e descrição dos pacotes instalados na máquina:

www.fjp.mg.gov.br
42
# Lista de nomes e descrição dos pacotes instalados na máquina

library()
A função installed.packages() apresenta outras informações e detalhes sobre os pacotes ins

talados. Para obter os nomes e as versões dos pacotes instalados, utilizar o comando abaixo
# Lista com nome e versões dos pacotes instalados na máquina

installed.packages()[,c("Package","Version")]
• Pacotes carregados
Para obter uma lista dos pacotes carregados na presente sessão, executar a função search() sem
argumentos:
# Lista de pacotes carregados na presente sessão

search()
## [1] ".GlobalEnv" "package:kableExtra" "package:openxlsx"

## [4] "package:reshape2" "package:data.table" "package:knitr"
## [7] "package:forcats" "package:stringr" "package:dplyr"
## [10] "package:purrr" "package:readr" "package:tidyr"
## [13] "package:tibble" "package:ggplot2" "package:tidyverse"
## [16] "package:stats" "package:graphics" "package:grDevices"
## [19] "package:utils" "package:datasets" "package:methods"
## [22] "Autoloads" "package:base"
O primeiro argumento (“.GlobalEnv”) referese ao Environment atual. Os argumentos na forma

package:nome_do_pacote indicam que o pacote nome_do_pacote está carregado na sessão pre
sente do R.
• OBS.: Alguns pacotes, apesar de estarem presentes nas versões base do R e RStudio (ou seja,
que são baixadas junto com os programas) não são carregados automaticamente ao iniciar o
software. Assim, é preciso carregálos, da mesma forma que pacotes baixados, pelo comando
library("nome_do_pacote") para acessar seus conteúdos.

www.fjp.mg.gov.br
43
2.2.7.3 Atualizando pacotes
A grande maioria dos pacotes está em constante transformação, visto que os desenvolvedores sem
pre procuram novas maneiras de deixálos mais eficientes ou de resolver problemas encontrados
pelos usuários.7 Assim, é necessário atualizálos periodicamente, para obter as funções mais atuais
e, consequentemente, com menor chance de apresentarem erros. Para atualizar um pacote, simples
mente rode o comando de instalação de pacotes (install.packages("nome_do_pacote")) ou
acesse o menu Tools → Check for Packages Updates… no RStudio, como na imagem abaixo:
Figura 2.13: RStudio: Menu de atualização de pacotes
2.2.7.4 Obtendo ajuda sobre um pacote
Para obter ajuda sobre um pacote, são utilizados dois comandos principais:
# Ajuda de janela do pacote no RStudio

package?nome_do_pacote
# Manual de referência no RStudio
help(package = "nome_do_pacote")
O primeiro abre a janela de ajuda do pacote no próprio RStudio, contendo seu autor e links úteis so
bre a sua utilização. Como exemplo, a janela de ajuda obtida após package?tidyverse apresenta,
entre outras coisas, um link bastante útil sobre o pacote e seu conjunto de pacotes, com detalhamento
das funções, exemplos de suas utilizações, etc.
O comando help(package = "nome_do_pacote") exibe o manual e referência do pacote, isto
é, a página de ajuda de todas as funções de um pacote no próprio RStudio, proveviente de sua
7
Algumas funções, ou até mesmo pacotes, são descontinuados ou não são atualizados pelos desenvolvedors. Desta
forma, estas funcões podem ser removidas dos pacotes ou os pacotes passam a poder ser executados somente em
versões específicas dos pacotes ou do R. Assim, aconselhase acompanhar as páginas de desenvolvimento dos pacotes
ou de documentação oficial do R.

www.fjp.mg.gov.br
44
Figura 2.14: Ajuda RStudio: tidyverse

www.fjp.mg.gov.br
45
documentação oficial. Como exemplo, na figura abaixo é exibida a janela obtida após o comando
help(package = "readr"), sobre a ajuda do pacote readr, usado posteriormente neste curso
para a importação de dados no R.
Figura 2.15: Documentação oficial RStudio: readr
Além disso, é usual procurar no Google sobre a documentação oficial do pacote no CRAN, em que
podem ser obtidos detalhes de funcionamento das funções, exemplos, etc. Por exemplo, pode se
procurar sobre o pacote readr, por meio da busca no google para r cran package readr.
A primeira página dos resultados da busca corresponde à página de documentação oficial do
pacote no CRAN. No item Reference manual em Downloads, pode ser obtido o manual de
referência do pacote em .pdf. Este manual é o mesmo obtido pelo comando help(package =
"nome_do_pacote").
Adicionalmente, alguns pacotes incluem documentos adicionais, contidos nos arquivos baixados
em suas instalações na máquina. Estes documentos, chamados de vignettes (vinhetas), auxiliam
no aprendizado das funções de um pacote, contendo introduções e tutoriais. Se um pacote
possuir esta documentação, a sua página de help (que pode ser acessada por help(package =
'nome_do_pacote)) irá exibíla.
A visualização de vinhetas é obtida pela função vignette(). Os comandos abaixo mostram como
visualizar uma lista de todas as vinhetas contidas no computador (i.e. dos pacotes instalados na

www.fjp.mg.gov.br
46
Figura 2.16: Busca Google: pacote no CRAN

www.fjp.mg.gov.br
47
Figura 2.17: CRAN: Página de documentação oficial readr
máquina) e de todas vinhetas de um pacote específico. Esta lista será exibida no quadrante superior
esquerdo, ao lado do script corrente.
# Listar todas as vinhetas do computador
vignette()
# Listar todas as vinhetas de um pacote
vignette(package = "nome_do_pacote")
Cada vinheta possui um nome. Para acessála, digitar o comando abaixo, que irá abrir a aba Help
no quadrante direito inferior, com os seus conteúdos.
# Acessar uma vinheta
vignette("nome_da_vinheta")
2.2.7.5 Acessando funções de um pacote sem carregálo
Como mencionado, em linhas gerais, para acessar os conteúdos de um pacote (funções, documenta
ção, base de dados, etc), ele deve ser carregado na sessão presente do R (na memória do programa).
Contudo, em alguns casos, desejase utilizar apenas uma função de um pacote inteiro em uma de
terminada sessão do R. Assim, há a possibilidade de não carregar o pacote inteiro, mas executar a
função específica, por meio da sintaxe:

www.fjp.mg.gov.br
48
# Acessar uma função de um pacote sem carregá-lo

nome_do_pacote::nome_da_função()
O código acima corresponde ao uso de uma função específica de um pacote, sem que ele seja car
regado na sessão presente do R.
ATENÇÃO: para que o comando acima seja executado, o pacote deve estar instalado no com
putador (por meio do comando install.packages("nome_do_pacote"), apresentado anterior
mente).
O comando acima também é útil para situações em que funções de pacotes distintos, instalados e
carregados em uma mesma sessão, possuem o mesmo nome (ex.: funções data.table::dcast()
e reshape2::dcast()).
2.2.7.6 Dicas: scripts e pacotes
Duas dicas são destacadas para um fluxo de trabalho mais eficiente na organização de scripts e
utilização de pacotes:
• Carregar todos os pacotes no início dos scripts:
Esta prática é recomendada, já que garante que todas as dependências necessárias para executar
os códigos estarão carregadas na hora de executálas, como destacado em Gillespie and Lovelace
(2017).
• Designar um vetor contendo todos os pacotes necessários de uma sessão:
Gillespie and Lovelace (2017) recomendam designar um vetor contendo todos os pacotes que serão
carregados em uma sessão/script. Desta forma, o processo de carregar os pacotes (e instalar, se
necessário) será mais eficiente (i.e., menor quantidade de linhas para ser executado), além de per
mitir uma fácil referência a estes pacotes. Para utilizar esta prática, são utilizados conhecimentos
de vetores (comentados no capítulo seguinte do curso) e uma função da família apply (lapply()),
que foge do escopo deste curso. Porém, os comandos abaixo podem ser executados sem problemas
nos scripts e o funcionamento dos vetores será explicado posteriormente.
# Criar vetor contendo o nome dos pacotes utilizados: `pacotes`

pacotes <- c("pacote_1", "pacote_2", "pacote_3", ...)
# Instalar pacotes contidos no vetor `pacotes`
install.packages(pacotes)
# Carregar os pacotes contidos no vetor `pacotes`
carregar <- lapply(pacotes, library, character.only = TRUE)

www.fjp.mg.gov.br
49
O comando lapply(pacotes, library, character.only = TRUE) executa a função

library() para cada pacote contido no vetor de strings, pacotes.
2.2.8 Resumo do capítulo

Este capítulo teve o objeto de apresentar um entendimento inicial do R e de suas funcionalidades
básicas, que servem de fundamentação para qualquer programação nesta linguagem. Foram apre
sentados os seguintes aspectos:
• Como inserir comandos no Console e navegar sob seu histórico;

• Como realizar operações matemáticas básicas;
• Como nomear e utilizar objetos no R (básicos);
• Como executar funções (básicos);
• Como lidar com erros e obter ajuda no R;
• Como utilizar os Scripts;
• Como utilizar pacotes (básicos).
Dado que agora temos as principais referências às dúvidas à nossa disposição, assim como noções
básicas do funcionamento do R, o capítulo a seguir apresenta mais detalhes sobre os objetos no R,
em especial a sua principal família: vetores.

www.fjp.mg.gov.br
50
2.3 Objetos do R: Vetores

Os objetos organizam os dados de maneiras particulares e possuem usos específicos na utilização
do R, correspondendo a uma parcela fundamental da linguagem. Neste capítulo, iremos abordar a
família de dados mais importante no sistema base do R: os Vetores (Vectors).8 Os Vetores podem
ser entendidos como um conjunto de células contíguas que contêm dados (informações).
Em R, há um sistema relativamente complexo de classificação e categorização dos objetos (como
visto aqui e aqui). Para simplificar, ao longo do capítulo, iremos abordar apenas três conceitos de
categorização: tipo (type), modo (mode) e classe (class). Estes conceitos serão apresentados ao
longo do capítulo, à medida que for necessário.
De maneira sintética, pode se dizer que os vetores possuem duas propriedades universais (além dos
Atributos, que serão comentados mais adiante):
• Tipo (type), propriedade do vetor inteiro, que pode ser entendida como a forma de organiza
ção de dados mais complexa que um vetor pode conter como um de seus valores. Podemos
visualizar o tipo de um objeto pela função typeof():
# Obtendo o tipo do vetor `horas_aula_total`

typeof(horas_aula_total)
## [1] "double"
• Comprimento (length), que pode ser determinado pela função length():
# Determinando o comprimento do vetor `horas_aula_total`

length(horas_aula_total)
## [1] 1
Ou seja, o vetor horas_aula_total é um vetor de comprimento igual a 1 (vetor unitário) do tipo

double (números reais).
• Vetores: Vetores Atômicos (VA) e Listas
Dito isto, basicamente, os vetores podem ser divididos em:

8
A lista completa de objetos do R pode ser consultada em R Objects.

www.fjp.mg.gov.br
51
• Vetores Atômicos (atomic vectors);

• Listas (lists).
Em essência, a diferença entre vetores atômicos e listas reside no tipo (type) de elemento que cada
um é capaz de armazenar. Em vetores atômicos, o tipo é uma propriedade do vetor inteiro, e não
de um elemento individual do vetor. Assim, enquanto os vetores atômicos são homogêneos, isto é,
cada vetor pode conter somente elementos de um mesmo tipo, as listas podem ser heterogêneas,
ou seja, podem conter elementos de diferentes tipos.
O diagrama abaixo, de Wickham (2015a), mostra os principais vetores (atômicos e listas).
Figura 2.18: Principais Vetores
Iremos começar com os vetores atômicos, por ser o objeto mais básico empregado nas aplicações
fundamentais do R.
Para este capítulo, serão utilizadas algumas funcões do pacote purrr. Desta forma, instalar e car
regar o pacote tidyverse, que contém o pacote purrr, seguindo os comandos apresentados ante
riormente.
# Instalar pacote
install.packages('tidyverse')
# Carregar pacote
library('tidyverse')
2.3.1 Vetores atômicos

Como dito, os vetores atômicos contêm apenas elementos de um mesmo tipo. O R possui seis tipos
atômicos (básicos) de objetos:
1. character (string, i.e., uma sequência de caracteres)

2. integer (números inteiros)
3. double (números reais)
4. logical (lógicos)

www.fjp.mg.gov.br
52
5. raw
6. complex
Neste curso, será dado destaque às quatro primeiras categorias (character, integer, numeric e logi
cal), já que raw e complex não são comumente empregados em análises de dados. Os principais
tipos de vetores atômicos são apresentados na figura abaixo.
Figura 2.19: Vetores Atômicos mais comuns
A figura acima indica outro conceito de categorização dos objetos: o modo (mode). O modo de
um objeto é determinado de acordo com sua estrutura básica e representa uma classificação mutu
almente exclusiva dos objetos, isto é, cada objeto possui um, e apenas um, modo. Existem quatro
modos de vetores atômicos: logical, numeric, character e complex. Como visto, os vetores de modo
numeric (numérico) são compostos por dois tipos: integer (números inteiros) e double (números
reais). De maneira sintética, o modo e o tipo de um objeto podem ser vistos como o tipo de dados
mais complexo que um vetor atômico no R pode conter em seus valores. Mais detalhes podem ser
obtidos aqui.
Dito isto, lembramos que, até este momento, já criamos vetores neste curso. Os objetos
horas_aula_total, horas_aula_concluidas e horas_aula_restantes, por exemplo, são
vetores que contêm apenas um elemento numérico, isto é, são vetores unitários de modo numérico.
2.3.2 Criando vetores: função c()

O principal comando de criação de vetores é a função função c(), abreviação de combinar (com
bine), que permite criar vetores de qualquer comprimento (incluindo unitários).
# Criando um vetor com a função `c()`

(vetor_exemplo <- c(1, 2, 3, 4, 5))

www.fjp.mg.gov.br
53
## [1] 1 2 3 4 5
Ao criar um vetor com a função c() a partir de outros vetores atômicos, o resultado é outro vetor
atômico, isto é, a estrutura é simplificada para apenas um vetor.
# Criando um vetor atômico a partir de outros vetores atômicos
(vetor_atomico <- c(c(0, 10, 20, 30), c(1,2)))
## [1] 0 10 20 30 1 2
2.3.3 Sequências
2.3.3.1 Sequências simples (intervalo unitário)
O caractere : permite criar sequências de números inteiros, com um intervalo unitário, isto é, de 1
em 1.
# Sequência de 0 até 50, de 1 em 1
(0:50)
## [1] 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
## [26] 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
## [51] 50
Como visto, o resultado do comando 0:50 é maior do que o tamanho do Console, o que faz com que
sejam exibidos números entre colchetes ([1], [26] e [51], no exemplo), indicando qual a posição
do número dentro do vetor.
# Criar sequência do maior para o menor valor
(30:1)
## [1] 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6
## [26] 5 4 3 2 1
2.3.3.2 Sequências de outros intervalos
A função seq() permite especificar o valor que será somado à cada membro da sequência. Para
isto, especifique o valor somado no argumento by =. Além disso, pode ser especificado o tamanho
da sequência (quantidade de componentes do vetor), sem que seja especificado a quantia que será
somada, por meio do argumento length.out =.

www.fjp.mg.gov.br
54
# Sequência de 0 a 30, somando 2 à cada número

seq(from = 0, to = 30, by = 2)
## [1] 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30
# Sequência de 0 a 30, com onze componentes

seq(from = 0, to = 30, length.out = 11)
## [1] 0 3 6 9 12 15 18 21 24 27 30
# Sequência de 1 a 2, com cinco componentes, com incrementos decimais

seq(from = 1.0, to = 2.0, length.out = 5)
## [1] 1.00 1.25 1.50 1.75 2.00
2.3.3.3 Sequências com valores repetidos
A função rep() permite criar sequências de valores repetidos. Para isto, utilizar o argumento times
=.
# Criar uma sequência com dez repetições do número 14

rep(14, times = 10)
## [1] 14 14 14 14 14 14 14 14 14 14
2.3.4 Vetores Numéricos (numeric)
Como visto na Figura 18, em R, os vetores numéricos (Numeric vectors), compostos por valores
numéricos, são divididos em Integer e Double (números inteiros e reais, respectivamente). A função
typeof() permite descobrir o tipo do vetor.
# Tipo do vetor `horas_aula_concluidas`

typeof(horas_aula_concluidas)
## [1] "double"

www.fjp.mg.gov.br
55
O resultado acima mostra que ao criar um vetor numérico, o R assume, por padrão, números
reais (double).
Desta forma, para criar um vetor de números inteiros (tipo integer), devemos inserir o caractere L
logo após o número.
# Objeto com as horas/aula totais em número inteiro

h_a_total_inteiro <- (32L)
# Verificar o tipo
typeof(h_a_total_inteiro)
## [1] "integer"
OBS.1: Por padrão do R, o separador de casas decimais é o . (ponto), no lugar de , (vírgula).
# Criar um objeto decimal

decimal <- (0.25)
(decimal * 4)
## [1] 1
OBS.2: Em R, os números reais (doubles) são aproximações, dado que o computador pode alo
car uma quantidade fixa e limitada de memória para cada número no R. Desta forma, segundo
Grolemund (2014), em R, os números reais são precisos até 15 dígitos decimais (ou 16 dígitos sig
nificativos). Podemos verificar isto comparando a subtração do quadrado da raiz quadrada de 2 (o
que, em teoria, seria o próprio número 2) pelo número 2.
# Obter a raiz quadrada de 2

raiz_2 <- 2 ^ (1 / 2)
# Elevá-la ao quadrado
quadrado_raiz_2 <- raiz_2 ^ 2
# Subtração do objeto criado pelo número 2
quadrado_raiz_2 - 2
## [1] 0.0000000000000004440892
# Subtração com os números

2 - 2
## [1] 0

www.fjp.mg.gov.br
56
Como visto, a raiz quadrada de 2 (raiz_2) não pode ser expressa exatamente em 16 dígitos sig
nificativos. Como resultado, este valor é arredondado pelo R, o que faz com que a subtração do
quadrado da raiz de 2 (quadrado_raiz_2) por 2 seja algo bastante próximo, porém não exatamente,
de zero.
Em conclusão, atenção ao utilizar números reais nos cálculos. À frente entraremos em detalhes
com os operadores lógicos e como comparar valores, na Subseção Comparando Vetores.
OBS.3: Os objetos numéricos possuem caracteres especiais, para especificar algumas situações
específicas.
• Doubles possuem quatro valores especiais: NA, NAN, Inf e -Inf. De maneira superficial,
seus signficados são os seguintes:
– NAN provém de “Não é um Número” (Not A Number) e representam cálculos cujos

resultados são indefinidos, como 0/0.
– NA representam informações faltantes (missing values), isto é, variáveis cujos valores
não são conhecidos.
– Inf e -Inf representam valores infinitos (positivo e negativo, respectivamente).
• Integers possuem apenas um valor especial: NA, para indicar valores faltantes.
2.3.5 Vetores Lógicos (logical)
Os vetores lógicos são o tipo mais simples de vetores atômicos, por poderem conter apenas três
valores possíveis: TRUE, FALSE e NA. Estes valores representam informações lógicas, que podem
ser utilizadas para comparações e para determinar a veracidade de operações, entre outras apli
cações. Os valores/operadores lógicos, divididos entre “Verdadeiro” e “Falso”, são chamados de
valores/operadores booleanos (Boolean values). Toda vez que TRUE ou FALSE for digitado em caixa
alta no R, o R irá interpretálo como um dado de tipo lógico. Além disso, T e F são abreviações de
TRUE e FALSE, respectivamente.
# Exemplo de um vetor lógico

(vetor_logico <- c(TRUE, TRUE, FALSE, F))
## [1] TRUE TRUE FALSE FALSE
# Tipo do vetor
typeof(vetor_logico)

www.fjp.mg.gov.br
57
## [1] "logical"
# Tipo de outro vetor

typeof(T)
## [1] "logical"
2.3.6 Vetores de Caracteres (character)

Cada elemento de um vetor de caracteres (character vector) é denominado uma string. Os vetores de
caracteres são os mais complexos tipos dos vetores atômicos abordados neste curso, visto que cada
string pode conter uma quantidade qualquer de dados, isto é, qualquer quantidade de caracteres.
Como mencionado anteriormente, os símbolos ' e " (aspas) são os caracteres especiais utilizados
para escrever uma string. Assim, tudo que for rodeado por ' e " é tratado como uma string pelo R.
# Vetor de caracteres
(vetor_caracteres <- c("Este", "é", "um vetor atômico contendo caracteres"))
## [1] "Este"
## [2] "é"
## [3] "um vetor atômico contendo caracteres"
# Tipo do vetor
typeof(vetor_caracteres)
## [1] "character"
Lembrando que as strings podem conter mais do que letras, i.e., podem ser compostos de números,
símbolos, etc.
# Diferença entre vetores numéricos e strings

typeof(1)
## [1] "double"
typeof('1')
## [1] "character"

www.fjp.mg.gov.br
58
typeof('one')
## [1] "character"
2.3.7 Utilizando Vetores Atômicos

Em R, é possível realizar operações lógicas e matemáticas com vetores, isto é, executar certas “fun
ções” em cada elemento de um par de vetores (ou com os elementos de um vetor e com um “esca
lar”9 ). Funções que executam suas funcionalidades em cada elemento dos vetores são chamadas de
vetorizadas (vectorized functions) e apresentam vantagens significativas de eficiência: conveniên
cia (ou seja, é necessário escrever uma quantidade pequena de código para realizálas) e velocidade
(elas são executadas mais rapidamente no R).
Dica: A função str() corresponde a uma das principais funções para análise de objetos no R. Ela
informa, de maneira sintética, a estrutura de um objeto, isto é, todos os seus componentes e a forma
de organização dos dados no objeto.
x <- c(-5:20)
# Função `str()`
str(x)
## int [1:26] -5 -4 -3 -2 -1 0 1 2 3 4 ...
Como visto, a função str() informa que o objeto x é um vetor numérico de numéros inteiros
(integer), composto por 26 elementos (exibindo os 10 primeiros elementos no Console).
2.3.7.1 Vetores atômicos: Operações matemáticas básicas
Em R, as operações matemáticas básicas podem ser utilizadas em pares de vetores, de modo que os
operadores são aplicados aos elementos correspondentes de cada vetor. Assim, em uma adição entre
vetores (vetor1 e vetor2), o primeiro elemento do vetor1 será somado ao primeiro elemento do
vetor2, o segundo elemento do vetor1 ao segundo elemento do vetor2, etc. Abaixo, um exemplo
de operações matemáticas em vetores de mesmo comprimento.
# Operações matemáticas com vetores de mesmo comprimento

vetor1 <- c(1:5)
vetor2 <- c(6:10)
vetor1 + vetor2
9
Como visto, na realidade, em R não existem escalares, mas vetores unitários.

www.fjp.mg.gov.br
59
## [1] 7 9 11 13 15
vetor1 - vetor2
## [1] -5 -5 -5 -5 -5
vetor1 * vetor2
## [1] 6 14 24 36 50
vetor1 / vetor2
## [1] 0.1666667 0.2857143 0.3750000 0.4444444 0.5000000
length(vetor1)
## [1] 5
length(vetor1 + vetor2)
## [1] 5
O vetor resultante possui o mesmo comprimento (length) que os vetores originais.

As operações matemáticas também podem ser realizadas com vetores de comprimentos distintos.
Nestes casos, em R, o tamanho dos vetores é convertido/coagido (coerce), implicitamente. Para
que isto ocorra, o vetor de menor comprimento é repetido (ou reciclado) até que o comprimento do
maior vetor seja atingido. Este processo é chamado vector recycling (reciclagem dos vetores).
A partir desta regra, uma operação com um vetor e um escalar equivale a uma operação com um
vetor e um vetor unitário (i.e., composto por apenas um elemento), que terá seu elemento repetido
até que o comprimento do maior vetor seja atingido.
# Operações matemáticas com um vetor unitário

vetor3 <- c(0.5)
vetor1 + vetor3
## [1] 1.5 2.5 3.5 4.5 5.5

www.fjp.mg.gov.br
60
# Operações matemáticas com "escalares"

vetor1 + 0.5
## [1] 1.5 2.5 3.5 4.5 5.5
vetor1 * 0.5
## [1] 0.5 1.0 1.5 2.0 2.5
O processo de reciclagem dos vetores ocorre sem avisos no R em situações em que o comprimento
do maior vetor é um múltiplo inteiro do comprimento do menor vetor. Nas situações em que isto
não ocorre, ao realizar a operação matemática, será exibido um aviso no Console.
(vetor4 <- seq(from = 10, to = 100, length.out = 10))
## [1] 10 20 30 40 50 60 70 80 90 100
# Comprimento do maior vetor é múltiplo do menor vetor

vetor4 + 1:2
## [1] 11 22 31 42 51 62 71 82 91 102
# Comprimento do maior vetor não é múltiplo do menor vetor

vetor4 + 1:3
## Warning in vetor4 + 1:3: comprimento do objeto maior não é múltiplo do

## comprimento do objeto menor
## [1] 11 22 33 41 52 63 71 82 93 101
Por conta desta regra, devese estar bastante atento ao realizar operações com vetores de compri
mentos distintos.
2.3.7.2 Vetores atômicos: Operadores relacionais e lógicos (comparando vetores)
De maneira análoga aos operadores matemáticos, podemos realizar operações relacionais e lógicas
entre os vetores. Em outras palavras, podemos comparar dois vetores, testando a veracidade de
algumas afirmações, por exemplo, se o objeto1 é igual ao objeto2, se o objeto1 é maior do que
o objeto2, etc. Os seguintes caracteres são utilizados como operadores relacionais e lógicos entre
vetores:

www.fjp.mg.gov.br
61
Operador Sintaxe Descrição

> x > y x maior que y?
< x < y x menor que y?
>= x >= y x maior ou igual a y?
<= x <= y x menor ou igual a y?
== x == y x igual a y?
!= x != y x diferente de y?
%in% x %in% y x está contido em y?
& cond1 & cond2 Ambas cond1 E cond2 são verdadeiras?
| cond1 | cond2 cond1 OU cond2 são verdadeiras?
! !cond1 ! inverte os resultados de cond1
isTRUE() isTRUE(expressão) expressão é TRUE?
Consequentemente, é importante não confundir os símbolos == e =. Enquanto = é utilizado como

um operador de designação de objetos, como mencionado anteriormente, == é utilizado para com
parar vetores.
As operações lógicas utilizam os valores booleanos dos vetores lógicos (TRUE ou FALSE) para indi
car os seus resultados:
x <- 1
y <- 5
z <- 5
w <- 1:10
# Operações relacionais e lógicas
x > y
## [1] FALSE
x < y
## [1] TRUE
x != y
## [1] TRUE

www.fjp.mg.gov.br
62
y == z
## [1] TRUE
z | x <= y
## [1] TRUE
z & y <= x
## [1] FALSE
isTRUE(x * 5 == y)
## [1] TRUE
!(x < y)
## [1] FALSE
x %in% w
## [1] TRUE
Podemos utilizar os operadores com vetores de quaisquer comprimentos.
vetor_comparacao1 <- 1:10

vetor_comparacao1 < 5
## [1] TRUE TRUE TRUE TRUE FALSE FALSE FALSE FALSE FALSE FALSE
vetor_comparacao1 > 8
## [1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE TRUE TRUE

www.fjp.mg.gov.br
63
vetor_comparacao1 < 5 | vetor_comparacao1 > 8
## [1] TRUE TRUE TRUE TRUE FALSE FALSE FALSE FALSE TRUE TRUE
vetor_comparacao1 %% 3 == 0
## [1] FALSE FALSE TRUE FALSE FALSE TRUE FALSE FALSE TRUE FALSE
1:10 > 10:1
## [1] FALSE FALSE FALSE FALSE FALSE TRUE TRUE TRUE TRUE TRUE
c('a', 'b') == c('a', 'c')
## [1] TRUE FALSE
Os operadores xor(), any() e all() também podem ser utilizadas em operações relacionais, para
determinar se exatamente uma, pelo menos uma ou todas as comparações são verdadeiras, respec
tivamente. O primeiro retorna TRUE se exatamente uma das condições for veradeira. O segundo
retorna TRUE se pelo menos uma das condições for verdadeira. O terceiro retorna TRUE se todos as
condições forem verdadeiras.
v <- 1:4
# Retorna TRUE se exatamente uma das condições for verdadeira
xor(1 < 2, 1 < 3)
## [1] FALSE
# Retorna TRUE se pelo menos uma das condições for verdadeira

any(v == 2)
## [1] TRUE
# Retorna TRUE se todas as condições forem verdadeiras

all(v == 2)
## [1] FALSE
Dica: Evitar utilizar == para checar os valores especiais de objetos numéricos (NAN, NA, Inf e -Inf).
Utilizar as funções is.finite(), is.infinite(), is.na() e is.nan() no lugar. Além disso,
atentar para o fato de que a função is.na() aponta TRUE tanto para NA quanto para NAN.

www.fjp.mg.gov.br
64
2.3.7.3 Vetores atômicos: Funções matemáticas úteis
As seguintes funções executam operações matemáticas bastante úteis em análises de dados, como
a obtenção da média, da mediana, do desviopadrão, etc.
Função Operação
mean() Média
median() Mediana
sqrt() Raiz quadrada
log() Logarítimo
sd() Desviopadrão
abs() Valor absoluto
sum() Soma
Exemplos de aplicações de algumas das funções:
(vetor5 <- seq(from = 0, to = 16, by = 2))
## [1] 0 2 4 6 8 10 12 14 16
# Média do vetor
mean(vetor5)
## [1] 8
# Mediana do vetor
median(vetor5)
## [1] 8
# Desvio padrão do vetor

sd(vetor5)
## [1] 5.477226
# Raiz quadrada dos valores

sqrt(vetor5)
## [1] 0.000000 1.414214 2.000000 2.449490 2.828427 3.162278 3.464102 3.741657

## [9] 4.000000

www.fjp.mg.gov.br
65
# Logarítimo dos valores

log(vetor5)
## [1] -Inf 0.6931472 1.3862944 1.7917595 2.0794415 2.3025851 2.4849066

## [8] 2.6390573 2.7725887
# Valor absoluto dos elementos do vetor

abs(c(-3:3))
## [1] 3 2 1 0 1 2 3
# Soma dos elementos de um vetor

sum(vetor5)
## [1] 72
2.3.8 Atributos (Attributes)
Além de tipo (type) e comprimento (length), que podem ser conferidos pelas funções typeof() e
length(), mencionados anteriormente, os vetores possuem uma propriedade adicional: os atribu
tos (attributes). Os atributos representam informações suplementares sobre os dados (metadados,
i.e., dados sobre os dados), que podem ser ligadas aos objetos. Os atribtuos modificam aspectos
das estruturas dos vetores, atribuem características específicas a seus elementos e permitem a reali
zação de operações adicionais com os vetores. Desta forma, os metadados são úteis na descrição e
caracterização dos objetos (por exemplo, permitem nomear as colunas de uma base de dados, para
identificar quais dados estão contidos em cada uma delas). Por meio dos atributos, são criados ou
tros tipos de vetores, extremamente úteis em análises de dados e no próprio uso do R, como fatores
(factors) e datas e horasdata (dates e datetimes).10
Os principais atributos empregados nas funcionalidades fundamentais do R são:
• Nomes (names), que identificam os elementos de um vetor;

• Dimensões (dimensions, ou abreviando, dim), que determinam a dimensão de um vetor e,
consequentemente, podem fazer com que os vetores se comportem como matrizes;
• Classe (class) representa outra categorização de objetos e determina a maneira com que fun
ções (genéricas) operam com estes objetos.
10
Para mais detalhes, ver aqui.

www.fjp.mg.gov.br
66
Os atributos individuais de um objeto podem ser acessados ou modificados pela função attr(),
enquanto todos os atributos de um objeto podem ser acessados ou modificados pela função
attributes(). Caso o objeto não possua nenhum atributo, isto será indicado pelo resultado
da função attributes(nome_do_objeto), ao retornar o valor NULL (explicado na subseção
seguinte).
2.3.8.1 Nomes (names)
A função names() permite acessar os nomes de um vetor, assim como designálos (se eles não
existirem) ou modificálos (se já existirem).
• Nomear os elmentos de um vetor
Dito isto, em linhas gerais, existem três maneiras principais de nomear os elementos de um vetor
por meio das funções da base do R:
# Ao criá-lo, acrescentando os nomes no vetor como abaixo
x <- c(a = 1, b = 2, c = 3)
x
## a b c
## 1 2 3
# Ao criá-lo utilizando a função `setNames()`

y <- setNames(1:3, c("a", "b", "c"))
y
## a b c
## 1 2 3
# Designando um vetor de caracteres à função `names()`

x <- 1:3
names(x) <- c("a", "b", "c")
Para facilitar a seleção de elementos nomeados em vetores, seus nomes devem ser únicos e não
faltantes.
• Remover os nomes de um vetor
Para remover os nomes de um vetor, utilizar a função unname() ou a própria função names(), com
o objeto NULL (comentado na seção seguinte):

www.fjp.mg.gov.br
67
# Função ùnname()`
x <- unname(x)
# Função `names()`
names(y) <- NULL
2.3.8.2 Dimensões (dim): matrizes (matrix)
Ao adicionar o atributo dim a um vetor, é possível criar uma matriz (matrix). Uma matriz representa
um vetor de duas dimensões11 . Vale lembrar, portanto, que o tipo de um matriz é uma propriedade
de todo o vetor, de modo que seus elementos individuais não possuem tipos diferentes do restante
da matriz.
A quantidade de colunas de uma matriz é obtida por ncol(nome_da_matriz), enquanto a quan
tidade de linhas é obtida por nrow(nome_da_matriz). As matrizes podem ser criadas com o co
mando matrix() ou ao definir um vetor com as proporções desejadas no argumento dim.
# Comando `matrix()`, especificando a quantidade de linhas (nrow) e de colunas (ncol)

(z <- matrix(1:8, nrow = 4, ncol = 2))
## [,1] [,2]
## [1,] 1 5
## [2,] 2 6
## [3,] 3 7
## [4,] 4 8
# Adicionando o atributo `dim` a um vetor existente

w <- 1:6
dim(w) <- c(3, 2)
w
## [,1] [,2]
## [1,] 1 4
## [2,] 2 5
## [3,] 3 6
Assim como em vetores unidimensionais, as operações matemáticas em matrizes são vetorizadas,

isto é, ocorrem em parelelo em R. Assim, estas operações são intuitivas de serem realizadas.
11
Podem ser criados vetores com mais dimensões (arrays), mas não serão mencionados neste curso.

www.fjp.mg.gov.br
68
matriz1 <- matrix(1:4, ncol = 2)

matriz2 <- matrix(seq(from = 10, to = 40, length.out = 4), nrow = 2)
# Multiplicação dos elementos pelos elementos (produto dos elementos)
matriz1 * matriz2
## [,1] [,2]
## [1,] 10 90
## [2,] 40 160
# Divisão dos elementos por elementos

matriz2 / matriz1
## [,1] [,2]
## [1,] 10 10
## [2,] 10 10
# Produto matricial (produto de matrizes)

matriz1 %*% matriz2
## [,1] [,2]
## [1,] 70 150
## [2,] 100 220
Pode se transpôr uma matriz pela função t().
# Transpôr matriz: `t()`

(t_w <- t(w))
## [,1] [,2] [,3]

## [1,] 1 2 3
## [2,] 4 5 6
# Classe t_w
class(t_w)
## [1] "matrix" "array"

www.fjp.mg.gov.br
69
# Tipo t_w
typeof(t_w)
## [1] "integer"
Observase que a função t() retorna, necessariamente, um objeto de classe matrix e de tipo igual
ao objeto inicial (no caso, integer).
Em geral, em análise de dados, os objetos de classe matrix não são muito utilizados, visto que,
assim como vetores, estes objetos podem conter apenas um tipo de objeto. Como será visto ao
longo do curso, é costume utilizar as data.frames, pela possibilidade de serem heterogêneas, isto é,
por poderem conter objetos de diferentes tipos, o que é bastante útil em Ciência de Dados.
2.3.8.3 Classe (class)
Em R, a classificação dos objetos em classes (class) distintas determina como funções (genéricas)
operam com eles, isto é, representa diferenças nas aplicações que podem ser feitas com cada um
deles. Por exemplo, operações matemáticas não podem ser realizadas com vetores de caracteres
(character) ou fatores (factors). Esta característica é bastante relevante, especialmente quando al
gumas funções possuem comportamentos distintos para diferentes classes de objetos. Mais adiante,
iremos destacar as conversões automáticas de classes de objetos e como realizar, explicitamente, a
conversão para a classe desejada, assim como alguns problemas que advêm deste processo.
Para verificar a classe de um objeto, utilizar a função class().
# Verificar a classe de um objeto
class(horas_aula_concluidas)
## [1] "numeric"
2.3.9 NULL
O objeto NULL indica a ausência de um objeto. Geralmente associado aos vetores, é comumente
interpretado como um vetor de comprimento zero, pelo seu comportamento. Esta interpretação,
contudo, está equivocada segundo a documentação do R (2019b). O objeto NULL é um tipo de objeto
especial e corresponde a um objeto único, de modo que todas as instâncias que fazem menção a ele
se referem ao mesmo objeto. O objeto NULL não possui tipo, atributos ou propriedades modificáveis.
Segundo R Core Team (2019b), ele não deve ser confundido com um vetor ou lista de tamanho zero,
apesar ser entendido desta maneira por diversas referências. Para testar para NULL, utilizar a função
is.null().
O diagrama abaixo, de Wickham (2015a), mostra os principais tipos de vetores e o objeto NULL:

www.fjp.mg.gov.br
70
Figura 2.20: Vetores e NULL
2.3.10 Tipos de vetores: conversão e testes

Como mencionado, os vetores atômicos contêm apenas objetos que possuem o mesmo tipo. Porém
o que ocorre se misturarmos objetos de tipos diferentes em um mesmo vetor?
misturado1 <- c(TRUE, FALSE, 10L, 20L)

misturado2 <- c(1:3, 3.1, 3.2, 3.3)
misturado3 <- c(seq(0, 1, length.out = 5), 'a', 'b', 'c')
2.3.10.1 Conversão Implícita
Em R, quando diferentes tipos de objetos são inseridos em um mesmo vetor, eles são convertidos
(coerced). Isto ocorre, uma vez que o tipo é uma propriedade do objeto inteiro, e não de seus
elementos individuais. Ao agrupar elementos de tipos diferentes em um mesmo vetor atômico (por
meio da função c(), por exemplo), há uma conversão automática dos objetos para um mesmo tipo
(coerção implícita). Nela, sempre é preservado o tipo de maior complexidade. A ordem crescente
de complexidade dos tipos de objetos é a seguinte.
Logical → Integer → Double → Character
Assim, ao combinar um vetor de caracteres e outro de números inteiros, obtemos um caractere, por
exemplo. Podemos conferir os tipos dos vetores misturado*, criados logo acima.
# Lógico é convertido para qualquer outro tipo de vetor

typeof(misturado1)
## [1] "integer"
# Integer e double resultam em um double

typeof(misturado2)
## [1] "double"

www.fjp.mg.gov.br
71
# Qualquer vetor combinado com um character é convertido para character

typeof(misturado3)
## [1] "character"
Além da função typeof(), podemos utilizar as funções is_*(), do pacote purrr, para verificar
os tipos (*) dos objetos. Cada função fornece um resultado TRUE para os tipos de objetos marcados
com um x no quadro abaixo, de Wickham e Grolemund (2017), enquanto os objetos sem marcação
resultam em um resultado FALSE.
Figura 2.21: Funções para testar o tipo do objeto
# Verificando o tipo dos vetores criados

is_integer(misturado1)
## [1] TRUE
is_integer(misturado2)
## [1] FALSE

www.fjp.mg.gov.br
72
is_double(misturado2)
## [1] TRUE
is_character(misturado1)
## [1] FALSE
is_character(misturado3)
## [1] TRUE
Além disso, cada predicado possui a função is_scalar_*() para identifcar se determinado vetor,
do tipo (*) especificado, possui comprimento (length) igual a 1.
OBS.: Analogamente às funções is_*(), do pacote purrr, as funções is.*(), da base do R,
também são empregadas para determinar o tipo de um objeto. Elas também geram um vetor lógico
a partir de sua utilização. Contudo, segundo Wickham e Grolemund (2017) e Wickham (2015a), é
recomendado evitar o uso destas funções para verificar os tipos dos objetos, em função de resultados
que podem ser surpreendentes. Para mais detalhes, consultar Wickham e Grolemund (2017) e as
documentações do R e das funções, caso seja necessário.
OBS.2: Quando os objetos lógicos (TRUE e FALSE) são convertidos para numéricos, eles assumem
dois valores: 1 e 0, respectivamente. Podemos observar isto no objeto misturado1, que criamos
anteriormente, uma vez que, seguindo a ordem de complexidade apresentada, converteu, implicita
mente, os elementos lógicos para integer.
# TRUE e FALSE assumem valores 1 e 0, quando convertidos para numéricos

misturado1
## [1] 1 0 10 20
# Outro exemplo
c(TRUE, TRUE, FALSE, 1.1, 1.2, 1.3)
## [1] 1.0 1.0 0.0 1.1 1.2 1.3
Isto pode ser útil em funções matemáticas, que convertem automaticamente objetos lógicos para
numéricos. A partir desta funcionalidade, podemos obter o total ou a média de valores TRUE em um
vetor, por exemplo:

www.fjp.mg.gov.br
73
w <- c(rep(FALSE, times = 3), rep(TRUE, times = 5), FALSE, TRUE)

w
## [1] FALSE FALSE FALSE TRUE TRUE TRUE TRUE TRUE FALSE TRUE
# Número total de TRUEs

sum(w)
## [1] 6
# Proporção de TRUEs
mean(w)
## [1] 0.6
Na subseção seguinte, explicamos o que ocorre com a situação inversa, isto é, quando convertemos
um objeto numérico para lógico.
2.3.10.2 Conversão Explícita
Além das conversões automáticas (implícitas) que acontecem com algumas funções, é possível
converter explicitamente um objeto para a classe desejada. As funções as.*() fazem justamente
isto, convertendo o objeto para a classe (*) em questão.
x <- 0:10
class(x)
## [1] "integer"
# Converter para números reais

x_double <- as.double(x)
is_double(x_double)
## [1] TRUE

www.fjp.mg.gov.br
74
# Converter para lógicos

(x_logicos <- as.logical(x))
## [1] FALSE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE
is_logical(x_logicos)
## [1] TRUE
# Converter para lógicos

(x_caractere <- as.character(x))
## [1] "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "10"
class(x_caractere)
## [1] "character"
Como visto, quando convertemos um objeto numérico para lógico, o valor 0 é convertido para
FALSE, enquanto os valores restantes se tornam TRUE.
As coerções explícitas podem gerar erros supostamente inesperados, sendo fontes de frustração. Em
especial, a conversão de vetores de caracteres para outros tipos podem ser problemáticas. Nestes
casos, são exibidas advertências e gerados valores faltantes (NA), no lugar dos valores que não podem
ser convertidos de maneira apropriada.
x <- as.character(c(-10:1, 'a', 'b'))

x
## [1] "-10" "-9" "-8" "-7" "-6" "-5" "-4" "-3" "-2" "-1" "0" "1"
## [13] "a" "b"
# Conversão de caracteres para lógicos

as.logical(x)
## [1] NA NA NA NA NA NA NA NA NA NA NA NA NA NA

www.fjp.mg.gov.br
75
# Conversão de caracteres para números inteiros

as.integer(c(0, 1, 1.5, 'a'))
## Warning: NAs introduzidos por coerção
## [1] 0 1 1 NA
# Conversão de caracteres para números reais

as.double(c(0, 1, 1.5, 'a'))
## Warning: NAs introduzidos por coerção
## [1] 0.0 1.0 1.5 NA
Como visto, no segundo exemplo, o caractere 'a' não consegue ser convertido para um número
inteiro, tornandose o valor faltante, NA.
2.3.11 Selecionando elementos de vetores atômicos

Selecionar os elementos pertencentes a objetos é uma das operações mais fundamentais em R. Exis
tem três operadores básicos para a seleção (subsetting) e indexação de elementos em objetos: [, [[
e $. Nesta seção, iremos abordar os operadores empregados para a seleção de elementos de vetores
atômicos, [ e [[, com destque para o primeiro ([), por sua maior aplicabilidade.12
Resumidamente, [ pode ser utilizado para extrair um número qualquer de elementos de um objeto,
mantendo a sua classe inalterada. Em contrapartida, [[ extrai um único elemento de um objeto,
sem manter, necessariamente, a sua classe inalterada. Os diferentes usos de [ são comentados
e empregados a seguir, primeiramente para vetores unidimensionais (i.e., sem o attributo dim) e
depois para matrizes (que possuem mais de uma dimensão, especificada em dim).
2.3.11.1 Indexando vetores atômicos unidimensionais
Considerando um vetor x, criado de forma que cada dígito após a casa decimal de cada elemento
representa a posição original deste elemento no vetor (ex.: 3.1 indica que o número é o primeiro
elemento do vetor):
12
A seção sobre listas contém maneiras de indexar e selecionar elementos de listas e de base de dados, com suas
particularidades.

www.fjp.mg.gov.br
76
x <- c(3.1, 1.2, 4.3, 5.4, 2.5)
• [[
Como mencionado, [[ é utilizado para selecionar um único elemento de um vetor.
# Selecionar o primeiro elemento de `x`

x[[1]]
## [1] 3.1
# Estrutura
str(x[[1]])
## num 3.1
# Selecionar o último elemento de `x`

x[[length(x)]]
## [1] 2.5
• [
Dito isto, a utilização de [ para selecionar os elementos de x pode ser feita das seguintes maneiras.
• Números inteiros positivos retornam os elementos de acordo com suas posições no vetor.
Para usar este tipo de indexação, devemos escolher a(s) posição(ões) do(s) elemento(s) desejado(s)
e inseríla(s) em um vetor dentro de x[]. Podemos selecionar apenas um elemento, múltiplos ele
mentos ao criar um vetor com suas posições, por meio da função c(), ou até mesmo uma sequência
de elementos, com base em suas posições, por meio do caractere :, como no exemplo abaixo:
# Selecionar o segundo elemento de `x`

x[2]
## [1] 1.2

www.fjp.mg.gov.br
77
# Selecionar o primeiro e terceiro elementos de `x`

x[c(1,3)]
## [1] 3.1 4.3
# Selecionar do segundo ao quarto elementos de `x`

x[2:4]
## [1] 1.2 4.3 5.4
Se repertirmos a posição de elemento, seu valor será repetido no vetor resultante.
# Repetir a posição de um elemento

x[c(1,4,4)]
## [1] 3.1 5.4 5.4
• Números inteiros negativos excluem os elementos de acordo com suas posições no vetor.
Incluir o sinal de negativo (-) antes do vetor, como em x[-c()], exclui o(s) elemento(s) em questão.
# Excluir o primeiro e quinto elementos

x[-c(1,5)]
## [1] 1.2 4.3 5.4
OBS.: Não é possível misturar números inteiros positivos e negativos na seleção de elementos de
um vetor. Ao fazer isto, é exibida a seguinte mensagem: Error in x[c()] : only 0's may
be mixed with negative subscripts.
# Não misturar números inteiros positivos e negativos na seleção de objetos

x[c(-1,5)]
# Esta sintaxe não está correta
• Vetores lógicos retornam os elementos de acordo com os valores TRUE e FALSE.
Operações lógicas podem ser usadas para selecionar elementos de um vetor. Primeiramente, pode
mos identificar os vetores que queremos selecionar utilizando os operadores TRUE e FALSE, tendo
em vista suas posições no vetor.

www.fjp.mg.gov.br
78
# Selecionar os elementos de acordo com os operadores `TRUE` e `FALSE`

x[c(T, T, FALSE, TRUE, F)]
## [1] 3.1 1.2 5.4
ATENÇÃO: Notar que, ao utilizar a sintaxe x[vetor_logico], se o vetor vetor_logico dentro

de [] e x tiverem comprimentos distintos, a regra de reciclagem de vetores, explicada anteriormente,
será aplicada, de modo que o vetor de menor comprimento será reciclado até o comprimento do
maior.
No exemplo abaixo, o comprimento de x é 5, enquanto vetor_logico tem comprimento igual
a 2. Desta forma, o vetor_logico será repetido duas vezes, primeiramente por completo e, em
seguida, somente seu primeiro elemento, de modo que são selecionados o primeiro, terceiro e quinto
elementos dentro do vetor. Esta característica pode gerar resultados aparentemente inesperados,
portanto, cuidado.
# Sendo c(T,F), seleciona-se o primeiro, terceiro e quinto elementos de `x`
x[c(T,F)]
## [1] 3.1 4.3 2.5
Além disso, podemos utilizar expressões lógicas para selecionar elementos de um vetor, de acordo
com a condição desejada.
# Selecionar todos os elementos de `x` cujos valores são superiores a 3
x[x > 3]
## [1] 3.1 4.3 5.4
• Colchete vazio [] retorna o vetor original.
A aplicação desta forma de indexação é mais usual em matrizes e data.frames ou para uma nova
designação de objetos a partir do objeto original.
# []: Vetor original
x[]
## [1] 3.1 1.2 4.3 5.4 2.5
• Zero retorna um vetor numérico de comprimento igual a zero (0).
Esta aplicação pode ser utilizada para gerar dados para teste.

www.fjp.mg.gov.br
79
# Número 0 retorna um vetor de comprimento igual a zero

x[0]
## numeric(0)
• Nomes dos elementos retornam os elementos selecionados (somente se o vetor possuir este
atributo).
Se o vetor possuir o atributo names, podemos selecionar os elementos desejados de acordo com os
nomes designados a eles. Para tanto, devemos incluir os nomes como caracteres, i.e., entre aspas
(' ou ").
# Nomear os elementos de `x` com as 5 primeiras letras minúsculas do alfabeto

names(x) <- c(letters[1:5])
x
## a b c d e
## 3.1 1.2 4.3 5.4 2.5
# Selecionar os elementos `d` e è`

x[c('d', "e")]
## d e
## 5.4 2.5
# De maneira semelhante aos índices, podemos repetir os nomes para repetir seus valores
x[c('b', 'b', 'a')]
## b b a
## 1.2 1.2 3.1
OBS.: Como visto, a função letters() representa uma das constantes incluídas no R e contém
as letras do alfabeto em caixa baixa. Outras constantes são LETTERS (letras do alfabeto em caixa
alta), month.abb (abreviação de três letras dos meses em inglês), month.name (nomes dos meses
em inglês) e pi (a razão da circunferência de um círculo por seu diâmetro). Para mais detalhes,
consultar ?letters.

www.fjp.mg.gov.br
80
2.3.11.2 Indexando vetores atômicos multidimensionais (matrizes)
A indexação de matrizes (vetores atômicos multimensionais) possui similaridades com a usada para
vetores atômicos unidimensionais, mas também algumas particularidades.
# Criar uma matriz `y`
y <- matrix(11:22, nrow = 4, ncol = 3)
colnames(y) <- c(LETTERS[1:3])
y
## A B C
## [1,] 11 15 19
## [2,] 12 16 20
## [3,] 13 17 21
## [4,] 14 18 22
Se incluirmos apenas um dígito em matriz[dígito], iremos selecionar o elemento de acordo com

sua posição, seguindo a ordenação das colunas (seguindo do primeiro elemento da primeira coluna
ao último elemento da última coluna).
# Selecionar o segundo elemento de `y`
y[2]
## [1] 12
# Selecionar o décimo elemento de `y`

y[10]
## [1] 20
Adicionalmente, na indexação de matrizes, podemos selecionar os elementos tendo em vista as

dimensões destes objetos. Assim, ao usarmos dois indexadores em [, podemos escolher a dimensão
desejada, separando as linhas e colunas por uma vírgula, como em [ , ].
• As linhas correspondem ao lado esquerdo da vírgula.

• As colunas correspondem ao lado direito da vírgula.
Ou seja,
matriz[linhas, colunas]
Desta forma, podemos selecionar os elementos de acordo com suas posições na matriz.

www.fjp.mg.gov.br
81
# Selecionar o quarto elemento da primeira coluna

y[4,1]
## A
## 14
# Selecionar o primeiro elemento da última coluna

y[1,3]
## C
## 19
# Selecionar os dois primeiros elementos da última coluna

y[1:2, 3]
## [1] 19 20
Se deixarmos um espaço vazio antes ou depois da vírgula, selecionamos todos os elementos da

dimensão correspondente.
# Selecionar todos os elementos da primeira linha

y[1, ]
## A B C
## 11 15 19
# Selecionar todos os elementos da segunda coluna

y[ , 2]
## [1] 15 16 17 18
# Selecionar todos os elementos da primeira e segunda linha

y[c(1,2), ]
## A B C
## [1,] 11 15 19
## [2,] 12 16 20

www.fjp.mg.gov.br
82
OBS.: Esta característica (de selecionar dimensões inteiras pelo operador [) é compartilhada com
as bases de dados (data.frames) e representa uma maneira extremamente útil de se selecionar
elementos (sejam individuais, sejam linhas e colunas inteiras) destes objetos.
Adicionalmente, em matrizes que possuem o atributo names, como a criada anteriormente, podemos
selecionar os elementos destas porções nomeadas. No exemplo, demos nomes às colunas de y.
Desta forma, podemos selecionálas, respeitando a sintaxe matriz[linhas, colunas].
# Selecionar a coluna À`

y[, 'A']
## [1] 11 12 13 14
# Selecionar os dois primeiros elementos da segunda e terceira colunas

y[c(T,T,F,F), c("B","C")]
## B C
## [1,] 15 19
## [2,] 16 20
ATENÇÃO: Ao utilizar o operador [ em uma matriz (ou em data.frames), o resultado da ope

ração é simplificado em termos de estrutura. Mais especificamente, o objeto retornado possui uma
menor dimensão do que o objeto original, isto é, são removidos seus atributos (se eles existirem).
Para preservar a dimensão, deve ser especificado o argumento drop = FALSE.
# Operação sem preservar a dimensão

y[ , 1]
## [1] 11 12 13 14
class(y[ , 1])
## [1] "integer"
str(y[ , 1])
## int [1:4] 11 12 13 14

www.fjp.mg.gov.br
83
# Operação preservando a dimensão (argumento drop = FALSE)

y[ , 1, drop = FALSE]
## A
## [1,] 11
## [2,] 12
## [3,] 13
## [4,] 14
class(y[ , 1, drop = FALSE])
## [1] "matrix" "array"
str(y[ , 1, drop = FALSE])
## int [1:4, 1] 11 12 13 14
## - attr(*, "dimnames")=List of 2
## ..$ : NULL
## ..$ : chr "A"
Como visto, sem especificar drop = FALSE, o objeto retornado de y[ , 1] é um vetor de números
inteiros, sem atributos, isto é, sem dimensões nem nomes. Ao especificar o argumento drop =
FALSE, contudo, o objeto retornado possui sua classe preservada (matrix) e seus atributos, como
os nomes. Esta característica é uma fonte de possíveis erros e uma das justificativas para a utilização
de tibbles no lugar de data.frames. Para mais detalhes, ver Wickham (2015a) e Wickham and
Grolemund (2017).
2.4 Listas (list)

As listas (lists), também chamadas de Vetores Recursivos, são um dos princpais objetos em R e se
encontram em um patamar de complexidade acima dos vetores atômicos. Como mencionado ante
riormente, os vetores atômicos podem conter apenas um tipo de objeto, de modo que elementos de
tipos diferentes são convertidos para o tipo de maior complexidade ao combinar diferentes objetos.
Em contraposição, os elementos das listas podem pertencer a tipos distintos de objetos, ou seja,
elas são heterogêneas.
Para criar uma lista, utilizar o comando list().

www.fjp.mg.gov.br
84
# Criando uma lista

lista <- list(1, 2, 3)
lista
## [[1]]
## [1] 1
##
## [[2]]
## [1] 2
##
## [[3]]
## [1] 3
A função str() é bastante útil na utilização de listas, por apresentar sua estrutura, no lugar de seu
conteúdo.
# Função `str()`
str(lista)
## List of 3
## $ : num 1
## $ : num 2
## $ : num 3
Podemos nomear os elementos de uma lista ao criála ou utilizando a função names().
# Nomear uma lista ao criá-la

lista <- list(A = 1, B = 2, C = 3)
str(lista)
## List of 3
## $ A: num 1
## $ B: num 2
## $ C: num 3
# Remover os nomes de uma lista

(lista <- unname(lista))

www.fjp.mg.gov.br
85
## [[1]]
## [1] 1
##
## [[2]]
## [1] 2
##
## [[3]]
## [1] 3
# Adicionar os nomes pela função `names()`

names(lista) <- c(LETTERS[1:3])
lista
## $A
## [1] 1
##
## $B
## [1] 2
##
## $C
## [1] 3
Como dito, as listas podem conter elementos de tipos distintos.
# Criar uma lista contendo os principais tipos de vetores atômicos

lista <- list(logico = c(T,F),
inteiro = 100:105,
reais = seq(from = 0, to = 1, length.out = 5),
caracteres = letters[26:20])
str(lista)
## List of 4
## $ logico : logi [1:2] TRUE FALSE
## $ inteiro : int [1:6] 100 101 102 103 104 105
## $ reais : num [1:5] 0 0.25 0.5 0.75 1
## $ caracteres: chr [1:7] "z" "y" "x" "w" ...
Em última instância, listas podem conter outras listas.

www.fjp.mg.gov.br
86
# Lista contendo outra lista

lista2 <- list(lista,
list(letters[1:3]),
c(1:10))
names(lista2) <- c('lista_A', "lista_B", "vetor_C")
str(lista2)
## List of 3
## $ lista_A:List of 4
## ..$ logico : logi [1:2] TRUE FALSE
## ..$ inteiro : int [1:6] 100 101 102 103 104 105
## ..$ reais : num [1:5] 0 0.25 0.5 0.75 1
## ..$ caracteres: chr [1:7] "z" "y" "x" "w" ...
## $ lista_B:List of 1
## ..$ : chr [1:3] "a" "b" "c"
## $ vetor_C: int [1:10] 1 2 3 4 5 6 7 8 9 10
2.4.0.1 Selecionando elementos de uma lista
Além dos operadores de seleção de elementos já mencionados em vetores atômicos ([ e [[), em

listas também podemos usar o operador $. De maneira sintética, [ seleciona o elemento desejado de
uma lista, de acordo com sua posição ou nome, e retorna uma lista. Ou seja, [ preserva a estrutura
original do objeto inteiro.
Por outro lado, [[ e $ são utilizados para extrair um único elemento do objeto em questão. Desta
forma, [[ e $ retornam um objeto de classe igual ao elemento extraído, sem preservar a classe do
objeto inteiro. Por exemplo, se o primeiro elemento (chamado vetor_logico) dentro de uma lista
(lista) é um vetor atômico do tipo lógico, o resultado de lista[[1]] ou lista$vetor_logico
também será um vetor atômico do tipo lógico. Como visto anteriormente, em [[ podemos utilizar a
posição do elemento ou seu nome como argumento para selecionálo. Em $, por sua vez, devemos
utilizar apenas o nome do elemento.
Em resumo, ao extrair elementos de uma lista:
• [ preserva a estrutura original do objeto inteiro (retorna uma lista);

• [[ e $ não preservam a estrutura do objeto inteiro, apenas do elemento extraído (i.e, retornam
um objeto com a estrura do elemento individual).
# Operador `[`
lista["logico"]

www.fjp.mg.gov.br
87
## $logico
## [1] TRUE FALSE
str(lista["logico"])
## List of 1
## $ logico: logi [1:2] TRUE FALSE
lista2[c(1,3)]
## $lista_A
## $lista_A$logico
## [1] TRUE FALSE
##
## $lista_A$inteiro
## [1] 100 101 102 103 104 105
##
## $lista_A$reais
## [1] 0.00 0.25 0.50 0.75 1.00
##
## $lista_A$caracteres
## [1] "z" "y" "x" "w" "v" "u" "t"
##
##
## $vetor_C
## [1] 1 2 3 4 5 6 7 8 9 10
# Operador `[[`
lista[[1]]
## [1] TRUE FALSE
str(lista[[1]])
## logi [1:2] TRUE FALSE
# Operador `$`
lista$logico
## [1] TRUE FALSE

www.fjp.mg.gov.br
88
str(lista$logico)
## logi [1:2] TRUE FALSE
Como visto, podemos selecionar elementos de listas que estão contidas em outras listas.
# Selecionar o segundo elemento contido na primeira lista em `lista2` (ìnteiro`)

lista2$lista_A$inteiro
## [1] 100 101 102 103 104 105
str(lista2$lista_A$inteiro)
## int [1:6] 100 101 102 103 104 105
# O mesmo, preservando a estrutura de lista

lista2[[1]][2]
## $inteiro
## [1] 100 101 102 103 104 105
str(lista2[[1]][2])
## List of 1
## $ inteiro: int [1:6] 100 101 102 103 104 105
# O mesmo, utilizando nomes

lista2[["lista_A"]]["inteiro"]
## $inteiro
## [1] 100 101 102 103 104 105
str(lista2[["lista_A"]]["inteiro"])
## List of 1
## $ inteiro: int [1:6] 100 101 102 103 104 105
Podemos extrair elementos individuais dentro das listas, combinando [ e [[.

www.fjp.mg.gov.br
89
# Extrair o terceiro elemento da segunda lista (`lista_B`) dentro de `lista2`

lista2[[3]][2]
## [1] 2
lista2[["vetor_C"]][2]
## [1] 2
# Extrair o segundo elemento da `lista_B` contida em `lista2`

lista2[["lista_B"]][[1]][2]
## [1] "b"
Dica: Nomear os elementos das listas ajuda bastante, pela praticidade do operador $.
A estrutura de listas pode ser relativamente complexa e a representação de seus elementos e das
formas de indexação não é muito visual. Para facilitar o entendimento, este esquema de repre
sentação, criado por Wickham and Grolemund (2017), ou este, criado por Wickham (2015a), são
extremamente úteis, por serem bastante intuitivos.
2.5 Tabelas no R (data.frame)

As tabelas (data frames) correspondem a uma das estruturas mais importantes para análise de dados
em R e são criadas a partir de listas. Um data frame é uma lista nomeada de vetores, que devem
possuir o mesmo comprimento, com atributos de nomes designados às suas colunas e linhas (names
e row.names, respectivamente) e classe definida como data.frame. Desta forma, as data frames
possuem uma forma retangular e compartilham propriedades tanto com matrizes quanto com listas.
Algumas observações:
• O atibuto names() de uma data frame corresponde aos nomes de suas colunas, que também
podem ser designados por colnames(). Os nomes das linhas é obtido por rownames().
• A quantidade de colunas de uma base de dados é obtida por ncol() ou pelo comando
length(base_de_dados). A quantidade de linhas é obtida por nrow().
Podemos criar uma base de dados por meio do comando data.frame().

www.fjp.mg.gov.br
90
# Criar uma data.frame pelo comando `data.frame()`

df <- data.frame(c(0, 0.5), c(10,20))
# Especificar o nome das colunas pelo comando colnames()
colnames(df) <- c('A', "B")
df
## A B
## 1 0.0 10
## 2 0.5 20
str(df)
## 'data.frame': 2 obs. of 2 variables:

## $ A: num 0 0.5
## $ B: num 10 20
ATENÇÃO: Especificamos o argumento stringsAsFactors = F para que os caracteres não se

jam convertidos para fatores (factors), o que ocorre automaticamente em data.frames. Esta con
versão automática por parte de data frames é a origem de diversos erros ao ler dados no R, portanto,
cuidado.
2.5.0.1 Builtin Datasets (base de dados de exemplos)
A instalação padrão do R vem com diversas bases de dados incluídas no programa (builtin da
tasets), que podem ser utilizadas para testar funções e entender melhor o funcionamento geral da
linguagem. Estas bases encontramse no pacote datasets, carregado automaticamente ao iniciar
o R. Para acessar a lista completa de base de dados de exemplos do R, utilizar o comando data()
sem nenhum argumento.
# Acessar a lista completa de built-in datasets

data()
As bases de dados incluídas no pacote datasets já estão automaticamente disponíveis para serem
usadas no R. Para isto, basta apenas digitar seu nome (em uma função, no console, etc).
# Estrutura da base ìris`

str(iris)

www.fjp.mg.gov.br
91

## $ Sepal.Length: num 5.1 4.9 4.7 4.6 5 5.4 4.6 5 4.4 4.9 ...
## $ Sepal.Width : num 3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9 3.1 ...
## $ Petal.Length: num 1.4 1.4 1.3 1.5 1.4 1.7 1.4 1.5 1.4 1.5 ...
## $ Petal.Width : num 0.2 0.2 0.2 0.2 0.2 0.4 0.3 0.2 0.2 0.1 ...
## $ Species : Factor w/ 3 levels "setosa","versicolor",..: 1 1 1 1 1 1 1 1 1 1 ...
# Cinco primeiras linhas da base ìris`

head(iris, n = 5)
## Sepal.Length Sepal.Width Petal.Length Petal.Width Species

## 1 5.1 3.5 1.4 0.2 setosa
## 2 4.9 3.0 1.4 0.2 setosa
## 3 4.7 3.2 1.3 0.2 setosa
## 4 4.6 3.1 1.5 0.2 setosa
## 5 5.0 3.6 1.4 0.2 setosa
Acima, visualizamos a estrutura e as cinco primeiras linhas da base de dados iris por meio da
funcão head().
Além disso, outros pacotes, dplyr e ggplot2, por exemplo, vêm com bases de dados que são
usadas nos exemplos contidos em suas documentações.
• Para carregar a lista de base de dados de um pacote: data(package = "nome_do_pacote");
• Para carregar uma base de dados de um pacote específico: data(nome_da_base, package

= "nome_do_pacote").
# Exibir lista de base de dados do pacote `dplyr`

data(package = "dplyr")
# Carregar a base de dados "starwars" do pacote `dplyr`
data("starwars", package = 'dplyr')
2.5.0.2 Seleção de elementos de bases de dados
Como dito, bases de dados possuem características de matrizes e listas. Desta forma, a seleção de
seus elementos compartilham aspectos destes outros tipos de objetos. Podemos utilizar os opera
dores [, [[ e $.
• Seleção de elementos como listas:

www.fjp.mg.gov.br
92
Ao empregar apenas um indexador nos operadores de seleção (como em base_de_dados[indexador]),

as bases de dados se comportam como listas. Assim, as colunas são selecionadas pelo indexador
incluído no operador, ou seja,
base_de_dados[colunas].
Analogamente ao visto em seções anteriores, [ preserva a estrutura do objeto original, ou seja,
retorna uma data.frame, e pode ser usado para selecionar múltiplos elementos (colunas) da base
de dados.
# Selecionar a segunda coluna de `df`

str(df[2])
## 'data.frame': 2 obs. of 1 variable:

## $ B: num 10 20
# Selecionar as duas primeiras colunas de ìris`

str(iris[1:2])

## $ Sepal.Length: num 5.1 4.9 4.7 4.6 5 5.4 4.6 5 4.4 4.9 ...
## $ Sepal.Width : num 3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9 3.1 ...
Em contrapartida, [[ e $ retornam o elemento individual da base de dados, sem manter seus atri
butos, ou seja, sem preservar a estrutura inicial do objeto.
# `[[` para selecionar a segunda coluna de ìris`

str(iris[[2]])
## num [1:150] 3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9 3.1 ...
# `$` para selecionar a coluna "Species"

str(iris$Species)
## Factor w/ 3 levels "setosa","versicolor",..: 1 1 1 1 1 1 1 1 1 1 ...
• Seleção de elementos como matrizes:

www.fjp.mg.gov.br
93
Quando usamos os dois indexadores na seleção de elementos de bases de dados (linhas e colunas),
as bases de dados se comportam como matrizes na operação de seleção. Assim, utilizase a sintaxe
conhecida:
base_de_dados[linhas, colunas]
de modo que podemos selecionar elementos individuais de uma linha, coluna ou linhas inteiras e
colunas.
# Selecionar a última coluna de `df`

df[ , "B"]
## [1] 10 20
# Selecionar todas as observações cuja `Sepal.Length` seja menor do que 4.5

iris[iris$Sepal.Length < 4.5, ]

## 9 4.4 2.9 1.4 0.2 setosa
## 14 4.3 3.0 1.1 0.1 setosa
## 39 4.4 3.0 1.3 0.2 setosa
## 43 4.4 3.2 1.3 0.2 setosa
# Selecionar as duas primeiras linhas de ìris`

iris[c(1,2), ]

## 1 5.1 3.5 1.4 0.2 setosa
## 2 4.9 3.0 1.4 0.2 setosa
Há uma importante diferença ao selecionar elementos de uma base de dados pela sintaxe de listas
(base_de_dados[indexador]) e de matrizes (base_de_dados[linhas, colunas]), utilizando
o operador [. Analogamente à indexação de matrizes, ao selecionarmos apenas uma coluna pela
sintaxe base_de_dados[linhas, colunas], a estrutura do objeto resultante é simplificada (i.e.,
o objeto resultante passa a ser um vetor atômico), enquanto enquanto a indexação de listas preserva
a estrutura do objeto original (o objeto resultante é uma base de dados). Para preservar a estrutura
original do objeto pela sintaxe base_de_dados[linhas, colunas], devemos incluir o argumento
drop = FALSE.

www.fjp.mg.gov.br
94
# Sem incuir o argumento `drop = FALSE`: não preserva a estrutura `data.frame`

str(df[ , 2])
## num [1:2] 10 20
# Incuir o argumento `drop = FALSE`

str(df[ , 2, drop = FALSE])

## $ B: num 10 20
2.5.0.3 Comandos úteis com bases de dados
A partir dos conceitos expostos sobre base de dados (nomes das colunas, seleção de suas colunas,
etc) podemos fazer algumas operações bastante úteis com estes objetos a partir das funções base do
R.13
# Criar objeto contendo a base ìris` como exemplo

base <- iris
str(base)

## $ Sepal.Length: num 5.1 4.9 4.7 4.6 5 5.4 4.6 5 4.4 4.9 ...
## $ Sepal.Width : num 3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9 3.1 ...
## $ Petal.Length: num 1.4 1.4 1.3 1.5 1.4 1.7 1.4 1.5 1.4 1.5 ...
## $ Petal.Width : num 0.2 0.2 0.2 0.2 0.2 0.4 0.3 0.2 0.2 0.1 ...
• Renomear colunas de uma base de dados
Para renomear as colunas de uma base de dados, podemos utilizar as funções colnames() ou
names().
13
Existem soluções mais elegantes e eficientes para realizar estas e operações semelhantes com base de dados, porém
são necessárias a utilização de outros pacotes (como data.table e o próprio tidyverse), além do conhecimento
de outros tópicos que fogem do conhecimento deste documento (criação de funções, pipes, etc). Optouse por focar
nas formas essenciais de execturar estas tarefas.

www.fjp.mg.gov.br
95
# Renomear todas as colunas de uma base de dados

colnames(df) <- c("nova_coluna1", "nova_coluna2")
str(df)

## $ nova_coluna1: num 0 0.5
## $ nova_coluna2: num 10 20
names(df) <- c('z', "y")

str(df)

## $ z: num 0 0.5
## $ y: num 10 20
# Renomear colunas de uma base de dados de acordo com suas posições

names(df)[1] <- c("novo_nome")
str(df)

## $ novo_nome: num 0 0.5
## $ y : num 10 20
names(base)[1:2] <- c('S.Length', 'S.Width')

str(base)

## $ S.Length : num 5.1 4.9 4.7 4.6 5 5.4 4.6 5 4.4 4.9 ...
## $ S.Width : num 3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9 3.1 ...
## $ Petal.Length: num 1.4 1.4 1.3 1.5 1.4 1.7 1.4 1.5 1.4 1.5 ...
## $ Petal.Width : num 0.2 0.2 0.2 0.2 0.2 0.4 0.3 0.2 0.2 0.1 ...
Podemos renomear uma coluna de acordo com seu nome, sem depender, portanto, de
sua posição na base de dados, por meio do seguinte código: names(df)[names(df) ==
'nome_coluna_antigo'] <- 'nome_coluna_novo'

www.fjp.mg.gov.br
96
# Renomear uma coluna de acordo com seu nome

names(df)[names(df) == 'y'] <- 'coluna_y'
str(df)

## $ novo_nome: num 0 0.5
## $ coluna_y : num 10 20
• Reordenar colunas de uma base de dados
Podemos usar o operador [ para reordenar as colunas de uma base de dados a partir de seus nomes
ou posições.
# Obter os nomes das colunas de uma base de dados

(nomes_colunas <- colnames(base))
## [1] "S.Length" "S.Width" "Petal.Length" "Petal.Width" "Species"
# Reordenar colunas pelos seus nomes

base <- base[c("Petal.Length", "Petal.Width", "Species", "S.Length", "S.Width")]
str(base)

## $ Petal.Length: num 1.4 1.4 1.3 1.5 1.4 1.7 1.4 1.5 1.4 1.5 ...
## $ Petal.Width : num 0.2 0.2 0.2 0.2 0.2 0.4 0.3 0.2 0.2 0.1 ...
## $ S.Length : num 5.1 4.9 4.7 4.6 5 5.4 4.6 5 4.4 4.9 ...
## $ S.Width : num 3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9 3.1 ...
# Reordenar colunas pelas suas posições

base <- base[c(4,5,1:3)]
str(base)

## $ S.Length : num 5.1 4.9 4.7 4.6 5 5.4 4.6 5 4.4 4.9 ...
## $ S.Width : num 3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9 3.1 ...
## $ Petal.Length: num 1.4 1.4 1.3 1.5 1.4 1.7 1.4 1.5 1.4 1.5 ...
## $ Petal.Width : num 0.2 0.2 0.2 0.2 0.2 0.4 0.3 0.2 0.2 0.1 ...

www.fjp.mg.gov.br
97
• Excluir colunas de uma base de dados
Podemos excluir colunas de uma base de dados por nome ou posição, de várias maneiras.
# Excluir colunas de bases de dados por nome

base$S.Length <- NULL
str(base)

## $ S.Width : num 3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9 3.1 ...
## $ Petal.Length: num 1.4 1.4 1.3 1.5 1.4 1.7 1.4 1.5 1.4 1.5 ...
## $ Petal.Width : num 0.2 0.2 0.2 0.2 0.2 0.4 0.3 0.2 0.2 0.1 ...
base <- base[, ! names(base) %in% c('Species'), drop = F]

str(base)

## $ S.Width : num 3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9 3.1 ...
## $ Petal.Length: num 1.4 1.4 1.3 1.5 1.4 1.7 1.4 1.5 1.4 1.5 ...
## $ Petal.Width : num 0.2 0.2 0.2 0.2 0.2 0.4 0.3 0.2 0.2 0.1 ...
# Excluir colunas por posição

base[1:2] <- list(NULL)
str(base)

## $ Petal.Width: num 0.2 0.2 0.2 0.2 0.2 0.4 0.3 0.2 0.2 0.1 ...
base <- base[-1]

str(base)
## 'data.frame': 150 obs. of 0 variables
• Adicionar colunas a uma base de dados
Analogamente, podemos utilizar os operadores para adicionar colunas a uma base de dados.

www.fjp.mg.gov.br
98
# Adicionar colunas a uma base

base$Sepal.Length.base <- iris$Sepal.Length
str(base)

## $ Sepal.Length.base: num 5.1 4.9 4.7 4.6 5 5.4 4.6 5 4.4 4.9 ...
base[, c("Sepal.Width.base","Petal.Length.base")] <- iris[, c(2,3)]

str(base)

## $ Sepal.Width.base : num 3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9 3.1 ...
## $ Petal.Length.base: num 1.4 1.4 1.3 1.5 1.4 1.7 1.4 1.5 1.4 1.5 ...
# Adicionar uma coluna a partir de uma operação matemática (soma)

base[, 'soma_1_2'] <- base$Sepal.Length.base + base$Sepal.Width.base
str(base)

## $ Sepal.Width.base : num 3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9 3.1 ...
## $ Petal.Length.base: num 1.4 1.4 1.3 1.5 1.4 1.7 1.4 1.5 1.4 1.5 ...
## $ soma_1_2 : num 8.6 7.9 7.9 7.7 8.6 9.3 8 8.4 7.3 8 ...
2.5.0.4 Tibble
O objeto tibble é uma reimaginação do data frame, criado para lidar com alguns problemas usuais
obtidos no uso destes objetos. As referências utilizadas neste livro recomendam o uso deste objetos,
então vale a pena descobrir algumas de suas especificidades, nesta subseção do livro de Wickham
ou no Capítulo sobre tibbles do livro seminal de Wickham e Grolemund.

www.fjp.mg.gov.br

Apostila Unidade 2 - Curso R

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila Unidade 2 - Curso R

Enviado por

Direitos autorais:

Formatos disponíveis

Capítulo 2

Aula 2 ­ Básicos da Sintaxe do R

João Pedro Figueira Amorim Parga

Fundação João Pinheiro

2.1 Recaptulação: História do R

A filosofia por trás da linguagem S ajuda a compreender o funcionamento e a estrutura do R. Em

Fundação João Pinheiro

O sistema R pode ser divido em duas porções:

RStudio é um software de programação em R, caracterizado como um Ambiente de Desenvolvi­

Fundação João Pinheiro

Fundação João Pinheiro

2.2 Introdução ao R e RStudio: noções básicas

2.2.1 Executando comandos: Console

Localizado no painel esquerdo do RStudio, o Console corresponde ao local de inserção de códigos

Figura 2.1: RStudio: Console

Abaixo, alguns caracteres importantes para o Console:

• > marca o início de uma linha;

Fundação João Pinheiro

Para executar um comando no Console, devemos digitá­lo e pressionar a tecla Enter.

# Completando uma expressão

Fundação João Pinheiro

> # Sinais de operação ao fim de cada linha

2.2.1.1 Histórico de comandos

No Console, podemos acessar os comandos previamente executados na sessão presente do R. Di­

Figura 2.2: Histórico de comandos ­ Console

# Exibir os últimos 10 comandos do histórico

Fundação João Pinheiro

Figura 2.3: Aba History ­ Quadrante superior direito

2.2.2 Operações matemáticas básicas

Fundação João Pinheiro

# Divisão inteira (fornece apenas a porção inteira do resultado da divisão): %/%

# Resto da divisão (restante da divisão do número da esquerda pelo número da direita): %%

2.2.3 Designação de Objetos (Introdução à Objetos)

Um objeto (variável) é um dos conceitos mais importantes em linguagens de programação. Em R,

Fundação João Pinheiro

• Alt + - : pressionar a tecla Alt juntamente com a tecla - (o sinal de menos).

# Atribuir o valor 5 ao objeto x

# Exibir o objeto criado no Console

# Designar um valor a um objeto e exibí-lo simultaneamente

Fundação João Pinheiro

# Modificar o valor de um objeto: simplesmente fazer outra operação de designação

Assim, ao objeto x é designado um novo valor (3 ^ 2 = 9: 3 elevado a 2, igual a 9). O novo

2.2.3.1 Como nomear um objeto

Os nomes dos objetos podem conter somente os seguintes caracteres:

e não podem começar com:

Fundação João Pinheiro

2.2.3.2 Utilizando objetos

# Objetos contendo o total de horas/aula do curso e o montante concluído até o momento

# Obter a quantidade de horas/aula restantes

# Criar objeto contendo a quantidade de horas/aula restantes

2.2.4 Funções (noções básicas)

Fundação João Pinheiro

Os argumentos identificam os dados que serão transformados e representam especificações que

1. Os dados (data), que especificam onde a função será executada;

max(1, 2, 3, 10, 50, 100)

Fundação João Pinheiro

# Não especificar o argumento `file = `

2.2.5 Erros e ajuda: como e onde obter

A frustração é comum ao se começar a programar em R, em função do caminho natural para o

2.2.5.1 Ajuda Interna (RStudio): help e ?

Fundação João Pinheiro

## starting httpd help server ... done

Aula 2 Básicos da Sintaxe do R

RStudio é um software de programação em R, caracterizado como um Ambiente de Desenvolvi

Para executar um comando no Console, devemos digitálo e pressionar a tecla Enter.

No Console, podemos acessar os comandos previamente executados na sessão presente do R. Di

Figura 2.2: Histórico de comandos Console

Figura 2.3: Aba History Quadrante superior direito

– Introduction to R Datacamp: curso introdutório ao R do Datacamp. Bom ponto de

– Manipulação e Visualização de Dados: material online, em português, feito por Wal

Figura 2.4: Mensagem de erro Console

Figura 2.5: Mensagem de erro Resultado da busca no Google

Figura 2.6: Mensagem de erro Questão submetida ao Stackoverflow

• Dica Removendo todos os objetos do Environment: A função rm() possui o argumento

Figura 2.7: Mensagem de erro Resposta mais votada no Stackoverflow

Ao rodar o comando de instalação de pacotes (install.packages("nome_do_pacote")), o pa

Para visualizar os pacotes instalados na máquina, utilizase as funções library() e installed.packages(),