Curso R para Análise de Dados
Antônio Barreira
Aula 1 - Introdução
Para executar a linha de código em que se encontra no script, digite Ctrl+ENTER. Já no console, basta ENTER.
| Atalhos | |
|---|---|
| Executar atual linha de comando no script | Ctrl+Enter |
| Executar atual chuck inteiro | Ctrl+shift+Enter |
| Executar tudo no script | Ctrl+Alt+R |
| Dar um “knit” | Ctrl+Shift+K |
Pode-se criar um objeto (aqui sendo denominado “vetor”) seguinte maneira:
Vetor <- 1:10
Vetor = c(1:10)Os objetos criados podem ser verificados no environment. Perceber que a nomeação e a recuperação de objetos é case-sensitive. Pode-se verificar de onde os dados estão sendo “puxados” e armazenados com getwd(). Caso os dados não estejam vinculados ao local desejado, pode-se vinculá-los com setwd(). Objetos podem ser removidos do environment com rm(). Caso se queria remover todos os objetos do enviroment, pode-se utilizar `rm(list=ls())``.
setwd("C:/Users/amsba/OneDrive/Documentos/Curso_AnaliseMacro/AD01-1")Aula 2
Pacotes Básicos
Pacotes são coleções de funções que fazem alguma coisa no R. Via de regra, a instalação é feita pelo CRAN. Uma vez instalados no R, os pacotes ficam em sua respectiva library. Instala-se pacotes com a função install.packages().
install.packages('fBasics')Não é necessário reinstalar o pacote toda vez que for utilizá-lo, mas pode ser necessário “convocá-lo”. 
A diferença entre library e require é sutil: “The library() by default returns an error if the requested package does not exist. The require() is designed to be used inside functions as it gives a warning message and returns a logical value say, FALSE if the requested package is not found and TRUE if the package is loaded”. (…) Using require in custom functions is better practice than library, since require returns warning and FALSE, unlike library, which returns error if you provide a name of non-existent package.
Outra opção é usar ::, seguido da função desejada (por exemplo, pacote::funcao()). Neste caso, porém, apenas a função especificada é carregada. “The :: operator gets the variable from the package, while require loads whole package (…). The :: should be reserved for cases when you have naming conflicts between packages”.
# As duas funções fazem a mesma coisa:
require(fBasics)
library(fBasics)Para se usar pacotes em desenvolvimento do github, é necessário o Devtools.
install.packages('devtools')
require(devtools)
install_github("pedrocostaferreira/BETS")
install.packages('Rtools')Via de regra o melhor é utilizar a versão mais recente de um determinado pacote, mas as vezes pode ser necessário utilizar uma versão anterior do pacote que está no CRAN.
install_version("DBI",
version = "0.5",
repos = "http://cran.us.r-project.org")Caso ocorra “caminho inválido” ao se instalar um pacote, pode-se especificá-lo:
library(withr)
with_libpaths(new = "C:/Program Files/R/R-3.4.1/library",
install_github("StatsWithR/statsr"))Instalador de pacotes
install.packages('pacman')
install.packages('zoo')
#series temporais
install.packages('xts')O pacman permite instalar vários pacotes de uma vez só com a função p_load(), p.ex.:
p_load("timetk","janitor","here")Introdução ao Tidyverse
Instalando a família de pacotes do tidyverse
O que é o tidyverse?
O “arrumaverse” é uma coleção de pacotes R de código aberto introduzidos por Hadley Wickham e sua equipe que “compartilham uma filosofia de design, gramática e estruturas de dados subjacentes” de dados organizados.
# install.packages('tidyverse')
require(tidyverse)Aula 3 - Importações
O pacote readr. Não confundir read_csv() com read.csv
library(readr)
read_csv() #lê arquivos com separação com vírgulas
read_csv2() #lê arquivos separados com ponto-e-vírgula
read_delim() #lê arquivos com qualquer tipo de separação
read_fwf() #lê arquivos com distância fixa
read_table() #faz isso com arquivos separados por espaços em braco - muito comum para bases disponibilizadas em extensão .txt.
read_log() #lê arquivos em estilo Apache de logsTibbles
Tibbles são espécies de dataframes que são mais rápidos. Por exemplo, vejamos a criação do objeto heights
heights <- read_csv("heights.csv")Uma vez importado, basta digitar o nome atribuído para ver um resumo dos dados
heightsO modo tradicional é usando View() (Atentar-se para o “V” maiúsculo, lembre-se que a gramática das funções é case sensitive).
View(heights)Especificando os tipos de dados das colunas:
mtcars <- read_csv(readr_example("mtcars.csv"), col_types =
cols(
mpg = col_double(),
cyl = col_integer(),
disp = col_double(),
hp = col_integer(),
drat = col_double(),
vs = col_integer(),
wt = col_double(),
qsec = col_double(),
am = col_integer(),
gear = col_integer(),
carb = col_integer()
)
)Outro exemplo, agora com read_csv2():
# skip pula linhas (as vezes os arquivos tem cabeçalhos, como os do IBGE)
# col_names adiciona uma linha cabeçalho
# col_types indica qual o tipo de variável (coluna)
sidra = read_csv2('sidra.csv', skip=5,
col_names = c('mes', 'vendas', 'vendas_sa',
'receita', 'receita_sa'),
col_types =
cols(
mes = col_date(format='%d/%m/%Y'),
vendas = col_double(),
vendas_sa = col_double(),
receita = col_double(),
receita_sa = col_double()),
locale=locale(decimal_mark = ','))
View(sidra)Como o R analisa um vetor (função parse). Ver com ?parse_logical o argumento locale para usar es_MX, en_US, pt_BR, etc. O parse é a maneira de entender usada pelo R para entender cada coisa
str(parse_logical(c('TRUE','FALSE','NA')))
str(parse_date(c('2010-01-01','1979-10-14')))
str(parse_integer(c('1','231','.','456'),na='.'))
parse_double('1,23')
parse_double('1,23', locale = locale(decimal_mark = ','))
#por exemplo: col_double(decimal_mark = ",")
parse_number('$100')
parse_number('20%')
parse_number('1.200,86',locale = locale(decimal_mark = ',',
grouping_mark = '.'))Strings:
O charToRaw mostra o código hexadecimal do string. Há uma relação entre o hexadecimal e o caractere (encoding). Isso pode ser uma forma de contornar o inglês:
parse_character('Seção', locale = locale(encoding = 'Latin1'))
charToRaw('Seção')#Exemplo
parse_character('Seção',locale = locale(encoding = "UTF-8"))
subitem = read_csv2('subitem.csv',
locale = locale(encoding = 'Latin1'))
subitemDatas
FormatoISO8601: ano, mês, dia, hora, minuto e segundo
parse_datetime("2010-10-01T2010")
parse_datetime("20101010")Ou se pode especificar formato próprio:
# Ano: %Y (4 dígitos) ou %y (2 dígitos)
# Mês: %m (2 dígitos) ou %b (Jan) ou %B (Janeiro)
# Dia: %d (2 dígitos) ou %e (espaço)
# %H 0-23 hora.
# %I 0-12, deve ser usado com %p.
# %p AM/PM.
# %M minutos.
# %S segundos inteiros.
# %OS segundos reais.
# %Z Time zone
# %z (UTC, ex, +0800).Exemplo:
challenge <- read_csv(
readr_example("challenge.csv"),
col_types = cols(
x = col_double(),
y = col_date(format='%Y-%m-%d')
)
)
?read_csv
challenge
View(challenge)
problems()
#Também podemos escrever com write_csv()
write_csv(challenge, 'challenge.csv')C: Pacotes Brazucas
Há atualmente vários pacotes brasileiros interessantes, em especial: IPEA: IPEADATA FGV: BETS IBGE: sidrar Banco Central: O post Baixando dados do IPEADATA, FGV, Banco Central e IBGE com R pode ser uma boa fonte de informação.
BETS: Brazilian Economic Time Series
Um pacote em especial é o BETS, que tem diversas funções para coletar dados de diversas fontes. Destaca-se também pela estabilidade. Duas funções que merecem destaque são o BETSsearch onde retorna código a partir da busca por palavras chaves, e pega-se a função com BETSget.
library(BETS)
ipca = BETSget(433, from='2007-01-01')
tail(ipca)SIDRAR
O pacote é o do IBGE. O pacote SIDRAR que coleta dados do SIDRA, base de dados do IBGE, diretamente para o R. Por ele podem ser acessadas várias pesquisas da instituição, como o PNAD Contínua, PME, PMC, Contas Nacionais, etc. Um exemplo de uso está abaixo com a função get_sidra().
library(sidrar)
tabela = get_sidra(api='/t/6381/n1/all/v/4099/p/all/d/v4099%201')O argumento api indica qual dado será “puxado”. A vignette do SIDRAR no CRAN explixa como usar o argumento. O string pode ser identificado por meio site do SIDRA. No SIDRA, você pode procurar, digamos, a base do CNT - Contas Nacionais Trimestrais. Dentro do painel da base de dados, pode-se utilizar o botão que indica a Relação de Tabelas da Pesquisa e esolher a tabela de desejo. Uma vez no painel da tabela, pode ser escolher as variáveis (clicando-se nelas). Uma vez escolhida as variáveis, pressiona-se o botão de compartilhar (embaixo), e copia-se a url fornecida a partir do “/t”, que é o string a ser colocado entre aspas no argumento api do get_sidra().
GetBCBData
O pacote GetBCBData coleta dados do SGS/BCB e pode ser instalado do CRAN com a função install.packages(). Com o pacote instalado, coletar uma série do Sistema Gerenciador de Séries Temporais - SGS é bem simples. Precisamos indicar na função gbcbd_get_series() o código da série proveniente do SGS. Na página do sistema pode-se pesquisar as séries e códigos. Ao usar a função também pode se definir, opcionalmente, uma data de início (formato americano YYYY-MM-DD). O argumento use.memoise serve para indicar se queremos que os dados sejam salvos em cache. Vamos a um exemplo de coleta de dados da taxa SELIC (código 432):
# Carregar pacote
library(GetBCBData)
# Coletar dados da SELIC
dados_sgs <- gbcbd_get_series(
id = 432,
first.date = "2020-01-01",
use.memoise = FALSE
)
# Mais de um dado pode ser coletado de uma só vez
codigos_bcb <- c('Selic' = 432, "Câmbio" = 1)
dados_pib <- GetBCBData::gbcbd_get_series(
id = codigos_bcb,
use.memoise = FALSE
)Outros Pacotes
O ecoseries é outro pacote de dados, com dados do IPEADATA, do IBGE, do banco central. Talvez seja mais útil apenas para o caso do IPEADATA, pois os outros tem fontes diretas mais estáveis. A dificuldade é o código das séries. O rbcb é outro pacote interessante, mas ele não está no CRAN, apenas no github do wilsonfreitas, portanto necessita do devtools. Pode-se considerar um substituto do BETS. Há também o ribge em desenvolvimento.
devtools::install_github('wilsonfreitas/rbcb')
install.packages('rbcb')O pacote meedr
Por sua vez, o pacote meedr também pode ser instalado a partir do CRAN e oferece uma série de funções para coletar os dados de expectativas de mercado (Focus/BCB). Consulte os dados disponibilizados em https://www3.bcb.gov.br/expectativas/publico/consulta/serieestatisticas. Por exemplo, vamos coletar os dados de expectativas de inflação dos próximos 12 meses através da função get_inflation_12m(). Consulte as demais funções get_ do pacote para outros dados. Precisamos especificar um indicador como medida de inflação e podemos colocar uma data de início da série.
# Carregar pacote
library(meedr)
# Coletar dados de expectativas
dados_expectativas <- get_inflation_12m(
indicator = "IPCA",
first_date = "2020-01-01",
use_memoise = FALSE
)O pacote ipeadatar
Para dados macroeconômicos, regionais e sociais, o IPEA disponibiliza uma base de dados grande em seu site IPEADATA com acesso público. No R podemos usar o pacote ipeadatar para fazer a coleta de dados dessa fonte. O pacote ipeadatar costuma estar disponível no CRAN, mas recentemente passou por algumas atualizações e ficou com as últimas versões temporariamente indisponíveis. No entanto, conseguimos instalar uma versão estável (0.1.1) do pacote usando o install.packages(). Caso tenha dificuldades, confira alternativas neste post da Análise Macro:
# Instalar versão específica do pacote
install.packages(
"https://cran.r-project.org/src/contrib/Archive/ipeadatar/ipeadatar_0.1.1.tar.gz",
repos = NULL,
type = "source"
)Com o pacote instalado, podemos prosseguir com um exemplo, vamos fazer a coleta dos dados do saldo do CAGED. A única informação que precisamos passar para a função ipeadata(), que faz a coleta dos dados, é o código da variável desejada. Para saber o código podemos usar outra função do pacote, available_series(), que retorna um objeto tibble com todos as séries disponíveis no IPEADATA e seus respectivos códigos.
# Carregar pacote
library(ipeadatar)
# Tibble com todos os códigos das séries do IPEADATA
codigos_ipeadata <- available_series()
# Coletar dados do Saldo do CAGED
dados_ipeadata <- ipeadata(code = "CAGED12_SALDON12")O pacote PNADcIBGE
Para coletar os dados da Pesquisa Nacional por Amostra de Domicílios Contínua (PNAD Contínua) existe o pacote PNADcIBGE no R, havendo a possibilidade de dois tipos de microdados: anual ou trimestral. Vamos primeiro instalar o pacote, que está disponível no CRAN:
# Instalar pacote
install.packages("PNADcIBGE")A coleta dos microdados trimestrais ou anuais pode ser feita com a função get_pnadc(), no primeiro caso basta indicar o ano e o trimestre dos dados desejados nos argumentos da função. Abaixo um exemplo:
# Carregar pacote
library(PNADcIBGE)
# Coletar microdados do 1º trimestre de 2021
dados_pnadc <- get_pnadc(year = 2021, quarter = 1)D: O Tratamento do Pacote Tibble
Introdução
Nesta subseção do curso iremos aprender como funciona o objeto mais cômodo para amazenar dados, importar dados, trata-los e depois como classificar dados com os tipos apropriados. O pacote Tibble implementa uma data.frame, um pouco mais poderosa que a data.frame tradicional. Mas… o que exatamente é um data.frame?
A data frame is a table-like data structure available in languages like R and Python. Statisticians, scientists, and programmers use them in data analysis code . (…) The main point here is that data frames are a stable concept across multiple languages. The syntax is different, but the idea is largely the same. (www.oilshell.org)
O R não é mais uma linguagem exatamente nova. Várias estruturas não estão exatamente defasadas, mas são mais apropriadas para contextos antigos, como a classe que mais temos usado, os data.frame. Neste capítulo vamos conhecer os tibbles, que no fundo são data.frame, mas com pequenas otimizações muito úteis. Sua implementação é do pacote tibble, disponível no tidyverse.
library(tidyverse)Quase todas as funções dos pacotes do tidyverse produzem tibbles, mas nem sempre temos eles à disposição. Para transformar um data.frame em tibble, usamos a função as_tibble(). Uma vez alterado, a classe do objeto deixa de ser “data.frame” para ser “tbl_df” (ou seja, tibble data frame ). Vamos mostrar isso com a base de dados iris, com informações sobre flores, e que vem tradicionalmente armazenado no R por padrão.
class(iris)
dados <- as_tibble(iris)
class(dados)
dadosObserve que o próprio R reconhece um tibble como um sinônimo moderno de um data.frame. Você também pode criar tibbles do zero com a função tibble().
tibble(
x = 1:5,
y = 1,
z = x ^ 2 + y)Tribbles
Existem também tribbles, que são como os comuns, mas de entrada manual. Inserimos nomes de colunas como fórmulas, usando o símbolo ~ e depois os dados manualmente, por linha. Para volumes pequenos, são uma boa alternativa de controle fino dos dados.
tribble(
~x, ~y, ~z,
"a", 2, 3.6,
"b", 1, 8.5)tibbles vs. data.frame
Existem duas principais diferenças: printando e fazendo subconjuntos dos dados. Os prints de tibbles no terminal são adequados ao tamanho da tela, se limitam a 10 linhas e emitem o tipo de cada coluna. Isso é particularmente útil quando se trabalha como grandes volumes de dados.
as_tibble(iris)Você também pode ter controle mais fino, com os parâmetros n, dando o número de linhas, e width, o número de colunas. width = Inf mostra todas as colunas.
library(nycflights13)
flights %>%
print(n = 10, width = Inf)Você também pode definir opções de número máximo e mínimo.
options(tibble.print_max = n, tibble.print_min = m)Para subconjuntos, temos ferramentas melhores também. Podemos usar as maneiras clássicas que se aplicam a data.frame:
df <- tibble(
x = runif(5),
y = rnorm(5)
)
# Extrair por nome, das duas maneiras
df$x
df[["x"]]
# Extrair por posição
df[[1]]Algumas funções mais velhas, especialmente de pacotes pouco atualizados, não funcionam com tibbles. Não há problema, você sempre pode usar as.data.frame() para tornar um tibble em um data.frame.