Computacao-para-Ciencia-de-Dados---eBook (1)

Prévia do material em texto

1 
 
 
2 
 
 
Sumário 
Apresentação .............................................................................................................................................. 5 
UNIDADE 1: Introdução à Ciência de Dados e ao Ambiente R ....................................................................... 6 
1.1 Considerações Iniciais ........................................................................................................................ 6 
1.2 Introdução à Ciência de Dados ........................................................................................................... 6 
1.3 Áreas de Aplicação da Ciência de Dados ............................................................................................. 7 
1.4 Fluxo de Trabalho na Ciência de Dados ............................................................................................... 8 
1.5 Roteiro ..............................................................................................................................................10 
1.5.1 Pré-requisitos .............................................................................................................................10 
1.5.2 Recursos usados no módulo .......................................................................................................10 
1.5.3 Assuntos abordados no módulo..................................................................................................10 
1.6 Introdução ao Ambiente R.................................................................................................................11 
1.6.1 A Ferramenta RStudio ................................................................................................................12 
1.6.2 Como buscar Ajuda? ...................................................................................................................13 
1.6.3 Conceitos Básicos .......................................................................................................................14 
1.6.4 Objetos (Variáveis) .....................................................................................................................16 
1.6.5 Funções ......................................................................................................................................17 
1.6.6 Pacotes.......................................................................................................................................18 
1.6.7 Boas Práticas ..............................................................................................................................18 
1.6.8 Tipos de Variáveis .......................................................................................................................19 
1.6.9 Estrutura Condicional .................................................................................................................22 
1.6.10 Estrutura de Repetição .............................................................................................................23 
1.7 Considerações Finais .........................................................................................................................24 
UNIDADE 2: Exploração de Dados com a Ferramenta R ...............................................................................25 
2.1 Considerações Iniciais .......................................................................................................................25 
2.2 Importação/Leitura dos Dados ..........................................................................................................25 
2.2.1 Tipos de Estruturas de Dados .....................................................................................................25 
2.2.2 Definindo o Local dos Dados .......................................................................................................26 
2.2.3 Pacote para leitura dos dados .....................................................................................................26 
2.3 Limpeza dos Dados ............................................................................................................................29 
2.3.1 O Pacote tidyr ...........................................................................................................................30 
2.4 Transformação dos Dados .................................................................................................................34 
2.4.1 Valores faltantes e o “NA” ..........................................................................................................34 
2.4.2 Transformação de dados com o Pacote dplyr.............................................................................36 
2.5 Escrita dos dados e Leitura em outras fontes .....................................................................................39 
3 
 
2.5.1 Escrevendo arquivos no formato csv ..........................................................................................39 
2.5.2 Escrevendo arquivos no formato RData ....................................................................................39 
2.5.3 Escrevendo outros tipos de arquivos ..........................................................................................40 
2.5.4 Obtendo dados de outras fontes ................................................................................................41 
2.6 Considerações Finais .........................................................................................................................42 
UNIDADE 3: Modelagem de Dados com a Ferramenta R – Análise de Regressão Linear ...............................43 
3.1 Considerações Iniciais .......................................................................................................................43 
3.2 Análise de Regressão .........................................................................................................................43 
3.3 Análise de Regressão Linear ..............................................................................................................44 
3.3.1 Entendendo o conjunto de dados ...............................................................................................45 
3.4 Análise de Regressão Simples (ou de um Fator) .................................................................................47 
3.4.1 Visualizando os dados.................................................................................................................47 
3.4.2 A função do modelo linear ..........................................................................................................49 
3.4.3 A Análise de Correlação (R) .........................................................................................................51 
3.4.4 Avaliando a qualidade do modelo ...............................................................................................52 
3.4.5 Análise dos residuais ..................................................................................................................54 
3.5 Análise de Regressão Múltipla (ou de múltiplos Fator) ......................................................................56 
3.5.1 Visualizando o relacionamento nos dados ..................................................................................56 
3.5.2 Identificando preditores em potencial ........................................................................................57 
3.5.3 O processo de eliminação reversa ..............................................................................................59 
3.5.4 A análise dos residuais ................................................................................................................62 
3.6 Considerações Finais .........................................................................................................................65UNIDADE 4: Modelagem de Dados com a Ferramenta R – Análise de Redes Sociais ....................................66 
4.1 Considerações Iniciais .......................................................................................................................66 
4.2 Histórico da Análise de Redes Sociais e suas definições .....................................................................66 
4.3 Teoria dos Grafos ..............................................................................................................................67 
4.3.1 Identificando arestas importantes ..............................................................................................69 
4.3.2 Identificando vértices importantes – Métricas de Centralidade ..................................................70 
4.3.3 Identificando vértices influentes – Hub e Authority .....................................................................73 
4.3.4 Caracterizando a Estrutura do Grafo – Coesão ............................................................................74 
4.4 Análise de Redes Sociais com o Ambiente R ......................................................................................77 
4.4.1 Importando as informações da rede (nós e links) ........................................................................77 
4.4.2 Criando objetos do tipo grafo (rede) ...........................................................................................78 
4.4.3 Visualizando a rede ....................................................................................................................80 
4.4.4 Calculando as Métricas de Análise de Redes Sociais ....................................................................85 
4.5 Considerações Finais .........................................................................................................................91 
UNIDADE 5 - Visualização e Comunicação dos Dados ..................................................................................92 
4 
 
5.1 Considerações Iniciais .......................................................................................................................92 
5.2 RMarkdown ......................................................................................................................................92 
5.2.1 Estrutura de um arquivo RMarkdown .........................................................................................93 
5.2.2 Renderizando um documentos ...................................................................................................95 
5.2.3 Sintaxe .......................................................................................................................................96 
5.2.4 Opções de chunk ........................................................................................................................97 
5.3 Visualização de gráficos com o pacote ggplot2.................................................................................98 
5.3.1 Mapeamento estéticos .............................................................................................................100 
5.3.2 Objetos geométricos ................................................................................................................100 
5.3.3 Escalas ......................................................................................................................................102 
5.3.4 Tipos de Gráficos ......................................................................................................................104 
5.4 Considerações Finais .......................................................................................................................114 
Referências ...............................................................................................................................................115 
 
 
5 
 
 
Apresentação 
 
Prezado aluno, 
é uma grande satisfação contar com você para este módulo da especialização sobre o qual tratare-
mos sobre a Ciência de Dados e técnicas computacionais importantes que servirão de apoio para 
a análise de tais dados. 
 
Meu nome é Rogério Ferreira, sou professor da área de Ciência da Computação há dez anos. Sou 
Bacharel em Informática pela Universidade Estadual de Maringá (UEM), Mestre em Ciência da 
Computação (UEM) na área de Engenharia de Software, com ênfase na em Arquitetura de Linha 
de Produto para Sistemas Embarcados, e atualmente sou doutorando em Ciência da Computação 
e Matemática Computacional na Universidade de São Paulo (USP), com tese na área de Social 
Learning Analytics, uma área específica da ciência de dados que visa analisar dados relacionados 
à educação. Caso queira entrar em contato comigo, fique à vontade para me escrever no e-mail 
rogeriofrr@gmail.com. 
 
Aos longo dos próximos capítulos, vamos introduzir o que é ciência de dados e qual as competên-
cias exigidas para um cientista de dados na atualidade. Vamos aprender a usar o R, um ambiente 
computacional e uma linguagem de programação que vem se destacando quando o assunto é ma-
nipulação, análise e visualização gráfica de dados. Aprenderemos como ler, transformar, modelar 
e visualizar os dados, de modo a permitir que as conclusões do cientista de dados sejam facilmente 
comunicadas a terceiros. 
 
Ciência de Dados é um assunto fascinante! Vai ser um prazer tê-lo conosco nos próximos capítulos, 
para aprender mais sobre as técnicas computacionais utilizadas nessa ciência. 
mailto:rogeriofrr@gmail.com
6 
 
 
UNIDADE 1: Introdução à Ciência de Dados e ao Ambiente R 
 
1.1 Considerações Iniciais 
 
Neste primeiro capítulo, vamos iniciar os estudos sobre Ciência de Dados e as ferramentas compu-
tacionais que servem de apoio para analisar tais dados. Na seção 1.2 discutiremos o que é Big 
Data, Ciência de Dados e qual a importância destes dois conceitos em um cenário como o atual, 
em que a cada dia se produz um volume maior de dados, sobre as mais diferentes áreas do conhe-
cimento humano. Na seção 1.3 estudaremos algumas das inúmeras áreas em que a ciência de 
dados pode ser aplicada e alguns exemplos de dados que podem ser analisados. Na seção 1.4 
vamos aprender o fluxo de trabalho em ciência de dados, ou seja, quais são as etapas que um 
cientista de dados deve aprender e executar para realizar a análise de um conjunto de dados. Na 
seção 1.5 vamos apresentar o roteiro deste módulo, ou seja, quais assuntos serão estudados na 
sequência deste capítulo e nos capítulos seguintes. Na seção 1.6 vamos aprender os conceitos 
fundamentais do ambiente R e da ferramenta RStudio, utilizados ao longo deste módulo. Por fim, a 
seção 1.7 faz as considerações finais do capítulo. 
 
1.2 Introdução à Ciência de Dados 
 
 Antes de falarmos especificamente sobre Ciência de Dados, precisamos introduzir o con-
ceito de Big Data. Embora, normalmente, o termo Big Data esteja associado a grandes volumes de 
dados, sua definição formal é dada por um conjunto de cinco Vs: são dados produzidos com Vo-
lume, Velocidade, Variedade, Veracidade e Valor. Em outras palavras, Big Data é o fenômeno em 
que dados são produzidos em vários formatos e armazenados em uma grande quantidade de for-
matos e equipamentos. Esse fenômeno fica mais compreensível quando falamos em números: um 
smartphone de hoje tem maior capacidade que o melhor computador existente em 1985; hoje exis-
tem mais de seis bilhões de pessoas com acesso a telefones celulares; mais de 1,7 bilhões de 
pessoas no mundo estão usando redes sociais; um disco para armazenar todas as músicas exis-
tentes no mundo custa cerca de US$600,00; quase três milhões de e-mails são enviados a cadas 
segundo; cem horas de vídeos são carregados no Youtube por minuto; quinhentos milhões de 
tweets são publicados por dia no Twitter; e 100 terabytes de dados são carregados por dia no Fa-
cebook (AMARAL, 2016).Reflita! Analise a quantidade de informações digitais que você produz em um único dia: e-mails 
enviados, vídeos assistidos no Youtube, postagens em redes sociais, fotos e arquivos armazenados 
na nuvem, informações sobre sua localização captadas e armazenadas em seu celular, buscas 
feitas no Google, compras realizadas na Internet. Agora multiplique essa quantidade de dados por 
alguns bilhões, considerando a quantidade de pessoas no mundo que produzem as mesmas infor-
mações. É um volume de dados inimaginável, nunca antes produzido pela humanidade que vem 
sendo diariamente armazenado e está disponível para análise pelas grandes corporações. 
 Do ponto de vista tecnológico, o elemento principal associado ao Big Data é o registro de 
qualquer fenômeno em dados. Estes dados são persistidos e armazenados para reprodução ou 
análise, imediata ou não. Em outras palavras, o registro eletrônico de um fenômeno qualquer pode 
ser registrado e ter seus dados armazenados, como o movimento do telefone celular, o acionamento 
7 
 
do freio do veículo, uma fotografia do céu ou a gravação da câmera de segurança. Com a capaci-
dade cada vez maior de armazenar dados de forma indiscriminada, eventos que há tempos atrás 
não tinham os seus dados armazenados, como o registro de um veículo monitorado por satélite, 
agora são registrados, caso os dados referentes a ele precisem ser inspecionados no futuro. 
 Uma vez que existe uma infinidade de dados armazenados e disponíveis, surgiu a necessi-
dade de transformar esses dados em informação e conhecimento. E é justamente esta a atribuição 
de um cientista de dados: um profissional altamente qualificado que tem por objetivo sistemático a 
descoberta e extração de conhecimento de vastos conjuntos de dados. Este contexto reflete a rea-
lidade muitas empresas e organizações que necessitam gerir grandes e heterogêneos volumes de 
dados de diferentes fluxos de informação. Neste cenário, a área de Ciência de Dados incorpora 
uma variedade de campos de outras áreas da ciência, como Mineração de Dados, Aprendizagem 
de Máquina, Análise Preditiva, Matemática, Estatística e Linguagens de Programação, com o obje-
tivo de criar e implementar uma nova geração de teorias e ferramentas computacionais para dar 
apoio ao processo de decisão. 
 Em resumo, a Ciência de Dados (ou Data Science) é um campo interdisciplinar para o de-
senvolvimento de sistemas de software e respectivas soluções para a extração de conhecimento 
em grandes volumes de dados (AMARAL, 2016). 
 
1.3 Áreas de Aplicação da Ciência de Dados 
 
 O grande volume de dados que vem sendo sistematicamente registrado e acumulado desde 
as últimas décadas tornou-se uma tendência e certamente irá continuar. O processo de digitalização 
nas organizações está em curso, daí a importância de obter informação útil e conhecimento para 
as organizações com base neste crescente volume de dados digitais. A necessidade e a evolução 
das técnicas de análise de dados têm por base o processo de digitalização ocorrido nos últimos 
anos. As áreas e tecnologias apresentadas nas próximas seções têm um papel fundamental no 
processo de análise sistemática dos grandes volumes de dados, com vista a encontrar soluções de 
software para mitigar e transformar os volumes de dados em informação e conhecimento útil para 
as empresas. 
 Marketing e Gestão de Vendas: na área de marketing, destaca-se a evolução das ferra-
mentas de Gestão de Relacionamento com o Cliente (Customer Relationship Management – CRM), 
as quais aplicam técnicas de mineração de dados para identificar e verificar diferentes grupos de 
clientes, a fim de efetuar previsões e antecipar o seu comportamento. Esta abordagem teve um 
crescimento exponencial com o fenômeno das redes sociais e da respectiva presença massiva dos 
clientes nestes ambientes virtuais. Neste cenário, leituras e regras simples como “se o cliente com-
pra o produto X, também poderá comprar os produtos Y e Z”, são sistematicamente definidas. O 
entendimento desses padrões de comportamento são fundamentais para o setor de marketing das 
empresas. 
 Economia e Finanças: atualmente, podemos considerar que as empresas financeiras (glo-
bais) têm por base a aplicação de algoritmos e técnicas de mineração de dados na definição de 
planos de investimento e financiamento de projetos em diferentes áreas de negócio, assim como 
para a gestão de portfólios financeiros. Contudo, geralmente este conhecimento (algoritmos e mi-
neração de dados) não é disponibilizado para terceiros, normalmente são protegidos e considera-
dos como ativos de conhecimento das organizações. 
 Análise de Crédito e Detecção de Fraudes: a análise de crédito tem sido uma das áreas 
com maior visibilidade de aplicação da ciência de dados. Sistemas de software analisam o risco 
8 
 
para atribuição de contratos de crédito a particulares e empresas. Estas tecnologias são aplicadas 
no âmbito de sistemas de apoio à decisão, no sentido de diminuir a incerteza no processo de deci-
são e aprovação de créditos. Além disso, instituições bancárias e financeiras utilizam sistemas de 
software para monitorar fraudes de cartões de crédito por meio da análise de dados de milhões de 
contas bancárias. 
 Telecomunicações: a área de telecomunicações é fértil no âmbito da produção massiva e 
sistemática de dados. Nesse sentido, as tecnologias de análise de dados têm sido amplamente 
aplicadas na gestão e digitalização dos dados criados, consumidos e disseminados nas redes glo-
bais de telecomunicações. Um dos principais problemas que podem ser enfrentados é a otimização 
da rede de telecomunicações. As empresas têm a opção de combinar seu conhecimento do desem-
penho da rede com dados internos (como as taxas de uso dos clientes) e dados externos (como as 
tendências sazonais) para redirecionar os recursos (como ofertas ou investimentos de capital) para 
determinados pontos da rede. 
 Internet das Coisas (Internet of Things – IoT): a Internet das coisas é um conjunto de 
objetos (coisas) incorporados com sensores conectados à Internet. As previsões para 2020 apon-
tam que a quantidade de dispositivos IoT será da ordem de 25 bilhões, enquanto a quantidade de 
dispositivos tradicionais de computação (smartphones, tablets entre outros dispositivos móveis) ul-
trapassará a ordem de 20 bilhões (VASCONCELOS e BARÃO, 2017). Neste contexto, é previsível 
um investimento massivo nos próximos anos para analisar os dados gerados por estes dispositivos. 
As organizações empresariais vão ser as que mais irão adotar as soluções de IoT. Tais soluções 
serão aplicadas para redução de custos operacionais, para o incremento da produtividade, assim 
como a criação de novos mercados e desenvolvimento de novas soluções e propostas de valor para 
as organizações. 
 Indústria 4.0: o termo Indústria 4.0 é recente e apresenta uma combinação entre indústria 
e IoT. A aplicação de técnicas da ciência de dados permite avaliar requisitos inerentes à instalação 
e utilização da IoT em máquinas industriais. Os dados são recolhidos e avaliados com base em 
implementações de vários tipos de sensores, tendo em conta a área industrial e de negócio, bem 
como pela utilização de equipamentos específicos de IoT. Os testes são efetuados com o recurso 
à aplicação de software funcional e de apoio à decisão em ambiente laboratorial. A indústria 4.0 tem 
adicionalmente como objetivo a análise da produtividade dos colaboradores associados a diferentes 
máquinas e processos industriais. 
Reflita! Esses são apenas alguns exemplos de áreas do conhecimento humano em que a ciência 
de dados pode ser aplicada. Agora, reflita sobre outras áreas que produzem e armazenam uma 
grande quantidade de dados que podem ser analisados, como: buscas na Internet, sistemas de 
recomendação (como filmes na Netflix, por exemplo), reconhecimento facial, sistemas de transporte 
e logística, saúde, sistemas de comparação de preços, entreoutros. 
 
1.4 Fluxo de Trabalho na Ciência de Dados 
 
 Como vimos anteriormente, a ciência de dados é um campo multidisciplinar e extremamente 
abrangente. O nosso objetivo aqui é fornecer uma sólida fundamentação nos conceitos e ferramen-
tas mais importantes que você irá usar ao longo da análise de um conjunto de dados. Não existe 
apenas uma forma de estruturar e aplicar os conhecimentos da Ciência de Dados. A forma de apli-
cação varia bastante conforme a necessidade do projeto ou do objetivo que se busca alcançar. 
Neste módulo, usaremos o modelo de fluxo de trabalho (workflow) mostrado na Figura 1.1, bastante 
9 
 
utilizado e sugerido por WICKHAM e GROLEMUND (2017). Os autores propõem o uso do ambiente 
R para o fluxo de trabalho. Aprenderemos sobre tal ambiente na Seção 1.6. 
 A primeira atividade do fluxo de trabalho é a Importação dos seus dados para o ambiente 
R. Isso normalmente significa que você precisa obter os dados armazenados em um arquivo, banco 
de dados ou site da Web e os carrega em um conjunto de dados no ambiente R. 
 
 Depois de importar seus dados, a próxima atividade é a Limpeza dos dados. Limpar os seus 
dados significa armazená-los de uma forma consistente e que corresponda à semântica do conjunto 
de dados com a maneira como ele é armazenado. Em resumo, quando seu os dados são “limpos”, 
cada coluna é uma variável e cada linha é uma observação. Os dados “arrumados” são importantes 
porque a estrutura consistente permite que você se concentre apenas em questões sobre o enten-
dimento e análise dos dados. 
 Depois de ter feito a limpeza dos dados, a próxima atividade é a de Transformação. A 
transformação inclui concentrar-se nas observações de interesse (como todas as pessoas de uma 
cidade ou todos os dados do ano anterior), criando novas variáveis que são funções de variáveis 
existentes (como de velocidade e tempo) e calculando um conjunto de estatísticas (como contagens 
ou médias). Frequentemente, as atividades de limpeza e transformação quando realizadas em con-
junto são chamadas de “disputas”, porque limpar e transformar seus dados de uma forma que seja 
natural para trabalhar, com frequência parece uma briga. 
 Uma vez que você tenha dados organizados com as variáveis necessárias para realizar as 
suas análises, existem duas atividades principais de geração de conhecimento: a visualização e a 
modelagem. Ambas têm pontos fortes e fracos complementares, de modo que qualquer análise real 
irá interagir entre elas muitas vezes. 
 A Visualização é uma atividade fundamentalmente humana. Uma boa visualização dos da-
dos trará conclusões que você não esperava ou levantará novas questões sobre os dados. Uma 
boa visualização também pode sugerir que você está fazendo a pergunta errada ou precisa coletar 
dados diferentes. As diferentes formas de visualizar os dados podem surpreendê-lo, mas elas não 
são a forma mais adequada para fazer conclusões porque exigem que um ser humano as interprete. 
 A Modelagem é uma atividade complementar à visualização. Depois de ter elaborado suas 
perguntas em relação aos dados com precisão suficiente, você pode usar um modelo para res-
pondê-las. Os modelos são uma ferramenta fundamentalmente matemática ou computacional, en-
tão eles geralmente representam bem o comportamento dos dados. Mas todo modelo faz suposi-
ções e, por sua própria natureza, um modelo não pode questionar suas próprias suposições. Isso 
significa que um modelo não pode, fundamentalmente, surpreendê-lo. É necessário interpretar ade-
quadamente se determinado modelo é uma boa representação dos dados. 
 
FIGURA 1.1: FLUXO DE TRABALHO PARA A CIÊNCIA DE DADOS, PROPOSTO POR WICKHAM E GROLEMUND (2017) 
10 
 
 A transformação, visualização e a modelagem são as três etapas fundamentais para propor-
cionar o completo Entendimento dos Dados. No fluxo de trabalho proposto, essas atividades po-
dem ser executadas de forma iterativa, até que as conclusões obtidas pelo cientista de dados sejam 
satisfatórias. Feito isso, o último passo no fluxo de trabalho é a Comunicação, uma atividade crítica 
de qualquer projeto de análise de dados. Não importa quão bem os modelos e as visualizações 
criadas o levaram a entender os dados, é de fundamental importância a criação de relatórios ou 
formas complementares de visualização que permitam comunicar as conclusões sobre os dados a 
terceiros, de forma fácil e intuitiva. 
 
1.5 Roteiro 
 
 Nesta seção iremos apresentar o conteúdo que estudaremos em cada capítulo do módulo. 
 
1.5.1 Pré-requisitos 
 
 Os únicos conhecimentos necessários que você precisará ter para compreender o conteúdo 
estudado neste módulo são alguns conceitos de estatística descritiva, entre eles: 
 Média 
 Mediana 
 Variância 
 Desvio padrão 
 Distribuição normal 
 Quartis 
 Esses conceitos não serão abordados aqui pois provavelmente você estudou um módulo 
específico sobre estatística básica para a ciência de dados, em que todos esses assuntos foram 
abordados. 
 
1.5.2 Recursos usados no módulo 
 
 Outro tema importante são os recursos que você irá utilizar ao longo do módulo. Em várias 
aulas, irei solicitar que você importe algum arquivo ou execute algum script já pronto para agilizar o 
andamento dos estudos. Todos esses recursos estão compactados em uma pasta que você pode 
baixar no seguinte link: https://bit.ly/31kU3lx. Recomendo que logo no início, você salve esse ar-
quivo e descompacte-o em alguma pasta no seu computador. Durante o módulo, sempre que eu 
solicitar que você utilize algum arquivo, você pode buscá-lo nessa pasta. 
 
1.5.3 Assuntos abordados no módulo 
 
 Este primeiro capítulo é uma introdução ao assunto ciência de dados. Já discutimos o que é 
Big Data, Ciência de Dados, áreas de aplicação, o fluxo de trabalho de um cientista de dados e 
quais são os pré-requisitos necessários para este módulo. Nas próximas seções, faremos uma in-
trodução ao Ambiente R, que será a ferramenta usada ao longo do módulo para analisar os dados. 
https://bit.ly/31kU3lx
11 
 
Caso você não conheça ou não tenha familiaridade com o R, aproveite as próximas seções para 
aprender os conceitos básicos desta ferramenta, que é uma das mais importantes (se não a mais 
importante) quanto se trata de análise de dados. A partir do próximo capítulo, começaremos a dis-
cutir as atividades que devem ser executadas por um cientista de dados para que ele possa exercer 
bem o seu trabalho, tomando como base o fluxo de trabalho proposto na Figura 1.1. 
 No Capítulo 2 iremos aprender sobre a arte de preparar os dados de forma a viabilizar sua 
visualização e modelagem, o que inclui as atividades de importação, limpeza e transformação dos 
dados. As três etapas que compõem essa preparação serão estudadas em detalhes: a leitura ou 
importação dos dados para o Ambiente R; a limpeza dos dados que visa garantir a consistência dos 
mesmos; e a transformação dos dados, cujo intuito é reordenar, resumir ou renomear os dados para 
facilitar as etapas seguintes. 
 No Capítulo 3, uma vez que nós entendemos os processos para realizar a importação/leitura 
dos dados, sua limpeza e transformação, começaremos a discutir a atividade de modelagem dos 
dados. Por questões didáticas, vamos abordar primeiro a modelagem de dados, e posteriormente 
a visualização destes. O objetivo de um modelo de dados é fornecer um resumo simples, em baixa 
dimensão, do conjunto de dados. Idealmente, o modelo irá representar “sinais” verdadeiros (isto é, 
padrões gerados pela situação que está sendo estudada), e ignorar o "ruído" (ou seja, variação 
aleatória em que você não está interessado) dos dados em questão. Neste capítulo, estudaremos 
modelos estatísticos para a análise de dados e aprenderemos os recursos básicos da Ferramenta 
R que podem nos auxiliar a compreender melhor tais modelos. 
 No Capítulo 4 estudaremos a Análise de Redes Sociais (Social Network Analysis – SNA), 
uma série de técnicascujo objetivo é a modelagem, a formulação e a solução de problemas que 
possuem uma estrutura de rede, sendo que tal estrutura normalmente é representada por meio de 
um grafo. Nesse capítulo, nosso objetivo é sensibilizar o cientista de dados sobre a importância de 
possuir essa competência, pois a análise de redes sociais possui uma série de aplicações práticas, 
que vão desde o projeto de redes de telecomunicações até às plataformas de mídias sociais (como 
Facebook e Twitter) que usam elementos deste tipo de análise na recomendação de amigos, entre 
outros processos. 
 Por fim, no Capítulo 5 estudaremos as etapas finais do fluxo de trabalho de um cientista de 
dados: a visualização e a comunicação dos dados. Como discutimos antes brevemente, não importa 
quão complexa seja a sua análise, uma das etapas mais importantes é disponibilizar os resultados 
da análise em relatórios e formas de visualização que permitam comunicá-los a terceiros de forma 
intuitiva. Essa é a última (e não menos importante) etapa da análise de dados. 
 
1.6 Introdução ao Ambiente R 
 
 R é uma linguagem de programação estatística que vem passando por diversas evoluções 
e se tornando cada vez mais uma linguagem de amplos objetivos. Podemos entender o R também 
como um conjunto de pacotes e ferramentas estatísticas, munido de funções que facilitam sua uti-
lização, desde a criação de simples rotinas até análises de dados complexas, com visualizações 
bem detalhadas. Segue alguns motivos para aprender R: 
 é completamente gratuita e de livre distribuição; 
 a curva de aprendizado é bastante amigável, sendo muito fácil de se aprender; 
 a enorme quantidade de tutoriais e ajuda disponíveis gratuitamente na Internet; 
 é excelente para criar rotinas e sistematizar tarefas repetitivas; 
12 
 
 é amplamente utilizado pela comunidade acadêmica e pelo mercado; 
 a quantidade enorme de pacotes, para diversos tipos de necessidades; 
 é uma ótima ferramenta para criar relatórios e gráficos. 
 
1.6.1 A Ferramenta RStudio 
 
 O ambiente R nativo se apresenta como uma simples “tela escura”, com uma linha para 
inserir comandos. Isso é um pouco assustador para quem está começando e bastante improdutivo 
para quem já faz uso intensivo da ferramenta. Felizmente, existem diversas ferramentas gráficas 
que apoiam o uso mais intuitivo do R, como a ferramenta RStudio, que utilizaremos durante todo o 
curso. 
 Entenda o RStudio como uma interface gráfica com diversas funcionalidades que melhoram 
ainda mais o uso e aprendizado do R. Na prática, o RStudio facilita muito o dia a dia de trabalho do 
cientista de dados. Portanto, desde já, ao falarmos em R, falaremos automaticamente no RStudio. 
Apesar de ser também uma ferramenta de uso comercial, você pode baixar e instalar facilmente a 
versão gratuita do RStudio, para diferentes sistemas operacionais no seguinte link: https://www.rstu-
dio.com/products/rstudio/download. 
 A Figura 1.2 mostra a interface do RStudio. Repare que ela é divida em quatro partes prin-
cipais: 
1) Editor de Código - no editor de código, você poderá escrever e editar os scripts. Um script 
nada mais é do que uma sequência de comandos/ordens que serão executadas em sequên-
cia pelo R. O editor do RStudio oferece facilidades como organização dos comandos, re-
curso de “auto-complete” dos comandos, destaque da sintaxe dos comandos, etc. 
2) Console - é no console que o R mostrará a maioria dos resultados dos comandos. Também 
é possível escrever os comandos diretamente no console, sem o uso do editor de código. É 
muito utilizado para testes e experimentos rápidos. Um uso rápido do console é, por exem-
plo, chamar a ajuda do R usando o comando ? (isso mesmo, a interrogação é um comando!). 
Provavelmente essa é a parte do RStudio que usaremos com mais frequência. 
3) Environment e History - no environment ficarão armazenados todos os objetos que são 
criados na sessão do R. Entenda sessão como o espaço de tempo entre o momento em que 
você inicia o R e o momento em que finaliza. Neste período, tudo que você faz usa memória 
RAM e o processador do computador. E na aba History, como você deve imaginar, o RStudio 
cria um histórico de comandos utilizados. 
https://www.rstudio.com/products/rstudio/download
https://www.rstudio.com/products/rstudio/download
13 
 
 
4) Files, Plots, Packages, Help e Viewer - nesta janela, estão várias funcionalidades do RStu-
dio, como descrito a seguir: 
i. na aba Files, você terá uma navegação de arquivos do seu computador; também será 
possível definir o diretório de trabalho (você também pode definir diretamente no código, 
como trataremos posteriormente), ou seja, o R entende o seu diretório de trabalho como 
ponto de partida para localizar arquivos que sejam chamados no script; 
ii. a aba Plots trará os gráficos gerados, possibilitando a exportação para alguns formatos 
diferentes, como .png e .pdf; 
iii. na aba Packages estão listados os pacotes (bibliotecas) instalados; você pode verificar 
quais estão carregados e, caso necessário, poderá carregar algum pacote necessário 
para a sua análise; também é possível instalar e atualizar pacotes; novamente, tudo isto 
é possível fazer diretamente no código, como veremos mais adiante; 
iv. a aba Help, como o próprio nome indica, é a ajuda do RStudio; esta aba será bastante 
utilizada, pois saber usar o help é fundamental para evitar desperdício de tempo; os 
usuários de R, em geral, são bastante solícitos, entretanto, uma olhadinha rápida no help 
pode evitar que você “desperdice” tempo desnecessariamente; 
v. por fim, a aba Viewer é utilizada para visualizar localmente conteúdo web; o gráfico das 
figuras é mostrado na aba Viewer porque é uma visualização em javascript, que pode 
ser adicionada a documentos html gerados usando o pacote RMarkdown, como veremos 
no capítulo 5. 
 
1.6.2 Como buscar Ajuda? 
 
 Independentemente do seu nível de conhecimento em R, sempre haverá a necessidade de 
buscar ajuda. Ou seja, saber procurar ajuda é essencial para aprimorar seus conhecimentos em 
 
FIGURA 1.2: INTERFACE GRÁFICA DO RSTUDIO 
14 
 
Ciência de Dados. Segue algumas dicas de como buscar ajuda para sanar dúvidas e resolver pro-
blemas em R: 
 sempre procure em inglês; apesar da comunidade R em língua portuguesa ser bem grande, 
a de língua inglesa é maior ainda; é muito provável que seus problemas e dúvidas já tenham 
sido sanados e outros usuários estarão disponíveis para respondê-los; 
 explore bem o help do próprio R; 
 conheça e aprenda a usar o Stack Overflow (http://stackoverflow.com/questions), a maior 
comunidade de ajuda técnica da Internet. 
 Se mesmo explorando todas as dicas acima não conseguir resolver seu problema, procure 
por fóruns específicos. 
Atenção! Se você for realizar uma pergunta em algum fórum ou site de perguntas e respostas, é 
importante atentar-se para alguns pontos que deverão ser informados, de modo a facilitar que outros 
usuários te auxiliem: 
 versão do R que está usando (digite o comando version() no console do RStudio para veri-
ficar); 
 sistema operacional; 
 forneça um exemplo replicável; 
 veja se a sua dúvida já não foi abordada em outro tópico neste fórum. 
1.6.3 Conceitos Básicos 
 
 Entenda o R como uma grande calculadora científica cheia de botões, mas, ao invés de 
clicar nos botões, você irá escrever os comandos. Ou seja, aprender R significa se familiarizar com 
os comandos e saber quando usá-los. Todos os comandos são baseados em inglês e seus nomes, 
normalmente, dão dicas a respeito do seu uso. 
 
1.6.3.1 Console 
 
 O console é uma das quatro partes principais do RStudio (observe na Figura 1.2). É nele 
que você vai digitar suas ordens (comandos) e também é onde o R vai “responder” tais ordens. Para 
que o R possa interpretar corretamente, será necessário que você conheça a sintaxe da linguagem 
e a escrita correta dos comandos. Olhando para o console, você verá o símbolo>. Este símbolo 
indica a linha onde você deve inserir os comandos. Clique nesse símbolo para posicionar o cursor 
na linha de comandos e digite seu primeiro comando em R: 2 * 3. Tecle Enter. Você verá o seguinte 
resultado: 
[1] 6 
 Além de outras funcionalidades mais interessantes, o R é como uma grande calculadora 
científica, como apontado anteriormente. Para entender melhor esse conceito, vamos exercitar um 
pouco o console de comandos. Digite um por um os seguintes comandos, tecle Enter ao final de 
cada um deles e acompanhe os resultados: 
7 * 9 + 2 * 6 
2.5 * 4 
https://stackoverflow.com/questions
15 
 
(50 + 7)/(8 * (3 - 5/2)) 
3 ^ 4 
 Repare que, na medida em que executa os comandos, o R vai respondendo. Esse é o com-
portamento básico do console, muito utilizado para obter-se resultados rápidos de comandos espe-
cíficos. Uma funcionalidade importante é o fato de que o R guarda um histórico dos últimos coman-
dos executados, e para acessá-los basta apertar a seta para cima no teclado. 
 
1.6.3.2 Scripts 
 
 Enquanto no console seus comandos são executados na medida em que você os “envia” 
com a tecla Enter, em um script você ordena a execução de uma sequência de comandos, escritos 
previamente, um seguido do outro. Esses scripts são escritos no editor de códigos do RStudio. Para 
entender melhor, localize o editor de códigos no RStudio e copie os mesmos comandos anteriores, 
executados no console. No editor de códigos, a ordem para a execução dos comandos não é a 
tecla Enter, para executá-los, clique em Source, no canto superior direito da área do editor de códi-
gos. 
 Repare bem, pois há uma setinha escura que revelará duas opções de Source (execução 
do script): Source, e Source with Echo. A diferença entre as duas opções é que a primeira executa 
mas não exibe as respostas no console, já a segunda executa mostrando as respostas no mesmo. 
A segunda opção será útil em outros casos de scripts muito grandes, ou em situações nas quais 
não convenha “poluir” o console com inúmeras mensagens. Há um atalho de teclado para o Source: 
ctrl + shift + enter. 
 Agora posicione o cursor do mouse com um clique em apenas um dos comandos do seu 
script. Em seguida, clique no ícone Run, também no canto superior na área do editor de códigos. 
Repare que, dessa vez, o R executou apenas um comando, aquele que estava na linha selecionada. 
Esse tipo de execução também é bastante útil, mas esteja atento, pois é muito comum que coman-
dos em sequência dependam da execução de comandos anteriores para funcionarem correta-
mente. Há, também, um atalho de teclado para o Run: ctrl + enter. Este é outro comando importante 
de ser lembrado, pois é muito importante e será bastante utilizado. 
 Ao digitar seus comandos no console, o máximo que você consegue recuperar são os co-
mandos imediatamente anteriores, usando a seta para cima. Já no editor de códigos, existe a pos-
sibilidade de salvar os seus scripts para continuar em outro momento ou em outro computador, 
preservar trabalhos passados ou compartilhar seus códigos com a equipe. 
 Um script em R tem a extensão (terminação) .R. Se você tiver o RStudio instalado e der dois 
cliques em um arquivo com extensão .R, o seu sistema operacional abrirá esse arquivo diretamente 
no RStudio. Ainda utilizando os comandos digitados no editor de códigos, vá em File > Save, esco-
lha um local e um nome para seu script e confirme no botão Save. Lembre-se sempre de ser orga-
nizado na hora de armazenar os seus arquivos. Utilize pastas para os diferentes projetos e dentro 
delas escolha nomes explicativos para os seus trabalhos. Para salvar mais rapidamente, utilize o 
atalho ctrl + S. 
 
 
16 
 
1.6.3.3 Comentários de código 
 
 Ao utilizar o símbolo # em uma linha, você está dizendo para o R ignorar aquela linha, pois 
trata-se de um comentário. Clique na primeira linha do seu script, tecle Enter para adicionar uma 
linha a mais e digite #Meu primeiro comentário de código! Repare que a cor do comentário é 
diferente. Execute novamente seu script com a opção Source e veja que nada mudou na execução. 
A título de experimento, retire o símbolo # e mantenha o texto do comentário. Execute novamente. 
O R tenta interpretar essa linha como comando e já que ele não consegue entendê-lo, exibe uma 
mensagem de erro no console. 
 O símbolo de comentário também é muito útil para suprimir linhas de código que servem 
para testar determinados comportamentos. Para exemplificar, adicione o símbolo # em qualquer 
uma das linhas com as operações e veja que ela não será mais executada, será ignorada, pois foi 
entendida pelo R como um simples comentário de código. 
 
1.6.4 Objetos (Variáveis) 
 
 Para que o R deixe de ser uma simples calculadora, será necessário aprender, dentre outras 
coisas, o uso de variáveis. Se você tem alguma noção de algoritmos, provavelmente já tem a intui-
ção do que é uma variável para uma linguagem de programação. No contexto do R, vamos entender 
variável como um objeto, ou seja, como uma estrutura predefinida que vai “receber” algum valor. 
Utilizando uma linguagem mais técnica, objeto (ou variável) é um pequeno espaço na memória do 
seu computador onde o R armazenará um valor ou o resultado de um comando, utilizando um nome 
que você mesmo definiu. 
 Conhecer os tipos de objetos do R é fundamental. Para atribuir valor a objetos, utiliza-se o 
símbolo <- ou o símbolo =. Estes são os símbolos que você verá com mais frequência daqui para 
frente. Execute, no console ou no editor de códigos, o seguinte comando x <- 15. Agora o nome x 
representa o valor 15. Para comprovar, execute apenas o nome do objeto x, o R mostrará o conte-
údo dele. A partir de então, você poderá utilizar esse objeto como se fosse o valor 15. Experimente 
os seguintes resultados: 
x + 5 
x * x / 2 
2 ^ x 
y <- x / 3 
 Leia a seção de boas práticas (seção 1.6.7) para criar um código organizado e aprender a 
organizar seus objetos e funções da melhor maneira possível. Todos os objetos que você criar 
estarão disponíveis na aba Environment. O RStudio possui ainda a função “auto-complete”. Digite 
as primeiras letras de um objeto (ou função) que você criou e, em seguida, use o atalho ctrl + barra 
de espaço. O RStudio listará tudo (objetos, funções ou pacotes) que começar com essas letras. 
Selecione algum item e tecle enter para escrevê-lo no editor de códigos. 
 
17 
 
1.6.5 Funções 
 
 Entenda função como uma sequência de comandos preparados para serem usados de 
forma simples e, assim, facilitar sua vida. Funções são usadas para tudo que você possa imaginar: 
cálculos mais complexos, estatísticas, análise de dados, manipulação de dados, gráficos, relatórios, 
etc. Assim que você o instala, o R já vem configurado com várias funções prontas para uso. A partir 
de agora, chamaremos esse conjunto de funções que já vem por padrão com a ferramenta de R 
Base. 
 Claro que as funções do R base não serão suficientes para resolver todos os problemas que 
você encontrará pela frente. Nesse sentido, o R também possui outro recurso muito interessante. 
Você pode instalar conjuntos extras de funções específicas de maneira muito simples: usando pa-
cotes. Exemplos funções do R base são: 
raiz.quadrada <- sqrt(16) #função para calcular raiz quadrada 
round(5.3499999, 2) #função para arredondamento 
 Uma função tem dois elementos básicos: o nome e o(s) parâmetro(s) (também chamados 
de argumentos). Por exemplo, a função log(10) possui o nome log() e apenas um parâmetro, que 
é o número que você quer calcular o log. Já a função round() possui dois parâmetros, o número 
que você quer arredondar e a quantidade de dígitos para arredondamento. Quando você usa uma 
função, você pode informar os parâmetros de duas formas: sequencialmente, sem explicitar o nome 
dos parâmetros, ou na ordem que quiser, explicitando o nome dos parâmetros. Veja o exemplo a 
seguir: 
round(5.3499999, 2) 
#é o mesmoque: 
round(digits = 2, x = 5.3499999) 
 Para saber como informar os parâmetros corretamente, utilize o comando ? para ver a do-
cumentação de funções, ou seja, conhecer para que serve, entender cada um dos seus parâmetros 
e ver exemplos de uso. 
?round 
??inner_join #procurar ajuda de funções que não estão "instaladas" ainda 
 Vale comentar que é possível informar objetos nos parâmetros das funções. 
x <- 3.141593 
round(x, 3) 
ceiling(x) 
 
 
 
 
18 
 
 Observe algumas das principais funções para estatísticas básicas no R na Tabela 1.1. 
Tabela 1.1 – Exemplos de funções estatísticas no R 
Função R Descrição 
sum() Soma de valores 
mean() Média 
var() Variância 
median() Mediana 
summary() Resumo estatístico 
quantile() Quantis 
 
1.6.6 Pacotes 
 
 Como dito antes, pacotes são conjuntos extras de funções que podem ser instalados além 
do R base. Existem pacotes para auxiliar as diversas linhas de estudo que você possa imaginar: 
estatística, econometria, ciências sociais, medicina, biologia, gráficos, machine learning, etc. Caso 
você precise de algum pacote específico, procure no Google pelo tema que necessita. Você encon-
trará o nome do pacote e o instalará normalmente. 
 No link https://cran.r-project.org/web/packages/available_packages_by_name.html você 
pode ver uma lista de todos os pacotes disponíveis no repositório central. Além desses, ainda existe 
a possibilidade de instalar pacotes “não oficiais”, que ainda não fazem parte de um repositório cen-
tral. Para instalar um pacote, execute o seguinte comando: 
install.packages("dplyr") #instala um pacote de manipulação de dados 
 Uma vez instalado, esse pacote estará disponível para uso sempre que quiser, sem a ne-
cessidade de instalá-lo novamente. Mas, sempre que iniciar um código novo, você precisará car-
regá-lo na memória. Para isso, use o seguinte comando: 
library(dplyr) 
Atenção! Para instalar um pacote, você precisa informar o nome entre aspas, caso contrário o 
pacote não funcionará. Porém, para carregar o pacote em memória, você pode referenciar o nome 
com ou sem aspas, ambas as formas funcionam. 
 
1.6.7 Boas Práticas 
 
 Rapidamente você perceberá que quanto mais organizado e padronizado mantiverem-se os 
seus códigos, melhor será para você e para sua equipe. Existem dois guias de boas práticas bas-
tante famosos na comunidade do R. Um sugerido por Hadley Wickham (WICKHAM e GROLE-
MUND, 2016) e outro por uma equipe do Google. Dentre as dicas de boas práticas, algumas são 
https://cran.r-project.org/web/packages/available_packages_by_name.html
19 
 
muito importantes, como, por exemplo: não use acentos e caracteres especiais. Outro ponto impor-
tante: o R não aceita variáveis que comecem com números. Você pode até usar números no meio 
do nome, mas nunca começar com números. O principal de tudo é: seja qual for o padrão que você 
preferir, escolha apenas um padrão e seja consistente a ele. A seguir são indicados os links dos 
dois guias citados anteriormente: 
 Guia sugerido Hadley Wickham: http://adv-r.had.co.nz/Style.html 
 Guia sugerido pelo Google: https://google.github.io/styleguide/Rguide.xml 
 
1.6.8 Tipos de Variáveis 
 
 Existem diversos tipos de objetos, e cada tipo “armazena” um conteúdo diferente, desde 
tabelas de dados recém-carregados a textos, números, ou simplesmente a afirmação de verdadeiro 
ou falso (Booleano). Veja alguns exemplos a seguir: 
inteiro <- 928 
outro.inteiro <- 5e2 #equivale ao número 500 
decimal <- 182.93 
alfanumerico <- 'exportação' #pode-se usar aspas simples ou duplas 
logico <- TRUE 
outro.logico <- FALSE 
 Podemos usar a função class() para ver o tipo de cada variável: 
class(inteiro) 
[1] "numeric" 
class(outro.inteiro) 
[1] "numeric" 
class(decimal) 
[1] "numeric" 
class(caracter) 
[1] "character" 
class(logico) 
[1] "logical" 
class(outro.logico) 
[1] "logical" 
http://adv-r.had.co.nz/Style.html
https://google.github.io/styleguide/Rguide.xml
20 
 
 Esses são alguns dos tipos básicos de objetos/variáveis no R que representam os tipos 
básicos de dados. Além destes, existem também os tipos “complexos”, que são vector, array, matrix, 
list, data.frame e factor. 
 Para a criação de vetores, usamos a função de combinação de valores c(), que significa 
combine. Esta função vai combinar todos os parâmetros em um único vetor. Atente-se ao seguinte: 
vetores são sequências unidimensionais de valores de um mesmo tipo. Vejamos alguns exemplos: 
vetor.chr <- c('tipo1', 'tipo2', 'tipo3', 'tipo4') 
vetor.num <- c(1, 2, 5, 8, 1001) 
vetor.num.repetidos <- c(rep(2, 50)) #usando funcão para repetir números 
vetor.num.sequencia <- c(seq(from=0, to=100, by=5)) #usando função para criar sequências 
vetor.logical <- c(TRUE, TRUE, TRUE, FALSE, FALSE) 
##veja o conteúdo das variáveis 
vetor.chr 
[1] "tipo1" "tipo2" "tipo3" "tipo4" 
vetor.num 
[1] 1 2 5 8 1001 
vetor.num.repetidos 
[1] 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 
[35] 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 
vetor.num.sequencia 
[1] 0 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 
[18] 85 90 95 100 
vetor.logical 
[1] TRUE TRUE TRUE FALSE FALSE 
 Data frame é, provavelmente, o tipo de dado complexo mais utilizado em R. É nele que você 
armazena conjuntos de dados estruturados em linhas e colunas (do tipo tabela). Um data frame 
possui colunas nomeadas, sendo que todas as colunas possuem a mesma quantidade de linhas. 
Conhecendo o tipo vector, você será capaz de entender como ele se relaciona com um data frame. 
Cada coluna de um data frame é um vetor. Um data frame pode ter colunas de diferentes tipos, mas 
cada coluna só pode ter registros de um único tipo. Esse conceito ficará mais claro a seguir, com o 
exemplo de criação de um data frame: 
#cria-se diferentes vetores 
nome <- c('João', 'José', 'Maria', 'Joana') 
21 
 
idade <- c(45, 12, 28, 31) 
adulto <- c(TRUE, FALSE, TRUE, TRUE) 
uf <- c('DF', 'SP', 'RJ', 'MG') 
#cada vetor é uma combinação de elementos de um MESMO tipo de dados 
#sendo assim, cada vetor pode ser uma coluna de um data.frame 
clientes <- data.frame(nome, idade, adulto, uf) 
clientes 
nome idade adulto uf 
1 João 45 TRUE DF 
2 José 12 FALSE SP 
3 Maria 28 TRUE RJ 
4 Joana 31 TRUE MG 
str(clientes) 
'data.frame': 4 obs. of 4 variables: 
$ nome : Factor w/ 4 levels "Joana","João",..: 2 3 4 1 
$ idade : num 45 12 28 31 
$ adulto: logi TRUE FALSE TRUE TRUE 
$ uf : Factor w/ 4 levels "DF","MG","RJ",..: 1 4 3 2 
 Para selecionar ou trabalhar separadamente com apenas um campo (coluna) do seu 
data.frame, deve-se utilizar o caracter $. Repare o uso do $ nos exemplos mostrados a seguir, 
neles usaremos um data frame chamado airquality, um conjunto de dados que já vem carregado 
no R base e possui informações sobre a qualidade do ar. 
head(airquality$Ozone) #explicaremos sobre o comando head() no Cap. 2 
[1] 41 36 12 18 NA 28 
tail(airquality$Ozone) #explicaremos sobre o comando tail() no Cap. 2 
[1] 14 30 NA 14 18 20 
class(airquality$Ozone) #Informa o tipo da coluna 
[1] "integer" 
22 
 
is.vector(airquality$Ozone) #Apenas para verificar que cada coluna de um data.frame é um 
vector 
[1] TRUE 
 Existem outros tipos de objetos complexos. Vamos apenas citar alguns deles na Tabela 1.2, 
pois nesse módulo utilizaremos muito pouco os demais tipos. 
Tabela 1.2 – Tipos de objetos/dados complexos no R 
Tipo Descrição Dimensão Homogêneo? 
vector 
Coleção de elementos simples. Todos os elemen-
tos precisam ser do mesmo tipo básico de dado. 
1 Sim 
array 
Coleção que se parece com o vector, mas é 
multidimensional. 
N Sim 
matrix Tipo especial de array com duas dimensões. 2 Sim 
list 
Objeto complexo com elementos que podem ser de 
diferentes tipos. 
1 Não 
data.frame 
Tipo especial de lista, onde cada coluna é um vetor 
de apenas um tipo e todas as colunas têm o 
mesmo número de registros. É o tipo mais utilizado 
para se trabalhar com dados.2 Não 
factor 
Tipo especial de vector, que só contém valores pre-
definidos (levels) e categóricos 
(characters). Não é possível adicionar novas cate-
gorias sem criação de novos levels. 
1 Não 
 
1.6.9 Estrutura Condicional 
 
 A estrutura condicional no R é algo bastante intuitivo. A estrutura de if (se) e else (então) usa 
os operadores lógicos apresentados anteriormente. Se a condição do if() for verdadeira, executa-
se uma tarefa específica, se for falsa, executa-se uma tarefa diferente. A estrutura parece algo do 
tipo: 
if( variavel >= 500 ) { 
 #executa uma tarefa se operação resultar TRUE 
} else { 
 #executa outra tarefa se operação resultar FALSE 
23 
 
} 
 
 
 
1.6.10 Estrutura de Repetição 
 
 Trata-se de um dos conceitos mais importantes de qualquer linguagem de programação, e 
em R não é diferente. Loops (ou laços) repetem uma sequência de comando quantas vezes você 
desejar (comando for), ou até que uma condição aconteça (comando while), variando-se alguns 
aspectos entre uma repetição e outra. 
 O comando for() é usado para realizar uma série de ordens para uma determinada sequên-
cia ou índices (vetor). Sua sintaxe é bem simples: 
for(i in c(1, 2, 3, 4, 5)) { 
 print(i^2) 
} 
[1] 1 
[1] 4 
[1] 9 
[1] 16 
[1] 25 
 O comando while() também é uma estrutura de controle de fluxo do tipo loop, mas, diferen-
temente do for(), executa as tarefas repetidamente até que uma condição seja satisfeita, como é 
mostrado no exemplo a seguir. 
i <- 1 
while(i <= 5){ 
 print(i) 
 i <- i + 1 
} 
[1] 1 
[1] 2 
[1] 3 
[1] 4 
24 
 
[1] 5 
 
 
 
1.7 Considerações Finais 
 
 Neste primeiro capítulo do módulo, introduzimos o conceito de ciência de dados, as áreas 
de aplicação e qual o fluxo de trabalho deve ser seguido por um cientista de dados para que ele 
possa realizar de forma adequada o seu trabalho. Nas seções finais, aprendemos os principais 
conceitos básicos sobre o ambiente R, uma ferramenta gratuita e de fácil aprendizado, sendo a 
mais utilizada atualmente para realizar a análise de dados. No próximo capítulo, daremos início aos 
estudos sobre o fluxo de trabalho definido para a ciência de dados. 
25 
 
 
UNIDADE 2: Exploração de Dados com a Ferramenta R 
 
2.1 Considerações Iniciais 
 
 Neste capítulo iremos aprender sobre como realizar a exploração de dados (tradução livre 
para data wrangling), a arte de preparar os dados de forma a viabilizar sua visualização e modela-
gem. Existem três principais fases relacionadas à exploração dos dados, como pode ser visualizado 
na Figura 2.1. Na Seção 2.2 você irá aprender como importar (ou ler) dados do disco para a Ferra-
menta R, seja de arquivos do tipo texto, bancos de dados ou outras fontes de dados. Na seção 2.3 
você irá aprender a “limpar” os dados, uma forma de garantir a consistência dos dados para tornar 
mais fáceis as fases de transformação, visualização e modelagem. Na seção 2.4 aprenderemos 
sobre a transformação dos dados, uma fase em que frequentemente é necessário criar novas vari-
áveis, resumir os dados, renomear ou reordenar as informações para facilitar o trabalho de visuali-
zação e modelagem. Na seção 2.5 aprenderemos a escrever dados em disco a partir do R, caso 
exista esta necessidade, além de outras formas de leitura. Por fim, a Seção 2.6 apresenta as con-
siderações finais. 
 
 
2.2 Importação/Leitura dos Dados 
 
 Após o entendimento do problema/projeto que será resolvido com a ciência de dados, pre-
cisamos fazer com que o R leia os dados. Seja lá qual for o assunto do projeto, é muito importante 
garantir uma boa fonte de dados. Dados ruins, inconsistentes, não confiáveis ou mal formatados 
podem gerar muita dor de cabeça para o cientista de dados. 
2.2.1 Tipos de Estruturas de Dados 
 
 Os dados podem ser apresentados de diversas maneiras, não existe um padrão único para 
a difusão ou divulgação. Sendo assim, é bom que você esteja preparado para lidar com qualquer 
tipo de estrutura de dados. Existem diversas classificações de estrutura de dados. Vamos utilizar 
uma classificação mais generalista, que diz respeito a como os dados são disponibilizados. Sendo 
 
FIGURA 2.1: TEMAS ABORDADOS NO CAPÍTULO: EXPLORAÇÃO DOS DADOS (ADAPTADO DE WICKHAM&GROLEMUND (2016)) 
26 
 
assim, podemos classificá-los em três grandes tipos quanto à sua estrutura ou forma: dados estru-
turados, semiestruturados e não estruturados. 
 Dados estruturados: talvez seja o formato de dados mais fácil de se trabalhar no R. São 
conjuntos de informações organizadas em colunas (atributos, variáveis, etc.) e linhas (regis-
tros, itens, observações, etc.). São dados mais comumente encontrados diretamente em 
bancos de dados, arquivos com algum tipo de separação entre as colunas, arquivos do Mi-
crosoft Excel, arquivos com campos de tamanho fixo, etc. 
 Dados não estruturados: Como o nome diz, estes dados não têm uma estrutura previsível, 
ou seja, cada conjunto de informações possui uma forma única. Geralmente são arquivos 
com forte teor textual. Não podemos dizer que são dados “desorganizados”, e sim que são 
organizações particulares para cada conjunto de informações. Podemos citar, por exemplo, 
e-mails, tweets, arquivos em PDF, imagens, vídeos, etc. Analisar este tipo de dado é muito 
mais complexo e exige conhecimento avançado em mineração de dados. Apesar disso, é o 
tipo de dado mais abundante na realidade. 
 Dados semiestruturados: São dados que também possuem uma organização fixa, porém 
não seguem o padrão de estrutura linha/coluna, ou seja, seguem uma estrutura mais com-
plexa e flexível, geralmente hierárquica, estruturada em tags ou marcadores de campos. 
São exemplos de arquivos semiestruturados: XML, JSON, HTML, etc. É o formato mais 
usado em troca de dados pela internet. Dados semiestruturados, algumas vezes, são facil-
mente transformados em dados estruturados. 
2.2.2 Definindo o Local dos Dados 
 
 O R sempre trabalha com o conceito de working directory, ou seja, uma pasta de trabalho 
que será utilizada para “ler” e “escrever” os dados. Para verificar qual o working directory atual, 
utilize o seguinte comando: 
getwd() #Get Working Directory 
Para informar ao R em qual pasta ele deve ler ou escrever os arquivos, utilizamos o comando set 
working directory, que muda o diretório padrão do R para leitura e escrita: 
setwd("D:/caminho/do/arquivo/arquivo.csv") 
2.2.3 Pacote para leitura dos dados 
 
 O R base possui funções para a leitura dos principais tipos de arquivos. Um outro pacote 
específico, e muito bom para isso, é o readr. O pacote tidyverse inclui o carregamento do pacote 
readr. Diversos tipos de arquivos são lidos pelo R: comma-separated values (csv), planilhas Excel, 
arquivos separados por delimitadores, colunas de tamanho fixo, etc. Talvez o tipo de arquivo (es-
truturado) mais comum hoje em dia, e mais simples de trabalhar, seja o csv. Começaremos a im-
portar dados com arquivos csv. 
library(tidyverse) #já carrega o readr 
#ou 
library(readr) 
27 
 
 Vamos importar um arquivo csv chamado senado.csv. Caso o arquivo esteja em seu working 
directory, basta passar apenas o nome do arquivo para a função, caso contrário será necessário 
informar todo o caminho até a pasta do arquivo. Usamos o read_csv() para fazer isso. 
senado <- read_csv("senado.csv") 
 Esse comando carrega o conteúdo do arquivo senado.csv para o objeto (variável) senado. 
Atenção! Sempre verifique se o arquivo a ser importado encontra-se no working directory considerado 
pelo R, pois é lá que ele vai buscar o arquivo. Utilize o comando getwd() para fazer a checagem. 
 Após o carregamento, começaremos a investigar o conteúdo desse objeto: os dados. head 
e tail são funções para ver a “cabeça” e a “cauda” dos seus dados, ou seja, o começo e o fim das 
amostras. É muito importante sempre observar a “aparência” dos dados após o carregamento. Essa 
observação ajuda a identificar erros básicos no carregamento,possibilitando ajustes o quanto antes, 
impedindo que esses erros se propaguem. Observe a Figura 2.2: na primeira linha temos os nomes 
das colunas e, em seguida, os registros (observações). 
 
 Outros comandos muito importantes para começar a investigar os dados são str(), class() 
e summary(). Para verificar o tipo do objeto, ou seja, sua classe, utilize: 
 class(senado) 
 Já para verificar a estrutura do objeto, ou seja, seus campos (quando aplicável), digite: 
str(senado) #structure 
 Para verificar estatísticas básicas do objeto (média, mediana, quantis, mínimo, máximo, 
etc.), quando aplicáveis, digite: 
 
FIGURA 2.2: INÍCIO E FIM DOS DADOS DO ARQUIVO SENADO.CSV 
28 
 
summary(senado) 
 Muitas vezes, nem sempre o caractere separador de arquivo será o ; típico do arquivo csv. 
Nesse caso será necessário usar o read_delim(), onde você pode informar qualquer tipo de sepa-
rador. Outro tipo de arquivo bastante comum é o de colunas com tamanho fixo (fixed width), também 
conhecido como colunas posicionais. Nesse caso, será necessário usar o read_fwf() informando o 
tamanho de cada coluna. O arquivo TA_PRECOS_MEDICAMENTOS.csv apresenta um conjunto de 
dados sobre medicamentos separados pelo delimitador |. O seguinte comando carrega o arquivo 
no objeto med. Em seguida visualize o início e o fim dos dados. 
med <- read_delim("TA_PRECOS_MEDICAMENTOS.csv", delim = '|') 
head(med) 
tail(med) 
 O arquivo fwf-sample.txt possui o formato de colunas fixas, sendo que a primeira coluna 
(Nome) tem tamanho vinte, a segunda (Estado) tem tamanho dez e a terceira (Código) tem tamanho 
doze. O seguinte comando pode ser usado para ler o arquivo e mostrar o seu resultado: 
data1 <- read_fwf("fwf-sample.txt", col_positions = fwf_widths(c(20, 10, 12), c("Nome", 
"Estado", "Codigo"))) 
head(data1) 
 O R oferece ainda a possibilidade de realizar a leitura de dados em tabelas de bancos de 
dados relacionais. Mostraremos um exemplo sobre como ler dados de uma tabela do Sistema Ge-
renciador de Banco de Dados (SGBD) MySQL. Primeiramente, é necessário instalar o pacote que 
possibilita a conexão com o MySQL (caso ele ainda não esteja instalado) e carregá-lo. 
install.packages("RMySQL") 
library(RMySQL) 
Atenção! Nos exemplos vistos aqui, usaremos o SGBD MySQL. Para realizar a conexão do R com 
outros SGBDs (PostgreSQL, Oracle, etc.) é necessários instalar e carregar os pacotes específicos 
para estes bancos. Pesquise quais pacotes devem ser instalados para conectar o R a outros 
SGBDs. 
 Em seguida é necessário usar o comando dbConnect para criar o objeto de conexão com o 
SGBD, utilizando os seguintes parâmetros: o SGBD, o usuário e a senha de acesso, a base de 
dados que se deseja acessar e o servidor em que estão os dados. A seguir temos um exemplo de 
uso do comando: 
mydb <- dbConnect(MySQL(), user="root", password="admin", dbname="reddit", 
host="127.0.0.1") 
 Os comandos dbListTables e dbListFields mostram, respectivamente, todas as tabelas exis-
tentes na base de dados e todos os campos de uma tabela específica: 
dbListTables(mydb) 
29 
 
dbListFields(mydb, "users") 
 O próximo passo é usar o comando dbSendQuery para criar um objeto do tipo “ponteiro” para 
o conjunto de dados para o qual se quer ler. Deve-se usar a cláusula SELECT para selecionar os 
campos da tabela. 
pointer <- dbSendQuery(mydb, "select id, Label, Degree, closnesscentrality, betweenesscen-
trality from users where id >= 7000") 
 Por fim, deve-se usar o comando fetch para efetivamente carregar os dados em um objeto, 
passando como parâmetro o ponteiro para os dados criado anteriormente e a quantidade de regis-
tros que serão carregados. Caso se queira carregar todos os registros, o segundo parâmetro deve 
ser igual a -1. 
users <- fetch(pointer, 12) 
head(users) 
 Após realizar as operações desejadas, encerramos a conexão: 
dbDisconnect(mydb) 
2.3 Limpeza dos Dados 
 
 No dia a dia de quem trabalha com dados, infelizmente, é muito comum se deparar com 
dados formatados de um jeito bastante complicado de se manipular. Isso acontece pois a forma de 
se trabalhar com dados é muito diferente da forma de se apresentar ou visualizar dados. A limpeza 
de dados também é considerada parte da exploração de dados. Infelizmente, não temos como 
apresentar um passo a passo padrão para limpeza de dados, pois isso depende completamente do 
tipo de dado que você receber, da análise que você quer fazer e da sua criatividade em manipulação 
de dados. Mas conhecer os pacotes certos ajuda muito nessa tarefa. 
Atenção! É muito mais fácil trabalhar no R com dados “bem estruturados”, onde cada coluna deve 
ser uma única variável e cada linha deve ser uma única observação. 
 Na contramão da limpeza de dados, você provavelmente terá o problema contrário ao final 
da sua análise. Supondo que você organizou seus dados perfeitamente, conseguiu executar os 
modelos que gostaria, gerou diversos gráficos interessantes e está satisfeito com o resultado, você 
ainda precisará entregar relatórios finais da sua análise em forma de tabelas sumarizadas e expli-
cativas, de modo que os interessados possam entender os dados facilmente, apenas com uma 
rápida análise visual. Neste caso, que tipo de tabela seria melhor produzir? Provavelmente, quem 
for ler seus relatórios entenderá mais rapidamente as tabelas com dados “desestruturados”, que 
possuem totalizadores e informações com resumos dos dados apresentados. É importante apren-
der a estruturar e desestruturar tabelas de todas as formas possíveis. 
 Para exemplificar, veja algumas tabelas disponíveis no pacote tidyverse, ilustrando os dife-
rentes tipos de organização. A Figura 2.3 mostra três tabelas que possuem basicamente os mesmos 
dados e informações, dispostos de forma diferente. 
30 
 
 
2.3.1 O Pacote tidyr 
 
 Apesar de existirem diversas possibilidades de situações que necessitem de limpeza de da-
dos, a conjugação de três pacotes consegue resolver a grande maioria dos casos: dplyr, tidyr e 
stringr. 
 O pacote tidyr é mais um dos pacotes criados por WICKHAM & GROLEMUND (2016). Este 
fato, por si só, já traz algumas vantagens: ele se integra perfeitamente com o pacote dplyr, usando 
o conector %>%, e tem a sintaxe de suas funções bastante intuitiva. 
install.packages("tidyr") 
library(tidyr) 
?tidyr 
 O pacote tidyr também tem suas funções, em que cada uma representa uma tarefa para 
organizar os dados. As funções que abordaremos são os seguintes: 
 gather() 
 spread() 
 separate() 
 unite() 
 Vale lembrar que tudo que for feito usando o pacote tidyr é possível executar também 
usando o R base, mas de uma forma um pouco menos intuitiva. Caso queira entender como usar o 
R base pra isso, procure mais sobre as funções melt() e cast(). 
 Gather: A função gather() serve para agrupar duas ou mais colunas e seus respectivos 
valores (conteúdos) em pares. Assim, o resultado após o agrupamento é sempre duas colunas. A 
primeira delas possui observações cujos valores chave eram as colunas antigas e a segunda possui 
os valores respectivos relacionados com as colunas antigas. Na prática, a função gather diminui o 
número de colunas e aumenta o número de linhas de nossa base de dados. 
 
FIGURA 2.3: TABELAS DO PACOTE TIDYVERSE, COM AS MESMAS INFORMAÇÕES DISPOSTAS DE FORMAS DIFERENTES 
31 
 
 Um problema comum é um conjunto de dados em que alguns dos nomes das colunas não 
são nomes de variáveis, mas valores de uma variável. Veja o conjunto de dados table4a mostrado 
na Figura 2.4; os nomes das colunas de 1999 e 2000 representam valores da variável year, e cada 
linha representa duas observações, e não apenas uma. 
 
 
 
 
 
 
 Para “arrumar” um conjunto de dados como este, precisamos reunir essas colunas 
em um novo par de variáveis. Para descrever essa operação, precisamos de três parâmetros: (i) o 
conjunto de colunas que representam valores, não variáveis; neste exemplo, essas são as colunas“1999” e “2000”; (ii) o nome da variável cujos valores formam os nomes das colunas; ela é comu-
mente chamada de chave, e neste exemplo será a coluna year; (iii) o nome da variável cujos valores 
estão espalhados pelas células; são comumente chamados de valor, e neste exemplo será a coluna 
cases. 
 Uma vez obtidos os parâmetros, basta executar a função gather como mostrado a seguir. A 
função irá disponibilizar as informações em um novo formato, como mostrado no lado esquerdo da 
Figura 2.5. 
t4a <- table4a %>% gather("1999", "2000", key = "year", value = "cases") 
head(t4a) 
 Spread: a função spread() faz o oposto da função gather(). Você usa quando uma obser-
vação está espalhada por várias linhas. Por exemplo, veja a table2 mostrada na Figura 2.3, as 
informações de cada país (cases e population) em um determinado ano está espalhada em duas 
linhas diferentes. Para “arrumar” isso, primeiro analisamos o conjunto de dados assim como fizemos 
com a função gather(). Desta vez, no entanto, precisamos apenas de dois parâmetros: (i) a coluna 
que contém nomes de variáveis, a coluna-chave, que neste exemplo é type; e (ii) a coluna que 
contém valores e forma múltiplas variáveis, a coluna-valor, que neste exemplo chama-se value. 
 
FIGURA 2.4: CONJUNTO DE DADOS TABLE4 
32 
 
 
 Uma vez obtidos os parâmetros, basta executar a função spread como mostrado a seguir. A 
função irá disponibilizar as informações em um novo formato, como mostrado no lado direito da 
Figura 2.6. 
table2.wide <- spread(table2, key = type, value = count) 
head(table2.wide) 
 
 Separate: a função separate() é usada para separar duas variáveis que estão em uma 
mesma coluna. Lembre-se: cada coluna deve ser apenas uma única variável! É bastante comum a 
 
FIGURA 2.5: FORMATO DO CONJUNTO DE DADOS APÓS A FUNÇÃO GATHER (FONTE: WICKHAM & GROLEMUND (2016)) 
 
FIGURA 2.6: FORMATO DO CONJUNTO DE DADOS APÓS A FUNÇÃO SPREAD (FONTE: WICKHAM & GROLEMUND (2016)) 
33 
 
existência de duas ou mais variáveis juntas em uma única coluna, mas nem sempre isso é prejudi-
cial, cabe avaliar quando vale a pena separá-las. Usaremos o exemplo da table3 mostrada na 
Figura 2.3. O resultado da execução do comando mostrado a seguir pode ser visualizado na Figura 
2.7. 
table3.wide <- table3 %>% separate(rate, into = c("cases", "population"), sep='/') 
head(table3.wide) 
 
 Unite: a função unite() é o oposto da função separate(), ela pega duas colunas (variáveis) 
e transforma em uma só. É muito utilizada para montar relatórios finais ou tabelas para análise 
visual. Vamos usar a table5, um conjunto de dados já disponível no R, para unir as colunas century 
e year em uma nova coluna. unite() usa como argumentos o data frame (conjunto de dados), o 
nome da nova variável a ser criada e o conjunto de colunas que devem ser combinados. Nós usa-
remos um argumento adicional chamado sep pois por padrão a função unite() usa o caractere 
underscore (_) entre os valores das colunas. Nós não queremos qualquer separador, portanto usa-
remos como argumento uma string vazia “”. o resultado da operação pode ser visto na Figura 2.8. 
table5.wide <- table5 %>% unite(new, century, year, sep = "") 
head(table5.wide) 
 
FIGURA 2.7: FORMATO DO CONJUNTO DE DADOS APÓS A FUNÇÃO SEPARATE (FONTE: WICKHAM&GROLEMUND (2016)) 
34 
 
 
2.4 Transformação dos Dados 
 
 Após obter uma boa fonte de dados, e carregá-los para poder trabalhá-los no R, você certa-
mente precisará realizar algumas transformações para que os dados estejam no ponto ideal para 
as fases finais de uma análise: execução de modelos econométricos, visualizações de dados, ta-
belas agregadas, relatórios, etc. A realidade é que, na prática, os dados nunca estarão do jeito que 
você de fato precisa. Portanto, é fundamental dominar técnicas de transformação de dados. 
 Entendamos a transformação de dados como o ato de transformar, reestruturar, limpar, agre-
gar e juntar os dados. Para se ter uma noção da importância dessa fase, alguns estudiosos da área 
de Ciência de Dados, como DASU & JOHNSON (2003), afirmam que 80% do trabalho é encontrar 
uma boa fonte de dados, limpar e preparar os dados, sendo que os 20% restantes seriam o trabalho 
de aplicar modelos e realizar alguma análise propriamente dita. 
 
2.4.1 Valores faltantes e o “NA” 
 
 Em casos onde não existe valor em uma coluna de uma linha, o R atribui NA. É muito comum 
lidar com conjuntos de dados que tenham ocorrências de NA em alguns campos. É importante 
saber o que se fazer em casos de NA, e nem sempre a solução será a mesma: varia de acordo 
com as suas necessidades. Em algumas bases de dados, quem gera o dado atribui valores gené-
ricos como 999 ou até mesmo um “texto vazio”, " ". Neste caso, você provavelmente terá que subs-
tituir esses valores “omissos” por NA. Imputar dados em casos de NA é uma das várias estratégias 
para lidar-se com ocorrência de missing no conjunto dos dados. Seguem algumas funções úteis 
para lidar-se com NA: 
 A função summary() pode ser usada para averiguar a ocorrência de NA. 
 A função is.na() realiza um teste para saber se a variável/coluna possui um valor NA. retorna 
TRUE se for NA e FALSE se não for. 
 
FIGURA 2.8: FORMATO DO CONJUNTO DE DADOS APÓS A FUNÇÃO UNITE (FONTE: WICKHAM & GROLEMUND (2016)) 
35 
 
 A função complete.cases() retorna TRUE para as linhas em que todas as colunas possuem 
valores válidos (preenchidos) e FALSE para as linhas em que, em alguma coluna, existe um 
NA. Ou seja, esta função diz quais são as linhas (amostras) completas em todas as suas 
características (campos). 
 Algumas funções possuem o argumento na.rm, ou semelhantes, para desconsiderar NA no 
cálculo. É o caso das funções mean() ou sum(). 
 Para os exemplos a seguir, vamos utilizar uma base de dados pré-carregada no R chamada 
airquality, que possui dados sobre a qualidade do ar em cidades norte-americanas. 
data("airquality") #base de dados pré-carregada no R 
summary(airquality) #verificando ocorrência de NA 
 
 Na Figura 2.9 é possível observar que existem 37 ocorrências de NA na coluna Ozone e sete 
ocorrências de NA na coluna Solar.R. A função is.na() pode mostrar as posições da coluna Ozone 
que possuem o valor NA. A Figura 2.10 mostra que na quinta posição da variável Ozone existe um 
valor de NA, o que pode ser verificado com o comando head. 
is.na(airquality$Ozone) 
 
FIGURA 2.9: OCORRÊNCIAS DE NA'S NA BASE DE DADOS AIRQUALITY 
36 
 
 
2.4.2 Transformação de dados com o Pacote dplyr 
 
 O pacote dplyr possui uma sintaxe simples e concisa, o que facilita o aprendizado e torna o 
pacote um dos preferidos para realizar tarefas de transformação de dados. Ao carregar o pacote 
tidyverse, você já carregará automaticamente o pacote dplyr, mas você também pode carregá-lo 
individualmente: 
install.packages("dplyr") 
library(dplyr) 
?dplyr 
 
 O dplyr cobre praticamente todas as tarefas básicas da transformação de dados: agregar, 
sumarizar, filtrar, ordenar, criar variáveis, dentre outras. As funções do dplyr reproduzem as princi-
pais tarefas da transformação, de forma bastante intuitiva: 
 select() 
 filter() 
 arrange() 
 group_by() 
 summarise() 
 Essas são as principais funções, mas existem outras disponíveis, como por exemplo slice(), 
rename() e transmute(). Além de nomes de funções intuitivos, o dplyr também faz uso de um 
recurso disponível bastante interessante, o operador %>% (originário do pacote magrittr). Este ope-
rador encadeia as chamadas de funções de forma que você não vai precisar ficar chamando uma 
 
FIGURA 2.10: VALORES DE NA NA BASE DE DADOS AIRQUALITY 
37 
 
função dentro da outra ou ficar fazendo atribuições usando diversas linhas para concluir suas ma-
nipulações. Aliás, podemos dizer que esse operador %>%, literalmente, cria um fluxo sequencial 
bastante claro e legível para todas as atividades de transformação. A seguir vamos ver com mais 
detalhes o funcionamento das principais