install.packages() e
library()?
ggplot2 para visualização,
dplyr para manipulação de dados, caret para
aprendizado de máquina). Isso evita que o R base fique sobrecarregado e
permite o desenvolvimento rápido de novas técnicas e métodos.
install.packages("nome_do_pacote"): Esta função baixa e
instala o pacote dos repositórios (como o CRAN) para o seu sistema
local. É uma ação que geralmente precisa ser feita apenas uma vez por
pacote (ou para atualizá-lo).library("nome_do_pacote") ou
require("nome_do_pacote"): Esta função carrega o pacote
instalado na memória da sessão R atual. As funções e dados contidos no
pacote só estarão disponíveis para uso após serem carregados com
library() (ou require()).dplyr em sua sessão de R, supondo que ele ainda não esteja
instalado. Qual seria o resultado se você tentasse usar uma função do
dplyr sem carregá-lo?
dplyr:# 1. Instalar o pacote (se ainda não estiver instalado)
# install.packages("dplyr")
# 2. Carregar o pacote na sessão atual
library(dplyr)## Warning: pacote 'dplyr' foi compilado no R versão 4.4.3##
## Anexando pacote: 'dplyr'## O seguinte objeto é mascarado por 'package:kableExtra':
##
## group_rows## Os seguintes objetos são mascarados por 'package:stats':
##
## filter, lag## Os seguintes objetos são mascarados por 'package:base':
##
## intersect, setdiff, setequal, union Se você tentasse usar uma função do `dplyr` (por exemplo, `mutate()`) sem carregá-lo previamente com `library(dplyr)`, o R emitiria um erro indicando que a função não foi encontrada, geralmente algo como: `Error: 'mutate' could not be found` ou `Error: object 'mutate' not found`. Isso ocorre porque o R só sabe onde encontrar e usar as funções de um pacote depois que ele é explicitamente carregado na sessão.media_idade_participantes
_ (underscore) para separar palavras, o que é uma
boa prática em R (snake_case).1_media_idade
preco_unitario como um valor numérico decimal
(19.99) e outra variável quantidade como um
número inteiro (50). Calcule o valor_total e
verifique o tipo de dado resultante. Qual a principal diferença entre um
número inteiro (integer) e um número real
(numeric/double) no R em termos de
armazenamento e uso?
preco_unitario <- 19.99
quantidade <- 50L # Sufixo 'L' para indicar explicitamente um inteiro
valor_total <- preco_unitario * quantidadeDiferença: * numeric (ou
double): Armazena números de ponto flutuante de precisão
dupla, que podem ter casas decimais. É o tipo numérico padrão no R.
Ocupa mais memória. * integer: Armazena números inteiros.
Para declarar um inteiro explicitamente, é preciso usar o sufixo
L (ex: 10L). Ocupa menos memória que
double. A principal diferença é a precisão e o uso
de memória. double é usado para a maioria dos
cálculos numéricos, lidando com decimais, enquanto integer
é otimizado para contagens ou índices que não exigem precisão decimal.
No cálculo acima, valor_total se torna double
porque a operação envolve um double
(preco_unitario), e o R promove o tipo de dado para o mais
abrangente para evitar perda de informação.
integer em vez de numeric e
demonstre como criar um vetor de inteiros de 1 a 10.
Resposta: Seria preferível armazenar contagens
como integer em vez de numeric porque
integer usa menos memória por elemento (geralmente 4 bytes)
em comparação com numeric (double, que usa 8
bytes). Para milhões de observações, essa diferença se traduz em uma
economia significativa de memória, o que pode melhorar o desempenho e
evitar o esgotamento da memória, especialmente em conjuntos de dados
grandes onde a precisão decimal não é necessária.
Para criar um vetor de inteiros de 1 a 10:
vetor_inteiros <- 1L:10L
print(vetor_inteiros)## [1] 1 2 3 4 5 6 7 8 9 10Note o uso do sufixo L para garantir que cada número
seja tratado como um inteiro.
nome_produto com o valor "Notebook Dell XPS" e
uma variável modelo com o valor "15 9500".
Concatenar estas duas variáveis com a adição da palavra “Modelo:” para
formar uma única string descricao_completa. Imprima
descricao_completa e verifique o tipo de dado.
nome_produto <- "Notebook Dell XPS"
modelo <- "15 9500"
descricao_completa <- paste(nome_produto, "Modelo:", modelo)
print(descricao_completa)## [1] "Notebook Dell XPS Modelo: 15 9500"O tipo de dado character é a forma como o R armazena
strings (textos).
') ou duplas (") para definir strings.
Explique quando seria preferível usar um tipo de aspa em detrimento do
outro, dando um exemplo prático.
\). # Usando aspas duplas para string com aspas simples
frase1 <- "Ele disse: 'Olá!'"
print(frase1)## [1] "Ele disse: 'Olá!'" # Usando aspas simples para string com aspas duplas
frase2 <- 'O livro se chama "A Arte da Programação".'
print(frase2)## [1] "O livro se chama \"A Arte da Programação\"." # Alternativa com escape, mas menos legível
frase3 <- "Ele disse: \"Olá!\""
print(frase3)## [1] "Ele disse: \"Olá!\""temperatura estiver
entre 20 e 30 graus Celsius (inclusive) E seu
pH for superior a 6.5. Crie variáveis para
temperatura = 25 e pH = 7.2. Utilizando
operadores de comparação e lógicos, determine se o produto é
aprovado.
temperatura <- 25
pH <- 7.2
aprovado <- (temperatura >= 20 & temperatura <= 30) & (pH > 6.5)
print(aprovado)## [1] TRUEO produto é TRUE, indicando que foi aprovado. O tipo de
dado é logical.
TRUE e FALSE. Qual é a
relação desses valores com os tipos de dados logical?
Demonstre como R trata esses valores em um contexto numérico (conversão
implícita).
TRUE e FALSE são a própria essência do tipo de
dado logical. Ou seja, o tipo de dado logical
é o que armazena esses valores booleanos. Eles não são apenas
representações, mas os valores literais desse tipo. O R tem uma
capacidade de coerção implícita que permite que logical
seja tratado como numérico em certas operações:
TRUE é convertido para 1.FALSE é convertido para 0. verdadeiro <- TRUE
falso <- FALSE
print(verdadeiro) # Tipo é logical## [1] TRUE print(as.numeric(verdadeiro)) # Converte para numérico## [1] 1 print(as.numeric(falso)) # Converte para numérico## [1] 0 # Exemplo prático: somar valores lógicos
soma_logicos <- TRUE + TRUE + FALSE
print(soma_logicos)## [1] 2A soma de TRUE + TRUE + FALSE resulta em 2,
porque TRUE é tratado como 1 e
FALSE como 0 na operação aritmética.
TRUE) ou “não passou”
(FALSE) em uma prova:
c(TRUE, FALSE, TRUE, TRUE, FALSE). Utilizando a coerção
implícita de R, calcule o número total de estudantes que passaram e o
percentual de aprovação.
status_aprovacao <- c(TRUE, FALSE, TRUE, TRUE, FALSE)
# Número total de estudantes que passaram (TRUEs são somados como 1)
total_aprovados <- sum(status_aprovacao)
print(paste("Total de aprovados:", total_aprovados))## [1] "Total de aprovados: 3" # Número total de estudantes
total_estudantes <- length(status_aprovacao)
print(paste("Total de estudantes:", total_estudantes))## [1] "Total de estudantes: 5" # Percentual de aprovação
percentual_aprovacao <- (total_aprovados / total_estudantes) * 100
print(paste("Percentual de aprovação:", percentual_aprovacao, "%"))## [1] "Percentual de aprovação: 60 %"data_inicio_projeto como “2023-01-15” e
data_fim_prevista como “2024-03-10”. Calcule a diferença em
dias entre essas duas datas.
data_inicio_projeto <- as.Date("2023-01-15")
data_fim_prevista <- as.Date("2024-03-10")
diferenca_dias <- data_fim_prevista - data_inicio_projeto
print(diferenca_dias)## Time difference of 420 daysO resultado é um objeto difftime, mas seu valor numérico
subjacente é double (representando os dias).
# Criar um objeto POSIXct (data e hora)
data_hora_evento <- as.POSIXct("2023-10-26 14:30:00", tz = "UTC")
print(data_hora_evento)## [1] "2023-10-26 14:30:00 UTC" # Extrair ano, mês e hora
ano <- format(data_hora_evento, "%Y")
mes <- format(data_hora_evento, "%m")
hora <- format(data_hora_evento, "%H")
print(paste("Ano:", ano))## [1] "Ano: 2023" print(paste("Mês:", mes))## [1] "Mês: 10" print(paste("Hora:", hora))## [1] "Hora: 14"O pacote amplamente utilizado para manipulação avançada de datas e
horas em R é o lubridate. Ele simplifica
muito a criação, parseamento e manipulação de objetos de data e hora,
oferecendo funções mais intuitivas do que as funções base do R.
c("Satisfeito", "Neutro", "Muito Insatisfeito", "Satisfeito"))
e converta-o para um fator. Mostre os níveis do fator e explique a
importância da ordem nos níveis para análise categórica ordinal.
# Vetor com dados colhidos
satisfacao_raw <- c("Satisfeito", "Neutro", "Muito Insatisfeito", "Satisfeito", "Neutro", "Neutro")
# Definir os níveis em ordem
niveis_satisfacao <- c("Muito Insatisfeito", "Insatisfeito", "Neutro", "Satisfeito", "Muito Satisfeito")
# Converter para fator com níveis ordenados
satisfacao_fator <- factor(satisfacao_raw, levels = niveis_satisfacao, ordered = TRUE)
print(satisfacao_fator)## [1] Satisfeito Neutro Muito Insatisfeito Satisfeito
## [5] Neutro Neutro
## 5 Levels: Muito Insatisfeito < Insatisfeito < Neutro < ... < Muito Satisfeito print(levels(satisfacao_fator))## [1] "Muito Insatisfeito" "Insatisfeito" "Neutro"
## [4] "Satisfeito" "Muito Satisfeito"A importância da ordem nos níveis de um fator categórico ordinal é que ela permite que o R (e as funções estatísticas) compreendam a relação hierárquica entre as categorias. Sem uma ordem definida, o R trataria as categorias como nominais (sem hierarquia), o que seria inadequado para variáveis como “satisfação” ou “grau de escolaridade”. A ordem é crucial para realizar comparações (e.g., “Satisfeito” é maior que “Neutro”), plotar gráficos com a sequência correta e aplicar modelos estatísticos que levam em conta essa ordenação.
c("Expresso", "Latte", "Cappuccino", "Expresso", "Filtro").
Converta este vetor em um fator sem ordem explícita. Por que, neste
caso, a ordem dos níveis não é tão crítica quanto no exercício anterior,
e qual seria um possível benefício de convertê-lo para fator?
tipos_cafe_raw <- c("Expresso", "Latte", "Cappuccino", "Expresso", "Filtro")
# Converter para fator sem ordem explícita
tipos_cafe_fator <- factor(tipos_cafe_raw)
print(tipos_cafe_fator)## [1] Expresso Latte Cappuccino Expresso Filtro
## Levels: Cappuccino Expresso Filtro Latte print(levels(tipos_cafe_fator))## [1] "Cappuccino" "Expresso" "Filtro" "Latte" print(is.ordered(tipos_cafe_fator)) # Verifica se os fatores estão ordenados, no caso FALSE## [1] FALSENeste caso, a ordem dos níveis não é tão crítica porque “Tipo de Café
Consumido” é uma variável categórica nominal. Não há
uma hierarquia natural ou uma ordem intrínseca entre “Expresso”, “Latte”
e “Cappuccino”; um não é “maior” ou “melhor” que o outro por natureza,
eles são apenas categorias distintas. Um possível benefício de converter
este vetor para fator é a eficiência de armazenamento e
processamento, especialmente em grandes conjuntos de dados.
Fatores armazenam os dados como inteiros mapeados para os níveis
(strings), o que pode economizar memória. Além disso, muitas funções
estatísticas e de plotagem em R (como table() ou
ggplot2) trabalham de forma mais eficiente e produzem
resultados mais claros e categorizados quando a variável é um fator.
capital_inicial = 10000, uma
taxa_juros_anual = 0.05 (5%) e um
periodo_anos = 3. Calcule o valor_futuro do
investimento usando a fórmula de juros compostos simples:
Valor Futuro = Capital Inicial * (1 + Taxa Juros)^Periodo.
capital_inicial <- 10000
taxa_juros_anual <- 0.15
periodo_anos <- 5
valor_futuro <- capital_inicial * (1 + taxa_juros_anual)^periodo_anos
print(paste("O valor futuro do investimento é:", round(valor_futuro, 2)))## [1] "O valor futuro do investimento é: 20113.57"largura = 8.5 e altura = 12.0. Calcule a
area (largura * altura) e o perimetro (2 *
(largura + altura)) de um retângulo.
largura <- 8.5
altura <- 12.0
area <- largura * altura
perimetro <- 2 * (largura + altura)
print(paste("Área do retângulo:", area))## [1] "Área do retângulo: 102" print(paste("Perímetro do retângulo:", perimetro))## [1] "Perímetro do retângulo: 41"titulo_relatorio com o texto
"Relatório Anual de Vendas" e uma variável
ano_relatorio com o texto "2023". Concatene
esses dois textos para formar a string relatorio_completo
no formato “Relatório Anual de Vendas (2023)”.
titulo_relatorio <- "Relatório Anual de Vendas"
ano_relatorio <- "2023"
relatorio_completo <- paste0(titulo_relatorio, " (", ano_relatorio, ")")
print(relatorio_completo)## [1] "Relatório Anual de Vendas (2023)" A função `paste0()` é usada aqui porque ela concatena strings sem adicionar um espaço como separador por padrão, o que é útil quando precisamos de controle preciso sobre os espaços.texto_limpo = " Análise de Dados com R ", remova os
espaços em branco extras do início e do final da string. Além disso,
transforme a string resultante para que todas as letras fiquem em
maiúsculas.
texto_original <- " Análise de Dados com R "
# Remover espaços em branco do início e fim
texto_sem_espacos_extras <- trimws(texto_original)
print(paste("Texto sem espaços extras:", texto_sem_espacos_extras))## [1] "Texto sem espaços extras: Análise de Dados com R" # Transformar para maiúsculas
texto_maiusculo <- toupper(texto_sem_espacos_extras)
print(paste("Texto em maiúsculas:", texto_maiusculo))## [1] "Texto em maiúsculas: ANÁLISE DE DADOS COM R"c(85, 92, 78, 65, 95, 88, 70, 80, 90, 75). Crie um vetor
com essas pontuações e, em seguida, calcule a média, mediana e o desvio
padrão dessas notas.
# 1. Criando o vetor 'pontuacoes'
pontuacoes <- c(85, 92, 78, 65, 95, 88, 70, 80, 90, 75)
# 2. Realizando os cálculos estatísticos
media_pontuacoes <- mean(pontuacoes)
mediana_pontuacoes <- median(pontuacoes)
desvio_padrao_pontuacoes <- sd(pontuacoes)
3 # Imprimindo os resultados## [1] 3 print(paste("Média das pontuações:", media_pontuacoes))## [1] "Média das pontuações: 81.8" print(paste("Mediana das pontuações:", mediana_pontuacoes))## [1] "Mediana das pontuações: 82.5" print(paste("Desvio Padrão das pontuações:", round(desvio_padrao_pontuacoes, 2)))## [1] "Desvio Padrão das pontuações: 9.89"temperaturas_celsius com os valores
c(10, 15, 20, 25, 30). Converta essas temperaturas para
Fahrenheit usando a fórmula F = C * 9/5 + 32 e armazene os
resultados em um novo vetor temperaturas_fahrenheit.
# 1. Criando o vetor
temperaturas_celsius <- c(10, 15, 20, 25, 30)
# 3. Realizando os cálculos
temperaturas_fahrenheit <- temperaturas_celsius * 9/5 + 32
3 # Imprimindo os resultados## [1] 3 print(temperaturas_fahrenheit)## [1] 50 59 68 77 86c("São Paulo", "Rio de Janeiro", "Belo Horizonte", "Curitiba").
Crie este vetor. Em seguida, adicione a cidade “Porto Alegre” ao final
do vetor e remova a cidade “Belo Horizonte”.
# 1. Criando o vetor 'cidades'
cidades <- c("São Paulo", "Rio de Janeiro", "Belo Horizonte", "Curitiba")
2 # Imprimindo o vetor criado## [1] 2 print(paste("Cidades originais:", paste(cidades, collapse = ", ")))## [1] "Cidades originais: São Paulo, Rio de Janeiro, Belo Horizonte, Curitiba" # 3. Adicionar "Porto Alegre"
cidades <- c(cidades, "Porto Alegre")
4 # Imprimindo## [1] 4 print(paste("Cidades após adicionar:", paste(cidades, collapse = ", ")))## [1] "Cidades após adicionar: São Paulo, Rio de Janeiro, Belo Horizonte, Curitiba, Porto Alegre" # 5. Remover "Belo Horizonte" (selecionando as que NÃO são "Belo Horizonte")
cidades <- cidades[cidades != "Belo Horizonte"]
6 # Imprimindo## [1] 6 print(paste("Cidades após remover:", paste(cidades, collapse = ", ")))## [1] "Cidades após remover: São Paulo, Rio de Janeiro, Curitiba, Porto Alegre"c("Ana Silva", "Bruno Costa", "Carla Dias", "Daniel Souza"),
crie este vetor. Em seguida, usando uma função R, selecione apenas os
nomes que contêm a letra ‘a’ (maiúscula ou minúscula).
nomes <- c("Ana Laura", "Bruno Costa", "Carla Dias", "Daniel Souza")
# Selecionar nomes que contêm 'l' ou 'L'
# Usamos `grep` para buscar padrões e `ignore.case = TRUE` para ignorar maiúsculas/minúsculas
nomes_com_l <- grep("l", nomes, ignore.case = TRUE, value = TRUE)
print(nomes_com_l)## [1] "Ana Laura" "Carla Dias" "Daniel Souza"Neste caso, os nomes contêm a letra ‘l’ (em maiúscula ou minúscula).
# 1. Sequência numérica de meses
meses_num <- 1:12
2 # Imprimindo a sequência criada## [1] 2 print(paste("Sequência de meses numéricos:", paste(meses_num, collapse = ", ")))## [1] "Sequência de meses numéricos: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12" # 3. Criando a sequência de datas mensais para 2023
data_inicio <- as.Date("2023-01-01")
sequencia_datas_2023 <- seq(from = data_inicio, by = "month", length.out = 12)
4 # Imprimindo a sequencia criada## [1] 4 print(sequencia_datas_2023, collapse = ", ")## [1] "2023-01-01" "2023-02-01" "2023-03-01" "2023-04-01" "2023-05-01"
## [6] "2023-06-01" "2023-07-01" "2023-08-01" "2023-09-01" "2023-10-01"
## [11] "2023-11-01" "2023-12-01"rep() é útil para a criação de dados para
simulações ou preenchimento de data frames.
# 1. Criando o vetor
vetor_repetido <- rep(c("Item X", "Item Y"), times = c(3, 2))
2 # Imprimindo o vetor## [1] 2 print(vetor_repetido)## [1] "Item X" "Item X" "Item X" "Item Y" "Item Y" # 3. Alternativa para repetição sequencial (cada elemento repetido 'n' vezes)
vetor_repetido_each <- rep(c("Item X", "Item Y"), each = 2)
4 # Imprimindo o vetor## [1] 4 print(vetor_repetido_each)## [1] "Item X" "Item X" "Item Y" "Item Y"A primeira solução times = c(3, 2) é a que responde ao
pedido direto. A segunda é para ilustrar each.
A função rep() é extremamente útil para a criação de
dados para simulações ou preenchimento de data frames porque permite
gerar rapidamente vetores com padrões repetidos. Em simulações, pode-se
gerar múltiplas observações para diferentes condições (ex:
rep("Tratamento A", 100)). No preenchimento de data frames,
é comum ter variáveis categóricas onde os níveis se repetem um certo
número de vezes, ou onde uma sequência de valores precisa ser replicada
para alinhar com outras colunas. Isso evita a digitação manual e garante
consistência nos dados.
c(100, 120, 150, 110, 80, 90, 100, 130, 200, 180, 170, 190).
Crie uma matriz 3x4 com esses dados, preenchendo por linha
(byrow = TRUE). Atribua nomes às linhas (“Produto A”,
“Produto B”, “Produto C”) e às colunas (“Q1”, “Q2”, “Q3”, “Q4”).
# 1. Criando o vetor, conforme enunciado do problema
dados_vendas <- c(100, 120, 150, 110, 80, 90, 100, 130, 200, 180, 170, 190)
# 2. Criando a matriz
matriz_vendas <- matrix(dados_vendas,
nrow = 3, ncol = 4, byrow = TRUE,
dimnames = list(
c("Produto A", "Produto B", "Produto C"),
c("Q1", "Q2", "Q3", "Q4")))
# O nome da linhas é o primeiro vetor da lista; e as colunas o segundo vetor da lista
3 # Imprimindo a matriz## [1] 3print(matriz_vendas)## Q1 Q2 Q3 Q4
## Produto A 100 120 150 110
## Produto B 80 90 100 130
## Produto C 200 180 170 190matriz_vendas criada no exercício anterior, calcule o total
de vendas para cada produto (soma das linhas) e o total de vendas para
cada trimestre (soma das colunas).
# 1. Assumindo que matriz_vendas já foi criada no exercício anterior
# 2. Calculando 0 total de vendas por produto (soma das linhas)
total_por_produto <- rowSums(matriz_vendas)
3 # Imprimindo o total de vendas por produto## [1] 3print(total_por_produto)## Produto A Produto B Produto C
## 480 400 740# 4. Calculando o total de vendas por trimestre (soma das colunas)
total_por_trimestre <- colSums(matriz_vendas)
5 # Imprimindo o total de vendas por trimestre## [1] 5print(total_por_trimestre)## Q1 Q2 Q3 Q4
## 380 390 420 430matriz_vendas do exercício anterior, acesse o valor de
vendas do “Produto B” no “Q3”. Em seguida, selecione todas as vendas do
“Produto A”.
# 1. Assumindo que matriz_vendas já foi criada no exercício anterior
2 # Acessar valor do Produto B no Q3## [1] 2matriz_vendas["Produto B", "Q3"]## [1] 1003 # Selecionar todas as vendas do Produto A## [1] 3matriz_vendas["Produto A", ]## Q1 Q2 Q3 Q4
## 100 120 150 110matriz_vendas, selecione as vendas dos “Produtos A e C”
para os “Q1 e Q2”. Explique a diferença entre usar um índice numérico e
um índice de nome para acessar elementos em uma matriz.
# Assumindo que matriz já foi criada no exercício anterior
# Selecionar vendas dos Produtos A e C para Q1 e Q2
matriz_vendas[c("Produto A", "Produto C"), c("Q1", "Q2")]## Q1 Q2
## Produto A 100 120
## Produto C 200 180Diferença entre índice numérico e índice de nome: *
Índice Numérico: Acessa elementos com base em sua
posição (índice) na matriz, começando de 1. Ex:
matriz[1, 2] acessa o elemento da primeira linha, segunda
coluna. É rápido e direto. * Índice de Nome: Acessa
elementos usando os nomes atribuídos às linhas e colunas. Ex:
matriz["NomeLinha", "NomeColuna"]. Torna o código mais
legível e robusto a futuras alterações na ordem das linhas/colunas, pois
não depende da posição. Em contextos de produção ou colaboração, o uso
de nomes é geralmente preferível, pois melhora a compreensibilidade do
código e o torna menos propenso a erros quando a estrutura subjacente da
matriz pode mudar (ex: se uma nova linha/coluna for inserida, os índices
numéricos mudariam, mas os nomes permaneceriam válidos).
data.frame com as seguintes informações
para 3 estudantes: Nome (texto), Idade
(numérico), Curso (fator com níveis “Engenharia”,
“Medicina”, “Direito”), e Status_Ativo (lógico). Preencha
com dados fictícios.
# 1. Criando o data-frame
estudantes_df <- data.frame(
Nome = c("João Silva", "Maria Santos", "Pedro Almeida"),
Idade = c(22, 21, 23),
Curso = factor(c("Engenharia", "Medicina", "Direito"),
levels = c("Engenharia", "Medicina", "Direito")),
Status_Ativo = c(TRUE, TRUE, FALSE)
)
2 # Imprimindo o data-frame## [1] 2print(estudantes_df)## Nome Idade Curso Status_Ativo
## 1 João Silva 22 Engenharia TRUE
## 2 Maria Santos 21 Medicina TRUE
## 3 Pedro Almeida 23 Direito FALSE(Nota: Por padrão, strings em data.frame são
convertidas para factor em versões mais antigas do R, mas
em versões recentes (R >= 4.0), elas permanecem
character a menos que stringsAsFactors = TRUE
seja especificado. O exemplo acima força factor para
Curso e o resultado mostra Nome como
factor por default.)
data.frame em relação a uma matriz em R para
armazenamento de dados tabulares? Dê um exemplo onde um
data.frame é mais adequado.
Resposta: A principal vantagem de um
data.frame em relação a uma matriz é que o
data.frame pode armazenar colunas com diferentes
tipos de dados, enquanto uma matriz exige que
todos os seus elementos sejam do mesmo tipo de dado. Essa flexibilidade
torna o data.frame a estrutura de dados mais fundamental e
amplamente utilizada para representar conjuntos de dados tabulares no R,
similar a uma tabela de banco de dados ou planilha.
Exemplo onde data.frame é mais adequado:
Imagine um conjunto de dados de clientes, onde você precisa
armazenar:
ID (numérico)Nome (texto)Idade (numérico)Ativo_no_sistema (lógico)Região (fator/texto)Uma matriz não conseguiria armazenar todos esses tipos de dados
juntos, pois tentaria coerção para um tipo comum (provavelmente texto),
perdendo a natureza numérica ou lógica original dos dados. Um
data.frame, por outro lado, manipula isso facilmente,
mantendo a integridade dos tipos de dados de cada coluna.
data.frame
estudantes_df criado anteriormente, acesse a coluna
Idade de duas maneiras diferentes: usando a notação
$ e a notação [[ ]]. Em seguida, selecione as
informações do estudante “Maria Santos”.
# 1. Assumindo que estudantes_df já foi criado
2 # Acessar coluna Idade usando $## [1] 2estudantes_df$Idade## [1] 22 21 23# 3. Acessar coluna Idade usando [[ ]]
idades_double_bracket <- estudantes_df[["Idade"]]
4 # Imprimindo ## [1] 4print(idades_double_bracket)## [1] 22 21 23# 5. Selecionar informações da estudante "Maria Santos"
maria_santos_info <- estudantes_df[estudantes_df$Nome == "Maria Santos", ]
6. # Imprimindo## [1] 6print(maria_santos_info)## Nome Idade Curso Status_Ativo
## 2 Maria Santos 21 Medicina TRUEdata.frame
estudantes_df, selecione apenas os nomes e os cursos dos
estudantes que estão Status_Ativo == TRUE.
# 1. Assumindo que estudantes_df já foi criado
# Selecionar nomes e cursos de estudantes ativos
estudantes_df[estudantes_df$Status_Ativo == TRUE, c("Nome", "Curso")]## Nome Curso
## 1 João Silva Engenharia
## 2 Maria Santos Medicinatemperaturas com valores
c(22.5, 23.1, 21.9).nome_estacao com o valor
"Verão 2023".data.frame observacoes_diarias com duas
colunas: Dia (inteiro de 1 a 3) e Chuva_mm
(numérico c(5, 0, 12)).# 1. Criando uma lista com temp (vetor), estacao (string) e dados_diarios (data.frame)
minha_lista <- list(
temp = c(22.5, 23.1, 21.9),
estacao = "Verão 2023",
dados_diarios = data.frame(Dia = 1:3, Chuva_mm = c(5, 0, 12))
)
2 # Imprimindo a lista## [1] 2print(minha_lista)## $temp
## [1] 22.5 23.1 21.9
##
## $estacao
## [1] "Verão 2023"
##
## $dados_diarios
## Dia Chuva_mm
## 1 1 5
## 2 2 0
## 3 3 123 # Imprimindo as características a lista criada## [1] 3print(str(minha_lista))## List of 3
## $ temp : num [1:3] 22.5 23.1 21.9
## $ estacao : chr "Verão 2023"
## $ dados_diarios:'data.frame': 3 obs. of 2 variables:
## ..$ Dia : int [1:3] 1 2 3
## ..$ Chuva_mm: num [1:3] 5 0 12
## NULLminha_lista criada
no exercício anterior, acesse o vetor temperaturas usando a
notação $ e o valor "Verão 2023" usando a
notação [[ ]] com o nome do elemento.
# Assumindo que minha_lista já foi criada
# Acessar o vetor temperaturas
minha_lista$temp## [1] 22.5 23.1 21.9# Acessar a string nome_estacao
minha_lista[["estacao"]]## [1] "Verão 2023"minha_lista$estacao## [1] "Verão 2023"minha_lista[[2]]## [1] "Verão 2023"minha_lista,
acesse o valor de Chuva_mm para o Dia = 3 do
data.frame dados_diarios que está dentro da
lista. Explique por que [[ ]] é preferível para acessar
elementos de uma lista quando se sabe o nome exato ou a posição.
# 1. Assumindo que minha_lista já foi criada
2 # Acessar Chuva_mm para o Dia 3## [1] 2minha_lista$dados_diarios$Chuva_mm[3]## [1] 123 # Alternativa: ## [1] 3minha_lista[["dados_diarios"]][3, "Chuva_mm"]## [1] 12Por que [[ ]] é preferível para acessar
elementos específicos: * [[ ]] é
usado para extrair um único elemento de uma lista pelo
seu nome ou posição, e o resultado é o próprio elemento (sem a estrutura
de lista). Por exemplo, minha_lista[[1]] ou
minha_lista[["temp"]] retornaria o vetor
c(22.5, 23.1, 21.9). * []
(colchete simples) é usado para extrair sub-listas (uma
ou mais partes da lista). O resultado é sempre outra lista. Por exemplo,
minha_lista[1] retornaria uma lista contendo o vetor
temperaturas. * $ é uma forma
sintática abreviada de [[ ]] para acessar elementos
nomeados, mas não funciona com índices numéricos ou variáveis para o
nome.
Portanto, quando se quer extrair o conteúdo *real* de um elemento da lista (não uma sub-lista) e você sabe o nome ou a posição, `[[ ]]` é o método mais explícito e robusto. Ele também permite o uso de variáveis para especificar o nome do elemento, o que `$` não permite (ex: `nome_elemento <- "temp"; minha_lista[[nome_elemento]]`).dados_temporarios = 1:10,
resultado_parcial = "ok",
analise_final = TRUE. Em seguida, remova apenas as
variáveis dados_temporarios e
resultado_parcial do ambiente de trabalho do R. Verifique
quais variáveis permanecem.
# 1. Criando variáveis para depois remover
dados_temporarios <- 1:10
resultado_parcial <- "ok"
analise_final <- TRUE
2 # Apresentando as variáveis criadas a partir do comando 'ls()'## [1] 2print("Variáveis antes de remover:")## [1] "Variáveis antes de remover:"print(ls())## [1] "analise_final" "dados_temporarios" "resultado_parcial"# 3. Removendo duas variáveis com o comando 'rm()'
rm(dados_temporarios, resultado_parcial)
3 # Imprimindo as variáveis que permaneceram depois da remoção## [1] 3print("Variáveis depois de remover:")## [1] "Variáveis depois de remover:"print(ls())## [1] "analise_final"A saída exata de ls() dependerá de quais variáveis foram
criadas nas execuções anteriores na mesma sessão).
Resposta:
Para remover todos os objetos do ambiente global, você pode usar:
rm(list = ls())Explicação: * ls(): Retorna um
vetor de strings com os nomes de todos os objetos no ambiente atual. *
rm(list = ...): A função rm() aceita um
argumento list que recebe um vetor de nomes de objetos a
serem removidos. Ao passar ls() para list,
você efetivamente remove todos os objetos listados.
**Por que é uma boa prática:**
Limpar o ambiente antes de iniciar um novo script ou análise é uma boa prática para garantir a **reprodutibilidade**, **evitar conflitos de nomes** e **gerenciar a memória**.
* **Reprodutibilidade:** Garante que o script será executado exatamente da mesma forma em qualquer máquina, sem depender de objetos remanescentes de sessões anteriores que podem não ser recriados.
* **Evitar Conflitos:** Previne que variáveis ou funções com o mesmo nome de sessões anteriores interfiram ou sobrescrevam resultados inesperadamente.
* **Gerenciamento de Memória:** Libera a memória RAM ocupada por objetos grandes e não mais necessários, o que é crucial ao trabalhar com conjuntos de dados extensos ou em ambientes com recursos limitados.protocolo = "Exp_A",
data_execucao = "2023-10-26",
responsavel = "Dr. Silva". Crie uma string
log_experimento que combine essas informações no formato:
“Experimento: Exp_A - Data: 2023-10-26 - Responsável: Dr. Silva”.
# 1. Criando as variáveis do enunciado
protocolo <- "Exp_A"
data_execucao <- "2023-10-26"
responsavel <- "Dr. Silva"
# 2. Concatenando essas variáveis
log_experimento <- paste("Experimento:", protocolo,
"- Data:", data_execucao,
"- Responsável:", responsavel)
3 # IMprimindo o resultado da variável concatenada## [1] 3print(log_experimento)## [1] "Experimento: Exp_A - Data: 2023-10-26 - Responsável: Dr. Silva"partes_url = c("https:/", "rpubs", "com", "adlauro", "estatistica_com_r").
Concatene esses elementos para formar uma URL completa no formato “https://rpubs.com/adlauro/estatistica_com_r”. Use uma
função que permita especificar o separador.
# 1. Criando o vetor conforme solicitado no enunciado
partes_url = c("https:/", "rpubs", "com", "adlauro", "estatistica_com_r")
# Concatenando as partes
url_completa <- paste0(partes_url[1],"/",partes_url[2],".",partes_url[3],"/",partes_url[4],"/",partes_url[5])
3 # Imprimindo as url## [1] 3print(url_completa)## [1] "https://rpubs.com/adlauro/estatistica_com_r"peso_kg = 75 e
altura_m = 1.75. Calcule o IMC usando a fórmula
IMC = peso / (altura^2).
# 1. Definindo as variáveis do enunciado
peso_kg <- 75
altura_m <- 1.75
# 2. Realizando o cálculo
imc <- peso_kg / (altura_m^2)
3 # Imprimindo o resultado## [1] 3print(paste("O IMC é:", round(imc, 2)))## [1] "O IMC é: 24.49"despesas = c(500, 200, 350, 150). Se cada despesa
deve ser convertida para dólares (considerando
cotacao_dolar = 5.36), calcule o valor total das despesas
em dólares e o valor médio de cada despesa em dólares.
# 1. Definindo as variáveis do enunciado
despesas <- c(500, 200, 350, 150)
cotacao_dolar <- 5.36
# 2. Realizando os cálculos
despesas_dolar <- despesas / cotacao_dolar
3 # Imprimindo os resultados## [1] 3print("Despesas em dólar (individual):")## [1] "Despesas em dólar (individual):"print(round(despesas_dolar, 2))## [1] 93.28 37.31 65.30 27.99# 4. Realizando os cálculos
total_despesas_dolar <- sum(despesas_dolar)
5 # Imprimindo os resultados## [1] 5print(paste("Total de despesas em dólar:", round(total_despesas_dolar, 2)))## [1] "Total de despesas em dólar: 223.88"# 6. Realizando os cálculos
media_despesas_dolar <- mean(despesas_dolar)
7 # Imprimindo os resultados## [1] 7print(paste("Média das despesas em dólar:", round(media_despesas_dolar, 2)))## [1] "Média das despesas em dólar: 55.97"pontuacao_final for
maior que 1000. Crie uma variável
pontuacao_final = 1050. Verifique se o participante é
elegível ao bônus. Em seguida, verifique se a
pontuacao_final é diferente de 1000.
pontuacao_final <- 1050
elegivel_bonus <- pontuacao_final > 1000
print(paste("É elegível ao bônus?", elegivel_bonus))## [1] "É elegível ao bônus? TRUE"diferente_de_mil <- pontuacao_final != 1000
print(paste("É diferente de 1000?", diferente_de_mil))## [1] "É diferente de 1000? TRUE"idades = c(18, 25, 16, 30, 22). Selecione apenas
as idades que são maiores ou iguais a 18 e
menores que 25.
idades <- c(18, 25, 16, 30, 22)
idades_selecionadas <- idades[idades >= 18 & idades < 25]
print(paste("Idades selecionadas:", paste(idades_selecionadas, collapse = ", ")))## [1] "Idades selecionadas: 18, 22"score_credito for maior que 700 OU a
renda_anual for maior que 50000. Crie as
variáveis score_credito = 680 e
renda_anual = 60000. Determine se o empréstimo é aprovado.
score_credito <- 680
renda_anual <- 60000
aprovado_emprestimo <- (score_credito > 700) | (renda_anual > 50000)
print(paste("Empréstimo aprovado?", aprovado_emprestimo))## [1] "Empréstimo aprovado? TRUE"condicao_A = TRUE e condicao_B = FALSE. Avalie
o resultado das seguintes expressões lógicas: !(condicao_A)
e (condicao_A & condicao_B) | condicao_A.
condicao_A <- TRUE
condicao_B <- FALSE
resultado1 <- !(condicao_A)
print(paste("!(condicao_A):", resultado1))## [1] "!(condicao_A): FALSE"resultado2 <- (condicao_A & condicao_B) | condicao_A
print(paste("(condicao_A & condicao_B) | condicao_A:", resultado2))## [1] "(condicao_A & condicao_B) | condicao_A: TRUE"resultado2:
(condicao_A & condicao_B) avalia para
(TRUE & FALSE), que é FALSE.(FALSE | condicao_A) avalia para
(FALSE | TRUE), que é TRUE.pi_aproximado = 3.1415926535. Arredonde este valor para 3
casas decimais. Em seguida, arredonde-o para o inteiro mais próximo
usando a regra padrão de arredondamento (0.5 para cima).
pi_aproximado <- 3.1415926535
# Arredondar para 3 casas decimais
pi_arredondado_3casas <- round(pi_aproximado, digits = 3)
print(paste("Pi arredondado para 3 casas:", pi_arredondado_3casas))## [1] "Pi arredondado para 3 casas: 3.142"# Arredondar para o inteiro mais próximo
pi_arredondado_inteiro <- round(pi_aproximado)
print(paste("Pi arredondado para inteiro:", pi_arredondado_inteiro))## [1] "Pi arredondado para inteiro: 3"preco_bruto = 12.5678. Utilize as funções
floor() e ceiling() para obter o menor inteiro
maior ou igual a preco_bruto e o maior inteiro menor ou
igual a preco_bruto, respectivamente. Explique a diferença
no uso de floor e ceiling em comparação com
round.
preco_bruto <- 12.5678
# Menor inteiro maior ou igual (teto)
preco_teto <- ceiling(preco_bruto)
print(paste("Preço (teto):", preco_teto))## [1] "Preço (teto): 13"# Maior inteiro menor ou igual (piso)
preco_piso <- floor(preco_bruto)
print(paste("Preço (piso):", preco_piso))## [1] "Preço (piso): 12"floor, ceiling
e round:
round(x, digits): Arredonda
x para o número de casas decimais especificado em
digits. O arredondamento é feito para o número mais
próximo, com 0.5 sendo arredondado para o inteiro par mais próximo
(regra “round half to even” no R por padrão, embora o comportamento
possa parecer como “round half up” para muitos casos com números
positivos).floor(x): Retorna o maior inteiro que
é menor ou igual a x. Ele “arredonda para baixo” em direção
ao infinito negativo.ceiling(x): Retorna o menor inteiro
que é maior ou igual a x. Ele “arredonda para cima” em
direção ao infinito positivo.round visa aproximar um número, floor
e ceiling visam sempre para baixo ou para cima,
respectivamente, independentemente da proximidade ao inteiro. Isso é
útil em contextos como cálculo de quantidades mínimas ou máximas,
alocações de recursos, ou faixas de preços.prob_evento_raro com o valor 0.000000000123 e
uma variável populacao_global com o valor
8000000000. Exiba ambos os números no console e observe
como o R os representa.
prob_evento_raro <- 0.000000000123
populacao_global <- 8000000000
print(prob_evento_raro)## [1] 1.23e-10print(populacao_global)## [1] 8e+09O R automaticamente converte números muito pequenos ou muito grandes
para notação científica (também conhecida como notação exponencial) para
uma representação mais concisa e legível. e-10 significa
* 10^-10 e e+09 significa
* 10^9.
3.45e-3 e
1.8e+5. Explique a conveniência da notação científica para
a legibilidade de dados em escala muito diferente.
valor_pequeno_notacao <- 3.45e-3
valor_grande_notacao <- 1.8e+5
# Para exibir em formato decimal padrão, pode-se ajustar as opções de impressão
options(scipen = 999) # Desativa a notação científica para números grandes
print(valor_pequeno_notacao)## [1] 0.00345print(valor_grande_notacao)## [1] 180000options(scipen = 0) # Volta ao padrão3.45e-3 significa 3.45 * 10^-3, que é
0.00345.1.8e+5 significa 1.8 * 10^5, que é
180000.0.000000000123 ou 8000000000, mas
1.23e-10 e 8e+09 são inequívocos.1e-5 é 100
vezes maior que 1e-7) sem contar zeros.