EAE1106 - Métodos Computacionais para Economia
Faculdade de
Economia, Administração, Contabilidade e Atuária
Universidade de São
Paulo
Prof. Arthur Viaro
1º semestre de 2026
R é uma linguagem criada especificamente para análise estatística e computação científica, amplamente utilizada em:
O ecossistema do Tidyverse torna R extremamente poderoso para manipulação e visualização de dados
Junto com Python, R é uma das duas linguagens dominantes em ciência de dados — muitas equipes usam ambas
R possui uma comunidade acadêmica enorme, com pacotes para praticamente qualquer método estatístico
Para programar em R, você precisará instalar a linguagem e um ambiente de desenvolvimento (IDE). As opções mais populares são:
O RStudio foi por muitos anos o ambiente padrão para desenvolvimento em R e continua sendo amplamente utilizado. Entretanto, o Visual Studio Code (VSCode) oferece maior flexibilidade, suporte a múltiplas linguagens e um amplo ecossistema de extensões.
Outra alternativa interessante é o Positron, desenvolvido pela mesma empresa responsável pelo RStudio (Posit). O Positron combina a experiência tradicional do RStudio com a flexibilidade e modernidade do VSCode, sendo uma excelente opção para novos usuários.
Se você utiliza Anaconda, é possível instalar o R e integrá-lo ao Jupyter Notebook sem precisar instalar o R separadamente. Essa abordagem facilita o gerenciamento de pacotes e ambientes de desenvolvimento.
Para facilitar o processo, utilizaremos o canal
conda-forge, que mantém as versões do R mais atualizadas. O
comando abaixo instalará o R base, o kernel do Jupyter e as principais
bibliotecas de análise de dados (como ggplot2 e
dplyr) de uma só vez.
O parâmetro
--yesno final serve para aceitar automaticamente a instalação de todas as dependências, tornando o processo mais direto. A instalação pode levar alguns minutos dependendo da velocidade da internet.
Com a instalação concluída, o R já estará integrado ao seu ambiente padrão. Ao criar um novo notebook, a opção R estará disponível na lista de kernels.
Primeiro, instale o R e o VSCode em seu computador:
Instalar a extensão R para VSCode
Essa extensão fornece recursos como destaque de sintaxe, execução de código e integração com o terminal R.
languageserverO pacote languageserver habilita funcionalidades como autocompletar, documentação automática e verificação de código.
install.packages("languageserver")O Radian é um terminal interativo para R que oferece uma experiência mais moderna, incluindo autocompletar, destaque de sintaxe e melhor navegação no histórico de comandos.
conda install -c conda-forge radianwhere radianC:\Users\SeuUsuario\anaconda3\Scripts\radian.exeAgora, vamos configurar o VSCode para utilizar o Radian:
{
"r.rterm.windows": "C:\\Users\\SeuUsuario\\anaconda3\\Scripts\\radian.exe",
"r.rpath.windows": "C:\\Program Files\\R\\R-4.5.0\\bin\\R.exe",
"r.bracketedPaste": true
}Importante: em caminhos do Windows, utilize barras invertidas duplas (
\\) dentro do arquivo JSON.
Alguns atalhos tornam a escrita de código em R mais rápida e confortável.
[
{
"key": "alt+-",
"command": "type",
"args": { "text": " <- " },
"when": "editorTextFocus && editorLangId == r"
},
{
"key": "ctrl+shift+m",
"command": "type",
"args": { "text": " %>% " },
"when": "editorTextFocus && editorLangId == r"
}
]Os atalhos configurados são semelhantes aos utilizados em ambientes como RStudio e Jupyter Notebook e permitem:
Alt + -: inserir rapidamente o operador de atribuição
(<-);Ctrl + Shift + M: inserir o operador pipe
(|>).Após salvar as configurações, reinicie o VSCode para que as alterações sejam aplicadas.
Em R, bibliotecas são chamadas de pacotes. Para instalar um pacote,
utilize a função install.packages():
Após a instalação, o pacote pode ser carregado com a função
library():
Importante:
install.packages()precisa ser executado apenas uma vez em cada computador. Jálibrary()deve ser executado sempre que uma nova sessão do R for iniciada.
R funciona como uma calculadora poderosa:
## [1] 3## [1] 7## [1] 20## [1] 3.333333## [1] 1024## [1] 1## [1] 3Para funções de cálculo matemático e estatístico básico:
## [1] 4## [1] 42## [1] 4.60517## [1] 2## [1] 6.643856## [1] 2.861353## [1] 2.718282## [1] 3.14Em Python, o operador de atribuição é =. Já em R, o
operador de atribuição padrão é <- (embora
= também funcione):
## [1] "numeric"## [1] "numeric"## [1] "character"Dica: No RStudio, use Alt + - (Windows/Linux) ou Option + - (Mac) para digitar
<-rapidamente.
R possui diferentes tipos de dados para representar valores numéricos. Por padrão, números são armazenados como valores numéricos de ponto flutuante (double precision), mesmo quando não possuem casas decimais.
Nota:
Numericé um termo mais amplo que engloba tanto números decimais (double) quanto inteiros (integer), enquantodoublese refere estritamente a números de ponto flutuante de dupla precisão.
## [1] "numeric"## [1] "double"## [1] "numeric"## [1] "double"Para criar um valor explicitamente inteiro, utiliza-se o sufixo
L:
## [1] "integer"## [1] "integer"## [1] TRUEEmbora integer e double sejam armazenados
de formas diferentes, ambos representam valores numéricos. Por isso, a
função is.numeric() retorna TRUE para os dois
casos.
## [1] TRUE## [1] TRUE## [1] TRUE## [1] TRUEA conversão entre tipos pode ser realizada com funções da família
as.*().
## [1] 3## [1] 5Importante:
as.integer()remove a parte decimal do número, ou seja, realiza um truncamento e não um arredondamento.
## [1] 3## [1] -3Para arredondar valores, utilize funções como round(),
floor() ou ceiling():
## [1] 4## [1] 3## [1] 4No R, o tipo de dado para texto se chama character.
Aceita aspas simples ou duplas. É equivalente à classe str
do Python.
## [1] "100"# Concatenação de textos com paste() e paste0()
paste(curso, "na", universidade) # Adiciona espaço por padrão## [1] "Economia na USP"## [1] "Economia@USP"A tabela abaixo resume o equivalente das operações de string para quem vem do Python:
| Operação | R | Python |
|---|---|---|
| Comprimento | nchar(x) |
len(x) |
| Fatiamento | substr(x, start, stop) |
x[start:stop] |
| Caixa Alta | toupper(x) |
x.upper() |
| Caixa Baixa | tolower(x) |
x.lower() |
| Limpar espaços | trimws(x) |
x.strip() |
| Substituição | gsub(pattern, replacement, x) |
x.replace(pattern, replacement) |
## [1] 7## [1] "ECONOMIA"## [1] "economia"## [1] "texto com espaços"Nota de Sintaxe: O R utiliza índices base 1 (o primeiro caractere está na posição 1) e o intervalo final é inclusivo.
## [1] "Econ"# Substituição de padrões (em Python: texto.replace("a", "@"))
gsub("a", "@", "banana") # Substitui todas as ocorrências## [1] "b@n@n@"## [1] "b@nana"Para construir strings formatadas (similar às f-strings do Python),
utilizamos a função sprintf() baseada na sintaxe C.
A função permite inserir valores de variáveis dentro de um texto
usando marcadores de posição (placebholders) como %s para
strings, %d para inteiros e %.2f para números
de ponto flutuante com 2 casas decimais.
## [1] "O(a) aluno(a) Murilo obteve nota 9.50"Declarados sempre em caixa alta: TRUE (ou T) e
FALSE (ou F).
# Booleanos em R: TRUE e FALSE (em Python: True e False)
verdadeiro <- TRUE
falso <- FALSE
class(verdadeiro)## [1] "logical"## [1] TRUE## [1] FALSE## [1] TRUE## [1] TRUE## [1] TRUE## [1] FALSEEm Python, os operadores lógicos são and (E),
or (OU) e not (NÃO). Em R, utilizam-se
&, | e ! para operações
elemento a elemento em vetores.
## [1] TRUE TRUE FALSE FALSE## [1] TRUE TRUE TRUE TRUE## [1] FALSE FALSE FALSE FALSEOs operadores && e || realizam
avaliação com curto-circuito, ou sejam comparam apenas o primeiro
elemento de cada vetor ou expressão e param assim que o resultado é
conhecido.
## [1] TRUE## [1] FALSE## [1] TRUE## [1] TRUEO R possui alguns valores reservados para representar situações
específicas. NA indica um valor ausente (missing
value), NULL representa um objeto nulo ou vazio,
Inf e -Inf representam infinito positivo e
negativo, respectivamente, e NaN (Not a Number)
indica um resultado numérico indefinido ou inválido.
Para verificar esses valores, podem ser utilizadas funções como
is.na(), is.null() e
is.infinite().
## [1] 10 20 NA 40## NULL## [1] Inf## [1] -Inf## [1] NaN## [1] TRUE## [1] TRUE## [1] TRUE## [1] TRUEO vetor é a estrutura de dados mais importante do R e a base para praticamente todas as operações da linguagem. Ele é semelhante a uma lista unidimensional ou array em Python, mas com uma diferença importante: todos os elementos de um vetor devem possuir o mesmo tipo de dado (numérico, texto, lógico etc.).
Vetores são criados com a função c() (combine),
que concatena valores em uma única estrutura:
notas <- c(8.5, 9.0, 7.5, 10.0, 8.0)
alunos <- c("Ana", "Bruno", "Carlos", "Diana", "Eduardo")
notas## [1] 8.5 9.0 7.5 10.0 8.0## [1] "Ana" "Bruno" "Carlos" "Diana" "Eduardo"É possível criar sequências de números usando o operador
: ou a função seq(), e repetir valores com
rep():
## [1] 1 2 3 4 5 6 7 8 9 10## [1] 0.0 0.2 0.4 0.6 0.8 1.0## [1] 1.00 25.75 50.50 75.25 100.00## [1] 0 0 0 0 0## [1] 1 2 1 2 1 2Quando um vetor contém valores numéricos, o R disponibiliza diversas funções para realizar cálculos estatísticos de forma simples e eficiente, como tamanho, soma, média, desvio padrão, valor mínimo e valor máximo.
## [1] 5## [1] 43## [1] 8.6## [1] 0.9617692## [1] 7.5## [1] 10Uma das principais características do R é a vetorização. Operações matemáticas e funções são aplicadas automaticamente a todos os elementos de um vetor, sem a necessidade de laços de repetição explícitos.
Essa abordagem torna o código mais simples, legível e eficiente (em Python, para obter o mesmo resultado, seria necessário usar a biblioteca NumPy ou uma compreensão de lista).
## [1] 85 90 75 100 80## [1] 9.0 9.5 8.0 10.5 8.5## [1] 2.915476 3.000000 2.738613 3.162278 2.828427Os elementos de um vetor podem ser acessados por posição. Diferentemente de Python, a indexação em R começa em 1, e não em 0. Também é possível selecionar múltiplos elementos, intervalos de posições ou excluir elementos específicos.
## [1] 8.5## [1] 7.5## [1] 8.5 7.5 8.0## [1] 9.0 7.5 10.0 8.0## [1] 9.0 7.5 10.0A indexação lógica é um dos recursos mais poderosos do R. Ela permite filtrar elementos com base em condições, retornando apenas aqueles que satisfazem o critério especificado.
# Equivalente em Python: [n for n in notas if n >= 9]
# Notas maiores ou iguais a 9
notas[notas >= 9]## [1] 9 10## [1] "Bruno" "Diana"Além da indexação por posição, os elementos de um vetor podem receber nomes. Isso facilita a identificação dos dados e permite acessar valores diretamente pelo nome associado a cada elemento.
## Ana Bruno Carlos Diana Eduardo
## 8.5 9.0 7.5 10.0 8.0## Ana
## 8.5Uma matriz é uma estrutura bidimensional composta por linhas e colunas. Em R, todos os elementos de uma matriz devem ser do mesmo tipo de dado, assim como ocorre com os vetores. Pode-se pensar em uma matriz como um conjunto de vetores de mesmo comprimento organizados em forma de tabela.
Matrizes são criadas com a função matrix(), na qual
especificamos os dados e suas dimensões:
## [,1] [,2] [,3]
## [1,] 1 3 5
## [2,] 2 4 6O padrão é preencher por colunas. Use byrow = TRUE para
preencher por linhas.
## [,1] [,2] [,3]
## [1,] 1 2 3
## [2,] 4 5 6Também é possível construir matrizes combinando vetores existentes.
cbind(): Combina vetores como colunas.rbind(): Combina vetores como linhas.## v1 v2
## [1,] 1 4
## [2,] 2 5
## [3,] 3 6## [,1] [,2] [,3]
## v1 1 2 3
## v2 4 5 6Os elementos de uma matriz são acessados utilizando a sintaxe
matriz[linha, coluna]:
## [1] 6Também é possível selecionar linhas ou colunas inteiras:
## [1] 4 5 6## [1] 3 6Além disso, podemos selecionar múltiplas linhas ou colunas simultaneamente:
## [,1] [,2] [,3]
## [1,] 1 2 3
## [2,] 4 5 6## [,1] [,2]
## [1,] 1 3
## [2,] 4 6As matrizes possuem diversos atributos úteis para descrever sua estrutura:
nrow(): retorna o número de linhas;ncol(): retorna o número de colunas;dim(): retorna as dimensões da matriz (linhas e
colunas);rownames(): define ou consulta os nomes das
linhas;colnames(): define ou consulta os nomes das
colunas.## [1] 2 3## [1] 2## [1] 3## Coluna1 Coluna2 Coluna3
## Linha1 1 2 3
## Linha2 4 5 6A nomeação de linhas e colunas torna a matriz mais legível e facilita a identificação dos dados, especialmente em aplicações estatísticas e análise de dados.
Também podemos executar operações com matrizes, como multiplicação elemento a elemento, produto matricial, transposição e cálculo de determinante:
A <- matrix(1:9, nrow = 3, ncol = 3)
B <- matrix(2:10, nrow = 3, ncol = 3)
# produto dos elementos de matrizes
A * B## [,1] [,2] [,3]
## [1,] 2 20 56
## [2,] 6 30 72
## [3,] 12 42 90## [1] 2## [,1] [,2] [,3]
## [1,] 63 120 177
## [2,] 51 96 141
## [3,] 60 114 168## [,1] [,2] [,3]
## [1,] 1 2 3
## [2,] 11 5 6
## [3,] 7 8 9## [1] 42Fatores (factors) são estruturas utilizadas para representar variáveis categóricas. Em vez de armazenar apenas os valores observados, um fator também mantém informações sobre todas as categorias possíveis (chamadas de níveis). Eles são amplamente utilizados em análise estatística, modelagem e visualização de dados.
Um fator pode ser visto como o equivalente às variáveis categóricas (Categorical) do pandas em Python.
# Criar um fator
regiao <- c("Sul", "Norte", "Sudeste", "Norte", "Sul", "Centro-Oeste")
regiao_fator <- factor(regiao)
regiao_fator## [1] Sul Norte Sudeste Norte Sul
## [6] Centro-Oeste
## Levels: Centro-Oeste Norte Sudeste Sul## [1] "Centro-Oeste" "Norte" "Sudeste" "Sul"## [1] 4## regiao_fator
## Centro-Oeste Norte Sudeste Sul
## 1 2 1 2Algumas variáveis categóricas possuem uma ordem natural entre suas categorias, como níveis de escolaridade, satisfação ou classificação de risco. Nesses casos, podemos criar um fator ordenado (ordered factor).
# Fator ordenado (ordinal)
escolaridade <- c("Médio", "Superior", "Fundamental", "Superior", "Médio")
escolaridade_ord <- factor(escolaridade,
levels = c("Fundamental", "Médio", "Superior"),
ordered = TRUE
)
escolaridade_ord## [1] Médio Superior Fundamental Superior Médio
## Levels: Fundamental < Médio < SuperiorComo existe uma ordem definida entre os níveis, comparações passam a fazer sentido:
## [1] TRUEListas são estruturas de dados flexíveis que podem armazenar elementos de diferentes tipos e tamanhos em um único objeto.
Diferentemente dos vetores, que exigem elementos do mesmo tipo, uma lista pode conter números, textos, vetores, matrizes, data frames e até mesmo outras listas.
## [[1]]
## [1] "R"
##
## [[2]]
## [1] 2026
##
## [[3]]
## [1] TRUE
##
## [[4]]
## [1] 1 2 3Os elementos de uma lista podem ser acessados de duas formas. O
operador [ ] retorna uma sublista,
enquanto [[ ]] retorna o conteúdo do
elemento.
## [[1]]
## [1] 2026## [1] "list"## [1] 2026## [1] "numeric"Uma lista nomeada associa um nome a cada elemento, facilitando a organização e o acesso aos dados. Esse conceito é semelhante aos dicionários (dictionaries) em Python.
# Criando uma lista nomeada
estudante <- list(
nome = "Ana Silva",
nusp = 12345,
notas = c(8.5, 9.0, 7.5),
aprovado = TRUE
)
estudante## $nome
## [1] "Ana Silva"
##
## $nusp
## [1] 12345
##
## $notas
## [1] 8.5 9.0 7.5
##
## $aprovado
## [1] TRUEOs elementos podem ser acessados pelo nome ou pela posição:
## [1] "Ana Silva"## [1] 8.5 9.0 7.5## [1] "Ana Silva"## [1] 9Também é possível modificar elementos existentes ou adicionar novos elementos à lista:
# Adicionar um novo elemento
estudante$curso <- "Economia"
# Alterar um elemento existente
estudante$nusp <- 99999
estudante## $nome
## [1] "Ana Silva"
##
## $nusp
## [1] 99999
##
## $notas
## [1] 8.5 9.0 7.5
##
## $aprovado
## [1] TRUE
##
## $curso
## [1] "Economia"O data frame é a estrutura de dados mais utilizada
em análise de dados em R. Ele organiza informações em formato tabular,
com linhas representando observações e colunas representando variáveis.
É semelhante ao DataFrame da biblioteca pandas em
Python.
Uma característica importante é que cada coluna pode possuir um tipo de dado diferente (numérico, texto, lógico etc.), mas todos os valores dentro de uma mesma coluna devem ser do mesmo tipo.
# Criar um data frame
df <- data.frame(
nome = c("Ana", "Bruno", "Carlos", "Diana"),
nota = c(8.5, 7.0, 9.5, 8.0),
aprovado = c(TRUE, TRUE, TRUE, TRUE),
stringsAsFactors = FALSE
)
dfO R oferece diversas funções para explorar rapidamente a estrutura e o conteúdo de um data frame:
## [1] 4## [1] 3## [1] 4 3## [1] "nome" "nota" "aprovado"## 'data.frame': 4 obs. of 3 variables:
## $ nome : chr "Ana" "Bruno" "Carlos" "Diana"
## $ nota : num 8.5 7 9.5 8
## $ aprovado: logi TRUE TRUE TRUE TRUE## nome nota aprovado
## Length:4 Min. :7.00 Mode:logical
## Class :character 1st Qu.:7.75 TRUE:4
## Mode :character Median :8.25
## Mean :8.25
## 3rd Qu.:8.75
## Max. :9.50Como um data.frame pode ser visto como uma lista de
colunas de mesmo comprimento, podemos utilizar diferentes formas de
acesso.
## [1] "Ana" "Bruno" "Carlos" "Diana"## [1] 8.5 7.0 9.5 8.0## [1] 8.5 7.0 9.5 8.0## [1] 8.5 7.0 9.5 8.0Também é possível acessar linhas específicas ou células individuais:
## [1] "Ana"## [1] 7A indexação lógica permite selecionar apenas as linhas que satisfazem uma determinada condição. Esse tipo de operação é semelhante ao boolean indexing utilizado no pandas.
Estruturas condicionais permitem executar diferentes blocos de código dependendo do resultado de uma condição lógica.
Em R, a principal estrutura de decisão é composta por
if, else if e else, com sintaxe
semelhante à do Python, mas utilizando chaves {} para
delimitar os blocos de código.
# if / else if / else
nota <- 7.5
if (nota >= 9) {
cat("Conceito A\n")
} else if (nota >= 7) {
cat("Conceito B\n")
} else if (nota >= 5) {
cat("Conceito C\n")
} else {
cat("Reprovado\n")
}## Conceito BQuando a condição precisa ser avaliada para todos os elementos de um
vetor, podemos utilizar a função ifelse(), que realiza a
operação de forma vetorizada (similar ao método
numpy.where() no Python).
# ifelse() — versão vetorizada
notas <- c(5.0, 8.0, 4.5, 9.0, 6.0)
resultado <- ifelse(notas >= 5, "Aprovado", "Reprovado")
resultado## [1] "Aprovado" "Aprovado" "Reprovado" "Aprovado" "Aprovado"Laços de repetição permitem executar um mesmo bloco de código várias
vezes. Em R, as estruturas mais comuns são for e
while.
O laço for percorre os elementos de um vetor ou
sequência, atribuindo cada valor sucessivamente à variável de
iteração.
## Iteração: 1
## Iteração: 2
## Iteração: 3
## Iteração: 4
## Iteração: 5# Iterando sobre um vetor
frutas <- c("maçã", "banana", "laranja")
for (fruta in frutas) {
cat("Fruta:", fruta, "\n")
}## Fruta: maçã
## Fruta: banana
## Fruta: laranjaO laço while repete a execução de um bloco de código
enquanto uma condição permanecer verdadeira.
# while loop
contador <- 1
while (contador <= 5) {
cat("Contador:", contador, "\n")
contador <- contador + 1
}## Contador: 1
## Contador: 2
## Contador: 3
## Contador: 4
## Contador: 5Importante: Embora os laços estejam disponíveis, eles são menos usados em R do que em outras linguagens, pois muitas operações são naturalmente vetorizadas.
## [1] 50 80 45 90 60Funções da família apply() também ajudam a substituir
muitos laços explícitos.
A família apply no R (incluindo apply,
lapply, sapply, tapply) é um
conjunto de funções essenciais para aplicar operações repetitivas em
vetores, listas ou matrizes, substituindo loops for por um
código mais eficiente e limpo. Elas permitem aplicar funções como
sum, mean ou personalizadas sobre linhas ou
colunas.
apply(): Usada para matrizes ou data frames. Permite
aplicar funções nas margens: 1 para linhas, 2 para colunas.lapply(): Aplica uma função a cada elemento de uma
lista ou vetor e sempre retorna uma lista.sapply(): Similar ao lapply, mas tenta
simplificar o resultado para um vetor ou matriz, se possível.tapply(): Aplica uma função a subconjuntos de um vetor,
baseando-se em um fator (agrupamento).## [1] 25.00 64.00 20.25 81.00 36.00Funções permitem encapsular trechos de código reutilizáveis em uma única unidade. Elas podem receber argumentos, realizar cálculos e retornar resultados.
# Definir uma função
calcular_media <- function(x) {
soma <- sum(x)
n <- length(x)
return(soma / n)
}
calcular_media(c(8, 9, 7, 10))## [1] 8.5Argumentos também podem possuir valores padrão, que serão utilizados caso nenhum valor seja informado.
# Funções com múltiplos argumentos e valores padrão
calcular_conceito <- function(nota, corte_aprovacao = 5) {
if (nota >= 9) {
conceito <- "A"
} else if (nota >= 7) {
conceito <- "B"
} else if (nota >= corte_aprovacao) {
conceito <- "C"
} else {
conceito <- "F"
}
return(conceito)
}
calcular_conceito(8.5)## [1] "B"## [1] "F"## [1] "C"As funções também podem retornar listas, o que é útil quando queremos mais de um resultado.
# Funções podem retornar listas (múltiplos valores)
estatisticas <- function(x) {
list(
media = mean(x),
mediana = median(x),
desvio = sd(x),
minimo = min(x),
maximo = max(x)
)
}
notas <- c(8.5, 9.0, 7.5, 10.0, 6.0, 8.0)
resultado <- estatisticas(notas)
resultado$media## [1] 8.166667## [1] 1.36626Em algumas situações, não é necessário criar uma função com nome.
Nesses casos, podemos utilizar funções anônimas (funções lambda em
Python), normalmente passadas como argumento para outras funções, como
lapply, sapply, map (do pacote
purrr), ou apply. Ideais para operações curtas e de uso
único.
## [1] 25## [1] 1 4 9 16 25Antes da versão 4.1, usava-se a palavra-chave
function:
## [1] 1 4 9 16 25print() vs cat()As funções print() e cat() servem para
exibir informações na tela, mas possuem comportamentos diferentes.
print()A função print() exibe o objeto em sua representação
padrão, incluindo aspas em textos e informações sobre a estrutura do
objeto.
## [1] "Olá mundo"Também funciona bem para vetores, listas e data frames:
## [1] 8 9 10cat()A função cat() (concatenate and print)
concatena os argumentos e os imprime de forma mais simples, sem aspas
nem índices.
## Olá mundoPara quebrar linhas, é necessário usar \n:
## Iteração: 1Iteração: 2Iteração: 3Iteração: 4Iteração: 5## Iteração: 1
## Iteração: 2
## Iteração: 3
## Iteração: 4
## Iteração: 5Quando usar?
print() para inspecionar objetos durante a análise
de dados e depuração.cat() para produzir mensagens formatadas e mais
amigáveis ao usuário.Regra prática:
print()mostra o objeto como o R o enxerga;cat()mostra o texto como o usuário deve enxergar.
| Conceito | Python | R |
|---|---|---|
| Atribuição | x = 5 | x <- 5 |
| Índice inicial | 0 | 1 |
| Tipo básico de dado | list, dict | vector |
| Listas heterogêneas | list | list |
| Tabular data | pandas DataFrame | data.frame / tibble |
| Strings | str(“texto”) | “texto” |
| print(x) | cat(x) / print(x) | |
| Importar biblioteca | import pandas as pd | library(tidyverse) |
| Comentário | # comentário | # comentário |
1. Indexação em R começa em 1 (não em 0):
## [1] "a"## [1] "d"2. Operações vetorizadas são nativas:
# Em Python com listas simples, isso geraria erro
# Precisaria de numpy: np.array(notas) + 1
notas <- c(7, 8, 9, 6)
notas + 1## [1] 8 9 10 7## [1] 14 16 18 123. O operador %in% verifica pertencimento
(equivalente ao in do Python):
## [1] TRUE## [1] TRUE FALSE TRUE4. A família apply substitui muitos
laços:
## [,1] [,2] [,3] [,4]
## [1,] 1 4 7 10
## [2,] 2 5 8 11
## [3,] 3 6 9 12## [1] 22 26 30## [1] 6 15 24 33## [1] 1 4 9 16 251. Crie um vetor com o PIB (em trilhões de reais) dos seguintes estados brasileiros: SP = 2.3, RJ = 0.9, MG = 0.8, RS = 0.6, PR = 0.5. Calcule a média, a soma total e identifique quais estados têm PIB acima da média.
2. Crie um data frame com informações de 5 países (nome, PIB per capita, população, continente). Depois: - Selecione apenas os países com PIB per capita > 10.000 - Adicione uma coluna com o PIB total (per capita × população)
3. Escreva uma função calcular_gini(x)
que recebe um vetor de rendas e retorna o coeficiente de Gini. (Dica: o
coeficiente de Gini é \(G = \frac{\sum_i
\sum_j |x_i - x_j|}{2n^2\bar{x}}\))
4. Usando um laço for, crie um vetor
com os 20 primeiros termos da sequência de Fibonacci. Depois refaça
usando abordagem vetorizada.
5. Crie uma função que, dado um data frame com
colunas receita e custo, calcule e retorne uma
lista com: lucro total, margem média, número de operações lucrativas e
número de operações com prejuízo.
Material baseado em: Wickham, H., Çetinkaya-Rundel, M. & Grolemund, G. (2023). R for Data Science (2ª ed.). O’Reilly. Disponível em: https://r4ds.hadley.nz/