Capítulo 2 Operações Básicas no R

Antes de começar a desenvolver o seu código, é necessário entender a forma de trabalhar com o R e o RStudio. Isso inclui os componentes da linguagem, os diferentes tipos de objetos e as operações que podem ser realizadas com base nos comandos existentes. Entender o uso do R e como tirar vantagem da sua linguagem é essencial para o desenvolvimento do material futuro. Este é o principal capítulo para aqueles que estão se familiarizando com o uso da ferramenta.

Neste capítulo iremos percorrer os passos iniciais sobre o ponto de vista de alguém que nunca trabalhou com o R e, possivelmente, nunca teve contato com outra linguagem de programação. Aqueles já familiarizados com o programa irão encontrar pouca informação nova e, portanto, sugiro a leitura da próxima seção. É recomendado, porém, que no mínimo esse usuário verifique os temas tratados para confirmar ou não o seu conhecimento sobre as funcionalidades do programa. Muitas das sugestões apresentadas aqui tem potencial de aumentar significativamente a sua produtividade no trabalho.

2.1 Como o R Funciona?

A maior dificuldade que um usuário iniciante possui ao começar a desenvolver rotinas com o R é a forma de trabalho. A nossa interação com computadores foi simplificada ao longo dos anos e atualmente estamos confortáveis com o formato de interação do tipo aponte e clique. Isto é, caso se queira efetuar alguma operação no computador, basta apontar o mouse para o local específico na tela e clicar o botão do mouse ou teclado que realize tal operação. Uma série de passos nesse sentido permite a execução de tarefas complexas no computador. Mas não se engane, essa forma de interação no formato aponte e clique é apenas uma camada por cima do que realmente acontece no computador. Por trás de todo clique existe um comando sendo executado, seja na abertura de um arquivo pdf, direcionamento do browser para uma página na internet ou qualquer outra operação cotidiana de trabalho. Esse comando foi criado pelo desenvolvedor do programa para rodar dentro do seu sistema operacional.

Enquanto esse formato de interação visual e motora tem seus benefícios ao facilitar e popularizar o uso de computadores, é pouco flexível e eficaz quando se trabalha com procedimentos computacionais. Ao conhecer os possíveis comandos disponíveis ao usuário, é possível criar um arquivo contendo alguns comandos em sequência e, futuramente, simplesmente pedir que o computador execute esse arquivo com os nossos procedimentos. Uma rotina de computador é nada mais do que um texto que instrui, de forma clara e objetiva, o que o computador deve fazer. Investe-se certo tempo para a criação do programa, porém, no futuro, esse irá executar sempre da mesma maneira o procedimento gravado. No médio e longo prazo, existe um ganho significativo de tempo entre o uso de uma rotina do computador e uma interface do tipo aponte e clique.

Além disso, o risco de erro humano na execução do procedimento é quase nulo, pois os comandos e a sua sequência estão registrados no arquivo texto e irão ser executados sempre da mesma maneira. Da mesma forma, esse aglomerado de comandos pode ser compartilhado com outras pessoas, as quais podem replicar os resultados em seus computadores. Essa é uma das grandes razões que justificam a popularização de programação na realização de pesquisa em dados. Todos os procedimentos executados podem ser replicados pelo uso de um script.

No uso do R, o ideal é mesclar o uso do mouse com a utilização de comandos. O R e o RStudio possuem algumas funcionalidades através do mouse, porém a sua capacidade é otimizada quando os utilizamos via inserção de comandos específicos. Quando um grupo de comandos é realizado de uma maneira inteligente, temos um script do R que deve preferencialmente produzir algo importante para nós no final de sua execução. Em Finanças, isso pode ser o valor atualizado de um portfólio de investimento, o cálculo do risco de uma carteira, a performance histórica de uma estratégia de investimento, o resultado de uma pesquisa acadêmica, entre diversas outras possibilidades.

O R também possibilita a exportação de arquivos, tal como figuras a serem inseridas em um relatório técnico ou informações em um arquivo texto. De fato, o próprio relatório técnico pode ser dinamicamente criado dentro do R através da tecnologia RMarkdown. Por exemplo, este livro que estás lendo foi escrito utilizando o pacote bookdown (Xie 2016). O livro é compilado com a execução dos códigos e as suas saídas são registradas em texto. Todas as figuras e os dados do livro podem ser atualizados com a execução de um simples comando. Usuários que possuem interesse em construir documentos cujos dados e figuras devem ser atualizados periodicamente, sugiro fortemente o estudo das ferramentas destacadas anteriormente. No capítulo 12 iremos mostrar uma introdução a essas ferramenta de construção de documentos dinâmicos.

2.2 Objetos e Funções

No R, tudo é um objeto, e cada tipo de objeto tem suas propriedades. Por exemplo, o valor de um índice de inflação pode ser representado como um objeto do tipo vetor numérico, em que cada elemento desse vetor é a inflação acumulada até um período de tempo. As datas relacionadas com esses valores podem ser representadas como texto (character) ou a própria classe Date. Por fim, podemos representar conjuntamente os dados de inflação e as datas armazenando-os em um objeto único do tipo dataframe, o qual nada mais é do que uma tabela com linhas e colunas. Esses objetos fazem parte do ecossistema do R e é através da manipulação destes que tiramos o máximo proveito do software.

Enquanto representamos dados como um objeto específico no R, um tipo especial de objeto é a função, a qual representa um procedimento preestabelecido que está disponível para o usuário. O R possui uma grande quantidade de funções, as quais possibilitam que o usuário realize uma vasta gama de procedimentos. Por exemplo, os comandos básicos do R, não incluindo demais pacotes, somam um total de 1243 funções.

Cada função possui um próprio nome. Por exemplo, a função mean é um procedimento que calcula a média de valores utilizados como input. Caso quiséssemos calcular o valor médio da sequência 1,2,3,4,5, basta inserir no prompt o seguinte comando e apertar enter:

mean(1:5, na.rm = TRUE)
## [1] 3

O comando 1:5, utilizado anteriormente, cria uma sequência com início em 1 e final em 5 (maiores detalhes sobre a criação de sequências serão dados em seção futura). Observe que a função mean é utilizada com parênteses de início e fim. Esses parênteses servem para destacar as entradas (inputs), isto é, as informações enviadas para a função produzir alguma coisa. Observe que cada entrada é separada por uma vírgula, tal como em MinhaFct(input1, input2, input3, ...). No caso do código anterior, note que usamos a opção na.rm = TRUE. Essa é uma instrução específica para a função mean ignorar elementos do tipo NA (not available), caso eles existam. Por enquanto, essa breve introdução a funções já serve o seu propósito. No capítulo 8 iremos tratar deste assunto com maior profundidade.

2.3 O Formato Brasileiro

Antes de começar a explicar o uso do R e RStudio, é importante ressaltar algumas regras de formatação de números e códigos para o caso brasileiro.

decimal: O decimal no R é definido pelo ponto (.), tal como em 2.5 e não vírgula, como em 2,5. Esse é o padrão internacional, e a diferença para a notação brasileira gera muita confusão. Alguns softwares, tal como o Microsoft Excel, fazem essa conversão automaticamente no momento da importação dos dados. Porém isso não ocorre na maioria dos casos. Como regra geral, utilize vírgulas apenas para separar os termos de entradas em uma função. Em nenhuma situação deve-se utilizar a vírgula como separador de casas decimais. Sempre dê prioridade para o formato internacional, pois esse será compatível com a grande maioria dos dados. Outros pesquisadores também podem ter dificuldade de entender o seu código, caso utilize a notação local para o decimal.

caracteres latinos: devido ao seu padrão internacional, o R apresenta problemas para entender caracteres latinos, tal como cedilha e acentos. Caso possa evitar, não utilize esses tipos de caracteres no código para nomeação de variáveis ou arquivos. Nos textos (objeto de caracteres), é possível utilizá-los desde que a codificação do objeto esteja correta (UTF-8 ou Latin1). Recomenda-se que o código do R seja escrito na língua inglesa. Isso automaticamente elimina o uso de caracteres latinos e facilita a usabilidade do código por outras pessoas que não entendam a língua portuguesa. Destaca-se que essa foi a escolha utilizada para o livro. Os nomes dos objetos nos exemplos estão em inglês, assim como também os comentários do código.

formato das datas: as datas no R são formatadas de acordo com o padrão ISO 8601, seguindo o padrão YYYY-MM-DD, onde YYYY é o ano em quatro números, MM é o mês e DD é o dia. Por exemplo, uma data em ISO 8601 é 2020-07-30. No Brasil, as datas são formatadas como DD/MM/YYYY. Reforçando a regra, sempre dê preferência ao padrão internacional. Vale salientar que a conversão entre um formato e outro é bastante fácil e será apresentada em capítulo futuro.

No momento de instalação do R, diversas informações sobre o formato local do seu computador são importadas. Para saber qual o formato que o R está configurado, digite o seguinte comando no prompt (canto esquerdo inferior do RStudio) e aperte enter:

# get local format
Sys.localeconv()
##     decimal_point     thousands_sep          grouping 
##               "."                ""                "" 
##   int_curr_symbol   currency_symbol mon_decimal_point 
##            "BRL "              "R$"               "," 
## mon_thousands_sep      mon_grouping     positive_sign 
##               "."        "\003\003"                "" 
##     negative_sign   int_frac_digits       frac_digits 
##               "-"               "2"               "2" 
##     p_cs_precedes    p_sep_by_space     n_cs_precedes 
##               "1"               "1"               "1" 
##    n_sep_by_space       p_sign_posn       n_sign_posn 
##               "1"               "1"               "1"

A saída de Sys.localeconv() mostra como o R interpreta pontos decimais e o separador de milhares, entre outras coisas. Como você pode ver no resultado anterior, este livro foi compilado usando a notação brasileira de moeda, mas usa o ponto para decimais. Conforme mencionado anteriormente, é boa política de trabalho seguir a notação internacional, especialmente para o ponto decimal. Se necessário, você pode (temporariamente) alterar seu formato local para a notação internacional usando o seguinte comando.

# set local format to English
Sys.setlocale("LC_ALL", "English")

Caso desejes incorporar esta mudança de forma permanente, deves buscar entender e modificar como o seu sistema operacional registra o formato local, ou então incorporar o comando anterior na inicialização do R. Essa mudança, porém, não é essencial. Se trabalhares com o R no formato padrão de instalação, o formato internacional será utilizado nos itens mais importantes e provavelmente não terás problema com isso.

2.4 Tipos de Arquivos

Assim como outros programas, o R possui um ecossistema de arquivos. Cada tipo de extensão tem uma finalidade diferente. Na grande maioria dos casos, o trabalho se concentrará em uma extensão apenas: arquivos .R. A seguir apresenta-se uma descrição de diversas extensões de arquivos. Os itens da lista estão ordenados por ordem de importância e uso. Note que omitimos arquivos de figuras tal como .png, .jpg, .gif entre outros, pois estes não são exclusivos do R.

Arquivos com extensão .R: Representam arquivos do tipo texto contendo diversas instruções para o R. Esses são os arquivos que conterão o código da pesquisa. Também pode ser chamado de um script ou rotina de pesquisa. Exemplos: Minha_pesquisa.R, Minhas_Funções.R.

Arquivos com extensão .RData e .rds: armazenam dados nativos do R. Esses arquivos servem para salvar objetos criados em diferentes sessões. Por exemplo, podes guardar o resultado de uma pesquisa em uma tabela, a qual é salva em um arquivo com extensão .RData ou .rds. A diferença entre os dois formatos anteriores é que o RData possibilita armazenar mais de um objeto do R, enquanto o .rds armazena apenas um. No capítulo 4 iremos tratar desse assunto com maior profundidade. Os arquivos salvos nesse formato podem ser futuramente carregados em outra sessão do R. Exemplos: Meus_dados.RData, Resultados_Pesquisa.rds.

Arquivos com extensão .Rmd, .md e .Rnw: representam arquivos para a edição de documentos dinâmicos relacionados a linguagem Rmarkdown e markdown. O uso desses arquivos permite a criação de documentos onde texto e código são integrados. No capítulo 12 iremos ver a forma de usar o RMarkdown no RStudio.

Arquivos com extensão .Rproj: contém informações para a edição de projetos no RStudio. O uso desse tipo de arquivo facilita a criação de projetos no R, tal com um novo pacote ou um script de pesquisa. O uso desse arquivo possibilita configurar um projeto qualquer e também facilita a utilização de ferramentas de controle de código, tal como controle de versões. O seu uso, porém, não é essencial. Para aqueles com interesse em conhecer esta funcionalidade, sugiro a leitura do manual do RStudio. Exemplo: Meu_Projeto.Rproj.

2.5 Explicando a Tela do RStudio

Após instalar os dois programas, R e RStudio, abra o programa RStudio. Procure o seu ícone na área de trabalho ou via menu Iniciar. Destaca-se que o R também possui um programa de interface e isso muitas vezes gera confusão. Deve-se procurar o atalho correto para o RStudio. A janela resultante deve ser igual a figura 2.1, apresentada a seguir.

A tela do RStudio

Figura 2.1: A tela do RStudio

Observe que o RStudio automaticamente detectou a instalação do R e inicializou a sua tela, no lado esquerdo.

Caso não visualizar na tela do RStudio algo como:

	R version 3.4.4 (2018-03-15) -- "Someone to Lean On"
	Copyright (C) 2018 The R Foundation for Statistical Computing
	Platform: x86_64-pc-linux-gnu (64-bit)

	R is free software and comes with ABSOLUTELY NO WARRANTY.
	You are welcome to redistribute it under certain conditions.
	Type 'license()' or 'licence()' for distribution details.

	Natural language support but running in an English locale

	R is a collaborative project with many contributors.
	Type 'contributors()' for more information and
	'citation()' on how to cite R or R packages in publications.

	Type 'demo()' for some demos, 'help()' for on-line help, or
	'help.start()' for an HTML browser interface to help.
	Type 'q()' to quit R.

o R não foi instalado corretamente. Repita os passos de instalação do capítulo anterior e confirme o aparecimento da respectiva mensagem de inicialização no lado esquerdo inferior do RStudio.

Como um primeiro exercício, clique em file, New File e R Script. Deve aparecer um editor de texto no lado esquerdo da tela. É nesse editor que iremos inserir os nossos comandos, os quais são executados de cima para baixo, na mesma direção em que normalmente o lemos. Note que essa direção de execução introduz uma dinâmica de recursividade: cada comando depende do comando executado nas linhas anteriores. Após realizar os passos definidos anteriormente, a tela resultante deve ser semelhante à apresentada na figura 2.2.

Explicando a tela do RStudio

Figura 2.2: Explicando a tela do RStudio

Nesse ponto, uma sugestão é modificar o esquema de cores do RStudio para uma configuração mais escura. Não é uma questão de gosto estético mas sim de saúde física. Dado que irás passar bastante tempo na frente do computador, vale a pena modificar as cores para aliviar o constante brilho da tela. Dessa forma, conseguirás trabalhar por mais tempo sem forçar a sua visão. Podes configurar o esquema de cores do RStudio indo na opção Tools, Global Options e então em Appearance. Um esquema de cores escuras que pessoalmente gosto e sugiro é o Ambience.

Voltando ao RStudio, os principais itens/painéis são:

Editor de scripts (Script editor): localizado no lado esquerdo e acima da tela. Esse painel é utilizado para escrever scripts inteiros. Passaremos a maior parte do tempo escrevendo códigos nesse editor.

Console do R (R prompt): localizado no lado esquerdo e abaixo do editor de scripts. Apresenta o prompt do R, o qual também pode ser utilizado para dar comandos para o R. A principal função do prompt é testar código e apresentar os resultados dos comandos inseridos no editor de scripts.

Área de trabalho (Environment): localizado no lado direito e superior da tela. Mostra todos os objetos, incluindo variáveis e funções atualmente disponíveis para o usuário. Observe também a presença do painel History, o qual mostra o histórico dos comandos já executados.

Pacotes (Panel Packages): mostra os pacotes instalados e carregados pelo R. Um pacote é nada mais que um módulo no R. Podemos instalar diferentes módulos para diferentes tarefas. Logo em seguida iremos destacar com mais detalhes o uso de pacotes no R e RStudio. Observe a presença de quatro abas: Files, para carregar e visualizar arquivos do sistema; Plots, para visualizar figuras; Help, para acessar o sistema de ajuda do R e Viewer, para mostrar resultados dinâmicos e interativos, tal como uma página da internet.

Como um exercício introdutório, vamos inicializar duas variáveis. Dentro do console do R (lado esquerdo inferior), digite os seguintes comandos e aperte enter ao final de cada linha. O símbolo <- é nada mais que a junção de < com -. O símbolo ' representa uma aspa simples e sua localização no teclado Brasileiro é no botão abaixo do escape (esc), lado esquerdo superior do teclado.

# set x and y
x <- 1
y <- 'text'

Após a execução, dois objetos devem aparecer no painel Environment, um chamado x com o valor 1, e outro chamado y com o conjunto de caracteres text. O histórico de comandos na aba History também foi atualizado com os comandos utilizados anteriormente.

Agora, vamos mostrar na tela os valores de x. Para isso, digite o seguinte comando no prompt e aperte enter novamente:

# print it
print(x)
## [1] 1

A função print é uma das principais funções para mostrarmos valores no prompt do R. O texto apresentado como [1] indica o índice do primeiro número da linha. Para verificar isso, digite o seguinte comando, o qual irá mostrar vários números na tela:

# print vector from 50 to 100
print(50:100)
##  [1]  50  51  52  53  54  55  56  57  58  59  60  61  62  63
## [15]  64  65  66  67  68  69  70  71  72  73  74  75  76  77
## [29]  78  79  80  81  82  83  84  85  86  87  88  89  90  91
## [43]  92  93  94  95  96  97  98  99 100

Nesse caso, utilizamos o símbolo : em 50:100 para criar uma sequência iniciando em 50 e terminando em 100. Observe que temos os valores 1, 15, 29 e 43. Esses representam os índices do primeiro elemento apresentado na linha. Por exemplo, o décimo quinto elemento do vetor criado é o valor 64.

2.6 Executando Códigos em um Script

Agora, vamos juntar todos os códigos digitados anteriormente e colar na tela do editor (lado esquerdo superior), assim como mostrado a seguir:

# set objects
x <- 1
y <- 'my text'

# print it
print(x)
print(1:50)

Após colar todos os comandos no editor, salve o arquivo .R em alguma pasta pessoal. Esse arquivo, o qual no momento não faz nada especial, registrou os passos de um algoritmo simples que cria vários objetos e mostra os seus valores. Futuramente esse irá ter mais forma, com a importação de dados, manipulação e modelagem dos mesmos e saída de tabelas e figuras.

No RStudio existem alguns atalhos predefinidos para executar códigos que economizam bastante tempo. Para executar um script inteiro, basta apertar control + shift + s. Esse é o comando source. Com o RStudio aberto, sugiro testar essa combinação de teclas e verificar como o código digitado anteriormente é executado, mostrando os valores no prompt do R. Visualmente, o resultado deve ser próximo ao apresentado na figura 2.3.

Exemplo de Rotina no R

Figura 2.3: Exemplo de Rotina no R

Outro comando muito útil é a execução por linha. Nesse caso não é executado todo o arquivo, mas somente a linha em que o cursor se encontra. Basta apertar control+enter. Esse atalho é bastante útil no desenvolvimento de rotinas pois permite que cada linha seja testada antes de executar o programa inteiro. Como um exemplo de uso, aponte o cursor para a linha print(x) e pressione control + enter. Verás que o valor de x é mostrado na tela inferior. A seguir destaco esses e outros atalhos do RStudio, os quais também são muito úteis.

  • control+shift+s executa o arquivo atual do RStudio, sem mostrar comandos no prompt (sem eco);
  • control+shift+enter: executa o arquivo atual, mostrando comandos na tela (com eco);
  • control+enter: executa a linha selecionada, mostrando comandos na tela;
  • control+shift+b: executa os códigos do início do arquivo até a linha atual onde o cursor se encontra;
  • control+shift+e: executa os códigos da linha onde o cursor se encontra até o final do arquivo.

Sugere-se que esses atalhos sejam memorizados e utilizados. Isso facilita bastante o uso do programa. Para aqueles que gostam de utilizar o mouse, uma maneira alternativa para rodar o código do script é apertar o botão source, localizado no canto direito superior do editor de rotinas. Isto é equivalente ao atalho control+shift+s.

Caso desejes rodar um código salvo em um arquivo .R, podes utilizar o comando source. Por exemplo, imagine que tens um script principal com a pesquisa e outro script que realiza alguma operação de suporte tal como a importação de dados para o R. Essas operações foram desmembradas em arquivos diferentes como uma forma de organizar o código.

Para executar o script de suporte, basta chamá-lo no script principal com o comando source, como no código a seguir:

# source (execute) file
source('import-data.R')

Nesse caso, o script em import-data.R será executado de forma equivalente a abrir o mesmo manualmente e apertar control+shift+s.

Como podemos ver, existem diversas maneiras de executar uma rotina de pesquisa. Na prática, porém, iras centralizar o uso em dois comandos apenas: control+shift+s para rodar o script inteiro e control+enter para rodar por linha.

2.7 Testando Código

O desenvolvimento do código segue um ciclo. Primeiro você escreverá uma nova linha de comando em uma rotina. Essa linha será testada com o atalho control + enter, verificando-se a ocorrência de erros e as saídas na tela. Caso não houver erro e o resultado for igual ao esperado, parte-se para a próxima linha de código.

Um ciclo de trabalho fica claro, a escrita do código da linha atual é seguida pela execução, seguido da verificação de resultados, modificação caso necessário e assim por diante. Esse é um processo normal e esperado. Dado que uma rotina é lida e executada de cima para baixo, você precisa ter certeza de que cada linha de código está corretamente especificada antes de passar para a próxima.

Quando você está tentando encontrar um erro em um script preexistente, o R oferece algumas ferramentas para controlar e avaliar sua execução. Isso é especialmente útil quando você possui um código longo e complicado. A ferramenta de teste mais simples e fácil de utilizar que o RStudio oferece é o ponto de interrupção do código. No RStudio, você pode clicar no lado esquerdo do editor e aparecerá um círculo vermelho, como na Figura 2.4.

Exemplo de debug

Figura 2.4: Exemplo de debug

O círculo vermelho indica um ponto de interrupção do código que forçará o R a parar a execução nessa linha. Após isso, você pode verificar o conteúdo dos objetos existentes. Quando a execução atinge o ponto de interrupção, o prompt mudará para browser[1]> e você poderá verificar o conteúdo dos objetos. No console, você tem a opção de continuar a execução para o próximo ponto de interrupção ou interrompê-la. O mesmo resultado pode ser alcançado usando a função browser. Dê uma olhada:

# set x
x <- 1

# set y
browser()
y <- 'My humble text'

# print contents of x
print(x)

O resultado prático do código anterior é o mesmo que utilizar o círculo vermelho do RStudio, figura 2.4. Porém, o uso do browser permite mais controle sobre onde a execução deve ser interrompida.

2.8 Criando Objetos Simples

Um dos comandos mais básicos no R é a definição de objetos. Como foi mostrado nas seções anteriores, pode-se definir um objeto com o uso do comando <-, o qual, para o português, é traduzido para o verbo defina (assign em inglês). Considere o seguinte código:

# set x
x <- 123

# set x, y and z in one line
my.x <- 1 ; my.y <- 2; my.z <- 3

Lê-se esse código como x é definido como 123. A direção da seta define onde o valor será armazenado. Por exemplo, utilizar 123 -> x também funcionaria, apesar de ser uma sintaxe pouco utilizada ou recomendada. Note que também é possível escrever diversos comandos na mesma linha com o uso da semi-vírgula (;).

O uso do símbolo <- para a definição de objetos é específico do R. Na época da concepção da linguagem S, de onde o R foi baseado, existiam teclados com uma tecla que definia diretamente o símbolo de seta. Essa escolha foi definida pelo fácil acesso ao símbolo. Atualmente, no Windows, o atalho para esse símbolo é alt + -.

É possível também usar o símbolo = para definir objetos assim como o <-, porém a utilização do = com esse fim específico não é recomendada. O símbolo de igualdade tem uso especial dentro da definição de argumentos de uma função. Esse caso será explicado e demonstrado em capítulos futuros.

O nome dos objetos é importante no R. Tirando alguns casos específicos, o usuário pode nomear os objetos como quiser. Essa liberdade, porém, pode ser um problema. É desejável sempre dar nomes curtos que façam sentido ao conteúdo do objeto e que sejam simples de entender. Isso facilita o entendimento do código por outros usuários e faz parte das normas sugeridas para a estruturação do código. Observe que todos os objetos criados nesse livro possuem nomenclatura em inglês e formatação específica, onde espaços entre substantivos e verbos são substituídos por ponto, tal como em my.x e my.file. Outra possibilidade é utilizar o traço baixo (_), tal como my_x e my_file. Não tem nenhum ganho computacional entre um e outro. Deves escolher um que aches mais atrativo visualmente. Aqui, o mais importante é a consistência do formato. Sempre mantenha o mesmo padrão em todo o código.

O R executa o código procurando objetos e funções disponíveis. Se tentarmos acessar um objeto que não existe, o R irá dar como resultado uma mensagem de erro, como a seguir:

print(z)
## Error in print(z): object 'z' not found

Isso ocorre pois o objeto z não existe no enviromnent atual do R. Se criarmos uma variável z como z <- 123 e repetirmos o comando print(z), não teremos a mesma mensagem de erro.

Um ponto importante aqui é a definição de objetos de classes diferentes com o uso de símbolos específicos. O uso de aspas duplas (" ") ou simples (' ') define objetos da classe texto enquanto números são definidos pelo próprio valor. Conforme será mostrado, cada objeto no R tem uma classe e cada classe tem um comportamento diferente. Portanto, objetos criados com o uso de aspas pertencem à classe character. Para confirmar isso, verifique o próximo código.

# set vars
x <- 1
y <- '1'

# display classes
class(x)
## [1] "numeric"
class(y)
## [1] "character"

As saídas anteriores mostram que a variável x é do tipo numérico, enquanto a variável y é do tipo texto (character). Ambas fazem parte das classes básicas de objetos no R. Iremos estudar este assunto mais profundamente no capítulo 7.

2.9 Criando Vetores

Nos exemplos anteriores criamos objetos simples tal como x <- 1 e x <- 'abc'. Enquanto isso é suficiente para demonstrar os comandos básicos do R, na prática tais comandos são bastante limitados, uma vez que um problema real de análise de dados certamente irá ter um maior volume de informações a serem processadas.

Um dos procedimentos mais utilizados no R é a criação de vetores atômicos. Esses são objetos que guardam uma série de elementos. Todos os elementos de um vetor atômico devem possuir a mesma classe, o que justifica a sua propriedade atômica. Um exemplo seria representar no R uma série de preços diários de uma ação. Tal série possui vários valores numéricos que formam um vetor da classe numérica.

Vetores atômicos são criados no R através do uso do comando c, o qual é oriundo do verbo em inglês combine. Por exemplo, caso eu quisesse combinar os valores 1, 2 e 3 em um objeto/vetor, eu poderia fazê-lo através do seguinte comando:

# set vector
x <- c(1,2,3)
print(x)
## [1] 1 2 3

Esse comando funciona da mesma maneira para qualquer número de elementos. Caso necessário, poderíamos criar um vetor com mais elementos simplesmente adicionando valores após o 3, tal como em x <- c(1, 2, 3, 4, 5).

O uso do comando c não é exclusivo para vetores numéricos. Por exemplo, poderíamos criar um vetor de outra classe de dados, tal como character:

y <- c('text 1', 'text 2', 'text 3', 'text 4')
print(y)
## [1] "text 1" "text 2" "text 3" "text 4"

A única restrição no uso do comando c é que todos os itens do vetor tenham a mesma classe. Se inserirmos dados de classes diferentes, o R irá tentar transformar os itens para a mesma classe seguindo uma lógica própria, onde a classe mais complexa sempre tem preferência. Caso ele não consiga transformar todos os elementos para uma classe só, uma mensagem de erro será retornada. Observe no próximo exemplo como os valores numéricos no primeiro e segundo elemento de x são transformados para a classe de caracteres.

x <- c(1, 2, '3')
print(x)
## [1] "1" "2" "3"

Isso ocorre pois a classe de texto é mais complexa que a classe numérica. O uso do comando class confirma que o objeto x é da classe character:

class(x)
## [1] "character"

Outra utilização do comando c é a combinação de vetores. De fato, isto é exatamente o que fizemos ao executar o código c(1, 2, 3). Neste caso, cada vetor possuía um elemento. Podemos realizar o mesmo com vetores maiores. Veja a seguir:

# set x and y
x <- c(1, 2, 3)
y <- c(4, 5)

# print combination of x and y
print(c(x, y))
## [1] 1 2 3 4 5

Portanto, o comando c possui duas funções principais: criar e combinar vetores.

2.10 Conhecendo os Objetos Criados

Após a execução de diversos comandos no editor ou prompt, é desejável saber quais são os objetos criados pelo código. É possível descobrir essa informação simplesmente olhando para o lado direito superior do RStudio, na aba da área de trabalho. Porém, existe um comando que sinaliza a mesma informação no prompt. Com o fim de saber quais são as variáveis atualmente disponíveis na memória do R, pode-se utilizar o comando ls. Observe o exemplo a seguir:

# set vars
x <- 1
y <- 2
z <- 3

# show current objects
ls()
## [1] "x" "y" "z"

Os objetos x, y e z foram criados e estavam disponíveis no ambiente de trabalho atual, juntamente com outros objetos. Para descobrir os valores dos mesmos, basta digitar os nomes dos objetos e apertar enter no prompt:

x
## [1] 1
y
## [1] 2
z
## [1] 3

Destaca-se que digitar o nome do objeto na tela tem o mesmo resultado que utilizar a função print. De fato, ao executar o nome de uma variável, internamente o R passa esse objeto para a função print.

No R, conforme mostrado, todos os objetos pertencem a alguma classe. Para descobrir a classe de um objeto, basta utilizar a função class. Observe no exemplo a seguir que x é um objeto da classe numérica e y é um objeto da classe de texto (character).

# set vars
x <- 1
y <- 'a'

# check classes
class(x)
## [1] "numeric"
class(y)
## [1] "character"

Outra maneira de conhecer melhor um objeto é verificar a sua representação em texto. Todo objeto no R possui uma representação textual e a verificação desta é realizada através da função str:

# print textual representation of a vector
print(str(1:10))
##  int [1:10] 1 2 3 4 5 6 7 8 9 10
## NULL

Essa função é particularmente útil quando se está tentando entender os detalhes de um objeto mais complexo, tal como uma tabela. A utilidade da representação textual é que nela aparece o tamanho do objeto e suas classes internas. Nesse caso, o objeto 1:10 é da classe integer e possui dez elementos. No tidyverse, a função equivalente é dplyr::glimpse. Veja o exemplo a seguir para um vetor atômico:

# glimpse a vector
dplyr::glimpse(1:10)
##  int [1:10] 1 2 3 4 5 6 7 8 9 10

No código anterior, usamos o operador :: para explicitamente dizer ao R que a função glimpse pertence ao pacote dplyr, o qual faz parte do tidyverse. Caso não conseguir rodar o exemplo anterior, provavelmente não tens o pacote dplyr instalado em sua máquina. Iremos ver o tópico de instalação de pacotes logo em seguida.

2.11 Mostrando e Formatando Informações na Tela

Como já vimos, é possível mostrar o valor de uma variável na tela de duas formas, digitando o nome dela no prompt ou então utilizando a função print. Explicando melhor, a função print é voltada para a apresentação de objetos e pode ser customizada para qualquer tipo. Por exemplo, caso tivéssemos um objeto chamado table que representasse um objeto tabular, poderíamos criar uma função chamada print.table que irá mostrar uma tabela na tela com um formato especial tal como número de linhas, nomes das colunas, etc. A função print, portanto, pode ser customizada para cada classe de objeto.

Porém, existem outras funções específicas para apresentar texto (e não objetos) no prompt. A principal delas é cat (Concatenate and Print). Essa toma como input um texto, processa-o para símbolos específicos e o apresenta na tela. Essa função é muito mais poderosa e personalizável do que print.

Por exemplo, caso quiséssemos mostrar na tela o texto 'O valor de x é igual a 2', poderíamos fazê-lo da seguinte forma:

# set var
x <- 2

# print with cat()
cat('The value of x is', x)
## The value of x is 2

Função cat também funciona para vetores:

# set vec
x <- 2:5

# print with cat()
cat('The values in x are: ', x)
## The values in x are:  2 3 4 5

A customização da saída da tela é possível através de comandos específicos. Por exemplo, se quiséssemos quebrar a linha da tela, poderíamos fazê-lo através do uso do caractere reservado \n:

# set char
my.text <- ' First line,\nSecond Line,\nThird Line'

# print with new lines
cat(my.text)
##  First line,
## Second Line,
## Third Line

Observe que o uso do print não resultaria no mesmo efeito, uma vez que esse comando apresenta o texto como ele é, sem processar para efeitos específicos:

print(my.text)
## [1] " First line,\nSecond Line,\nThird Line"

Outro exemplo no uso de comandos específicos para texto é adicionar um espaçamento tab no texto apresentado com o símbolo \t. Veja a seguir:

# set char with \t
my.text <- 'A->\t<-B'

# print with cat()
cat(my.text)
## A->	<-B

Vale destacar que, na grande maioria dos casos de pesquisa, será necessário apenas o uso de \n para formatar textos de saída. Outras maneiras de manipular a saída de texto no prompt com base em símbolos específicos são encontradas no manual oficial do R.

Parte do processo de apresentação de texto na tela é a customização do mesmo. Para isto, existem duas funções muito úteis: paste e format.

A função paste cola uma série de caracteres juntos. É uma função muito útil, a qual será utilizada intensamente para o resto dos exemplos deste livro. Observe o código a seguir:

# set chars
my.text.1 <- 'I am a text'
my.text.2 <- 'very beautiful'
my.text.3 <- 'and informative.'

# using paste and cat
cat(paste(my.text.1, my.text.2, my.text.3))
## I am a text very beautiful and informative.

O resultado anterior não está muito longe do que fizemos no exemplo com a função print. Note, porém, que a função paste adiciona um espaço entre cada texto. Caso não quiséssemos esse espaço, poderíamos usar a função paste0:

# using paste0
cat(paste0(my.text.1, my.text.2, my.text.3))
## I am a textvery beautifuland informative.

Outra possibilidade muito útil no uso do paste é modificar o texto entre a junção dos itens a serem colados. Por exemplo, caso quiséssemos adicionar uma vírgula (,) entre cada item, poderíamos fazer isso através do uso do argumento sep, como a seguir:

# using custom separator
cat(paste(my.text.1, my.text.2, my.text.3, sep = ', '))
## I am a text, very beautiful, and informative.

Caso tivéssemos um vetor atômico com os elementos da frase em um objeto apenas, poderíamos atingir o mesmo resultado utilizando paste o argumento collapse:

# using paste with collapse argument
my.text <-c('Eu sou um texto', 'muito bonito', 'e charmoso.')
cat(paste(my.text, collapse = ', '))
## Eu sou um texto, muito bonito, e charmoso.

Prosseguindo, o comando format é utilizado para formatar números e datas. É especialmente útil quando formos montar tabelas e buscarmos apresentar os números de uma maneira visualmente atraente. Por definição, o R apresenta uma série de dígitos após a vírgula:

# cat without formatting
cat(1/3)
## 0.3333333

Caso quiséssemos apenas dois dígitos aparecendo na tela, utilizaríamos o seguinte código:

# cat with format and two digits
cat(format(1/3, digits=2))
## 0.33

2.12 Conhecendo o Tamanho dos Objetos

Na prática de programação com o R, é muito importante saber o tamanho das variáveis que estão sendo utilizadas. Isso serve não somente para auxiliar o usuário na verificação de possíveis erros do código, mas também para saber o tamanho necessário em certos procedimentos de iteração tal como loops, os quais serão tratados em capítulo futuro.

No R, o tamanho do objeto pode ser verificado com o uso de quatro principais funções: length, nrow, ncol e dim.

A função length é destinada a objetos com uma única dimensão, tal como vetores atômicos:

# set x
x <- c(2,3,3,4,2,1)

# get length x
n <- length(x)

# display message
cat(paste('The length of x is', n))
## The length of x is 6

Para objetos com mais de uma dimensão, por exemplo matrizes e dataframes, utilizam-se as funções nrow, ncol e dim para descobrir o número de linhas (primeira dimensão) e o número de colunas (segunda dimensão). Veja a diferença a seguir.

# set matrix and print it
x <- matrix(1:20, nrow = 4, ncol = 5)
print(x)
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    5    9   13   17
## [2,]    2    6   10   14   18
## [3,]    3    7   11   15   19
## [4,]    4    8   12   16   20
# find number of rows, columns and elements
my.nrow <- nrow(x)
my.ncol <- ncol(x)
my.length <- length(x)

# print message
cat(paste('\nThe number of lines in x is ', my.nrow))
## 
## The number of lines in x is  4
cat(paste('\nThe number of columns in x is ', my.ncol))
## 
## The number of columns in x is  5
cat(paste('\nThe number of elements in x is ', my.length))
## 
## The number of elements in x is  20

Já a função dim mostra a dimensão do objeto, resultando em um vetor numérico como saída. Essa deve ser utilizada quando o objeto tiver mais de duas dimensões. Na prática, esses casos são raros. Um exemplo para a variável x é dado a seguir:

print(dim(x))
## [1] 4 5

Para o caso de objetos com mais de duas dimensões, podemos utilizar a função array para criá-los e dim para descobrir o seu tamanho:

# set array with dimension
my.array <- array(1:9, dim = c(3,3,3))

# print it
print(my.array)
## , , 1
## 
##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9
## 
## , , 2
## 
##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9
## 
## , , 3
## 
##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9
# print its dimension
print(dim(my.array))
## [1] 3 3 3

Uma observação importante aqui é que as funções length, nrow, ncol e dim não servem para descobrir o número de letras em um texto. Esse é um erro bastante comum. Por exemplo, caso tivéssemos um objeto do tipo texto e usássemos a função length, o resultado seria o seguinte:

# set char object
my.char <- 'abcde'

# find its length (and NOT number of characters)
print(length(my.char))
## [1] 1

Isso ocorre pois a função length retorna o número de elementos. Nesse caso, my.char possui apenas um elemento. Para descobrir o número de caracteres no objeto, utilizamos a função nchar, conforme a seguir:

# using nchar for number of characters
print(nchar(my.char))
## [1] 5

Conforme foi destacado anteriormente, cada objeto tem suas propriedades e funções específicas para manipulação.

2.13 Selecionando Elementos de um Vetor Atômico

Após a criação de um vetor atômico de qualquer classe, é possível que se esteja interessado em apenas um ou alguns elementos desse mesmo vetor. Por exemplo, caso estivéssemos buscando atualizar o valor de um portfólio de investimento, o nosso interesse dentro de um vetor contendo preços de uma ação é somente para o preço mais recente. Todos os demais preços não seriam relevantes para a nossa análise e, portanto, poderiam ser ignorados.

Esse processo de seleção de pedaços de um vetor atômico é chamado de indexação e é executado através do uso de colchetes []. Observe o exemplo de código a seguir:

# set my.x
my.x <- c(1, 5, 4, 3, 2, 7, 3.5, 4.3)

Se quiséssemos apenas o terceiro elemento de my.x, utilizaríamos o operador de colchete da seguinte forma:

# get third element of my.x
elem.x <- my.x[3]
print(elem.x)
## [1] 4

Também podemos utilizar o comando length, apresentado anteriormente, para acessar o último elemento do vetor:

# get last element of my.x
last.elem <- my.x[length(my.x)]

# print it
print(last.elem)
## [1] 4.3

No caso de estarmos interessado apenas no último e penúltimo valor de my.x utilizaríamos o operador de sequência (:):

# get last and second last elements
piece.x.1 <- my.x[ (length(my.x)-1):length(my.x) ]

# print it
print(piece.x.1)
## [1] 3.5 4.3

Uma propriedade única da linguagem R é que, caso for acessado uma posição que não existe no vetor, o programa retorna o valor NA (not available). Veja a seguir, onde tenta-se obter o quarto valor de um vetor com apenas três elementos.

# set vec
my.vec <- c(1,2,3)

# find fourth element (NA returned!)
print(my.vec[4])
## [1] NA

É importante conhecer esse comportamento do R, pois o não tratamento desses erros pode gerar problemas difíceis de identificar em um código mais complexo. Em outras linguagens de programação, a tentativa de acesso a elementos não existentes geralmente retorna um erro e cancela a execução do resto do código. No caso do R, dado que o acesso a elementos inexistentes não gera erro ou mensagem de warning, é possível que isso gere um problema em outras partes do script. O usuário deve prestar atenção toda vez que surgirem valores NA de forma inesperada nos objetos criados. Uma inspeção nos índices dos vetores pode ser necessária.

O uso de indexadores é muito útil quando se está procurando por itens de um vetor que satisfaçam alguma condição. Por exemplo, caso quiséssemos todos os valores de my.x que são maiores que 3, utilizaríamos o seguinte comando:

# get all values higher than 3
piece.x.2 <- my.x[my.x>3]

# print it
print(piece.x.2)
## [1] 5.0 4.0 7.0 3.5 4.3

É possível também indexar por mais de uma condição através dos operadores de lógica & (e) e | (ou). Por exemplo, caso quiséssemos os valores de my.x maiores que 2 e menores que 4, usaríamos o seguinte comando:

# get all values higher than 2 AND lower than 4
piece.x.3 <- my.x[ (my.x>2) & (my.x<4) ]

# print it
print(piece.x.3)
## [1] 3.0 3.5

Da mesma forma, havendo interesse nos itens que são menores que 3 ou maiores que 6, teríamos:

# get all values lower than 3 OR higher than 6
piece.x.4 <- my.x[ (my.x<3)|(my.x>6) ]

# print it
print(piece.x.4)
## [1] 1 2 7

A indexação lógica também funciona com a interação de diferentes variáveis, isto é, podemos utilizar uma condição lógica em uma variável para selecionar itens em outra:

# set my.x and my.y
my.x <- c(1,4,6,8,12)
my.y <- c(-2,-3,4,10,14)

# find elements in my.x where my.y are positive
my.piece.x <- my.x[ my.y > 0 ]

# print it
print(my.piece.x)
## [1]  6  8 12

Olhando mais de perto o processo de indexação, vale salientar que, quando utilizamos uma condição de indexação dos dados, esta-se criando uma variável do tipo lógica. Essa toma apenas dois valores: TRUE (verdadeiro) ou FALSE (falso). É fácil perceber isso quando criamos o teste lógico em um objeto e o mostramos na tela:

# set logical object
my.logical <- my.y > 0

# print it
print(my.logical)
## [1] FALSE FALSE  TRUE  TRUE  TRUE
# show its class
class(my.logical)
## [1] "logical"

As propriedades e operações com vetores lógicos serão explicadas em capítulo futuro.

2.14 Limpando a memória

Após a criação de diversas variáveis, o ambiente de trabalho do R pode ficar cheio de conteúdo já utilizado e dispensável. Nesse caso, é desejável limpar a memória do programa. Geralmente isso é realizado no começo de um script, de forma que toda vez que o script for executado, a memória estará totalmente limpa antes de qualquer cálculo. Além de desocupar a memória do computador, isso ajuda a evitar possíveis erros no código. Na grande maioria dos casos, a limpeza do ambiente de trabalho deve ser realizada apenas uma vez.

Por exemplo, dada uma variável x, podemos excluí-la da memória com o comando rm, conforme mostrado a seguir:

# set x and y
x <- 1
y <- 2

# print all existing objects
ls()

# remove x from memory
rm('x')

# print objects again
ls()

Observe que o objeto x não estará mais mais disponível após o uso do comando rm('x').

Em situações práticas, porém, é desejável limpar toda a memória utilizada por todos os objetos criados no R. Pode-se atingir esse objetivo com o seguinte código:

# clean up workspace (all existing objects)
rm(list=ls())

O termo list é um argumento da função rm, o qual define quais objetos serão eliminados. Já o comando ls() mostra todas os objetos disponíveis atualmente. Portanto, ao encadear ambos os comandos, limpamos da memória todos os objetos disponíveis para o R. Como comentado, uma boa política de programação é sempre iniciar o script limpando a memória do R. Atenção: apenas limpe toda a memória do R se já tiver salvo os resultados de interesse ou se puder replicá-los.

2.15 Mostrando e Mudando o Diretório de Trabalho

Assim como outros softwares, o R sempre trabalha em algum diretório. É com base nesse diretório que o R procura arquivos para importar dados. É nesse mesmo diretório que o R salva arquivos, caso não definirmos um endereço no computador explicitamente. Essa saída pode ser um arquivo de uma figura, o arquivo de texto ou uma planilha eletrônica. Como boa prática de criação e organização de scripts, deve-se sempre mudar o diretório de trabalho para onde o arquivo do script está localizado. Em sua inicialização, o R possui como diretório default a pasta de documentos do usuário.

Para mostrar o diretório atual de trabalho, basta utilizar a função getwd:

# get current directory
my.dir <- getwd()

# print it
print(my.dir)
## C:/MyRBook-pt/Edition2/Book Content/

O resultado do código anterior mostra a pasta onde este livro foi escrito. Esse é o diretório onde os arquivos do livro foram compilados.

A mudança de diretório de trabalho é realizada através do comando setwd. Por exemplo, caso quiséssemos mudar o nosso diretório de trabalho para C:/Minha pesquisa/, basta digitar no prompt:

# set dir
my.d <- 'C:/Minha Pesquisa/'
setwd(my.d)

Enquanto para casos simples, como o anterior, lembrar o nome do diretório é fácil, em casos práticos o diretório de trabalho pode ser em um lugar mais profundo da raiz de diretórios do sistema de arquivos. Nessa situação, uma estratégia eficiente para descobrir a pasta de trabalho é utilizar um explorador de arquivos, tal como o Explorer no Windows. Abra esse aplicativo e vá até o local onde quer trabalhar com o seu script. Após isso, coloque o cursor na barra de endereço e selecione todo o endereço. Aperte control+c para copiar o endereço para a área de transferência. Volte para o seu código e cole o mesmo no código. Atenção nesta etapa, o Windows utiliza a barra invertida para definir endereços no computador, enquanto o R utiliza a barra normal. Caso tente utilizar a barra invertida, um erro será mostrado na tela. Veja o exemplo a seguir.

my.d <- 'C:\Minha pesquisa\'
setwd(my.d)

O erro terá a seguinte mensagem:

Error: '\M' is an unrecognized escape in character string starting "'C:\M"
Error in setwd(my.d) : object 'my.d' not found

A justificativa para o erro é que a barra invertida \ é um caractere reservado no R e não pode ser utilizado isoladamente. Caso precises, podes definí-lo no objeto de texto com dupla barra, tal como em \\. Veja no exemplo a seguir, onde a dupla barra é substituída por uma barra única:

# set char with \
my.char <- 'using \\'

# print it
cat(my.char)
## using \

A solução do problema é simples. Após copiar o endereço, modifique todas as barras para a barra normal, assim como no código a seguir:

my.d <- 'C:/Minha pesquisa/'
setwd(my.d)

É possível também utilizar barras invertidas duplas \\ na definição de diretórios, porém não se recomenda essa formatação, pois não é compatível com outros sistemas operacionais.

Outro ponto importante aqui é o uso de endereços relativos. Por exemplo, caso esteja trabalhando em um diretório que contém um subdiretório chamado Data, podes entrar nele com o seguinte código:

# change to subfolder
setwd('Data')

Outra possibilidade pouco conhecida no uso de setwd é que é possível entrar em níveis inferiores do sistema de diretórios com .., tal como em:

# change to previous level
setwd('..')

Portanto, caso estejas trabalhando no diretório C:/My Research/ e executar o comando setwd('..'), o diretório atual de trabalho viraria C:/, um nível inferior a C:/My Research/.

Uma maneira mais moderna, e pouco conhecida, de definir o diretório de trabalho é usar as funções internas do RStudio. Este é um conjunto de funções que só funcionam dentro do RStudio e fornecem diversas informações sobre o arquivo sendo editado. Para descobrir o caminho do arquivo atual que está sendo editado no RStudio e configurar o diretório de trabalho para lá, você pode escrever:

my.path <- dirname(rstudioapi::getActiveDocumentContext()$path)
setwd(my.path)

Dessa forma, o script mudará o diretório para sua própria localização. Apesar de não ser um código exatamente bonito, ele é bastante funcional. Caso copie o arquivo para outro diretório, o valor de my.path muda para o novo diretório. Esteja ciente, no entanto, de que esse truque só funciona no editor de rotinas do RStudio e dentro de um arquivo salvo. O código não funcionará a partir do prompt.

Outro truque bastante útil para definir diretórios de trabalho no R é usar o símbolo ~. Esse define a pasta 'Documentos' no Windows, a qual é única para cada usuário. Portanto, ao executar setwd('~'), irás direcionar o R a uma pasta de fácil acesso e livre modificação pelo usuário atual do computador.

2.16 Comentários no Código

Comentários são definidos usando o símbolo #. Qualquer texto a direita desse símbolo não será processados pelo R. Note que até a cor do código muda no editor. Isso dá liberdade para escrever o que for necessário dentro do script. Um exemplo:

# This is a comment
# This is another comment
x <- 'abc' # this is another comment, but mixed with code

my.l <- list(var1 = 1:10,   # set var 1
             var2 = 2:5)    # another var

Os comentários são uma maneira de comunicar qualquer informação importante que não pode ser inferida diretamente do código. O uso correto de comentários é tão importante quanto o código em si. Quando bem feitos, aumentam a reproducibilidade, organização e entendimento do código. Em geral, você deve evitar o uso de comentários que são muito óbvios ou muito genéricos. Por exemplo:

# read a .csv file
df <- read.csv ('MyDataFile.csv')

Como você pode ver, é bastante óbvio que a linha df <- read.csv('MyDataFile.csv') está lendo um arquivo .csv. O nome da função, read.csv já afirma isso. Então, o comentário não foi bom pois não adicionou novas informações ao usuário. Uma melhor abordagem seria definir o autor, a descrição da funcionalidade do script e explicar melhor a origem e a última atualização do arquivo de dados. Vamos dar uma olhada:

# Script for reproducing results of JOHN (2018)
# Author: Mr Researcher (dontspamme@emailprovider.com)
# Last script update: 2018-01-10
#
# File downloaded from www.sitewithdatafiles.com/data-files/
# The description of the data goes here
#
# Last file update: 2017-12-05
df <- read.csv('MyDataFile.csv')

Com esses comentários, o usuário saberá o propósito do script, quem o escreveu e a data da última edição. A origem do arquivo e a data de atualização mais recente também estão disponíveis. Se o usuário quiser atualizar os dados, tudo o que ele tem a fazer é ir ao mencionado site e baixar o novo arquivo. Isso facilitará o uso futuro e o compartilhamento do script.

Outro uso de comentários é definir seções no código, como em:

# Script for reproducing results of JOHN (2018)
# Author: Mr Researcher (dontspamme@emailprovider.com)
# Last script update: 2018-01-10
#
# File downloaded from www.sitewithdatafiles.com/data-files/
# The description of the data goes here
#
# Last file update: 2017-12-05

# Clean data -------------------------
# - remove outliers
# - remove unnecessary columns

# Create descriptive tables ----------


# Estimate models --------------------


# Report results ---------------------

O uso de uma longa linha de traços (-) é intencional. Isto faz com que o RStudio identifique as seções do código e apresente no espaço abaixo do editor de rotinas um atalho para acessar as correspondentes linhas de cada seção. Teste você mesmo, copie e cole o código acima em um novo script do R, salve o mesmo, e verás que as seções aparecem em um botão entre o editor e o prompt. Desta forma, uma vez que você precisa mudar uma parte específica do código, você pode procurar a seção rapidamente.

Quando começar a compartilhar código com outras pessoas, logo perceberás que os comentários são essenciais e esperados. Eles ajudam a transmitir informações que não estão disponíveis no código. Uma nota aqui, ao longo do livro você verá que os comentários do código são, na maior parte do tempo, bastante óbvios. Isso foi intencional, pois mensagens claras e diretas são importantes para novos usuários, os quais fazem parte da audiência deste livro.

2.17 Cancelando a Execução de um Código

Toda vez que o R estiver executando algum código, uma sinalização visual no formato de um pequeno círculo vermelho no canto direito do prompt irá aparecer. Caso conseguir ler, o texto indica o termo stop. Esse símbolo não somente indica que o programa ainda está rodando mas também pode ser utilizado para cancelar a execução de um código. Para isso, basta clicar no botão. Outra maneira de cancelar uma execução é apontar o mouse no prompt e pressionar a tecla Esc, no canto esquerdo superior do teclado.

Para testar o cancelamento de código, copie e cole o código a seguir em um script do RStudio. Após salvar, rode o mesmo com control+shift+s.

for (i in 1:100) {
  cat('\nRunning code (please make it stop by hitting esc!)')
  Sys.sleep(1)
}

O código anterior usa um comando especial do tipo for para mostrar a mensagem a cada segundo. Neste caso, o código demorará 100 segundos para rodar. Caso não desejes esperar, aperte esc para cancelar a execução. Por enquanto, não se preocupe com as funções utilizadas no exemplo. Iremos discutir o uso do comando for no capítulo 8.

2.18 Procurando Ajuda

Uma tarefa muito comum no uso do R é procurar ajuda. Até mesmo usuários avançados comumente procuram ajuda sobre tarefas específicas no programa, seja para entender detalhes sobre algumas funções ou estudar um novo procedimento. O uso do sistema de ajuda do R faz parte do cotidiano.

É possível buscar ajuda utilizando tanto o painel de help do RStudio como diretamente do prompt. Para isso, basta digitar o ponto de interrogação junto ao objeto sobre o qual se deseja ajuda, tal como em ?mean. Nesse caso, o objeto mean é uma função e o uso do comando irá abrir o painel de ajuda sobre ela.

No R, toda tela de ajuda de uma função é igual, conforme se vê na Figura 2.5 apresentada a seguir. Esta mostra uma descrição da função mean, seus argumentos de entrada explicados e também o seu objeto de saída. A tela de ajuda segue com referências e sugestões para outras funções relacionadas. Mais importante, os exemplos de uso da função aparecem por último e podem ser copiados e colados para acelerar o aprendizado no uso da função.

Tela de ajuda da função mean

Figura 2.5: Tela de ajuda da função mean

Caso quiséssemos procurar um termo nos arquivos de ajuda, bastaria utilizar o comando ??"standard deviation". Essa operação irá procurar a ocorrência do termo em todos os pacotes do R e é muito útil para aprender como realizar alguma operação, nesse caso o cálculo de desvio-padrão.

Como sugestão, o ponto inicial e mais direto para aprender uma nova função é observando o seu exemplo de uso, localizada no final da página de ajuda. Com isto, podes verificar quais tipos de objetos de entrada a mesma aceita e qual o formato e o tipo de objeto na sua saída. Após isso, leia atentamente a tela de ajuda para entender se a mesma faz exatamente o que esperas e quais são as suas opções de uso nas respectivas entradas. Caso a função realizar o procedimento desejado, podes copiar e colar o exemplo de uso para o teu próprio script, ajustando onde for necessário.

Outra fonte muito importante de ajuda é a própria internet. Sites como stackoverflow e mailing lists específicos do R, cujo conteúdo também está na internet, são fontes preciosas de informação. Havendo alguma dúvida que não foi possível solucionar via leitura dos arquivos de ajuda do R, vale o esforço de procurar uma solução via mecanismo de busca na internet. Em muitas situações, o seu problema, por mais específico que seja, já ocorreu e já foi solucionado por outros usuários.

Caso estiver recebendo uma mensagem de erro enigmática, vale copiar e colar a mesma para uma pesquisa no Google. Aqui apresenta-se outro benefício do uso da língua inglesa. É mais provável que encontres a solução se o erro for escrito inglês, dado o maior número de usuários. Caso não encontrar uma solução desta forma, podes inserir uma pergunta no stackoverflow ou no grupo Brasileiro do R no Facebook. Uma sugestão aqui é que poste junto um exemplo reproduzível do seu problema, de forma a facilitar a reconstituição da mensagem de erro. Veja um tutorial sobre isto neste link.

2.19 Pacotes do R

Um dos grandes benefícios do uso do R é o seu acervo de pacotes. Esses representam um conjunto de procedimentos agrupados em uma coleção de funções e voltados para a resolução de um problema qualquer. O R tem em sua essência uma filosofia de colaboração. Usuários disponibilizam os seus códigos para outras pessoas utilizarem. E, mais importante, todos os pacotes são gratuitos, assim como o R. Por exemplo, considere um caso em que está interessado em baixar dados da internet sobre o desemprego histórico no Brasil. Para isso, basta procurar e instalar o pacote específico que realiza esse procedimento.

Esses pacotes podem ser instalados de diferentes fontes, com as principais sendo CRAN (The Comprehensive R Archive Network), R-Forge e Github. A cada dia aumenta a quantidade e diversidade de pacotes existentes para o R. O próprio autor deste livro possui diversos pacotes disponíveis no CRAN, cada um para resolver algum problema diferente. Na grande maioria, são pacotes para importar e organizar dados financeiros.

O CRAN é o repositório oficial do R e é livre. Qualquer pessoa pode enviar um pacote e todo código enviado está disponível na internet. Existe, porém, um processo de avaliação que o código passa e certas normas rígidas devem ser respeitadas sobre o formato do código, o manual do usuário e a forma de atualização do pacote. Para quem tiver interesse, um tutorial claro e fácil de seguir é apresentado no site http://r-pkgs.had.co.nz/intro.html. As regras completas estão disponíveis no site do CRAN - https://cran.r-project.org/web/packages/policies.html. A adequação do código a essas normas é responsabilidade do desenvolvedor e gera um trabalho significativo, principalmente na primeira submissão.

A lista completa de pacotes disponíveis no CRAN, juntamente com uma breve descrição, pode ser acessada no link packages do site do R - https://cran.r-project.org/. Uma maneira prática de verificar a existência de um pacote para um procedimento específico é carregar a página anterior e procurar no seu navegador de internet a palavra-chave que define o seu procedimento. Caso existir o pacote com a palavra-chave, a procura acusará o encontro do termo na descrição do pacote.

Outra fonte importante para o encontro de pacotes é o Task Views, em que são destacados os principais pacotes de acordo com a área e o tipo de uso. Veja a tela do Task Views na Figura .

Tela do Task Views

Figura 2.6: Tela do Task Views

Ao contrário do CRAN, o R-Forge e o Github não possuem restrição quanto ao código enviado e, devido a isso, tendem a ser escolhidos por alguns desenvolvedores. A responsabilidade de uso, porém, é do próprio usuário. Na prática, é muito comum os desenvolvedores manterem uma versão em desenvolvimento no Github e outra oficial no CRAN. Quando a versão em desenvolvimento atinge um estágio de maturidade, a mesma é enviada ao CRAN.

O mais interessante no uso de pacotes é que estes podem ser acessados e instalados diretamente no R via a internet. Para saber qual é a quantidade atual de pacotes no CRAN, digite e execute os seguintes comandos no prompt:

# find current available packages
df.cran.pkgs <- available.packages()

# get size of matrix
n.cran.packages <- nrow(df.cran.pkgs)

# print it
print(n.cran.packages)
## [1] 16065

Atualmente, 2020-07-30 09:08:04, existem 16065 pacotes disponíveis nos servidores do CRAN.

Também se pode verificar a quantidade de pacotes localmente instalados com o comando installed.packages():

# get number of local (installed) packages
n.local.packages <- nrow(installed.packages())

# print it
print(n.local.packages)
## [1] 438

Nesse caso, o computador em que o livro foi escrito possui 438 pacotes do R instalados. Note que, apesar do autor ser um experiente programador do R, apenas uma pequena fração do pacotes disponíveis no CRAN está sendo usado! Esse valor é provavelmente diferente do seu. Sugere-se rodar esses códigos para verificar o número de pacotes instalados na sua máquina.

2.19.1 Instalando Pacotes do CRAN

Para instalar um pacote, basta utilizar o comando install.packages. Como exemplo, vamos instalar um pacote que será utilizado nos capítulos futuros, o readr:

# install pkg readr
install.packages('readr')

Copie e cole este comando no prompt e pronto! O R irá baixar os arquivos necessários e instalar o pacote readr e suas dependências. Após isto, as funções relativas ao pacote estarão prontas para serem usadas. Observe que definimos o nome do pacote na instalação como se fosse texto, com o uso das aspas ("). Caso o pacote instalado seja dependente de outro pacote, o R automaticamente instala o mesmo. Assim, todos os requerimentos para o uso do respectivo pacote já serão satisfeitos e tudo funcionará perfeitamente. É possível, porém, que um pacote tenha uma dependência externa. Como um exemplo, o pacote RndTexExams depende da existência de uma instalação do LaTex. Geralmente essa é anunciada na sua descrição e um erro é sinalizado na execução do programa quando o LaTex não é encontrado. Fique atento, portanto, a esses casos.

Aproveitando o tópico, sugiro que o leitor já instale todos os pacotes do tidyverse com o seguinte código:

# install pkgs from tidyverse
install.packages('tidyverse')

2.19.2 Instalando Pacotes do Github

Para instalar um pacote diretamente do Github, é necessário instalar antes o pacote devtools, disponível no CRAN:

# install devtools
install.packages('devtools')

Após isto, utilize função devtools::install_github para instalar um pacote diretamente do Github. No exemplo a seguir instalamos a versão em desenvolvimento do pacote ggplot2, cuja versão oficial também está disponível no CRAN:

# install ggplot2 from github
devtools::install_github("hadley/ggplot2")

Observe que o nome do usuário do repositório também é incluído. No caso anterior, o nome hadley pertence ao desenvolvedor do ggplot2, Hadley Wickham. No decorrer do livro notará que esse nome aparecerá diversas vezes, dado que Hadley é um prolífico e competente desenvolvedor de diversos pacotes do R.

Um aviso aqui é importante. Os pacotes do github não são moderados. Qualquer pessoa pode enviar código para lá e o conteúdo não é checado de forma independente. Nunca instale pacotes do github sem conhecer os autores. Apesar de improvável, é possível que esses possuam código malicioso.

2.19.3 Carregando Pacotes

Dentro de uma rotina de pesquisa, utilizamos a função library para carregar um pacote. Cada pacote deve ser carregado a cada sessão. Alguns pacotes, tal como o base com os comandos básicos do R, são inicializados automaticamente. A grande maioria, porém, deve ser carregada no início dos scripts. Veja o exemplo a seguir:

# load dplyr
library(dplyr)

A partir disso, todas as funções do pacote estarão disponíveis para o usuário. Note que não é necessário utilizar aspas (") ao carregar o pacote. Caso utilize uma função específica do pacote e não deseje carregar todo ele, pode fazê-lo através do uso do símbolo especial ::, conforme o exemplo a seguir.

# call fct fortune() from pkg fortune
fortunes::fortune(10)
## 
## Overall, SAS is about 11 years behind R and S-Plus in
## statistical capabilities (last year it was about 10 years
## behind) in my estimation.
##    -- Frank Harrell (SAS User, 1969-1991)
##       R-help (September 2003)

Nesse caso, utilizamos a função fortune do próprio pacote fortunes, o qual mostra na tela uma frase possivelmente engraçada escolhida do mailing list do R. Nesse caso, selecionamos a mensagem número 10. Se não tiver disponível o pacote, o R mostrará a seguinte mensagem de erro:

## Error in library("fortune") : there is no package called "fortune"

Para resolver, utilize o comando install.packages("fortunes") para instalar o pacote no seu computador. Execute o código fortunes::fortune(10) no prompt para confirmar a instalação. Toda vez que se deparar com essa mensagem de erro, deves instalar o pacote que está faltando.

Outra maneira de carregar um pacote é através da função require. Essa tem um comportamento diferente da função library e deve ser utilizada dentro da definição de funções. Caso o usuário crie uma função customizada que necessite de procedimentos de um pacote em particular, o mesmo deve carregar o pacote no escopo da função. Por exemplo, veja o código a seguir, em que criamos uma função dependente do pacote quantmod:

my.fct <- function(x){
  require(quantmod)

  df <- getSymbols(x, auto.assign = F)
  return(df)
}

Nesse caso, a função getSymbols faz parte do pacote quantmod. Não se preocupe agora com a estrutura utilizada para criar uma função no R. Essa será explicada em capítulo futuro.

2.19.4 Atualizando Pacotes

Ao longo do tempo, é natural que os pacotes disponibilizados no CRAN sejam atualizados para acomodar novas funcionalidades ou se adaptar a mudanças em suas dependências, como uma mudança no código base do R. Assim, é recomendável que os usuários atualizem os seus pacotes instalados para uma nova versão através da internet. Esse procedimento é bastante fácil. Uma maneira direta de atualizar pacotes é clicar no botão update no painel de pacotes no canto direito inferior do RStudio, conforme mostrado na figura 2.7.

Atualizando pacotes no R

Figura 2.7: Atualizando pacotes no R

A atualização de pacotes através do prompt também é possível. Para isso, basta utilizar o comando update.packages, conforme mostrado a seguir.

update.packages()

O comando update.packages() compara a versão dos pacotes instalados em relação a versão disponível no CRAN. Caso tiver alguma diferença, a nova versão é instalada. Após a execução do comando, todos os pacotes estarão atualizados com a versão disponível nos servidores do CRAN.

2.20 Utilizando Code Completion com a Tecla tab

Um dos recursos mais úteis do RStudio é o preenchimento automático de código (code completion). Essa é uma ferramenta de edição que facilita o encontro de nomes de objetos, nome de pacotes, nome de arquivos e nomes de entradas em funções. O seu uso é muito simples. Após digitar um texto qualquer, basta apertar a tecla tab e uma série de opções aparecerá. Veja a Figura 2.8 apresentada a seguir, em que, após digitar a letra f e apertar tab, aparece uma janela com uma lista de objetos que iniciam com a respectiva letra.

Uso do autocomplete para objetos

Figura 2.8: Uso do autocomplete para objetos

Essa ferramenta também funciona para pacotes. Para verificar, digite library(r) no prompt ou no editor, coloque o cursor entre os parênteses e aperte tab. O resultado deve ser algo parecido com a figura 2.9, mostrada a seguir.

Uso do autocomplete para pacotes

Figura 2.9: Uso do autocomplete para pacotes

Observe que uma descrição do pacote ou objeto também é oferecida. Isso facilita bastante o dia a dia, pois a memorização das funcionalidades e dos nomes dos pacotes e os objetos do R não é uma tarefa fácil. O uso do tab diminui o tempo de investigação dos nomes e evita possíveis erros de digitação na definição destes.

O uso dessa ferramenta torna-se ainda mais benéfico quando os objetos são nomeados com algum tipo de padrão. No restante do livro observarás que os objetos tendem a ser nomeados com o prefixo my., como em my.x, my.num. O uso desse padrão facilita o encontro futuro do nome dos objetos, pois basta digitar my., apertar tab e uma lista de todos os objetos criados pelo usuário aparecerá.

Outro uso do tab é no encontro de arquivos e pastas no computador. Basta criar uma variável como my.file <- " ", apontar o cursor para o meio das aspas e apertar a tecla tab. Uma tela com os arquivos e pastas do diretório atual de trabalho aparecerá, conforme mostrado na figura 2.10. Nesse caso específico, o R estava direcionado para a minha pasta de códigos, em que é possível enxergar diversos trabalhos realizados no passado.

Uso do autocomplete para arquivos

Figura 2.10: Uso do autocomplete para arquivos

Uma dica aqui é utilizar o tab com a raiz do computador. Assumindo que o disco do seu computador está alocado para C:/, digite my.file <- "C:/" e pressione tab após o símbolo /. Uma tela com os arquivos da raiz do computador aparecerá no RStudio. Podes facilmente navegar o sistema de arquivos utilizando as setas e enter.

O autocomplete também funciona para encontrar e definir as entradas de uma função. Por se tratar de um tópico mais avançado, deixamos o seu uso e demonstração para o capítulo 8.

2.21 Interagindo com Arquivos e o Sistema Operacional

Em muitas situações de uso do R será necessário interagir com os arquivos do computador, seja criando novas pastas, descompactando e compactando arquivos, listando e removendo arquivos do disco rígido do computador ou qualquer outro tipo de operação. Na grande maioria dos casos, o interesse é na manipulação de arquivos contendo dados.

2.21.1 Listando Arquivos e Pastas

Para listar arquivos do computador, basta utilizar o função list.files. O argumento path define o diretório para listar os arquivos. Na construção deste livro foi criado um diretório chamado data. Esse contém todos os dados necessários para recriar os exemplos do livro. Pode-se verificar os arquivos nessa pasta com o seguinte código:

my.f <- list.files(path = "data", full.names = TRUE)
print(my.f)
##  [1] "data/AdjustedPrices-InternacionalIndices.RDATA"                
##  [2] "data/BGS_Cache"                                                
##  [3] "data/BovStocks_2011-12-01_2016-11-29.csv"                      
##  [4] "data/BovStocks_2011-12-01_2016-11-29.RData"                    
##  [5] "data/example_gethfdata.RDATA"                                  
##  [6] "data/FileWithLatinChar_ISO-8859-9.txt"                         
##  [7] "data/FileWithLatinChar_UTF-8.txt"                              
##  [8] "data/FileWithLatinChar.txt"                                    
##  [9] "data/grunfeld.csv"                                             
## [10] "data/HFData_6_Assets_15 min.RData"                             
## [11] "data/HFData_equity_6_Assets_15 min_2016-09-12_2016-09-30.RData"
## [12] "data/HFData.csv"                                               
## [13] "data/Ibov_xls.xlsx"                                            
## [14] "data/Ibov_xlsx.xlsx"                                           
## [15] "data/Ibov.csv"                                                 
## [16] "data/IbovStocks_long.csv"                                      
## [17] "data/MktIndices_and_Symbols.csv"                               
## [18] "data/MySQLiteDatabase.SQLITE"                                  
## [19] "data/Ret_BR.csv"                                               
## [20] "data/SP500_2011-11-13_2016-11-11.csv"                          
## [21] "data/SP500-Excel.xlsx"                                         
## [22] "data/SP500-Stocks_long.csv"                                    
## [23] "data/SP500-Stocks_wide.csv"                                    
## [24] "data/SP500-Stocks-WithRet.RData"                               
## [25] "data/SP500-Stocks-WithRet.rds"                                 
## [26] "data/SP500.csv"                                                
## [27] "data/TDData.csv"                                               
## [28] "data/temp_fst.fst"                                             
## [29] "data/temp_rds.rds"                                             
## [30] "data/temp_writexl.xlsx"                                        
## [31] "data/temp_xlsx.xlsx"                                           
## [32] "data/temp_xts.RData"                                           
## [33] "data/temp.csv"                                                 
## [34] "data/temp.fst"                                                 
## [35] "data/temp.RData"                                               
## [36] "data/temp.rds"                                                 
## [37] "data/temp.txt"                                                 
## [38] "data/temp.xlsx"

Observe que nesse diretório encontram-se vários arquivos .csv, .rds e .xlsx. Esses contêm dados que serão utilizados em capítulos futuros a respeito da importação e exportação de dados. Recomenda-se utilizar o argumento full.names como TRUE, o qual faz com que o retorno da função list.files contenha o caminho completo do arquivo. Isso facilita, por exemplo, uma possível importação de dados em que é necessário indicar não somente o nome do arquivo, mas a sua localização completa no computador. Destaca-se que também é possível listar os arquivos de forma recursiva, isto é, listar os arquivos de subpastas do endereço original. Para verificar, tente utilizar o seguinte código no seu computador:

# list all files recursively
list.files(path = getwd(), recursive = T, full.names = TRUE)

O comando anterior irá listar todos os arquivos existentes na pasta atual e subpastas de trabalho. Dependendo de onde o comando foi executado, pode levar um certo tempo para o término do processo. Caso precisar cancelar a execução, aperte esc no teclado.

Para listar pastas (diretórios) do computador, basta utilizar o comando list.dirs. Veja a seguir.

# list directories
my.dirs <- list.dirs(recursive = F)
print(my.dirs)
##  [1] "./_book"                       
##  [2] "./_bookdown_files"             
##  [3] "./.Rproj.user"                 
##  [4] "./BGS_Cache"                   
##  [5] "./css"                         
##  [6] "./data"                        
##  [7] "./DFP Cache Folder"            
##  [8] "./eqs"                         
##  [9] "./fig_ggplot"                  
## [10] "./figs"                        
## [11] "./ftp files"                   
## [12] "./html_files"                  
## [13] "./images"                      
## [14] "./latex_files"                 
## [15] "./many_datafiles"              
## [16] "./Other scripts"               
## [17] "./ProcAnFinDataR_pt_ed_2_cache"
## [18] "./ProcAnFinDataR_pt_ed_2_files"
## [19] "./Scripts"                     
## [20] "./tabs"                        
## [21] "./TD Files"

No caso anterior, o comando lista todos os diretórios do trabalho atual sem recursividade. A saída do comando mostra os diretórios que utilizei para escrever este livro. Isso inclui o diretório de saída do livro (./_book), o diretório com os dados (./data), entre outros. Nesse mesmo diretório, encontram-se os capítulos do livro, organizados por arquivos e baseados na linguagem RMarkdown (.Rmd). Para listar somente os arquivos com extensão .Rmd, utiliza-se o argumento pattern da função list.files, como a seguir:

list.files(pattern = "*.Rmd$")
##  [1] "_BemVindo.Rmd"                            
##  [2] "00a-Sobre-NovaEdicao.Rmd"                 
##  [3] "00b-Prefacio.Rmd"                         
##  [4] "01-Introducao.Rmd"                        
##  [5] "02-Operacoes-Basicas.Rmd"                 
##  [6] "03-Scripts-Pesquisa.Rmd"                  
##  [7] "04-Importacao-Exportacao-Local.Rmd"       
##  [8] "05-Importacao-Internet.Rmd"               
##  [9] "06-Objetos-Armazenamento-ONLINE.Rmd"      
## [10] "07-Objetos-Basicos-ONLINE.Rmd"            
## [11] "08-Programacao-com-R-ONLINE.Rmd"          
## [12] "09-Limpando-Estruturando-Dados-ONLINE.Rmd"
## [13] "10-Figuras-ONLINE.Rmd"                    
## [14] "11-Modelagem-ONLINE.Rmd"                  
## [15] "12-Reportando-resultados-ONLINE.Rmd"      
## [16] "13-Exemplos-Pesquisa-ONLINE.Rmd"          
## [17] "14-Referencias.Rmd"                       
## [18] "index.Rmd"                                
## [19] "ProcAnFinDataR_pt_ed_2.Rmd"

O texto *.Rmd$ orienta o R a procurar todos arquivos que terminam o seu nome com o texto .Rmd. Os símbolos '*'' e '$' são operadores específicos para o encontro de padrões em texto em uma linguagem chamada regex (regular expressions). Os arquivos apresentados anteriormente contêm todo o conteúdo deste livro, incluindo este próprio parágrafo, localizado no arquivo 02-OperacoesBasicas.Rmd!

2.21.2 Apagando Arquivos e Diretórios

A remoção de arquivos é realizada através do comando file.remove:

# create temporary file
my.file <- 'data/tempfile.csv'
write.csv(x = data.frame(x=1:10),
          file = my.file)

# delete it
file.remove(my.file)
## [1] TRUE

Lembre-se que deves ter permissão do seu sistema operacional para apagar um arquivo. Para o nosso caso, o retorno TRUE mostra que a operação teve sucesso.

Para deletar diretórios e todos os seus elementos, utilizamos unlink:

# create temp dir
dir.create('temp')

# fill it with file
my.file <- 'temp/tempfile.csv'
write.csv(x = data.frame(x=1:10),
          file = my.file)

unlink(x = 'temp', recursive = TRUE)

A função, neste caso, não retorna nada. Podes checar se o diretório existe com dir.exists:

dir.exists('temp')
## [1] FALSE

2.21.3 Baixando Arquivos da Internet

O R pode baixar arquivos da Internet diretamente no código. Isso é realizado com a função download.file. Veja o exemplo a seguir, onde baixamos uma planilha de Excel do site da Microsoft:

# set link
link.dl <- 'go.microsoft.com/fwlink/?LinkID=521962'
local.file <- 'temp_file.xlsx' # name of local file

download.file(url = link.dl,
              destfile = local.file)

O uso de download.file é bastante prático quando se está trabalhando com dados da Internet que são constantemente atualizados. Basta baixar e atualizar o arquivo com dados no início do script. Poderíamos continuar a rotina lendo o arquivo baixado e realizando a nossa de análise.

Um exemplo nesse caso é a tabela de empresas listadas na bolsa divulgada pela CVM (comissão de valores mobiliários). A tabela está disponível em um arquivo zipado no site. Podemos baixar o arquivo, descompactá-lo e depois ler a tabela para analisar os dados.

library(readr)
library(dplyr)

# set destination link and file
my.link <- 'http://sistemas.cvm.gov.br/cadastro/SPW_CIA_ABERTA.ZIP'
my.destfile <- 'temp.zip'

# download file
download.file(my.link, destfile = my.destfile)

# read it
df.cvm <- read_delim(my.destfile,
                     delim = '\t',
                     locale = locale(encoding = 'Latin1'))

# delete temp file
file.remove(my.destfile)
## [1] TRUE
# check available columns
print(names(df.cvm))
##  [1] "CD_CVM"             "DENOM_SOCIAL"      
##  [3] "DENOM_COMERC"       "SETOR_ATIV"        
##  [5] "PF_PJ"              "CNPJ"              
##  [7] "DT_REG"             "DT_CONST"          
##  [9] "DT_CANCEL"          "MOTIVO_CANCEL"     
## [11] "SIT_REG"            "DT_INI_SIT"        
## [13] "SIT_EMISSOR"        "DT_INI_SIT_EMISSOR"
## [15] "CATEG_REG"          "DT_INI_CATEG"      
## [17] "AUDITOR"            "CNPJ_AUDITOR"      
## [19] "TP_ENDER"           "LOGRADOURO"        
## [21] "COMPL"              "BAIRRO"            
## [23] "CIDADE"             "UF"                
## [25] "PAIS"               "CD_POSTAL"         
## [27] "TEL"                "FAX"               
## [29] "EMAIL"              "TP_RESP"           
## [31] "RESP"               "DT_INI_RESP"       
## [33] "LOGRADOURO_RESP"    "COMPL_RESP"        
## [35] "BAIRRO_RESP"        "CIDADE_RESP"       
## [37] "UF_RESP"            "PAIS_RESP"         
## [39] "CEP_RESP"           "TEL_RESP"          
## [41] "FAX_RESP"           "EMAIL_RESP"        
## [43] "TP_MERC"

Existem diversas informações interessantes nestes dados. E, mais importante, o arquivo está sempre atualizado. O código anterior estará sempre buscando os dados mais recentes a cada execução.

2.21.4 Utilizando Arquivos e Diretórios Temporários

Um aspecto interessante do R é que ele possui um folder temporário que é criado na inicialização do programa. Esse folder serve para guardar quaisquer arquivos descartáveis gerados pelo R. A cada nova sessão do R, um novo diretório temporário é criado. O endereço atual desse diretório é verificado com tempdir:

windows.tempdir <- tempdir()
print(windows.tempdir)
## C:\Users\MARCEL~1\AppData\Local\Temp\Rtmp8Emo2H

O último texto do diretório, neste caso 'Rtmp8Emo2H' é aleatóriamente definido e irá trocar a cada nossa sessão do R. Ao reinicializarmos o computador, todas pastas temporárias serão deletadas.

A mesma dinâmica é encontrada para nomes de arquivos. Caso queira, por algum motivo, utilizar um nome temporário e aleatório para algum arquivo, utilize tempfile:

windows.tempfile <- tempfile()
cat(windows.tempfile)
## C:\Users\MARCEL~1\AppData\Local\Temp\Rtmp8Emo2H\file33f84f149a2b

Um caso prático no uso de tempfile é o download da planilha Excel anterior. Dado que iremos sobrescrever o arquivo a cada execução de código, não precisamos manter o mesmo na pasta de trabalho. Podemos então baixar o arquivo na pasta temporária, a qual será apagada futuramente. Veja a seguir:

# set link
link.dl <- 'go.microsoft.com/fwlink/?LinkID=521962'
local.file <- paste0(tempfile(),'.xlsx')

download.file(url = link.dl,
              destfile = local.file)

Nesse caso, não precisamos apagar o arquivo pois o mesmo será removido do disco rígido do computador quando reinicializarmos o sistema.

2.22 Exercícios

  1. Crie um novo script, salve o mesmo em uma pasta pessoal e defina dois objetos: um contendo uma sequência entre 1 e 100 e outro com o texto do seu nome (ex. 'Ricardo'). Execute o código com os atalhos no teclado.

  2. No script anterior, use o objeto de texto criado e mostre a seguinte frase no prompt do R: "My name is ....".

  3. Verifique qual o diretório de trabalho atual da sua sessão do R. Modifique o diretório de trabalho para a área de Desktop e mostre na tela a seguinte mensagem: 'My desktop address is ....'.

  4. Utilize o R para baixar o arquivo compactado com o material do livro, disponível em https://www.msperlin.com/blog/files/padfer%20files/Codigos_Dados_padfeR_ed2.zip. Salve o mesmo como um arquivo na pasta temporária da sessão (veja função tempdir).

  5. Utilize a função unzip para descompactar o arquivo baixado na questão anterior e, após a operação, utilize função file.remove para remover o arquivo zipado do computador, após a sua descompactação. Quantos arquivos estão disponíveis no arquivo zipado?

  6. Toda vez que o usuário instala um pacote do R, os arquivos desse são armazenados localmente em uma pasta específica do computador. Utilizando comando Sys.getenv('R_LIBS_USER') e list.dirs, liste todos os diretórios desta pasta. Quantos pacotes estão disponíveis nesta pasta?

  7. No mesmo assunto do exercício anterior, liste todos os arquivos em todas as subpastas do diretório contendo os arquivos dos diferentes pacotes. Em média, quantos arquivos são necessários para cada pacote?

TODO: CHECAR EXERCICIO NO WINDOWS!!

  1. Instale pacote GetTDData no seu computador. Leia o manual do pacote e utilize a função GetTDData::get.yield.curve para baixar a curva de juros atual no sistema financeiro Brasileiro. Verifique o exemplo de uso da função para entender como utilizá-la.

  2. Utilizando pacote devtools, instale a versão de desenvolvimento do pacote ggplot2 no repositório de Hadley Hickman. Carregue o pacote usando library e crie uma figura simples com o código qplot(y = rnorm(10), x = 1:10).

  3. DESAFIO - Utilizando sua capacidade de programação, verifique no seu computador qual pasta, a partir do diretório de raiz, possui o maior número de arquivos. Apresente na tela do R as cinco pastas com maior número de arquivos.

Referências

Xie, Yihui. 2016. Bookdown: Authoring Books and Technical Documents with R Markdown. CRC Press.