Introdução ao R

Inovação Tecnológica e Processos de Desenvolvimento

Anderson Ribeiro Duarte

O que é o R

  • Linguagem de programação voltada para Estatística e Ciência de Dados;

  • É uma linguagem funcional, ou seja, as ações ocorrem por meio de funções aplicadas a objetos;

  • Apesar de ser um software estatístico, é utilizado por diversas áreas;

  • É uma linguagem cujo aprendizado básico é relativamente simples.

O que é o R

  • O R é um software de licença livre;

  • Para instalá-lo, basta acessar o link a seguir: https://cran.r-project.org/

  • Após sua instalação, ele apresenta a seguinte janela

O que é o R

RStudio

  • Como é possível observar, a interface do R é bastante simples;

  • Para uma melhor utilização da linguagem, foi desenvolvido um ambiente de desenvolvimento denominado RStudio;

  • O RStudio oferece uma interface com mais opções do que a interface nativa do R

  • Ele pode ser obtido no link https://posit.co/download/rstudio-desktop/;

  • Nessa disciplina, utilizaremos o RStudio como ambiente de desenvolvimento.

RStudio

O RStudio, desenvolvido pela empresa Posit, é composto por quatro janelas:

  • Console - Janela de linha de comando, que apresenta resultados de cálculos;

  • Source - Espaço para apresentação de scripts e bases de dados;

  • Environment - Espaço destinado para visualização de objetos e histórico de cálculos

  • Files, Plots, Packages… - Espaço destinado à visualização de arquivos em pastas, gráficos, tópicos de ajuda, dentre outros.

RStudio

RStudio

  • Essas janelas podem ser organizadas conforme a preferência do usuário

  • O trabalho ocorre principalmente nas janelas Source e Console.

  • Agora, ao conhecer o ambiente de trabalho, será iniciada à utilização do R como ferramenta de cálculo e análise de dados.

O R como linguagem de programação

  • O R é dito uma linguagem funcional, ou seja, todas as ações são realizadas por meio de funções aplicadas a objetos:

    • Objeto: Elemento computacional que representa uma entidade do mundo real.

    • Função: instrução que atua em um objeto, de forma bastante semelhante a uma função matemática;

  • Exemplo:

    • Objeto: número 2

    • Função: \(f(x) = \sqrt{x}\)

    • Aplicação: \(f(2) = \sqrt{2}\)

O R como linguagem de programação

O exemplo anterior seria representado da seguinte maneira em R

#Objeto: Número 2
2
[1] 2
#Função: raiz de x - Em R representada por sqrt(x)
sqrt(2)
[1] 1.414214

Observe que a função retorna diretamente o resultado. Do mesmo modo, é possível realizar diversas operações em R.

O R como calculadora

  • A primeira e mais simples função do R é como calculadora científica

  • No R é possível a realização das mais diversas operações matemáticas e matriciais.

  • Para tal, basta utilizar seu console. Veja alguns exemplos básicos:

    #Soma de dois valores
5 + 8
    [1] 13
    #Produto de dois valores
15.3 * 6.57
    [1] 100.521
    #Seno de um ângulo
sin(pi/2)
    [1] 1

O R como calculadora

As principais operações matemáticas são definidas pelas seguintes funções:

Aritiméticas

  • Soma: +

  • Subtração: -

  • Multiplicação: *

  • Divisão: /

  • Raiz: sqrt()

  • Potência: ^

  • \(e^x\): \(exp(x)\)

  • Módulo: \(abs()\)

Lógicas

  • Maior : \(>\)

  • Menor: \(<\)

  • Maior ou igual: \(>=\)

  • Menor ou igual: \(<=\)

  • Igual a: \(==\)

  • Diferente de: \(!=\)

  • E: &

  • Ou: |

O R como calculadora

Alguns exemplos:

#Subtração
2.5 - 0.37
[1] 2.13
#Multiplicação
5*9
[1] 45
#Raiz de -5
sqrt(-5)
[1] NaN
#Verificar se um número é maior que outro
3 > 2
[1] TRUE
#Verificar se dois números são iguais
2 == 3
[1] FALSE
#Verificar se duas palavras são diferentes
"CASA" != "casa"
[1] TRUE

O R como calculadora

Com os exemplos, é possível notar algumas características:

  • O R separa decimais por . (ponto)

  • Comparações verdadeiras retornam TRUE

  • Comparações falsas resultam em FALSE

  • Operações indefinidas resultam em NaN (not a number).

  • Caracteres são atribuídos entre aspas.

  • O R é case sensitive (diferencia minúsculas de maiúsculas)

Essas características são importantes no momento dos cálculos.

Atribuição de variáveis

  • De modo geral, não se utiliza os valores diretamente no R.

  • Os valores são atribuídos à variáveis, que podem ser utilizadas a qualquer tempo.

  • Para atribuir uma variável ao R, utiliza-se o operador <-.

  • Utiliza-se o atalho alt + - (hífen) para evitar a digitação do operador.

  • Para imprimir ou utilizar os valores, basta executar o valor no console.

  • Veja como atribuir as variáveis

Atribuição de variáveis

#Atribuir a x o valor 5.6 + 2.7
x <- 5.6 + 2.7

#Imprimir o valor
x
[1] 8.3
#Atribuir uma frase à variável y
y <- "Isso é uma frase"
y
[1] "Isso é uma frase"
#Salvar uma comparação lógica
z = 5 > 4
z
[1] TRUE
#Podemos atribuir e imprimir ao mesmo tempo, fazendo a atribuição entre parênteses
(w <- 2 + 5)
[1] 7

Tipos de variáveis

Conforme visto nos exemplos, o R trabalha com uma série de formatos de variáveis. Os principais são:

  • numeric: Valores numéricos. Pode ser do tipo

  • character: cadeia de caracteres

  • logical: valores lógicos

  • factor: variável categórica, com níveis definidos.

É possível verificar o tipo de variável com o uso da função typeof(). Verificação das variáveis anteriores

Tipos de variáveis

#Variável numérica
x
[1] 8.3
typeof(x)
[1] "double"
#Variável caractere
y
[1] "Isso é uma frase"
typeof(y)
[1] "character"
#Variável lógica
z
[1] TRUE
typeof(z)
[1] "logical"

Script

  • Conforme visto, o R trabalha com funções e objetos por meio de comandos escritos;

  • Entretanto, muitas vezes é necessário estabelecer uma rotina de comandos;

  • Nesse caso, seria inviável a digitação consecutiva de uma série de comandos.

  • Para sanar esse problema, em R é possível escrever as instruções separadamente e executá-las quando necessário. O que permite essa prática são os Scripts.

  • Os Scripts nada mais são do que arquivos de texto que armazenam os códigos que serão executados.

Script

Os Scripts no RStudio são exibidos na janela Source. Para criar um novo script, existem três possibilidades:

  • Acessar o caminho File -> New File -> R Script

  • Clicar no ícone +, localizado abaixo da opção File selecionar R Script

  • Utilizar o atalho Ctrl + Shift + N.

  • As instruções que seriam executadas diretamente no console, podem ser digitadas no Script para serem executados a qualquer momento.

  • É possível salvar nosso Script para futura utilização clicando no ícone de disquete.

  • É possível abrir o Script clicando no ícone que apresenta uma pasta com uma seta verde.

Script

  • Entretanto, o Script em si é apenas um conjunto de instruções. Diferente do console, ele não executa os comandos.

  • Para executar os comandos digitados no script, existem alguns caminhos:

    • Clicar na linha na qual o comando foi digitado e utilizar o atalho Ctrl + Enter.

    • Selecionar várias linhas de código e e utilizar o atalho Ctrl + Enter para executar múltiplos comandos.

Script

  • A ideia do Script é organizar uma sequência de instruções, que será utilizada na análise de dados.

  • Para organizar melhor o Script, é possível utilizar comentários que descrevam os comandos.

  • Um comentário não será executado em nenhuma condição.

  • É possível inserir comentários em no script usando o símbolo de #

  • Veja agora um exemplo de Script, com as instruções anteriores.

Script

Por que aprender R em Inovação?

# =====================================================
# CONFIGURAÇÃO INICIAL
# =====================================================

pacotes <- c("ggplot2", "dplyr")

instalar <- pacotes[!(pacotes %in% installed.packages()[,"Package"])]

if(length(instalar)) install.packages(instalar)

library(ggplot2)
library(dplyr)

Por que aprender R em Inovação?

  • Tomada de decisão baseada em evidências
  • Construção de indicadores tecnológicos
  • Avaliação de eficiência em P&D
  • Monitoramento de patentes
  • Análise de crescimento tecnológico

Aplicação em Inovação

Intensidade Tecnológica

set.seed(123)

empresa <- c("Startup A","Startup B","Startup C","Startup D")
faturamento <- c(2.5, 5.0, 3.2, 8.4) * 10^6
pd <- c(400000, 900000, 500000, 1200000)

dados <- data.frame(empresa, faturamento, pd)

dados <- dplyr::mutate(dados,
                       intensidade_pd = pd / faturamento)

dados
    empresa faturamento      pd intensidade_pd
1 Startup A     2500000  400000      0.1600000
2 Startup B     5000000  900000      0.1800000
3 Startup C     3200000  500000      0.1562500
4 Startup D     8400000 1200000      0.1428571

Visualização

grafico_intensidade <- ggplot(dados,
                              aes(x = empresa,
                                  y = intensidade_pd)) +
  geom_col() +
  labs(title = "Intensidade Tecnológica (P&D / Receita)",
       y = "Intensidade",
       x = "Empresa") +
  theme_minimal()

grafico_intensidade
ggsave("intensidade_tecnologica.png",
       plot = grafico_intensidade,
       width = 8,
       height = 5,
       dpi = 300)

Crescimento de Patentes

anos <- 2010:2024
patentes <- cumsum(rpois(length(anos), lambda = 5))

dados_patentes <- data.frame(anos, patentes)

dados_patentes
   anos patentes
1  2010        4
2  2011       11
3  2012       15
4  2013       23
5  2014       32
6  2015       34
7  2016       39
8  2017       47
9  2018       52
10 2019       57
11 2020       66
12 2021       71
13 2022       77
14 2023       82
15 2024       84
grafico_patentes <- ggplot(dados_patentes,
                           aes(x = anos,
                               y = patentes)) +
  geom_line() +
  geom_point() +
  labs(title = "Acúmulo de Patentes ao Longo do Tempo",
       x = "Ano",
       y = "Patentes acumuladas") +
  theme_minimal()

grafico_patentes
ggsave("curva_patentes.png",
       plot = grafico_patentes,
       width = 8,
       height = 5,
       dpi = 300)

Eficiência Inovadora

empresa2 <- c("A","B","C","D")
patentes2 <- c(10, 25, 12, 30)
investimento <- c(2,5,3,6)

dados2 <- data.frame(empresa2, patentes2, investimento)

dados2 <- dplyr::mutate(dados2,
                        eficiencia = patentes2 / investimento)

dados2
  empresa2 patentes2 investimento eficiencia
1        A        10            2          5
2        B        25            5          5
3        C        12            3          4
4        D        30            6          5
melhor <- dados2$empresa2[which.max(dados2$eficiencia)]
melhor
[1] "A"
grafico_eficiencia <- ggplot(dados2,
                             aes(x = empresa2,
                                 y = eficiencia)) +
  geom_col() +
  labs(title = "Eficiência Inovadora",
       y = "Patentes por Milhão Investido",
       x = "Empresa") +
  theme_minimal()

grafico_eficiencia
ggsave("eficiencia_inovadora.png",
       grafico_eficiencia,
       width = 8,
       height = 5,
       dpi = 300)

Boas práticas

Introdução

Discussão de boas práticas no desenvolvimento de projetos de análise de dados.

usualmente os scripts e arquivos são trabalhados de forma isolada. Entretanto, quando a complexidade aumenta, é útil seguir algumas regras que facilitam tanto no desenvolvimento, quanto no compartilhamento dos resultados e no trabalho em equipe.

O foco aqui é em dois tópicos específicos:

  • Projetos

  • Códigos

Entretanto, antes de iniciarmos a discussão dessas práticas, vamos apresentar o conceito de pipe.

Pipe

Ao se trabalhar com dados em R, muitas vezes é necessário o encadeamento de funções, ou a aplicação em etapas destas funções em objetos salvos. Esta prática apresenta algumas desvantagens, é possível destacar duas:

  1. A depender da quantidade de encadeamentos, a legibilidade, bem como a identificação de parâmetros podem ser prejudicados.

  2. Pode ocorrer um acúmulo desnecessário de objetos na memória do R. Se forem objetos de grande dimensão, tais operações podem prejudicar o desempenho das operações.

Observe um exemplo com a base de dados nycflights13, do pacote nycflights que compila os voos dos aeroportos de Nova Iorque ocorridos no ano de 2013.

Pipe

Suponha calcular o tempo médio de vôo em minutos dos voos com origem do aeroporto JFK com destino ao aeroporto de Atlanta (ATL), no mês de janeiro, removendo voos com duração superior ao percentil 95, que podem ter enfrentado algum problema durante o voo. Como fazer este procedimento utilizando o pacote base?

Pipe

#Carrega o pacote nycflights13
pacman::p_load(nycflights13)

#Estrutura dos dados
glimpse(flights)
Rows: 336,776
Columns: 19
$ year           <int> 2013, 2013, 2013, 2013, 2013, 2013, 2013, 2013, 2013, 2…
$ month          <int> 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1…
$ day            <int> 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1…
$ dep_time       <int> 517, 533, 542, 544, 554, 554, 555, 557, 557, 558, 558, …
$ sched_dep_time <int> 515, 529, 540, 545, 600, 558, 600, 600, 600, 600, 600, …
$ dep_delay      <dbl> 2, 4, 2, -1, -6, -4, -5, -3, -3, -2, -2, -2, -2, -2, -1…
$ arr_time       <int> 830, 850, 923, 1004, 812, 740, 913, 709, 838, 753, 849,…
$ sched_arr_time <int> 819, 830, 850, 1022, 837, 728, 854, 723, 846, 745, 851,…
$ arr_delay      <dbl> 11, 20, 33, -18, -25, 12, 19, -14, -8, 8, -2, -3, 7, -1…
$ carrier        <chr> "UA", "UA", "AA", "B6", "DL", "UA", "B6", "EV", "B6", "…
$ flight         <int> 1545, 1714, 1141, 725, 461, 1696, 507, 5708, 79, 301, 4…
$ tailnum        <chr> "N14228", "N24211", "N619AA", "N804JB", "N668DN", "N394…
$ origin         <chr> "EWR", "LGA", "JFK", "JFK", "LGA", "EWR", "EWR", "LGA",…
$ dest           <chr> "IAH", "IAH", "MIA", "BQN", "ATL", "ORD", "FLL", "IAD",…
$ air_time       <dbl> 227, 227, 160, 183, 116, 150, 158, 53, 140, 138, 149, 1…
$ distance       <dbl> 1400, 1416, 1089, 1576, 762, 719, 1065, 229, 944, 733, …
$ hour           <dbl> 5, 5, 5, 5, 6, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 6, 6, 6…
$ minute         <dbl> 15, 29, 40, 45, 0, 58, 0, 0, 0, 0, 0, 0, 0, 0, 0, 59, 0…
$ time_hour      <dttm> 2013-01-01 05:00:00, 2013-01-01 05:00:00, 2013-01-01 0…

Pipe

#Uma abordagem por objetos
##Filtrando voos pela origem, destino e mês
voo_jfk_atl <- subset(flights, origin == "JFK" & dest == "ATL" & month == 1)

##Calculando o percentil 95
p95 <- quantile(voo_jfk_atl$air_time, .95, na.rm = T)

#Filtrando voos com tempo superior ao p95
voo_jfk_atl_95 <- subset(voo_jfk_atl, air_time < p95)

#Calculando a média e convertendo em horas
mean(voo_jfk_atl_95$air_time, na.rm = T)
[1] 119.7603

Pipe

Note que utilizou-se 4 linhas e criou-se 4 objetos para chegar ao resultado final. É possível fazer todo o procedimento em um encadeamento de funções:

#Abordagem funcional

mean(
  subset(
    subset(flights, origin == "JFK" & dest == "ATL" & month == 1), air_time <
      quantile(
        subset(flights, origin == "JFK" & dest == "ATL" & month == 1)$air_time,
        .95, na.rm = T))$air_time, 
  na.rm = T)
[1] 119.7603

Ambos retornaram os mesmos resultados. A primeira abordagem é mais organizada, mas cria objetos auxiliares, que deveriam ser apagados posteriormente. A segunda abordagem é bastante confusa, pois apresenta uma série de encadeamentos.

Pipe

Uma alternativa a estas opções é a utilização do comando pipe %>%. O comando pipe é um encadeador natural, disponível no pacote magrittr, nativo no tidyverse.

Ele age da seguinte forma. Suponha ter 2 funções encadeadas. Em código, algo do tipo f(x, y), ou seja, aplicar ao objeto x, a função f() com parâmetro y.

Utilizando o pipe, tem-se a seguinte forma: x %>% f(y).

No caso de dois encadeamentos, do tipo g(f(x, y), z), em pipe x %>% f(y) %>% g(z).

Para tornar mais claro, vamos observar alguns exemplos e posteriormente verificar como ficaria nossa tarefa anterior usando o operador.

Pipe

#Carregamento do pacote magrittr
pacman::p_load(magrittr)

#Média de dados - Normal e Pipe
mean(flights$air_time, na.rm = T)
[1] 150.6865
flights$air_time %>% mean(na.rm = T)
[1] 150.6865
#Número de voos ocorridos no mês de janeiro - Normal e Pipe
nrow(subset(flights, month== 1))
[1] 27004
flights %>% subset(month == 1) %>% nrow
[1] 27004
#Abordagem do problema inicial via pipe
flights %>% 
  subset(origin == "JFK" & dest == "ATL" & month == 1) %>% 
  subset(air_time < quantile(air_time, .95, na.rm = T)) %>% 
  .[, "air_time"] %>% 
  colMeans() 
air_time 
119.7603

Pipe

Note que o código é tão organizado quanto aquele que definiu vários objetos, porém, não foi necessária a definição de nenhum objeto. O pipe é bastante intuitivo na utilização de funções que serão utilizadas durante esse curso, como aquelas do pacote dplyr. No RStudio, para incluir um pipe, basta utilizar o atalho ctrl+shift+M.

No ano de 2022, foi incluído no R um operador pipe nativo, definido pelos símbolos |>. Existem algumas diferenças entre eles, que podem ser analisadas neste link.

Projetos

Agora com a utilização básica do pipe, vamos começar a falar sobre projetos de análise de dados.

Um projeto de análise de dados se baseia em dois elementos fundamentais: dados e códigos.

Os dados podem ser oriundos de diversas fontes: planilhas, bancos de dados, sites, APIs, corpus, etc.

Já os scripts são os conjuntos de instruções que utilizamos para manipular os dados e gerar os resultados desejados a partir deles.

Projetos

Nesse sentido, em um projeto de análise de dados, conforme a complexidade escala, é bastante útil desenvolvermos uma estrutura que facilite a compreensão de todo o processo. Para isso, podemos utilizar algumas boas práticas que favorecem sua organização.

Como a ferramenta nessa disciplina é o RStudio, deve-se aprender como organizar um projeto dentro deste ambiente.

Criação de um projeto

Um projeto no RStudio nada mais é do que um diretório no qual todo o fluxo de trabalho é organizado.

A criação de um projeto favorece a organização dos elementos utilizados na análise de dados e otimiza o funcionamento das funcionalidades do software.

Por exemplo, ao definir um projeto, o diretório de trabalho é automaticamente definido para sua pasta de localização.

Também é possível usar referências relativas em arquivos e pastas, o que torna o código mais simples.

É possível compartilhar todo o projeto em uma pasta compactada, garantindo a consistência do fluxo de trabalho e dos arquivos.

Criação de um projeto

Para criar um projeto, basta seguir o seguinte caminho do sistema: File -> New Project.... Após seguir esse caminho, serão apresentadas as seguintes opções:

Criação de um projeto

  • Em New Directory, o projeto será criado em uma nova pasta. Você deverá indicar o caminho no qual a pasta será criada. Prefira essa opção para projetos novos.

  • Em Existing Directory, o projeto será criado em uma pasta existente. Você deverá indicar o caminho no qual a pasta está. Essa opção é útil quando você pretende organizar um projeto já iniciado.

  • Em Version Control, um projeto específico para utilização de ferramentas de controle de versão, como git e github é criado. Esse assunto é bastante específio e não abordaremos nesse curso, mas sugiro que todos leiam sobre em algum momento.

Criação de um projeto

Vamos utilizar a primeira opção. Na janela a seguir, deve ser escolhido o tipo de projeto. No caso de um projeto geral, deve-se escolher a opção New Project.

Criação de um projeto

Após escolher o tipo de projeto, precisamos escolher um nome para o projeto e a pasta no qual ele será alocado. O Rstudio criará uma subpasta dentro da pasta indicada, com o nome do projeto.

A opção Use renv with this project é voltada para a utilização do pacote renv, que facilita o controle de versão e o compartilhamento de projetos, garantindo a utilização de pacotes compatíveis por exemplo. Como não será detalhada sua utilização, vamos manter desmarcada. Para finalizar, assinale a opção Open in new session e clique em Create Project.

Criação de um projeto

Após a criação do projeto, será iniciada uma nova seção e o projeto estará disponível no canto superior direito da janela de recursos do R (source):

Note que outros projetos podem ser acessados diretamente pelo mesmo menu.

Agora que com o projeto criado, o trabalho chega na estrutura das pastas e arquivos.

Estrutura de pastas

Conforme mencionado, ao se criar um projeto, uma nova pasta é criada. Inicialmente essa pasta contém apenas um arquivo do tipo R Project (.RProj), e uma pasta com arquivos do usuário. Essa pasta será automaticamente definida como diretório de trabalho nessa sessão.

Estrutura de pastas

Uma boa prática que favorece a organização de um projeto de análise/ciência de dados é a criação de pastas específicas para cada tipo de arquivo. A quantidade de pastas depende da complexidade do projeto.

Por exemplo, projetos que trabalham com bases de dados distintas podem ter pastas por formato. Scripts com objetivos distintos podem ser separados em pastas específicas, e assim por diante.

Estrutura de pastas

Entretanto, em uma abordagem inicial, duas pastas são indicadas: scripts e datasets. A primeira receberá os scripts e a segunda os conjuntos de dados. Os nomes são opcionais. A seguir um exemplo de projeto com essa estrutura:

As pastas podem ser criadas tanto pelo sistema operacional, quanto pela aba File do Rstudio. Essa aba fornece opções para manipulação de pastas e arquivos. Pastas adicionais podem ser criadas, por exemplo para armazenar figuras geradas, bancos de dados exportados, relatórios, dentre diversas outras possibilidades.

Agora com uma estrutura básica definida para o projeto, uma discussão de algumas boas práticas relacionadas aos códigos em R.

Códigos

A partir do momento que conhecemos o problema e definimos uma estrutura para o projeto, pode-se iniciar o processo de execução da análise de dados. E no R, a análise de dados é realizada com base em código.

Um código é um conjunto ordenado de instruções desenvolvido para a realização de uma tarefa específica. No caso de uma análise de dados, os códigos são responsáveis por tarefas como importação e manipulação de dados, modelagem e visualização.

Códigos

Nesse sentido, assim como uma receita que deve ser seguida à risca para que o roduto final seja satisfatório, é importante que o código esteja bem organizado para garantir algumas características ideais, das quais destacaremos a legibilidade.

O código deve ser facilmente compreendido por outros humanos, com estrutura clara, nomes representativos para seus elementos. Ele deve apresentar comentários que facilitem sua interpretação por outros leitores e deve ser facilmente reprodutível. Além disso, deve-se evitar complexidades desnecessárias.

Para garantir essa legibilidade, podemos seguir algumas boas práticas que favorecem tal organização. Vamos listar algumas delas:

Estrutura do código

Em projetos de análise de dados em linguagem R, o código quase sempre apresenta algumas etapas comuns, devido à natureza do probelma.

Uma boa abordagem para o desenvolvimento de códigos legíveis é a organização dessas tarefas em uma ordem que faça sentido para a execução das tarefas. Uma proposta que quase sempre funciona é a seguinte:

  1. Carregamento de pacotes

  2. Importação de scripts

  3. Definição de funções e valores globais

  4. Leitura de dados

  5. Códigos.

Essa ordem garante que não faltarão elementos para a execução da próxima. Por exemplo, o carregamento de pacotes deve ser sempre a primeira etapa, pois as demais podem depender dela. A seguir algumas dicas para cada sessão.

Carregamento de pacotes

O uso de gerenciadores de pacotes é interessante para evitar longos códigos iniciais de carregamento, checagem de pacotes instalados, etc.

O pacote pacman ajuda bastante nessa tarefa.

A função p_load() carrega os pacotes instalados e aqueles que ainda não estão instalados ela instala e carrega na sequência.

Importação de scripts

Para tornar o código mais acessível e menos extenso, uma possibilidade é a segmentação do código em scripts menores, específicos para cada função.

Por exemplo, pode se desenvolver um script para reunir as funções desenvolvidas para a tarefa, outro para tarefas de organização de dados, para verificação de consistência, dentre outras possibilidades.

Para carregar scripts no formato .R, utiliza-se a função source().

Importação de scripts

Uma outra prática interessante é nomear os scripts conforme a tarefa específica e numerá-los por ordem de importação.

Por exemplo, suponha 3 scripts externos: um com funções desenvolvidas especificamente para a análise, um para transformação de dados e um terceiro para a geração de estatísticas descritivas. Uma possibilidade seria:

  • 1_funcoes

  • 2_transformacao_dados

  • 3_analise_descritiva

O uso de nomes que indicam a tarefa realizada pelo script ajuda no desenvolvimento, manutenção e reprodutibilidade do código. Use nomes sucintos e não utilize espaços.

Perceba que foi utilizada a nomeação do tipo snake_case . Outros tipos de nomeação, como PascalCase ou camelCase podem ser utilizadas para nomear os arquivos.

Definição de funções e valores globais

Caso seu script de análise de dados não contenha muitas funções, uma opção é incluí-las no código principal.

Nesse caso, lembre-se sempre de fazê-lo no início do documento.

Incluir funções no meio do código ou entre as análises pode gerar dificuldades para tratamento de erros ou ajustes na função.

Assim como as funções, caso seu script possua variáveis globais, as defina no início do código.

Leitura de dados

Usualmente trabalha-se com bases de dados de terceiros. Esses dados costumam vir nomeados conforme a utilização do fornecedor dos dados. Para facilitar o trabalho, é sempre importante renomear os dados de uma forma que seja compreensível e faça sentido para você. Assim, ao receber os dados para análise:

  1. Crie um backup com os dados originais

  2. Renomeie os arquivos com um nome que facilite sua compreensão e manipulação.

  3. Caso haja mais de uma base de dados, utilize a mesma convenção aplicada aos scripts e renomeie os dados.

Leitura de dados

Por exemplo, suponha que para um projeto foram recebidos dois arquivos: Dados de vendas 2024.xlsx e Dados de vendas 2025.xlsx. se o interesse for uma análise comparativa entre esses anos, bons nomes para os arquivos seriam: vendas_24 e vendas_25.

São nomes mais simples de trabalhar em código e explicam bem a função de cada conjunto de dados.

Para finalizar, veja algumas regras para uma melhor escrita dos códigos

Boas práticas na escrita de códigos

O código de modelagem de dados é a parte mais importante do processo. Todos os cuidados tomados até aqui ocorreram para possibilitar uma melhor execução do código e, consequentemente, resultados melhores.

Cada programador/analista tem suas nuances para escrita de código. Inclusive alguns estudos alegam que é possível identificar um programador pelo código, como se fosse uma impressão digital.

Boas práticas na escrita de códigos

Entretanto, para escrever um código legível e inteligível, existem algumas regras globais que facilitam a compreensão, justamente por representarem características que agradam a maioria dos programadores. São elas: espaçamento, indentação e comentários.

Entretanto, antes de falar das três principais características, existe uma característica específica do R que deve ser abordada: a atribuição.

Atribuição

Em linguagem R, é possível atribuir valores a objetos de duas formas: utilizando os símbolos = e <-. Porém, o símbolo = também é utilizado dentro de funções na atribuição de parâmetros.

Nesse caso, uma prática que torna mais clara a distinção entre o que é objeto e o que é parâmetro, é a seguinte regra:

  • utilize <- para atribuir objetos (atalho alt + - no Rstudio);

  • utilize = para atribuir parâmetros.

Dessa forma o código fica ainda mais claro para leitura de terceiros e do próprio programador.

Espaçamento

Observe o código a seguir. Ele filtra os voos dos aeroportos JFK e ATL no mês de janeiro:

#|eval: false

##Filtrando voos pela origem, destino e mês
voo_jfk_atl<-subset(flights,origin=="JFK"&dest=="ATL"&month==1)

Você acha ele um pouco confuso, desorganizado?

Se a resposta é sim, provavelmente é porque não foram utilizados espaços entre seus elementos.

Espaçamento

Um código é como um livro. Cada instrução funciona como uma frase, inserida no contexto do problema.

É importante utilizar espaços entre seus elementos para melhorar a redação da frase.

Imagine ler a frase anterior sem espaços: Cadainstruçãofuncionacomoumafrase,inseridanocontextodoproblema. É legível, mas desagradável.

Compare os códigos com e sem espaço. Qual você prefere?

#|eval: false

##Filtrando voos pela origem, destino e mês
voo_jfk_atl<-subset(flights,origin=="JFK"&dest=="ATL"&month==1)

voo_jfk_atl <- subset(flights, origin == "JFK" & dest == "ATL" &
                        month == 1)

Então, lembre-se de dar espaço para seu código “respirar”.

Indentação

Uma outra característica importante é a indentação. Ela permite a distinção de níveis entre as tarefas realizadas pelo código. Podemos saber, por exemplo, quais tarefas de uma função são subtarefas de uma outra, ou se algum processo depende de outro para ser realizado.

Para entender sua importância, vamos utilizar um exemplo. A seguir, um script que gera um diagrama de dispersão com curva de ajuste:

flights   %>%   
group_by(dest)  %>%  
summarize(
distance = mean(distance),
speed = mean(distance / air_time, na.rm = TRUE)) %>%  
ggplot(aes(x = distance, y = speed)) +
geom_smooth(
method = "loess",
span = 0.5,
se = FALSE, 
color = "white", 
linewidth = 4) +
geom_point()

Indentação

Perceba que é difícil compreender onde um processo começa e outro termina, quais as dependências do script, as funções aplicadas, etc. O que causa essa dificuldade é a falta de indentação. Note como fica mais fácil identificar os elementos com o código indentado:

flights  %>%  
  group_by(dest)  %>%  
  summarize(
    distance = mean(distance),
    speed = mean(distance / air_time, na.rm = TRUE)
  ) %>%  
  ggplot(aes(x = distance, y = speed)) +
  geom_smooth(
    method = "loess",
    span = 0.5,
    se = FALSE, 
    color = "white", 
    linewidth = 4
  ) +
  geom_point()

Indentação

É fácil perceber agora a ordem das operações. O conjunto de dados flights foi agrupado pelo destino(dest), calculadas a distância (distance) e a velocidade médias (speed) e gerado o gráfico por meio das funções ggplot(cria as camadas), geom_smooth (cria a linha do modelo ajustado) e geom_point (plota os pontos).

Outros ponto importante é a quebra de linha a cada operador pipe. Ela garante uma melhor leitura de cada passo do código. O mesmo vale para os sinais de + do pacote ggplot.

Já a quebra de linhas por parâmetro é opicional. Mas recomenda-se não utilizar linhas de código muito longas para evitar a necessidade de rolagem de janela para visualização do comando completo.

Indentação

Veja a função anterior sem quebra de linhas por parâmetro:

flights  %>%  
  group_by(dest)  %>%  
  summarize(distance = mean(distance),speed = mean(distance / air_time, na.rm = TRUE)
  ) %>%  
  ggplot(aes(x = distance, y = speed)) + 
  geom_smooth(method = "loess", span = 0.5, se = FALSE, color = "white", linewidth = 4) +
  geom_point()

Comentários

Pra finalizar, vamos tratar dos comentários. Comentários são úteis para explicar o que ocorre em determinadas áreas do código. Além disso, no RStudio, os comentários funcionam como delimitador de seções.

Para inserir um comentário no código, utilizamos o caractere #. Qualquer texto escrito após esse caractere será considerado um comentário. Veja um exemplo:

#Esse é um comentário. A linha a seguir não é executada.
#mean(rnorm(100, 0, 1))

#A linha a seguir é executada.
mean(rnorm(100, 0, 1))
[1] -0.02529334

Comentários

Conforme dito, é possível utilizar um comentário para criar uma sessão. Uma sessão de código serve para separar áreas que realizam tarefas distintas.

No RStudio, existe uma funcionalidade que delimita as seções automaticamente. Para isso, basta utilizar o atalho Ctrl + Shift + R. Ao utilizar esse atalho, será exibida uma janela para nomear a sessão:

Comentários

Após escrever o nome da seção, será adicionado o comentário que gera a sessão:

Comentários

Ao adicionar uma sessão, o RStudio cria um atalho para a linha de código em dois locais: No menu outline, localizado na parte superior direita da janela de recursos (Source), e no canto inferior esquerdo da mesma janela:

Utilize esse recurso para facilitar a navegação pelo código, o que facilita o reconhecimento de cada uma das tarefas executadas em cada parte do código.

Encerramento

O R permite transformar teoria em evidência e dados em estratégia.