4 Começando com o R

Neste capítulo, vamos iniciar nossa jornada no mundo do R e do RStudio, explorando a interface, os primeiros passos na programação e as ferramentas essenciais para análises.

4.1 A interface do RStudio

O RStudio oferece um ambiente de desenvolvimento integrado (IDE) que facilita a escrita, execução e organização de código em R. Possui uma interface simples mas bastante funcional, composta por quatro painéis principais, como pode ser visto na Figura @ref(fig:rstudio).

Source (Editor) (canto superior esquerdo): Aqui você escreve e edita seus scripts, que são conjuntos de comandos em R. Execute o código selecionado com o botão “Run” ou o atalho Ctrl + Enter. Para abrir um novo script, use o menu File -> New File -> R Script ou o atalho Ctrl + Shift + N. O RStudio oferece recursos como destaque de sintaxe, autocompletar e dicas de código para facilitar a escrita.
Console (canto inferior esquerdo): O console é onde os comandos são executados e os resultados são exibidos. Você pode digitar comandos diretamente no console ou executá-los a partir do editor.
Environment (Ambiente) (canto superior direito): Neste painel, você visualiza os objetos criados na sua sessão, como variáveis, data frames e funções. É possível explorar os valores, estruturas e dimensões dos objetos.
Files/Plots/Packages/Help/Viewer (canto inferior direito): Este painel multifuncional contém abas para gerenciar arquivos, visualizar gráficos, instalar pacotes, acessar a documentação do R e visualizar páginas web.
- Files: Navegue pelos arquivos do seu projeto, abra-os e crie novas pastas.
- Plots: Visualize os gráficos gerados, exporte-os em diferentes formatos e navegue entre eles.
- Packages: Instale, atualize e remova pacotes, além de visualizar a documentação dos pacotes instalados.
- Help: Acesse a documentação do R, busque por funções e pacotes, e visualize exemplos de uso.
- Viewer: Visualize páginas web, documentos HTML e outros conteúdos dentro do RStudio.

4.2 Criar um projeto no RStudio

Organizar seu trabalho em projetos no RStudio é importante para manter seus arquivos e códigos estruturados, especialmente em projetos complexos. Um projeto agrupa todos os arquivos relevantes, como scripts, dados, resultados e figuras, em um único diretório.

Para criar um novo projeto, siga os passos:

Clique em File -> New Project.
Escolha o tipo de diretório (geralmente “New Directory”).

Selecione o tipo de projeto (geralmente “New Project”).

Dê um nome ao projeto e escolha o local onde ele será salvo.

Dê um bom nome para seu novo projeto e preste atenção ao local em que você irá salvar ele.

4.3 Primeiros códigos

Com o projeto criado, vamos escrever nossos primeiros códigos no editor de scripts. Tente digitar o seguinte:

1 + 1

Posicione o cursor na linha que acabou de digitar, clique em Run ou pressione Ctrl + Enter para executar o código e ver o resultado no console.

1 + 1

[1] 2

Esta foi uma operação muito simples, então vamos ver alguns códigos mais interessantes.

Para armazenar valores, criamos objetos usando o operador de atribuição <- ¹ (atalho: Alt + - ). O nome do objeto deve ser simples, mas com um significado

x <- 10 # leia-se: x recebe o valor 10

Neste exemplo, o objeto denominado x armazena o valor 10. Notem que ao executar este comando, o objeto recém criado aparece na janela Environment, confirmando a criação do objeto.

Este exemplo também mostrou como usar um comentário, que é um texto não interpretado pelo programa. Os comentários são bastante úteis para explicar as linhas de código. São escritos após o símbolo #. Para comentar uma ou várias linhas, selecione o texto e pressione Ctrl+Shift+C.

Para verificar o valor que está atribuído a um objeto, basta digitar o nome do objeto²:

[1] 10

Um objeto pode ter seu valor modificado ou copiado com uma nova atribuição:

y <- x # y recebe o valor de x
x <- x * 2 # x recebe o valor de x multiplicado por 2
z <- x + y # z recebe a soma de x e y

y

[1] 10

[1] 20

[1] 30

Observe que a ordem de execução dos comandos é importante no resultado.

4.3.1 Vetores

Um dos objetos mais útil na programação em R é o vetor, que pode ser entendido como uma sequência de valores armazenada em um objeto. Para criar um vetor, utilizamos a função c():

primos6 <- c(2, 3, 5, 7, 11, 13)
primos6

[1]  2  3  5  7 11 13

A função str nos mostra a estrutura do vetor:

str(primos6)

 num [1:6] 2 3 5 7 11 13

indicando que o objeto primos6 é um vetor numérico (num).

Uma parte do vetor pode ser extraída como uso de colchetes [ ]:

primos6[3] # acessa o terceiro elemento do vetor

[1] 5

primos6[4:6] # acessa do 4° ao 6° elemento do vetor

[1]  7 11 13

As operações com vetores são aplicadas a todos os elementos dele:

primos6^2 # Eleva cada elemento de primos6 ao quadrado

[1]   4   9  25  49 121 169

mean(primos6) # Calcula a média dos elementos de primos6

[1] 6.833333

4.3.2 Funções de pacotes

Muitas funções são disponibilizadas em pacotes. Para acessar uma função de um pacote usamos a sintaxe pacote::função. Por exemplo, para acessar as funções first e last do pacote dplyr:

dplyr::first(primos6)

[1] 2

dplyr::last(primos6)

[1] 13

Alternativamente, é possível carregar o pacote com a função library e depois usar as funções diretamente:

library(dplyr)
first(primos6)

[1] 2

last(primos6)

[1] 13

4.3.3 Gráficos

Para criar uma gráfico, podemos usar várias das funções base do R para esse fim. Neste exemplo, a função hist cria um gráfico do tipo histograma para um conjunto de 10.000 valores gerados aleatoriamente pela função rnorm.

r <- rnorm(10000)
hist(r)

No Capítulo 8 veremos como utilizar o pacote ggplot2 para criar gráficos mais elaborados.

4.4 Criar uma função no R

Em R, as funções são blocos de código que executam tarefas específicas. Elas são ferramentas poderosas para organizar e reutilizar código, tornando-o mais modular, legível e fácil de manter.

As principais vantagens de usar funções são a divisão do código em partes menores, a reutilização do código, evitando a repetição (DRY³).

Para criar uma função no R, a sintaxe básica é a seguinte:

nome_da_funcao <- function(argumentos) {
  # Corpo da função (código a ser executado)
  return(valor_de_retorno)  # Opcional: especifica o valor retornado pela função
}

nome_da_funcao: Um nome descritivo para a função, que indica sua finalidade.
argumentos: Valores de entrada que a função recebe para realizar sua tarefa.
corpo da função: O código que será executado quando a função for chamada.
return(): (Opcional) Especifica o valor que a função retorna após sua execução.

Como exemplo, vamos criar uma função que simula o lançamento de um dado de seis faces: lancar_dado

lancar_dado <- function(n = 1) {
  resultado <- sample(1:6, size = n, replace = TRUE)
  return(resultado)
}

Essa função recebe um argumento n que especifica o número de lançamentos a serem simulados. O valor padrão de n é 1, ou seja, se o argumento não for especificado, a função simulará um único lançamento.

Para usar a função recém criada, basta chamá-la pelo nome e passar o valor desejado para o argumento n

lancar_dado(n = 1)

[1] 1

lancar_dado(n = 3)

[1] 4 3 2

4.5 Data-frame

O data frame é uma estrutura bidimensional em que cada componente forma uma coluna e o conteúdo de cada componente forma as linhas. Em um data frame, é importante que todas as colunas tenham o mesmo comprimento, de modo que a estrutura de dados resulte em um formato retangular. Também podemos imaginá-lo como um agrupamento de vetores de mesmo tamanho.

Para criá-lo, usamos a função data.frame

df <- data.frame(
  x = c("a", "b", "c"),
  y = c(16, 32, 64)
)
df

Idem ao anterior, mas com os vetores sendo criado anteriormente e separadamente

x <- c("a", "b", "c")
y <- c(16, 32, 64)
df <- data.frame(x, y)
df

O pacote tibble foi criado como uma atualização⁴ do data-frame, e pode ser utilizado de maneira similar:

tb <- tibble::tibble(
  x = c("a", "b", "c"),
  y = c(16, 32, 64)
)
tb

# A tibble: 3 × 2
  x         y
  <chr> <dbl>
1 a        16
2 b        32
3 c        64

O data-frame é o formato adequado para armazenar os dados no formato Tidy Data, junto com o tibble (seção @ref(tidydata))

4.5.1 Data-frames nativos no R

Existe uma grande quantidade de data-frames pré instalados no R que não necessitam de importação. Alguns dos nossos exemplos irão usar alguns destes data-frames, por exemplo, o data-frame iris, que contém as medidas, em centímetros, do comprimento e largura das pétalas e sépalas de três espécies de plantas: Iris setosa, I. versicolor e I. virginica.

4.6 O operador pipe: `%>%` ou `|>`

O operador pipe %>% é uma ferramenta muito útil para expressar uma sequência de ações sobre um objeto. Foi introduzido pela primeira vez no pacote magrittr com o objetivo de facilitar a programação e melhorar a legibilidade do código. Ele permite encadear funções de forma mais intuitiva e legível, como se estivesse “canalizando” os dados de uma função para a próxima. A partir da versão 4.1 do R, foi introduzido um novo operador pipe nativo: |>.

Sempre carregue o pacote magrittr antes de usar o pipe %>%.

library(magrittr)

No exemplo abaixo, as duas linhas de código são equivalentes: aplica-se a função f ao objeto x.

f(x) # Sem o pipe
x %>% f() # O pipe passa o objeto x para dentro da função f

Veja abaixo o pipe em ação:

library(magrittr)


Anexando pacote: 'magrittr'

O seguinte objeto é mascarado por 'package:purrr':

    set_names

O seguinte objeto é mascarado por 'package:tidyr':

    extract

x <- c(1, 2, 3, 5, 8, 13, 21) # criar um vetor x
x %>% add(2) # somar 2 a cada elemento do vetor x

[1]  3  4  5  7 10 15 23

x %>% "+"(2) # equivalente à operação anterior

[1]  3  4  5  7 10 15 23

x %>%
  "*"(3) %>%
  "+"(1) %>%
  "^"(2) # várias operações aplicadas sequencialmente ao vetor x

[1]   16   49  100  256  625 1600 4096

x %>% sum() # soma os elementos do vetor

[1] 53

No caso de uma função com vários argumentos, o pipe passa o objeto para a primeira posição da função, o argumento mais à esquerda:

sample(x, size = 1)

[1] 1

x %>% sample(size = 1) # idem ao anterior com o pipe passando o objeto x para a função sample

[1] 1

No caso de ser necessário que o objeto seja passado para outro argumento à direita, que não seja o primeiro, utilizamos um . como marcador:

iris %>%
  lm(Petal.Length ~ Species, data = .) # o objeto iris é passado para o argumento data com um .


Call:
lm(formula = Petal.Length ~ Species, data = .)

Coefficients:
      (Intercept)  Speciesversicolor   Speciesvirginica  
            1.462              2.798              4.090

O símbolo de igualdade = também pode ser utilizado para atribuição, mas o símbolo <- é preferido pela maioria dos programadores em R.↩︎
a função print é chamada implicitamente↩︎
Don’t repeat yourself↩︎
Principais diferenças aqui ↩︎