Capítulo 1 Noções Básicas do R
1.1 Uma descrição do R
1.1.1 História do R
A linguagem R, nasceu durante a década de 90, inicialmente como um projeto de pesquisa de Ross Ihaka e Robert Gentleman, ambos estatísticos e pesquisadores associados na época ao departamento de estatística da Universidade de Auckland (IHAKA; GENTLEMAN, 1996). Porém, as origens da linguagem R retornam a década de 70, com o desenvolvimento da linguagem S, em um dos mais importantes laboratórios de pesquisa do mundo, a Bell Labs (PENG, 2015).
Pois como foi descrito por IHAKA; GENTLEMAN (1996), a linguagem R foi desenvolvida com fortes influências das linguagens S e Scheme. Sendo que a própria sintaxe da linguagem R, se assemelha muito a da linguagem S. Por isso, muitos autores como PENG (2015) e CHAMBERS (2008), caracterizam a linguagem R como um dialeto da linguagem S. Segundo IHAKA; GENTLEMAN (1996) a linguagem S representava uma forma concisa de se expressar ideias e operações estatísticas para um computador e, por isso, foi uma fonte de inspiração importante para o R. Em outras palavras, comparado às demais linguagens, a linguagem S oferecia uma sintaxe mais atrativa e confortável para estatísticos executarem as suas ideias, e grande parte dessa sintaxe, foi transportada para o R.
1.1.2 R
R é um software estatístico que oferece um ambiente para análise interativa de dados, e que conta com uma poderosa linguagem de programação, e é dessa linguagem que vamos tratar neste livro. Diferente de outras linguagens como C e C++, que são linguagens compiladas, a linguagem R é uma linguagem interpretada. Isso significa, que para trabalharmos no R, vamos estar constantemente enviando comandos escritos para o Console do programa, e esse Console vai avaliar os comandos que enviarmos (segundo as “regras gramaticais” da linguagem R), antes de executá-los.
Logo, o console é o coração do R, e a mais importante ferramenta do programa (ADLER, 2010, p 11), pois é nele que se encontra o interpretador que vai avaliar e executar todos os nossos comandos. O uso de uma linguagem de programação, representa uma maneira extremamente eficiente de se analisar dados, e que de certa forma, adquire um aspecto interativo no R, ou cria uma sensação de que estamos construindo (interativamente) uma conversa com o console. Ou seja, o trabalho no R funciona da seguinte maneira: 1) você envia um comando para o console; 2) o comando é avaliado pelo console e é executado; 3) o resultado desse comando é retornado pelo console; 4) ao olhar para o resultado, você analisa se ele satisfaz os seus desejos; 5) caso não, você faz ajustes em seu comando (ou utiliza um comando completamente diferente), e o envia novamente para o console; e assim, todo o ciclo recomeça.
1.1.3 O sistema e universo do R
O universo do R pode ser divido em duas partes, sendo elas:
O sistema “básico” do R, que é composto pelos pacotes básicos da linguagem. Esses pacotes são a base da linguagem R, e são comumente chamados pela comunidade, por
base R. Pois diversas das funções básicas do R, advém de um pacote chamadobase. Lembrando que você pode baixar e instalar esses pacotes básicos, pelo site do Comprehensive R Archive Network (CRAN R).Todo o resto, ou mais especificamente, todos os pacotes externos ao sistema “básico”, desenvolvidos pelo público em geral da linguagem. A grande maioria desses pacotes também estão disponíveis através do Comprehensive R Archive Network (CRAN R), mas alguns outros estão presentes apenas em outras plataformas, como o GitHub.
Todas as funcionalidades e operações disponíveis no R, são executadas através de suas funções, e essas funções são divididas em “pacotes”. O sistema “básico” do R, contém um conjunto de pacotes que oferecem as funcionalidades básicas da linguagem. Alguns desses pacotes básicos, são base (fornece funções de uso geral) e stats (fornece funções para análises e operações estatísticas). Caso você precise de funcionalidades que vão além do que está disponível neste sistema “básico”, ou neste conjunto de pacotes “básicos” do R, é neste momento em que você precisa instalar outros pacotes que estão fora desse sistema “básico”, e que oferecem funções que possam executar as funcionalidades que você deseja. Vamos dissecar alguns desses pacotes “externos” ao longo deste material, com especial atenção ao conjunto de pacotes fornecidos pelo tidyverse.
Pelo fato do R ser gratuito e open source, várias pessoas estão constantemente desenvolvendo novas funcionalidades, e efetivamente expandindo o universo da linguagem R. Esses pacotes desenvolvidos pelos próprios usuários da linguagem, servem como grande apoio ao trabalho de outros usuários. Ou seja, se você possui um problema a sua frente, é muito provável que alguém tenha enfrentado o mesmo problema, ou algo próximo, e que tenha desenvolvido uma solução para aquele problema no formato de um pacote do R. Assim, você pode resolver os seus problemas, com a ajuda do trabalho de outras pessoas que passaram pelas mesmas dificuldades.
1.1.4 RStudio
O RStudio, é um Ambiente de Desenvolvimento Integrado (Integrated Development Environment - IDE, em inglês) para o R. Em síntese, esse programa oferece um ambiente com diversas melhorias, atalhos e ferramentas que facilitam de maneira expressiva, o seu trabalho com o R. Algumas dessas funcionalidades incluem: indentação automática, realces de código, menus rápidos para importação e exportação de arquivos, além de diversos atalhos de teclado úteis. Sendo, portanto, uma ferramenta muito recomendada para qualquer usuário que venha a trabalhar com a linguagem R (GILLESPIE; LOVELACE, 2017).
Para encontrar mais detalhes sobre o programa, você pode consultar o site oficial do RStudio.
1.2 Introdução ao R e RStudio: noções básicas
1.2.1 Executando comandos: Console
Você trabalha no R através de sua linguagem de programação. Você importa os seus dados, remove ou acrescenta colunas, reordena a sua base, constrói gráficos, e estima os seus parâmetros, através de comandos escritos que devem ser interpretados e executados pelo Console. Qual o porquê de tudo isso? Por que precisamos de um console para interpretar os nossos comandos? A resposta se encontra no fato de que o seu computador não fala a sua língua!
Ou seja, o seu computador não sabe o que os verbos “ordenar” e “selecionar” significam, estejam eles em qualquer língua humana que você conseguir imaginar agora. Pois o seu computador, só fala e compreende uma única língua, que é extremamente difícil para nós seres humanos, que são os bits ou bytes de informação. Se quisermos nos comunicar com o nosso computador, e passarmos instruções e comandos para serem executados por ele, nós devemos repassar essas informações como bits de informação. Com isso, o trabalho do Console, e principalmente do interpretador presente nele, é o de traduzir os seus comandos escritos na linguagem R (que nós seres humanos conseguimos entender), para comandos em bits, de forma que o seu computador possa compreender o que você está pedindo a ele que faça.
Tanto no programa padrão do R, quanto no RStudio, o console se localiza a esquerda de sua tela, como mostrada na figura 1.1:
Figura 1.1: Consoles no R padrão (à esquerda) e no RStudio (à direita)
Figura 1.2: Consoles no R padrão (à esquerda) e no RStudio (à direita)
Ao olhar para o Console, você pode perceber que em sua parte inferior, nós temos no início da linha um símbolo de “maior que” (>). Esse símbolo, significa que o Console está pronto e esperando por novos comandos a serem interpretados. Ou seja, você coloca os seus comandos à frente deste símbolo, e em seguida, você aperta Enter para confirmar o envio dos comandos. Assim, os comandos serão avaliados, e o console vai lhe retornar o resultado destes comandos. Há algumas ocasiões em que o console vai apenas executar os comandos, e não irá lhe mostrar automaticamente o resultado. Isso geralmente ocorre quando você está salvando os resultados desses comandos em um objeto (iremos aprender sobre eles mais a frente).
Como um exemplo clássico, eu posso utilizar o R como uma simples calculadora, ao escrever o comando “1 + 3” no Console (e apertar a tecla Enter), e como não estou salvando o resultado dessa soma em algum objeto, o console me mostra automaticamente o resultado dessa operação.
1 + 3## [1] 4Vale destacar, que todo comando que você escrever no Console, deve estar completo para ser avaliado. Dito de outra forma, quando você escreve no Console, algum comando que ainda está incompleto de alguma forma (por exemplo, que ainda está faltando fechar algum par de parênteses, ou está faltando uma vírgula, ou está faltando algum valor a ser fornecido), e você aperta Enter para ele ser avaliado, o símbolo > do Console, será substituído por um +, te indicando que ainda falta algo em sua expressão. Neste caso, o Console ficará esperando até que você escreva o restante, e complete o comando, como mostrado na figura 1.2. Em uma situação como essa, você pode abortar a operação, e reescrever do início o seu comando, ao apertar a tecla Esc de seu computador.
Figura 1.3: Expressões incompletas
1.2.2 Comentários
O R possui diversos caracteres especiais, e que sofrem ou geram efeitos distintos ao serem avaliados. Um desses caracteres, é o hash (#), que no R, representa o início de um comentário. Ou seja, todo e qualquer comando, letra ou expressão escrita após o símbolo # (incluindo o próprio símbolo #), será completamente ignorado pelo Console. Portanto, o símbolo # constitui uma forma útil de incluirmos anotações e comentários em nossos comandos. Por exemplo, você talvez tenha dificuldade de lembrar o que cada função faz, e por isso, você pode utilizar o símbolo # para inserir pequenas descrições e lembretes ao longo de seus comandos, para relembrá-lo o que cada função faz.
# A função sum() serve para somar um
# conjunto de números.
sum(1,2,3,4,5)## [1] 151.2.3 Comandos e resultados
O símbolo de “maior que” (>) no Console, também representa uma forma útil de você diferenciar o que é um comando a ser interpretado pelo R, e o que foi retornado pelo R como o resultado desse comando. Ou seja, todo bloco de texto em seu Console, que estiver logo à direita do símbolo >, representa um bloco de comandos a serem avaliados (ou que já foram avaliados) pelo R. Em contrapartida, todo texto que não possuir o símbolo > à sua esquerda, representa o resultado do comando anterior, ou então, uma mensagem de erro referente a esse comando anterior.
Uma outra forma útil de identificar os resultados de seus comandos, é perceber que eles sempre vêm acompanhados por algum índice numérico no início de cada linha. Esse índice pode estar dentro de um par de colchetes (como [1]), ou pode estar livre, como no resultado da função data.frame() apresentado na figura 1.3. Perceba que esses números são apenas índices, logo, eles não fazem parte do resultado de seus comandos, e são apenas valores que marcam o início cada linha de seu resultado.
Figura 1.4: Comandos e seus respectivos resultados no Console
1.2.4 Histórico de comandos
O Console possui uma memória dos comandos que você executou anteriormente. Tanto que esses comandos e seus resultados, permanecem visíveis ao navegarmos pelo Console. Porém, você também pode navegar pelos comandos previamente executados, ao utilizar a seta para cima (\(\uparrow\)) de seu teclado, quando estiver no Console. Através dessa tecla, os comandos executados anteriormente são apresentados na linha de inserção de códigos do próprio Console.
Porém, você também pode visualizar de forma mais eficiente o seu histórico de comandos, ao acessar a janela History do RStudio, que fica na parte direita e superior de sua tela, como mostrado na figura 1.4. Uma outra forma de abrirmos essa janela, está na função history(). Com essa função, você pode determinar até quantos comandos anteriores devem ser exibidos nessa janela.
# Exibir os últimos 10 comandos executados
history(10)
Figura 1.5: Aba History - Quadrante superior direito
Para mais, você também pode visualizar esse histórico de comandos, por meio de uma pequena janela aberta em seu Console, como na figura 1.5. Quando estiver no console, você pode acessar essa janela, ao pressionar as teclas Ctrl + \(\uparrow\).
Figura 1.6: Histórico de comandos - Console
1.2.5 Operações matemáticas básicas
O R pode ser utilizado como uma simples calculadora, através de seus operadores aritméticos.
# Simples Adição
3 + 15## [1] 18
# Multiplicação
3 * 125## [1] 375
# Potenciação
3 ^ 4## [1] 81
# Miscelânia de operadores
((4.505 * 100)/ 5) + 0.015 ## [1] 90.115Você irá rapidamente perceber que esses operadores são extremamente úteis e estão por toda parte, sendo utilizados em diversas outras operações muito mais complexas. Por isso, é importante que você leve um tempo se familiarizando com esses operadores. Temos na tabela 1.1, uma lista dos principais operadores aritméticos, além de alguns comandos no R, que exemplificam o seu uso.
 |
1.3 Introdução a objetos
Uma das principais características do R, é que ele é uma linguagem orientada a objetos (object oriented). Objetos são o método que o R possui para guardar os valores, funções e resultados que você produz. Como foi posto por ADLER (2010, p 50), todo código do R, busca utilizar, manipular ou modificar de alguma forma, um objeto do R. Logo, quando você estiver trabalhando com seus dados no R, você estará constantemente aplicando operações e transformações sobre os objetos onde seus dados estão guardados, de uma forma interativa e dinâmica.
Para que um objeto seja criado, o R necessita de uma forma de referenciar aquele objeto, ou em outras palavras, uma forma de reconhecer o objeto ao qual você está requisitando. Esse mecanismo consiste fundamentalmente de um nome (CHAMBERS, 2008, p 24). Ou seja, todo objeto no R, possui um nome, e será através desse nome, que você será capaz de acessar esse objeto. Portanto, para você salvar todo e qualquer resultado ou valor no R, você precisa obrigatoriamente salvá-lo dentro de um objeto, isto é, dar um nome a esse resultado ou valor que você está gerando.
No exemplo abaixo, eu estou guardando a minha idade em um objeto chamado idade_pedro. Dessa forma, quando eu precisar deste número em algum momento de minha análise, eu preciso apenas chamar pelo nome onde guardei este número, ou nos termos do R, pelo nome dei ao objeto onde guardei este número.
idade_pedro <- 22Após criarmos o objeto de nome idade_pedro, eu posso acessar o valor que foi salvo nele, ao chamar pelo nome do objeto no Console.
idade_pedro## [1] 22Sempre que você estiver criando um objeto, ele irá seguir essa estrutura acima. Você possui primeiro o nome do objeto, depois o símbolo de assignment (<-), e por último, o valor (ou o conjunto de valores) que você quer guardar dentro deste objeto. Independente do quê, ou, do porquê, o código à direita do símbolo de assignment faz, ao ver essa estrutura, você sabe de antemão que esses comandos estão criando um objeto.
Figura 1.7: Estrutura necessária para criar um objeto
Nós podemos sobrepor o valor guardado em um objeto, ao atribuir um novo valor a este objeto. Neste caso, estaríamos perdendo o valor que salvamos anteriormente neste objeto. Como exemplo, se eu atribuir o texto “Importado” ao objeto idade_pedro. Após este novo comando, se chamarmos pelo nome do objeto, o R irá lhe mostrar o novo texto que acabamos de guardar, e o número 22 que estava anteriormente guardado nele, se perdeu.
idade_pedro <- "Importado"
idade_pedro## [1] "Importado"Caso você tenha que sobrepor o valor de um objeto, mas você não quer perder o valor que está salvo em nele, você deve conectar este valor a um novo objeto. Se um valor não está conectado a um nome, o R vai jogar este valor fora, por isso, precisamos de uma nova conexão até ele, ou em outras palavras, precisamos conectá-lo a um novo nome. Dessa forma, podemos tranquilamente sobrepor o valor guardado em idade_pedro, pois agora, o valor 22 está guardado em um outro objeto.
idade_pedro <- 22
numero_importante <- idade_pedro
idade_pedro <- "Importado"
# Ao chamar pelo nome de
# ambos os objetos, temos dois valores
# diferentes
idade_pedro## [1] "Importado"
numero_importante## [1] 221.3.1 Como nomear um objeto
Como foi destacado por WICKHAM; GROLEMUND (2017), existem regras sobre como você pode nomear os seus objetos no R. Segundo TEAM (2020b, p 4), o nome de um objeto, pode conter qualquer símbolo alfanumérico (qualquer letra ou número), inclusive letras acentuadas. Sendo que o nome desse objeto, deve obrigatoriamente se iniciar por uma letra, ou por um ponto (.), como por exemplo, os nomes: População; dados.2007; .abc; media_1990.
Porém, um nome não pode começar por um número, logo, um nome como 1995populacao, não é permitido. Também não é possível, que se inicie um nome por um ponto (.) caso ele seja seguido por um número. Logo, você não pode criar um objeto com o nome .2media, mas você pode criar um objeto que possua o nome .m2edia ou .media2.
Em suma, o nome de um objeto pode conter os seguintes tipos de caractere:
- Letras.
- Números.
-
_(underline). -
.(ponto).
Além disso, o nome de um objeto pode se iniciar com um:
- Letra.
-
.(ponto, desde que não seja seguido por um número).
Porém, o nome de qualquer objeto, não deve começar por um:
-
_(underline). - Número.
-
.(ponto) seguido de um número.
Pode ser difícil pensar em um nome para os seus objetos. Mas a melhor alternativa, é sempre dar um nome claro e descritivo aos seus objetos, mesmo que esse nome possa ficar muito extenso. Por exemplo, microdados_pnad_2020 para uma base de dados contendo os microdados da PNAD de 2020; ou vetor_idade, para um vetor que contém as idades das pessoas que foram entrevistadas em uma pesquisa.
1.3.2 O R é case-sensitive
O R é uma linguagem case-sensitive. Isso significa, que ele é capaz de diferenciar a capitalização de sua escrita. Logo, um objeto chamado a, é um objeto completamente diferente de um objeto chamado A. Veja o exemplo abaixo.
casa <- 10 ^ 2
cAsa <- 2 + 2
casa## [1] 100
cAsa## [1] 4Como visto, os objetos casa e cAsa contêm valores diferentes, e, portanto, representam objetos distintos.
1.3.3 Como utilizar objetos
Um objeto é de certa forma, uma referência até um certo conjunto de valores, e você utiliza, ou acessa essa referência, através do nome que você deu a esse objeto. Logo, sempre que você quiser utilizar os valores que estão guardados em algum objeto (seja dentro de alguma função ou em alguma operação específica), você precisa apenas utilizar o nome que você deu a esse objeto.
Por exemplo, se eu quero somar um conjunto de valores guardados em um objeto chamado vec_num, eu posso fornecer o nome deste objeto à função sum().
## [1] 481.4 Funções (noções básicas)
Como destacado por CHAMBERS (2016), até as funções que você utiliza, são objetos no R. A grande maioria das funções são escritas e utilizadas, segundo o formato abaixo. Portanto, sempre que você for utilizar uma função no R, você deve escrever o nome dessa função, e em em seguida, abrir um par de parênteses. Dentro destes parênteses, você irá fornecer os argumentos (ou input’s) que serão utilizados pela função para gerar o seu resultado.
nome_da_função(lista_de_argumentos)Os operadores aritméticos utilizados até aqui (+, -, *, etc.) também são funções para o R, porém, eles representam um tipo especial de função. Pois nós podemos posicionar os seus argumentos, ao redor desses operadores (ex: 2 + 3). Por outro lado, nós podemos escrever esses operadores (ou essas funções), da forma “tradicional”, ou como as demais funções no R são escritas, o que é demonstrado logo abaixo. Perceba que pelo fato do nome da função (a função que representa o operador +), se iniciar por um símbolo que não respeita as regras que definimos anteriormente (sobre como nomear um objeto), para nos referirmos a esse objeto, ou a essa função, nós devemos contornar o nome dessa função por acentos graves.
# O mesmo que 2 + 3
`+`(2, 3)## [1] 5
# O mesmo que 12 + 8
`+`(12, 8)## [1] 20Os argumentos da função identificam os dados que serão transformados, ou representam especificações que vão modificar o comportamento da função, ou modificar a metodologia de cálculo utilizada. Dessa forma, nós definimos os argumentos das funções (i.e., incluímos as especificações desejadas) para que possamos obter os resultados de acordo com as nossas necessidades. Sendo que a lista_de_argumentos, corresponde a uma lista onde cada argumento é separado por uma vírgula (,), como no exemplo abaixo.
exemplo_função(argumento1 = valor_argumento1, argumento2 = valor_argumento2)Um argumento pode ser um símbolo, que contém um valor específico (ex.: argumento1 = valor_argumento1) ou o argumento especial ‘...’, que pode conter qualquer número de argumentos (geralmente, o argumento especial é encontrado em funções em que a quantidade de argumentos que será passada é desconhecida). Algumas funções possuem valores padrões em seus argumentos. Em outras palavras, caso você não defina algum valor específico para este tipo de argumento, a função vai utilizar um valor pré-definido para esse argumento. Usualmente, os valores padrão são os valores mais comuns, que utilizam as metodologias mais conservadoras ou tradicionais de cálculo da função.
Por exemplo, a função sum() possui o argumento na.rm, que define se os valores NA presentes em um objeto, devem ser ignorados ou não durante o cálculo da soma. Por padrão, esse argumento é configurado para FALSE (falso). Isso significa, que qualquer valor NA que estiver presente no objeto a ser somado, vai alterar o comportamento da soma executada por sum(). Por isso, se quisermos ignorar os valores NA durante o cálculo da soma, nós precisamos definir explicitamente o argumento na.rm para TRUE (verdadeiro).
## [1] NA
sum(vec, na.rm = TRUE)## [1] 14.3Ao definirmos os valores a serem utilizados em cada argumento de uma função, nós não precisamos determinar o nome do argumento a ser utilizado. Como exemplo, veja a função rnorm() abaixo. O primeiro argumento (n) da função, define o número de observações a serem geradas; o segundo (mean), define a média desses valores; e o terceiro (sd), define o desvio padrão que esses valores vão seguir ao serem gerados.
# A função rnorm() e seus argumentos
rnorm(n, mean, sd)Quando nós não definimos explicitamente o nome do argumento que estamos utilizando, o R vai conectar o valor que fornecemos, de acordo com a ordem que os argumentos aparecem na função. Ou seja, o primeiro valor, será conectado ao primeiro argumento da função. Já o segundo valor, será conectado ao segundo argumento da função. E assim por diante. Isso significa, que se quisermos configurar algum argumento, fora da ordem em que ele aparece na função, nós teremos que explicitar o nome do argumento a ser utilizado.
rnorm(10, 15, 2.5)## [1] 16.12547 14.95360 14.20483 12.67659 11.28135 12.31202 17.50007
## [8] 13.44683 11.53893 19.67323
rnorm(n = 10, sd = 2.5, mean = 15)## [1] 16.06275 14.40338 17.64621 17.21606 13.45189 20.51526 14.36243
## [8] 11.43876 14.63900 15.518851.5 Erros e ajuda: como e onde obter
Ao começar a aplicar o conhecimento exposto neste livro, você rapidamente irá enfrentar situações adversas, onde vão surgir muitas perguntas das quais eu não ofereço uma resposta aqui. Por isso, é muito importante que você conheça o máximo de recursos possíveis, dos quais você pode consultar e pedir por ajuda (WICKHAM; GROLEMUND, 2017).
Hoje, a comunidade internacional de R, é muito grande, e há diversos locais onde você pode encontrar ajuda, e aprender cada vez mais sobre a linguagem. Nessa seção, vamos explicar como utilizar os guias internos do R e do RStudio, além de algumas técnicas de pesquisa e de perguntas que podem te ajudar a responder as suas dúvidas.
1.5.1 Ajuda Interna do R: help() e ?
Toda função no R, possui uma documentação interna, que contém uma descrição completa (ou quase sempre completa) da função. Essas documentações são muitas vezes úteis, especialmente para descobrirmos os argumentos de uma função, ou para compreendermos que tipo de valores devemos utilizar em um certo argumento, ou então, em ocasiões mais específicas, para adquirirmos um conhecimento mais completo sobre o comportamento de uma função.
Para acessar essa documentação, você pode anteceder o nome da função com o operador ?, ou então, utilizar a função help() sobre o nome da função de interesse. Como exemplo, com os comandos abaixo, você pode consultar a documentação interna da função mean().
# Usando `help()`
help("mean")
# Usando `?`
?meanSe você estiver no programa padrão do R, ao executar um desses comandos, um arquivo HTML contendo a documentação será aberto em seu navegador. Mas se você estiver no RStudio, a documentação será aberta na janela de Help do próprio RStudio, localizada no quadrante direito e inferior de sua tela, como mostrado na figura 1.7.
Figura 1.8: Documentação interna da função de média no RStudio
A documentação interna de uma função, lhe dá uma descrição completa sobre quais tipos de valores devem (ou podem) ser inseridos em cada argumento da função. Entretanto, caso você esteja apenas em dúvida sobre os nomes dos argumentos de uma função, você pode rapidamente sanar essa dúvida, ao utilizar a função args() sobre o nome da função. Com essa função, uma estrutura é retornada, contendo a palavra chave function, e a lista de argumentos da função dentro de um par de parênteses. Porém, se a função de interesse possui diferentes métodos (como é o caso da função mean(), e de muitas outras funções), é muito provável que o resultado da função args() será de pouca utilidade, a menos que você pesquise por um método específico da função.
args("mean")## function (x, ...)
## NULLVeja no exemplo abaixo, que ao selecionarmos o “método padrão” da função de média (mean.default()), dois novos argumentos foram retornados (trim e na.rm) pela função args().
args("mean.default")## function (x, trim = 0, na.rm = FALSE, ...)
## NULLPor esses motivos, a documentação interna representa uma fonte mais completa e segura de consulta sobre uma função. Como exemplo, na figura 1.8 podemos ver a seção de Arguments, da documentação interna da função mean(). Nessa seção, podemos encontrar uma descrição sobre o que cada argumento faz e, principalmente, sobre que tipo de valor cada um desses argumentos é capaz de receber. Vemos abaixo, pela descrição do argumento x, que a função mean() possui métodos específicos para vetores numéricos, lógicos, de data, de data-hora e de intervalos de tempo. Com essas informações, nós sabemos, por exemplo, que a função não possui métodos para vetores de texto. Também podemos deduzir dessa descrição, que a função mean() é capaz de lidar apenas com vetores, e, portanto, o uso de data.frame’s e listas está fora de cogitação.
Figura 1.9: Seção de argumentos da documentação interna da função de média
1.5.2 Um exemplo clássico de ajuda interna
Um exemplo clássico em que a ajuda interna do R é bem útil, se encontra na função round(), que utilizamos para arredondar valores numéricos de acordo com um número de casas decimais.
# Arredondar 3.1455 para duas casas decimais
round(3.1455, digits = 2)## [1] 3.15Porém, há diversas maneiras de se arredondar um número, e você talvez se pergunte quais desses métodos estão disponíveis no R. Para responder a essa pergunta, você talvez pense em procurar por mais detalhes sobre a função round() em sua documentação interna. Temos o início dessa documentação na figura 1.9, e a primeira coisa que chama atenção é a lista de funções irmãs de round(). Ou seja, possuímos nessa lista, 5 funções diferentes (ceiling(), floor(), trunc(), round() e signif()), que buscam aplicar diferentes métodos de arredondamento.
Figura 1.10: Documentação interna da função round()
Ao olharmos para a descrição da função floor() (“takes the largest integer not greater than the corresponding value of x”, ou “seleciona o maior número inteiro que não é maior do que o valor correspondente em x”), podemos compreender que essa função busca sempre arredondar um número para baixo, independentemente de qual número esteja presente na última casa decimal. Também podemos entender pela descrição da função ceiling(), que ela executa justamente o processo contrário (“takes the smallest integer not less than the corresponding value of x”, ou “seleciona o menor número inteiro que não é menor que o valor correspondente de x”), e arredonda qualquer número sempre para cima.
## [1] 0 2 3 3 1
ceiling(vec)## [1] 1 3 4 4 2A seção de detalhes dessa documentação (mostrada na figura 1.10) é particularmente útil. Pois ela nos oferece uma boa descrição das implicações do padrão adotado pela função (IEC 60559). Além disso, a descrição presente na seção de detalhes também nos aponta uma particularidade importante sobre a função round(). Pois ao arredondar um decimal igual ao número 5, a função round() normalmente irá buscar o número inteiro par mais próximo.
Figura 1.11: Seção de detalhes da documentação interna da função round()
A importância deste ponto, emerge do fato de que algumas funções de arredondamento muito utilizadas possuem um comportamento diferente de round(), em uma situação como essa. Um exemplo está na função ARRED() do Excel, que sempre arredonda um número para cima, a partir do momento em que a sua última casa decimal atinge um valor igual ou acima de 5. Se os nossos números são arredondados de formas distintas ao longo de certos programas, diferentes valores ou resultados podem ser estimados. Em geral, nós desejamos evitar isso.
Para que essa diferença fique clara, se eu arredondar os números 9,5 e 6,5, a função round() vai gerar como resultado, os números 10 e 6. Pois durante o processo de arredondamento, a função round() está preocupada em encontrar o número par mais próximo do valor em questão, e não sobre qual direção o arredondamento vai assumir.
## [1] 10 6 4 2 21.5.3 Ajuda Externa: referências, documentação oficial e canais úteis
Apesar de útil, a documentação interna de uma função é limitada. Essa situação tende a se confirmar especialmente em pacotes externos aos pacotes básicos do R, ao encontrarmos em suas documentações, seções de Details rasas e de pouca utilidade. Por isso, é interessante se aprofundar e conhecer outras referências externas ao R, produzidas por autores/usuários (livros-texto, cursos online, etc) que oferecem o seu conhecimento sobre a linguagem como um suporte à comunidade.
Ao longo desse livro, vamos descrever diversas funções que provêm dos pacotes do tidyverse. Por isso, é interessante que você se familiarize com os sites desses pacotes24. Todos esses sites possuem uma página de “Reference”, que contém a documentação de todas as funções do pacote. Uma outra fonte rápida de informação, são as “colas” (ou “cheatsheets”) produzidas pela equipe do RStudio, chamadas de RStudio Cheatsheets.
Além disso, temos diversos livros-textos importantes sobre a linguagem, que oferecem diversos conhecimentos extremamente valiosos, como as obras de WICKHAM; GROLEMUND (2017); GILLESPIE; LOVELACE (2017); PENG (2015); GROLEMUND (2014); CHAMBERS (2008); ADLER (2010), além da documentação oficial da linguagem presente em TEAM (2020b); TEAM (2020a).
Também há diversos cursos e materiais disponíveis, que podem ser boas fontes de informação. Dentre eles, temos o curso Introduction to R, da plataforma Datacamp. Além disso, temos um bom material de consulta em português, construído pela equipe do Curso-R, além do material produzido pelo professor Walmes Marques Zeviani, intitulado Manipulação e Visualização de Dados.
Para mais, temos alguns blogs que fazem boas reflexões e sempre trazem um bom conteúdo sobre a linguagem. Esse é o caso do site R-Bloggers, que possui uma boa discussão sobre os mais diversos assuntos no R. Um outro exemplo, é o blog do Tidyverse, que constantemente descreve novos pacotes, novas funções disponíveis e novas aplicações para o R que podem ser muito interessantes para o seu trabalho.
Além dessas referências, é muito importante que você se familiarize com os canais de dúvida disponíveis, como o Stackoverflow. Pois esses canais serão, com certeza, a sua principal fonte de ajuda no R. Em síntese, o StackOverflow funciona da seguinte maneira: 1) alguém envia uma pergunta; 2) cada pergunta, é marcada por um conjunto de tags, que definem a linguagem de programação, ou pacote, ou assunto específico a que se refere a dúvida; 3) qualquer pessoa, pode postar uma resposta nessa pergunta, ou algum comentário que seja útil; 4) as respostas mais úteis e completas, serão votadas para cima, pelos próprios usuários do site; 5) dessa forma, as respostas mais úteis e completas, vão sempre aparecer primeiro na postagem da dúvida em questão.
Para encontrar perguntas especificamente voltadas para a linguagem R no StackOverflow, você deve sempre procurar por perguntas marcadas com a tag [r], ou por algum pacote específico da linguagem. Por exemplo, o StackOverflow contém um estoque enorme de dúvidas marcadas com a tag ggplot2, que se refere ao pacote ggplot2, que vamos discutir mais à frente. Logo, o StackOverflow representa uma fonte extremamente importante sobre esse pacote.
Além do StackOverflow, nós também possuímos o RStudio Community, que também é um canal de dúvidas bastante ativo, e que funciona de maneira muito similar ao StackOverflow. Onde pessoas fazem uma pergunta, que é marcada por tags que definem o pacote ou o assunto específico que a pergunta se refere. Porém, as perguntas no RStudio Community, tendem a assumir um aspecto mais parecido com uma discussão (ao invés de um caráter de pergunta-resposta presente no StackOverflow). Ou seja, uma pergunta abre de certa forma, uma discussão. Uma pessoa fornece uma resposta, depois outra fornece um outro olhar sobre a pergunta, o autor descreve novas dúvidas, novas respostas surgem, podendo assim, criar uma discussão infindável em torno da dúvida inicial.
As fontes de ajuda externas ao R, serão a sua maior ajuda, e a sua principal referência. Pois como foi destacado por CHASE (2020), ninguém é completamente autodidata. Todos nós cometemos erros, e uma das grandes vantagens de uma comunidade como a do R, é que muito conhecimento é produzido e compartilhado em torno desses erros. Por essa razão, ao invés de autodidatas (self-taught), CHASE (2020), assim como os autores desta obra, prefirímos nos caracterizar como seres instruídos pela comunidade (community-taught).
1.5.4 Um exemplo clássico de ajuda externa
Uma das primeiras dúvidas que atingem os iniciantes, diz respeito aos objetos criados, ou melhor dizendo, aos objetos não criados em sua sessão. Você já viu na seção Introdução a objetos, qual a estrutura básica necessária para criarmos um objeto (nome_do_objeto <- valor_do_objeto). Porém, você pode acabar se perdendo durante o seu trabalho, de forma a não saber quais objetos você criou em sua sessão. Em situações como essa, você pode executar a função ls(). Essa função irá listar o nome de todos os objetos que estão criados em sua sessão atual do R.
ls()## [1] "a" "Abril_2019" "abs_loop"
## [4] "abs_vec" "aggs" "alunos"
## [7] "ano" "anos" "aplicar_modelo"
## [10] "aplicar_teste" "apply_agg" "args"
## [13] "arquivo" "assinatura" "b"
## [16] "band_instruments" "barreiro" "billboard_long"
## [19] "billboard_sel" "br" "caminhos"
## [22] "casa" "cAsa" "Censo_2010"
## [25] "centro" "children" "chines"
## [28] "codes" "codigos" "col"
## [31] "col_width" "colocacoes" "cols_c"
## [34] "cols_desejadas" "cols_para_key" "coluna"
## [37] "colunas" "colunas_numericas" "como_texto"
## [40] "compras" "conc_vec" "construir_perfil"
## [43] "coord_arrow" "coord_text" "covid"
## [46] "covid_novo" "d" "D"
## [49] "dado" "dados_excel" "dados_por_pais"
## [52] "data" "data_aniversario" "data_frame"
## [55] "data_inicial" "datas" "datasus"
## [58] "datasus_agrup" "date_vec" "datetime_no_excel"
## [61] "def.chunk.hook" "df" "df_teste"
## [64] "df1" "df2" "dias"
## [67] "dists" "dobrar" "double_vec"
## [70] "dt" "dt1" "dt2"
## [73] "dts" "e_ano_bissexto" "economista_1"
## [76] "economista_anterior" "entrevista" "env1"
## [79] "env2" "erro_nao_vazio" "erros"
## [82] "estados_siglas" "exemplos" "expre"
## [85] "f" "f_env" "fim"
## [88] "fim_intervalo" "fizz_buzz" "flights"
## [91] "format_double" "format_fun" "format_hour"
## [94] "format_percent" "fruta" "frutas"
## [97] "funcionarios" "funcoes_formato" "github"
## [100] "grafico" "h" "horario_brasil"
## [103] "horario_japao" "horas" "hr"
## [106] "i" "id" "idade"
## [109] "idade_pedro" "identidade" "igual_a_referencia"
## [112] "ind" "info" "infos_compras"
## [115] "inicio" "inicio_intervalo" "janeiro"
## [118] "jogadas" "l" "letras"
## [121] "LETTERS" "lista" "lista_vazia"
## [124] "livros" "load_packages" "logaritmos"
## [127] "m" "maior_data" "marcas"
## [130] "marco" "matriz" "media"
## [133] "medias" "medidas" "menor_data"
## [136] "mensagem" "mes" "meses"
## [139] "minas_pop" "modelo" "modelos"
## [142] "msg" "mt" "n"
## [145] "n_colunas" "n_linhas" "n_niveis"
## [148] "name" "nao_e_NA" "niveis"
## [151] "niveis_atuais" "niveis_sexo" "nome"
## [154] "nomes" "nomes_arquivos" "nomes_colunas"
## [157] "normalizar" "nova_tab" "novo_covid"
## [160] "novos_niveis" "numero_importante" "numero_no_excel"
## [163] "numeros" "objs" "ordem"
## [166] "output_format" "Oxboys" "p"
## [169] "palavras" "pasta" "pckgs"
## [172] "pedaco" "per" "periodo"
## [175] "pesquisa" "pib" "PIB"
## [178] "PIB_remodelado" "planilhas" "plot_exemplo"
## [181] "ponto" "ponto_dis" "pontos"
## [184] "pontos_br" "por_uf" "prado"
## [187] "premio" "premios" "produto"
## [190] "quiet_print" "r" "r2s"
## [193] "referencia" "registro" "registro_venda"
## [196] "registros" "relig" "render_latex"
## [199] "reordenar_colunas" "repair_vec" "resultado"
## [202] "safe_log" "savassi" "scrabble_score"
## [205] "segundos" "sem_minuto_e_segundo" "sem_segundo"
## [208] "sequencia" "setor_id" "setores"
## [211] "soma" "somar" "somas"
## [214] "somatorios" "t" "tab"
## [217] "tab_tibble" "tab1" "tab2"
## [220] "tabela" "tem_na" "tema_imagem"
## [223] "teste" "text" "texto"
## [226] "tibble" "tipos" "tipos_col"
## [229] "totais" "total_caracteres" "transf"
## [232] "unidades" "usuarios" "v"
## [235] "v_Date" "v_letras" "v_POSIXct"
## [238] "v_POSIXlt" "v1" "v2"
## [241] "valor" "valores" "vec"
## [244] "vec_d" "vec_fator" "vec_num"
## [247] "vec1" "vec2" "vendas"
## [250] "vendas_wide" "vetor" "vetor_logico"
## [253] "vetor1" "vetor2" "vlog"
## [256] "w" "wb" "x"
## [259] "y"Com isso, caso você esteja em dúvida se você já criou ou não, um certo objeto em sua sessão, você pode conferir se o nome deste objeto aparece nessa lista resultante da função ls(). Caso o nome do objeto não se encontre nela, você sabe que o objeto em questão ainda não foi criado.
Por outro lado, você pode estar interessado em apagar um certo objeto de sua sessão. Tal resultado, pode ser atingido através da função rm(). Logo, se eu possuo um objeto chamado dados_2007, e eu desejo eliminá-lo de minha sessão, eu preciso apenas fornecer o nome deste objeto à função rm().
# Removendo o objeto chamado
# dados_2007 de minha sessão
rm(dados_2007)Na próxima seção, vamos abordar o uso de scripts no R, e um erro muito comum quando você está começando a utilizar scripts, é se esquecer de executar os comandos para criar um objeto. Ou seja, muitos iniciantes escrevem no script, os comandos necessários para criar o seu objeto, mas acabam se esquecendo de enviar esses comandos para o Console, onde eles serão avaliados e executados.
A função ls() oferece uma forma rápida de consulta, que pode sanar a sua dúvida em ocasiões como essa. Mas uma outra forma ainda mais efetiva de sanarmos essa dúvida, consiste em chamar pelo nome deste objeto no console. Se algum erro for retornado, há grandes chances de que você ainda não criou esse objeto em sua sessão. Veja o exemplo abaixo na figura 1.11, em que chamo por um objeto chamado microdados_pnad_2020, e um erro é retornado.
Figura 1.12: Mensagem de erro - Console
Sempre que você não souber o que um erro significa, ou a que termo ele está se referindo, faça uma pesquisa rápida sobre esse erro no Google. Se o seu erro está sendo gerado, ao executar uma função específica, você pode anteceder o erro gerado, por um “R” e pelo nome da função utilizada, na barra de pesquisa do Google. No nosso caso, talvez seja melhor pesquisarmos apenas pelo erro antecedido por um “R”, como na figura abaixo. Há alguma chance de você encontrar referências de ajuda em português. Porém, as chances são infinitamente maiores se você pesquisar por artigos e perguntas escritas em inglês. Por isso, se a sua mensagem de erro estiver em português (como é o caso da mensagem na figura acima), é melhor que você tente traduzi-la para o inglês, caso você tente pesquisar por ela no Google.
Podemos encontrar no primeiro link da página mostrada na figura 1.12, uma pergunta postada no StackOverflow. Como o StackOverflow é geralmente uma boa referência de ajuda, há uma boa chance de encontrarmos o que estamos necessitando nesse link.
Figura 1.13: Pesquisa Google sobre mensagem de erro
Ao acessarmos uma pergunta do StackOverflow, a primeira parte que aparece em sua tela, é a pergunta em si. Perguntas que são muito úteis, e que traduzem uma dúvida muito comum dos usuários, tendem a ser “votadas para cima”. A pergunta exposta na figura 1.13, possui 37 votos. Ou seja, essa pergunta foi útil o suficiente para ajudar no mínimo 37 pessoas.
Figura 1.14: Pergunta StackOverflow - Parte 1
Logo abaixo da pergunta em si, temos as respostas de usuários que se dispuseram a respondê-la. As respostas mais úteis para a pergunta em questão, tendem a ter maiores votos dos usuários e, por isso, tendem a aparecer primeiro na página em relação as outras respostas menos úteis. Como podemos ver na figura 1.14, a primeira resposta possui 33 votos.
Figura 1.15: Pergunta StackOverflow - Parte 2
A resposta mostrada na figura 1.14, é bem esclarecedora. Como o autor pontua, um erro do tipo “objeto x não foi encontrado” (ou “object x not found”) ocorre quando tentamos utilizar um objeto que ainda não existe, um objeto que ainda não foi definido. A partir do momento em que você define esse objeto, esse erro não ocorre mais.
Como pontuei anteriormente, é muito comum de um aluno escrever os comandos necessários para criar um objeto em seu script, mas se esquecer de enviar esses comandos do script para o Console, onde serão avaliados e executados. Por isso, sempre que ocorrer esse erro, confira se você conseguiu enviar os comandos para o Console. Também confira se os comandos utilizados para criar o objeto, foram de fato executados, isto é, confirme se nenhum erro apareceu durante a execução desses comandos. Pois a depender da gravidade do erro gerado, a execução dos comandos pode ter sido comprometida e, portanto, o objeto não pôde ser criado.
Por isso, sempre que enfrentar algum erro no R, tente fazer uma pesquisa rápida no Google. Em geral, você pode copiar e colar diretamente a mensagem, ou citar apenas trechos, ou a oração principal da mensagem de erro na pesquisa. É interessante sempre colocar um “r” antes da mensagem de erro, para definir um pouco melhor a sua pesquisa e encontrar links referentes à linguagem R.
Uma boa referência externa para compreender e solucionar erros no R, é o StackOverflow. Você pode encontrar todas as perguntas referentes à linguagem R disponíveis nesse site, ao pesquisar pela tag [r], ou, acessando diretamente o link dessas perguntas: https://stackoverflow.com/questions/tagged/r. Perceba na figura 1.15, que no momento de captura dessa imagem, existiam 432.084 perguntas disponíveis que descrevem alguma dúvida sobre a linguagem R. Hoje, esse número provavelmente é maior.
Figura 1.16: Pesquisando por todas as perguntas referentes à linguagem R
1.6 Scripts
Até o momento, estivemos utilizando diretamente o console para executarmos os nossos comandos. Porém, você provavelmente se sentiu um pouco perdido ao procurar pelos últimos comandos que você executou e, se sentiu um pouco frustrado ao ter que digitar novamente o comando caso queira executá-lo uma segunda vez. Por essa razão, à medida que você trabalha com o R, a necessidade de guardar os seus comandos anteriores em algum lugar, se torna cada vez mais urgente. Para isso, você pode utilizar um script.
Um script é um simples arquivo de texto, que contém a extensão .R, para indicar que todo o texto contido neste arquivo, representam comandos do R. Portanto, um script contém um conjunto de códigos e comandos do R que podem ser facilmente acessados, editados e executados através das ferramentas e atalhos do RStudio, tornando o seu fluxo de trabalho com o R mais eficiente. Ao utilizar o RStudio, os códigos contidos nos scripts podem ser executados individualmente ou em conjunto.
Para criar um script no RStudio, você possui duas opções: 1) clicar em File \(\rightarrow\) New File \(\rightarrow\) R Script; ou 2) utilizar o atalho Ctrl + Shift + N. Após criar o script, o quadrante esquerdo do RStudio será dividido verticalmente em dois: a parte superior comporta o editor de script’s e a inferior o Console. Como resultado, o seu ambiente do RStudio ficará semelhante ao ambiente exibido na figura 1.16.
(#fig:FIG criar script)Quadrantes da área de trabalho do RStudio, após a abertura de um script
Você pode criar títulos que delimitam as áreas, ou as etapas de seu script, e é uma forma muito eficiente de navegar pelo seu script, caso ele seja muito grande. Na figura 1.17, um exemplo destes títulos está identificado pela seta azul. Também na figura 1.17, temos uma caixa vermelha, e dentro dela podemos ver uma referência que aponta qual a seção, ou melhor, qual o título da seção no qual o nosso cursor se encontra atualmente. O meu cursor se encontra no momento, na seção “Importando os dados para o R”. Ao clicar sobre esta referência especificada na caixa vermelha, uma nova caixa de seleção irá aparecer contendo cada um dos títulos que você criou em seu script, e ao clicar sobre um destes títulos, você será redirecionado para o início desta seção no script.
Figura 1.17: Títulos e comentários em scripts
Esses títulos especiais, são formados pela união entre o caractere de comentário do R (# - hashtag), o texto que você quer inserir neste título, e vários sinais de menos (-) em sequência, formando assim a seguinte estrutura: ### <título desejado> -------. O número de hashtag’s e de sinais de menos que você insere, são arbitrários. Ao invés de escrevê-los a mão, o RStudio oferece um atalho que cria automaticamente esses títulos, através das teclas Ctrl + Shift + R.
Lembre-se que você também pode adicionar pequenas anotações e comentários em seu script com hashtags (#). Nós definimos em seções anteriores, que este é um caractere especial da linguagem, e que qualquer texto que você colocar a frente dele, será ignorado pelo console. Na figura 1.17, temos um exemplo deste comentário que está marcado por uma seta verde.
Esses comentários são uma boa forma de descrever o que os comandos abaixo dele fazem, ou então de apontar configurações e cuidados importantes que você deve ter com esses comandos. Isso é importante especialmente com aquelas funções que você raramente utiliza, pois é menos provável que você se lembre de como elas funcionam, ou de como elas se comportam.
1.6.1 Executando comandos de um script
A essa altura, você já sabe que para executarmos qualquer comando do R, ele precisa ser enviado para o console, onde será avaliado e executado. Por isso, ao utilizarmos um script, desejamos uma forma rápida de enviarmos esses comandos que estão guardados neste script, para o console do R. O RStudio oferece um atalho para isso, que é o Ctrl + Enter. Veja a figura 1.18, se o cursor de seu mouse estiver sobre o retângulo vermelho desenhado no script, ao apertar o atalho Ctrl + Enter, o RStudio enviará todo o bloco de comandos que criam o objeto dados_selecionados, para o console. Agora, se o cursor de seu mouse estivesse sobre o retângulo verde desenhado no script, o RStudio enviaria o bloco de comandos que formam o objeto media_estados.
Figura 1.18: Executando comandos de um script
Após enviar um bloco de comandos para o console, através deste atalho, o RStudio irá automaticamente mover o cursor de seu mouse para o próximo bloco de comandos. Desta maneira, você pode executar parte por parte de seu script em sequência e, conferir os resultados de cada bloco no console.
Além disso, o RStudio também oferece um outro atalho para caso você queira executar todos os comandos de um script de uma vez só. Para isso, você pode apertar as teclas Crtl + Alt + R.
1.6.2 Salvando um script
Ao salvar o seu script, você está salvando os comandos necessários para gerar os seus resultados. Isto é, através de script’s você possui uma poderosa ferramenta para a reprodutibilidade de sua análise. Em outras palavras, com um script, você é capaz de salvar os comandos necessários para se obter o resultado desejado, no lugar dos próprios resultados em si. Dito de outra forma, é muito mais prático carregarmos a metodologia necessária para se obter um resultado, do que o resultado em si. Pois você pode gerar repetidamente os mesmos resultados através dos comandos salvos em seu script, quantas vezes forem necessárias. Por outro lado, você não é capaz de gerar o script, ou os comandos necessários, ou a metodologia de cálculo utilizada, a partir de seus resultados.
Para salvar um script que está aberto em seu RStudio, você pode clicar em File \(\rightarrow\) Save As…, e escolher o diretório em que o arquivo será guardado. Você também pode salvar esse script, ao clicar sobre o símbolo de disquete, presente logo abaixo do nome desse script, no canto superior direito. Uma vez definido o nome do script e o local onde ele será guardado, você pode clicar em File \(\rightarrow\) Save, ou utilizar o atalho Ctrl + S para salvar o script corrente a medida em que você for editando-o.
Além desses pontos, lembre-se que um script é nada mais do que um arquivo de texto com uma extensão .R e, por isso, ele pode ser aberto normalmente por editores de texto padrão (como o Bloco de Notas do Windows, ou por programas como Notepad ++ e Sublime Text).
1.7 Pacotes
Como descrevemos anteriormente na seção O sistema e universo do R, o R pode ser divido em duas partes: os pacotes básicos da linguagem; e todos os demais pacotes externos que foram criados e ofertados pela comunidade do R. Um pacote (package) corresponde a unidade fundamental de compartilhamento de códigos e funções no R (WICKHAM, 2015b). Dito de outra forma, segundo as palavras de WICKHAM; GROLEMUND (2017), um pacote do R é uma coleção de funções, dados e documentação que estendem as funcionalidades do R.
No momento de escrita desta obra (novembro de 2020), existem mais de 16.000 pacotes disponíveis no CRAN. Segundo WICKHAM (2015b), esta grande variedade de pacotes representa uma das principais razões para o sucesso do R nos anos recentes, e ressalta o seguinte pensamento: é bastante provável que algum usuário já tenha enfrentado o mesmo problema que você, e após solucioná-lo, tenha ofertado um pacote que possa auxiliar você, na busca dessa solução. Logo, você pode obter enormes benefícios ao utilizar o conjunto de funções desenvolvidas por outros usuários para resolver os seus problemas.
1.7.1 Como utilizar um pacote
Como é descrito por ADLER (2010), para utilizarmos um pacote no R, precisamos “carregá-lo” para a nossa sessão. Porém, para “carregarmos” um pacote para a nossa sessão, esse pacote precisa estar instalado em nosso computador. Logo, em resumo, nós devemos realizar os seguintes passos 25:
- Instalar o pacote a partir do servidor do CRAN:
install.packages("nome_do_pacote"). - Carregar o pacote em cada sessão no R:
library(nome_do_pacote).
Você precisa executar o primeiro passo (instalar o pacote com a função install.packages()) apenas uma vez. Após instalar o pacote em sua máquina, você precisa carregar esse pacote através da função library() em toda sessão no R que você desejar utilizar as funções desse pacote. Ou seja, toda vez que iniciar o R, você precisa carregar o pacote para ter acesso às suas funções.
Por exemplo, se você desejasse utilizar as funções disponíveis no pacote ggplot2, que possui um conjunto de funções voltadas para a composição de gráficos, você precisaria dos comandos abaixo. Repare que o nome do pacote é fornecido como string à função install.packages(). Logo, sempre que for instalar um pacote, lembre-se de contornar o nome do pacote por aspas (simples ou duplas).
# Instalar o pacote `ggplot2` em seu computador
install.packages("ggplot2")
# Carregar o pacote `ggplot2` em sua sessão atual do R
library(ggplot2)Como GILLESPIE; LOVELACE (2017) destaca, uma boa prática a ser adotada é carregar todos os pacotes necessários sempre no início de seu script. Dessa forma, você está acoplando a sua sessão, todas as dependências necessárias para aplicar todas as funções dispostas ao longo de seu script.
1.7.2 Identificando os pacotes instalados em sua máquina e aqueles que foram carregados para a sua sessão
Um dos métodos mais diretos de se identificar se um determinado pacote está ou não carregado em sua sessão, consiste em você tentar utilizar uma das funções desse pacote. Se um erro aparecer durante esse processo, indicando que tal função não foi encontrada ou que ela não existe, há grandes chances de que o pacote pelo qual você está preocupado, não se encontra disponível em sua sessão atual.
Por exemplo, eu posso tentar utilizar a função mutate() do pacote dplyr como eu normalmente faria. Pela mensagem de erro abaixo, sabemos que o R não pôde encontrar a função mutate(), logo, o pacote dplyr provavelmente não foi carregado para a minha sessão até o momento.
mutate()Error in mutate() : não foi possível encontrar a função "mutate"Apesar de rápido, este método é um pouco inseguro. Pois, existe a chance de um dos pacotes que já estão carregados em minha sessão, possuir uma função com o mesmo nome mutate(). Em outras palavras, ao tentar executar a função mutate() em minha sessão, pode ser que o R encontre uma função mutate() diferente da que estou procurando. Por isso, um método mais seguro é necessário.
A resposta para tal necessidade se encontra na lista de environments conectados à minha sessão atual do R. Cada pacote que você carrega para a sua sessão, é representado por um environment que está acoplado ao seu environment principal. Logo, para descobrirmos se um pacote foi carregado com sucesso para a nossa sessão, podemos consultar se esse pacote está incluso na lista de todos os environments presentes em nossa sessão. Para obtermos uma lista dos environments presentes em nossa sessão, nós podemos executar a função search(), como abaixo:
search()## [1] ".GlobalEnv" "package:rlang"
## [3] "package:gapminder" "package:openxlsx"
## [5] "package:palmerpenguins" "package:magrittr"
## [7] "package:RcppRoll" "package:glue"
## [9] "package:nycflights13" "package:SAScii"
## [11] "package:haven" "package:readxl"
## [13] "package:vctrs" "package:lobstr"
## [15] "package:knitr" "package:lubridate"
## [17] "package:forcats" "package:stringr"
## [19] "package:dplyr" "package:purrr"
## [21] "package:readr" "package:tidyr"
## [23] "package:tibble" "package:ggplot2"
## [25] "package:tidyverse" "package:fs"
## [27] "package:yaml" "package:bslib"
## [29] "package:bookdown" "tools:rstudio"
## [31] "package:stats" "package:graphics"
## [33] "package:grDevices" "package:utils"
## [35] "package:datasets" "package:methods"
## [37] "Autoloads" "package:base"Os valores que estiverem na forma package:nome_do_pacote indicam o environment de um pacote que está carregado em sua sessão atual do R. Já o valor denominado .GlobalEnv, representa o global environment, que é o seu environment principal de trabalho, onde todos os seus objetos criados são salvos. Vamos descrever em mais detalhes esses pontos, na seção Noções básicas de environments. Por enquanto, perceba pelo resultado acima, que os pacotes tibble e tidyr estão carregados em minha sessão, pois os seus environments (package:tibble e package:tidyr) estão listados no resultado da função search().
Por outro lado, você talvez enfrente algum erro ao tentar carregar o pacote de seu interesse. Nesse caso, um bom movimento seria se certificar que esse pacote está instalado em sua máquina. Segundo ADLER (2010), se você precisa identificar todos os pacotes instalados em sua máquina, você pode executar a função library() sem definir nenhum argumento ou pacote em específico.
# Uma nova janela será aberta em seu RStudio
# contendo uma lista de todos os pacotes instalados
library()Caso o pacote que você está tentando carregar não apareça na lista resultante de library(), significa que esse pacote não está instalado em sua máquina. Logo, você precisa instalá-lo com a função install.packages() antes que você possa utilizar as funcionalidades desse pacote em sua sessão do R.
1.7.3 Acessando as funções de um pacote sem carregá-lo para sua sessão
Apesar de ser uma prática ideal na maioria das situações, você talvez não queira carregar um pacote específico e, mesmo assim, utilizar uma de suas funções. Tal opção pode gerar uma importante economia de espaço em sua memória RAM, durante a sua análise. Até porque, se você vai utilizar apenas uma única função do pacote, talvez não haja necessidade de carregar o pacote inteiro.
Para acessarmos uma função de um pacote que não foi carregado ainda em nossa sessão, precisamos chamar primeiro pelo pacote de onde estamos tirando a função, como na estrutura abaixo.
# Acessar uma função de um pacote sem carregá-lo
nome_do_pacote::nome_da_função()Logo, se você quisesse acessar a função filter() do pacote dplyr, por exemplo, você precisa primeiro chamar pelo pacote dplyr e, em seguida, posicionar duas vezes dois pontos (:) para acessar uma função ou objeto presente neste pacote. Por último, basta digitar o nome da função de interesse.
# Para acessar a função filter() sem chamar
# pelo pacote dplyr
dplyr::filter()1.7.4 Atualizando pacotes
A linguagem R está o tempo todo evoluindo e se aprimorando e, por essa razão, muitos dos pacotes disponíveis hoje, são constantemente atualizados, com o objetivo de implementar novas funcionalidades e/ou aperfeiçoar a eficiência de suas funções. Logo, é uma boa prática que você mantenha os pacotes instalados em seu computador, constantemente atualizados. Para atualizar um pacote, você precisa apenas instalá-lo novamente, através da função install.packages("nome_do_pacote"), ou acessar a opção Tools \(\rightarrow\) Check for Packages Updates… no RStudio, como está demonstrado na figura 1.19. Através dessa opção, o RStudio irá listar todos os pacotes que possuem versões mais recentes e, portanto, podem ser atualizados. A grande vantagem é que você pode atualizar todos os pacotes presentes nessa lista de uma vez só.
Figura 1.19: RStudio: Opção para atualização de pacotes
Exercícios
Questão 1.1. Tente calcular algumas operações básicas:
1.1.A) Qual é a soma entre 32397 e 55405?
1.1.B) Calcule a soma total do conjunto de valores dispostos no vetor conj abaixo.
conj <- c(290, 34, 512, 54, 89, 10)1.1.C) Considerando que, \(y = 3x^3 - 12x^2 + \frac{1}{15}x+ 25\), calcule o valor de \(y\) quando \(x\) é igual a 5.
Questão 1.2. Em cada item abaixo, temos uma mensagem de erro específica que supostamente apareceu em seu console. Tente explicar como ou porque essas mensagens podem aparecer em seu console. Em outras palavras, tente explicar o que essas mensagens significam, e qual foi o fato ocorrido que gerou esses erros:
1.2.A) Erro: objeto 'logica' não encontrado.
1.2.B) Error in bind_rows() : não foi possível encontrar a função "bind_rows"
1.2.C) Error in library(dplyr) : there is no package called ‘dplyr’
Questão 1.3. As próximas questões vão implicitamente esperar que você utilize algumas dessas funções: sum(), mean(), abs() e sd(). Claro que, o R te oferece a liberdade de escrever as suas próprias funções, ou de desenhar o seu próprio caminho até as soluções dessas questões. Portanto, não se preocupe se você encontrar uma solução para as questões abaixo, que não incluem o uso dessas funções específicas.
1.3.A) Considerando que a variável \(X\) segue uma distribuição normal, como você normalizaria (isto é, calcular o índice \(Z\) da distribuição) os valores presentes no vetor vec abaixo, que contém uma amostra de valores da variável \(X\).
vec <- c(0.5, 1.2, 2.5, 1.3, 2.2, 3.7)1.3.B) Utilizando novamente a variável vec, calcule o seu desvio médio.
vec <- c(0.5, 1.2, 2.5, 1.3, 2.2, 3.7)