# Criando um vetor de números inteiros
vetor_inteiro <- c(2, 4, 6, 8, 10)
# Criando um vetor de números reais
vetor_real <- c(3.14, 1.618, 2.718, 3.48, 1.9)
# Criando um vetor de caracteres
vetor_caracteres <- c("maçã", "banana", "laranja")
# Criando um vetor misto
vetor_misto <- c(1, 2, "maçã", "banana", "laranja")3 Objetos em R
3.1 Vetores em R
Vamos recapitular um pouco do que vimos anteriormento sobre vetores. Os vetores são um bloco de construção básica para programação em R. Vetores são muito versáteis, formando a base para construções mais complexas, como matrizes, listas e data frames. Eles desempenham um papel central na manipulação de dados.
Um vetor é uma estrutura de dados fundamental que consiste em uma sequência ordenada de elementos do mesmo tipo. Esses elementos podem ser números inteiros, números de ponto flutuante, caracteres, valores lógicos ou qualquer outro tipo de dado.
Em termos mais simples, um vetor é como uma “caixa” que pode conter vários valores do mesmo tipo. Cada valor dentro do vetor é chamado de elemento. Os elementos de um vetor podem ser acessados individualmente por meio de um índice que indica sua posição na sequência. Em R o primeiro elemento de um vetor é acessado pelo índice [1], em outras linguagens, como em Python, esse índice é [0].
3.1.1 Criação de Vetores e Manipulação de Propriedades
Um vetor em R é uma sequência ordenada de elementos do mesmo tipo. Você pode criar um vetor usando a função c(), que combina elementos em um único vetor. Por exemplo:
Para sabermos o comprimento de um vetor utilizamos a função length().
length(vetor_inteiro)[1] 5length(vetor_real)[1] 5length(vetor_caracteres)[1] 3length(vetor_misto)[1] 5Para sabermos a classe de um vetor utilizamos a função class().
3.1.2 Operações Aritméticas Vetoriais
Operações aritméticas em vetores são realizadas elemento por elemento, facilitando cálculos eficientes. Por exemplo:
# Soma de vetores
soma_vetores <- vetor_inteiro + vetor_real
soma_vetores[1] 5.140 5.618 8.718 11.480 11.900# Subtração de vetores
subtracao_vetores <- vetor_real - vetor_inteiro
subtracao_vetores[1] 1.140 -2.382 -3.282 -4.520 -8.100# Multiplicação de vetores
multiplicacao_vetores <- vetor_inteiro * 2
multiplicacao_vetores[1] 4 8 12 16 20# Divisão de vetores
divisao_vetores <- vetor_real / 3
divisao_vetores[1] 1.0466667 0.5393333 0.9060000 1.1600000 0.63333333.1.3 Aplicação da Regra da Reciclagem
A regra da reciclagem permite aplicar operações entre vetores de tamanhos diferentes. Essa regra permite que vetores de tamanhos distintos sejam combinados de maneira coerente em operações aritméticas ou lógicas. O vetor menor é “reciclado” ou replicado várias vezes para se ajustar ao tamanho do vetor maior, permitindo que as operações sejam realizadas de forma consistente em todos os elementos.
Para compreender melhor a regra da reciclagem, considere a seguinte operação:
Warning in vetor_a + vetor_b: longer object length is not a multiple of shorter
object lengthresultado[1] 11 22 31length(vetor_a)[1] 2length(vetor_b)[1] 3Note que o vetor vetor_a tem apenas dois elementos, enquanto o vetor vetor_b tem três elementos. Ao realizar a operação de adição, a regra da reciclagem faz com que o vetor vetor_a seja replicado para corresponder ao tamanho do vetor vetor_b. Isso resulta em vetor_a transformado em c(1, 2, 1) e, então, a operação de adição é realizada elemento a elemento:
Vale ressaltar que a regra da reciclagem funciona quando o comprimento do vetor maior é um múltiplo inteiro do comprimento do vetor menor. Caso contrário, um aviso ou erro será gerado.
3.1.4 Exploração de Vetores Lógicos
Vetores lógicos desempenham um papel crucial na programação e análise de dados, permitindo a seleção e filtragem de elementos com base em condições específicas. Um vetor lógico contém valores booleanos (TRUE ou FALSE), onde cada elemento indica se uma determinada condição é verdadeira ou falsa para o elemento correspondente no vetor original.
3.1.4.1 Aplicação de Vetores Lógicos: Filtragem e Seleção
Os vetores lógicos são frequentemente usados para filtrar e selecionar elementos de um vetor com base em uma condição. Suponha que temos um vetor de idades e queremos selecionar apenas as idades maiores que 18:
idades <- c(16, 21, 14, 30, 25)
condicao <- idades > 18
condicao[1] FALSE TRUE FALSE TRUE TRUEidades_maiores <- idades[condicao]
idades_maiores[1] 21 30 25## Também poderiamos incluir a condição
## diretamente no vetor que queremos filtrar
idades_maiores <- idades[idades > 18]
idades_maiores[1] 21 30 253.1.4.2 Operações Lógicas em Vetores Lógicos
Além da filtragem, os vetores lógicos podem ser combinados com operações lógicas. Por exemplo, é possível usar operadores como & (AND) e | (OR) para criar condições mais complexas:
idades <- c(16, 21, 14, 30, 25, 45)
condicao1 <- idades > 18
condicao2 <- idades < 30
condicao_final <- condicao1 & condicao2
idades_selecionadas <- idades[condicao_final]
idades_selecionadas[1] 21 25## Também poderiamos incluir a condição
## diretamente no vetor que queremos filtrar
idades_selecionadas <- idades[condicao_final]
idades_selecionadas <- idades[idades > 18 & idades < 30]3.1.5 Tratamento de Informações Faltantes
Ao lidar com dados do mundo real, é comum encontrar diversos tipos de informações faltantes, como valores ausentes (NA), valores que não são um número (NaN). O tratamento adequado desses valores é essencial para garantir a integridade das análises estatísticas.
3.1.5.1 Valores Ausentes (NA)
O valor NA (Not Available) é usado em R para representar informações ausentes. É fundamental identificar e tratar esses valores ao realizar análises estatísticas.
3.1.5.1.1 Identificação de Valores NA
Para identificar valores NA, você pode usar a função is.na():
3.1.5.1.2 Remoção de Valores NA
As funções na.omit() e na.exclude removem os valores NA de um vetor, mas pode levar à perda de outros dados associados:
[1] 1 3 4
attr(,"na.action")
[1] 2 5
attr(,"class")
[1] "omit"dados_sem_na_exclude <- na.exclude(dados)
dados_sem_na_exclude[1] 1 3 4
attr(,"na.action")
[1] 2 5
attr(,"class")
[1] "exclude"
3.1.5.1.3 Preenchimento de Valores NA
3.1.5.2 Valores que Não São um Número (NaN)
O valor NaN (Not a Number) é usado para representar resultados matemáticos inválidos, como a divisão por zero ou a raiz quadrada de um número negativo.
3.1.5.2.1 Identificação de Valores NaN
A função is.nan() identifica valores NaN:
resultado <- 0 / 0
resultado[1] NaNvalor_nao_eh_numero <- is.nan(resultado)
valor_nao_eh_numero[1] TRUE3.1.6 Vetores nomeados
Podemos atribuir um “nome” para cada elemento de um vetor. Com isso, podemos selecionar elementos nomeados do nosso vetor.
3.2 Matrizes
As matrizes e arrays são estruturas de dados bidimensionais e multidimensionais, respectivamente. Suas propriedades e funções permitem realizar uma variedade de operações, desde cálculos matriciais até resolução de sistemas lineares e decomposições espectrais.
3.2.1 Criação e Manipulação de Matrizes em R
A maneira mais simples para criarmos uma matriz em R é através das funções cbind() e rbind(), nas quais podemos concatenar vetores pelas colunas (columns) ou linhas (rows), respectivamente.
[,1] [,2] [,3] [,4]
vetor_a 1 2 3 4
vetor_b 5 6 7 8class(matriz_linha)[1] "matrix" "array" is.matrix(matriz_linha)[1] TRUEmatriz_coluna= cbind(vetor_a,
vetor_b)
matriz_coluna vetor_a vetor_b
[1,] 1 5
[2,] 2 6
[3,] 3 7
[4,] 4 8class(matriz_coluna)[1] "matrix" "array" is.matrix(matriz_coluna)[1] TRUEMatrizes também podem ser criadas através da função matrix(), que permite especificar os elementos, o número de linhas e colunas, e se os elementos devem ser preenchidos por linha ou por coluna.
3.2.2 Seleção de Elementos em Matrizes no R
A seleção de elementos em matrizes no R é uma operação fundamental para acessar e manipular dados específicos contidos na matriz. As técnicas de seleção permitem obter valores individuais, linhas, colunas ou subconjuntos da matriz com base em critérios específicos. Vamos explorar as diferentes formas de seleção de elementos em matrizes.
3.2.2.1 Seleção de Elementos Específicos
Podemos selecionar elementos específicos de uma matriz informando o número da linha e da coluna correspondentes.
3.2.2.2 Seleção de Linhas ou Colunas Inteiras
Podemos selecionar todas as entradas de uma linha ou coluna especificada.
coluna_2 <- A[, 2] # Seleciona a segunda coluna inteira
coluna_2[1] -1 4 -2linha_1 <- A[1, ] # Seleciona a primeira linha inteira
linha_1[1] 2 -1 33.2.2.3 Seleção com Base em Condições
Podemos selecionar elementos com base em condições específicas. A função which() é útil para selecionar elementos em matrizes com base em condições específicas. Ela retorna os elementos que atendem à condição fornecida.
## Exemplo 1: Seleção de Elementos Maiores que um Valor
B [,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9elementos_maior_que_3 <- B[which(B > 3)]
elementos_maior_que_3[1] 4 5 6 7 8 9## Exemplo 2: Seleção de Elementos Ímpares
elementos_impares <- B[which(B %% 2 != 0)]
elementos_impares[1] 1 3 5 7 93.2.2.4 Remoção de Linhas/Colunas (A[-linhas, -colunas])
Podemos remover linhas ou colunas da matriz, criando uma nova matriz sem as linhas ou colunas especificadas.
A [,1] [,2] [,3]
[1,] 2 -1 3
[2,] 1 4 1
[3,] 5 -2 7A_sem_terceira_coluna <- A[, -3] # Remove a terceira coluna da matriz
A_sem_terceira_coluna [,1] [,2]
[1,] 2 -1
[2,] 1 4
[3,] 5 -2A_sem_primeiras_duas_linhas <- A[-(1:2), ] # Remove as duas primeiras linhas da matriz
A_sem_primeiras_duas_linhas[1] 5 -2 7A_sem_linha_coluna <- A[-1, -2] # Remove a primeira linha e segunda coluna
A_sem_linha_coluna [,1] [,2]
[1,] 1 1
[2,] 5 73.2.3 Operações Matriciais e Funções de Matrizes
As operações matriciais e funções associadas desempenham um papel fundamental na manipulação e análise de dados em matrizes. Elas permitem realizar cálculos matemáticos essenciais para diversas aplicações, incluindo álgebra linear e estatísticas.
3.2.3.1 Soma e Subtração (A + B e A - B)
A adição e subtração de matrizes envolvem a combinação de elementos correspondentes nas matrizes A e B. As dimensões das matrizes devem ser compatíveis para que essas operações sejam válidas. Para verificarmos a dimensão de uma matriz utilizamos a função dim().
[,1] [,2] [,3]
[1,] 4 -3 7
[2,] 10 1 1
[3,] -5 2 3dim(A) [1] 3 3 [,1] [,2] [,3]
[1,] 2 -1 3
[2,] 1 4 1
[3,] 5 -2 7dim(B)[1] 3 3soma <- A + B
soma [,1] [,2] [,3]
[1,] 6 -4 10
[2,] 11 5 2
[3,] 0 0 10dim(soma)[1] 3 3subtracao <- A - B
subtracao [,1] [,2] [,3]
[1,] 2 -2 4
[2,] 9 -3 0
[3,] -10 4 -4dim(subtracao)[1] 3 33.2.3.2 Soma das Colunas (colSums(A)) e Soma das Linhas (rowSums(A))
Essas funções retornam vetores com as somas das colunas e das linhas da matriz A, respectivamente.
3.2.3.3 Média das Colunas (colMeans()) e Média das Linhas (rowMeans())
As funções colMeans() e rowMeans() fornecem as médias das colunas e das linhas de uma matriz, respectivamente.
3.2.3.4 Multiplicação por Escalar (k * A)
A multiplicação por um escalar \(k\) envolve a multiplicação de todos os elementos da matriz A pelo valor de \(k\).
k <- 2
A [,1] [,2] [,3]
[1,] 4 -3 7
[2,] 10 1 1
[3,] -5 2 3multiplicacao_escalar <- k * A
multiplicacao_escalar [,1] [,2] [,3]
[1,] 8 -6 14
[2,] 20 2 2
[3,] -10 4 63.2.3.5 Produto Elemento a Elemento (A * B)
O produto elemento a elemento envolve a multiplicação dos elementos correspondentes nas matrizes A e B. As dimensões das matrizes devem ser idênticas para que essa operação seja válida.
A [,1] [,2] [,3]
[1,] 4 -3 7
[2,] 10 1 1
[3,] -5 2 3B [,1] [,2] [,3]
[1,] 2 -1 3
[2,] 1 4 1
[3,] 5 -2 7produto_elemento_a_elemento <- A * B
produto_elemento_a_elemento [,1] [,2] [,3]
[1,] 8 3 21
[2,] 10 4 1
[3,] -25 -4 213.2.3.6 Produto Matricial (A %*% B)
O produto matricial é uma operação fundamental na álgebra linear. É obtido multiplicando as linhas da matriz A pelas colunas da matriz B e somando os resultados. As dimensões das matrizes devem ser compatíveis para essa operação.
produto_matricial <- A %*% B
produto_matricial [,1] [,2] [,3]
[1,] 40 -30 58
[2,] 26 -8 38
[3,] 7 7 8
3.2.3.7 Transposta (t(A))
A transposta de uma matriz A é obtida trocando suas linhas por colunas e vice-versa. Ela é denotada por \(t(A)\) e é usada em várias operações, como multiplicação matricial e decomposições.
A [,1] [,2] [,3]
[1,] 4 -3 7
[2,] 10 1 1
[3,] -5 2 3transposta_A <- t(A)
transposta_A [,1] [,2] [,3]
[1,] 4 10 -5
[2,] -3 1 2
[3,] 7 1 33.2.3.8 Determinante (det(A))
O determinante de uma matriz A é um valor escalar, e é utilizado para resolver sistemas de equações lineares, calcular inversas de matrizes e determinar propriedades de transformações geométricas.
determinante_A <- det(A)
determinante_A[1] 284
3.2.3.9 Inversa (solve(A))
A inversa de uma matriz A é uma matriz B tal que \(A \cdot B\) é a matriz identidade. Nem todas as matrizes têm inversa, e a função solve() calcula a inversa da matriz, quando possível.
inversa_A <- solve(A)
inversa_A [,1] [,2] [,3]
[1,] 0.003521127 0.08098592 -0.03521127
[2,] -0.123239437 0.16549296 0.23239437
[3,] 0.088028169 0.02464789 0.11971831
3.2.3.10 Diagonal (diag(A))
A função diag(A) retorna os elementos da diagonal principal da matriz A.
Para alterar os elementos da diagonal principal de uma matriz, podemos usar a função diag(), e atribuirmos à essa diagonal os valores desejados.
3.2.3.11 Autovalores e Autovetores (eigen(A))
Os autovalores e autovetores de uma matriz A são fundamentais em álgebra linear e em várias aplicações. A função eigen() retorna uma lista contendo os autovalores e autovetores de A.
autovalores_autovetores_A <- eigen(A)
autovalores_autovetores_Aeigen() decomposition
$values
[1] -1.136866+8.17786i -1.136866-8.17786i 2.273732+0.00000i
$vectors
[,1] [,2] [,3]
[1,] 0.04168976-0.5867388i 0.04168976+0.5867388i 0.1586595+0i
[2,] -0.69986415+0.0000000i -0.69986415+0.0000000i 0.8877981+0i
[3,] 0.37875419+0.1439966i 0.37875419-0.1439966i 0.4320205+0i
3.2.3.12 Produto Matricial Transposto (crossprod(A, B)) e Produto Matricial de A e B Transposto (tcrossprod(A, B))
Essas funções realizam o produto matricial de A e B, considerando suas transpostas.
O produto cruzado é também conhecido como “produto matricial interno” e é utilizado para diversos ajustes de modelos, análise multivariada, etc. Dada uma matriz A e uma matriz B, o produto interno entre elas é denotado como \(A^T \cdot B\) , e é calculado pela função crossprod(A, B).
produto_transposto <- crossprod(A, B)
produto_transposto [,1] [,2] [,3]
[1,] -15 50 -25
[2,] 4 -1 5
[3,] 15 -3 22O produto matricial externo também é conhecido como “produto matricial externo transposto” e é utilizada na mesmas ocasiões do primeiro. Dada uma matriz A e uma matriz B, o produto externo transposto entre elas é denotado como \(A \cdot B^T\) , e é calculado pela função tcrossprod(A, B).
produto_transposto_t <- tcrossprod(A, B)
produto_transposto_t [,1] [,2] [,3]
[1,] 24 -5 55
[2,] 23 11 57
[3,] -12 3 -293.2.3.13 Nomes de Linhas e Colunas (rownames(A), colnames(A))
As funções rownames() e colnames() permitem atribuir nomes às linhas e colunas de uma matriz, facilitando a identificação de elementos em análises e visualizações.
3.2.3.14 Matrizes Triangulares no R: Funções upper.tri() e lower.tri()
Matrizes triangulares desempenham são úteis quando o objetivo é economizar espaço de armazenamento e realizar cálculos mais eficientes. No R, as funções upper.tri() e lower.tri() são usadas para identificar os elementos acima e abaixo da diagonal principal de uma matriz, respectivamente.
3.2.3.14.1 Identificando Elementos Acima da Diagonal Principal (upper.tri())
A função upper.tri() retorna uma matriz de elementos lógicos que indica quais elementos de uma matriz estão acima da diagonal principal. Os elementos TRUE indicam que o elemento correspondente está acima da diagonal, enquanto os elementos FALSE indicam que o elemento está na diagonal ou abaixo dela.
3.2.3.14.2 Identificando Elementos Abaixo da Diagonal Principal (lower.tri())
Da mesma forma, a função lower.tri() retorna uma matriz de elementos lógicos que indica quais elementos estão abaixo da diagonal principal.
3.3 Arrays
Arrays são estruturas multidimensionais úteis para armazenar e manipular dados em várias dimensões, são usados em diversas áreas, como processamento de imagens, simulações numéricas, análise de dados multidimensionais e modelagem estatística. Eles são essenciais para lidar com dados que possuem mais de duas dimensões, onde as matrizes não são suficientes para representar a complexidade dos dados. Eles podem ser criados usando a função array(), onde você especifica os elementos do array e suas dimensões.
3.3.1 Criando Arrays
Podemos criar um array usando a função array() da seguinte maneira:
3.3.2 Acessando Elementos
Os elementos de um array são acessados usando índices que indicam a posição em cada dimensão. Por exemplo, para acessar o elemento na segunda linha, terceira coluna e quarta “profundidade” de um array arr, devemos fazer:
elemento <- arr[2, 3, 4]
elemento[1] 24Para acessarmos todos os elementos da primeira camada podemos fazer o seguinte:
arr[, , 1] [,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 63.3.3 Operações com Arrays
Assim como com vetores e matrizes, você pode realizar várias operações com arrays:
Soma e Subtração: Arrays podem ser somados e subtraídos elemento a elemento, desde que tenham as mesmas dimensões.
Multiplicação por Escalar: Você pode multiplicar um array por um escalar, o que multiplicará cada elemento do array pelo escalar.
Produto Elemento a Elemento: Dois arrays com as mesmas dimensões podem ser multiplicados elemento a elemento.
Operações Estatísticas: Funções como
sum(),mean(),max(),min()podem ser aplicadas aos elementos do array, opcionalmente especificando a dimensão ao longo da qual a operação deve ser realizada.
3.4 Data Frames em R
Data Frames são estruturas de dados bidimensionais em R, semelhantes a tabelas, que podem armazenar diferentes tipos de dados em suas colunas. Eles são amplamente utilizados para análise e manipulação de dados. Data Frames são uma estrutura de dados fundamental em R, e são usados em muitas aplicações, como análise de dados, modelagem estatística, visualização de dados e muito mais.
3.4.1 Criação de Data Frames
Para criar um Data Frame em R, podemos utilizar a função data.frame(). Cada argumento da função representa uma coluna do Data Frame.
# Exemplo de criação de Data Frame
meu_data_frame <- data.frame(
nome = c("Alice", "Bob", "Carol", "Ana", "João", "Carlos", "Patrícia", "Leonardo"),
idade = c(25, 30, 28, 20, 27, 50, 60, 45),
salario = c(5000, 6000, 5500, 8000, 2000, 3500, 10000, 3800 ),
meio_de_transporte = c('onibus', 'bicicleta', 'onibus', 'carro', 'carro', 'onibus', 'onibus', 'bicicleta')
)
## Nomes de colunas do nosso data.frame não possuem espaço, podem ser separadas por "." ou "_".Importante: Os vetores que compõem um Data Frame devem ter o mesmo comprimento. Caso contrário, o R reciclará os valores para preencher as colunas.
3.4.2 Imprimindo Data Frames
Para visualizar o conteúdo de um Data Frame, basta digitar o nome do Data Frame no console.
meu_data_frame nome idade salario meio_de_transporte
1 Alice 25 5000 onibus
2 Bob 30 6000 bicicleta
3 Carol 28 5500 onibus
4 Ana 20 8000 carro
5 João 27 2000 carro
6 Carlos 50 3500 onibus
7 Patrícia 60 10000 onibus
8 Leonardo 45 3800 bicicletaPara visualizar as primeiras linhas de um Data Frame, você pode usar a função head().
head(meu_data_frame) nome idade salario meio_de_transporte
1 Alice 25 5000 onibus
2 Bob 30 6000 bicicleta
3 Carol 28 5500 onibus
4 Ana 20 8000 carro
5 João 27 2000 carro
6 Carlos 50 3500 onibusPara visualizar as últimas linhas de um Data Frame, você pode usar a função tail().
tail(meu_data_frame) nome idade salario meio_de_transporte
3 Carol 28 5500 onibus
4 Ana 20 8000 carro
5 João 27 2000 carro
6 Carlos 50 3500 onibus
7 Patrícia 60 10000 onibus
8 Leonardo 45 3800 bicicletaPara ter uma visão geral do Data Frame, você pode usar a função str().
str(meu_data_frame)'data.frame': 8 obs. of 4 variables:
$ nome : chr "Alice" "Bob" "Carol" "Ana" ...
$ idade : num 25 30 28 20 27 50 60 45
$ salario : num 5000 6000 5500 8000 2000 3500 10000 3800
$ meio_de_transporte: chr "onibus" "bicicleta" "onibus" "carro" ...3.4.3 Acessando Colunas
Você pode acessar as colunas de um Data Frame usando o operador $ ou colchetes [].
# Acessar coluna usando o operador $
meu_data_frame$nome[1] "Alice" "Bob" "Carol" "Ana" "João" "Carlos" "Patrícia"
[8] "Leonardo"# Acessar coluna usando colchetes []
meu_data_frame[, "idade"][1] 25 30 28 20 27 50 60 453.4.4 Adcionando variáveis (colunas)
Para adcionar novas colunas em um data.frame podemos simplesmente atribuir seus valores através do seguinte código:
meu_data_frame$genero <- c("F", "M", "F", "F", "M", "M", "F", "M")3.4.5 Subconjuntos de Data Frames
Para criar subconjuntos de Data Frames, você pode usar a função subset() ou colchetes [] com condições lógicas.
subconjunto_df <- meu_data_frame[meu_data_frame$idade > 28, ] # Seleciona pessoas com idade maior que 28
subconjunto_df nome idade salario meio_de_transporte genero
2 Bob 30 6000 bicicleta M
6 Carlos 50 3500 onibus M
7 Patrícia 60 10000 onibus F
8 Leonardo 45 3800 bicicleta M# Usando a função subset()
subconjunto_df <- subset(meu_data_frame, idade > 28)
subconjunto_df nome idade salario meio_de_transporte genero
2 Bob 30 6000 bicicleta M
6 Carlos 50 3500 onibus M
7 Patrícia 60 10000 onibus F
8 Leonardo 45 3800 bicicleta Msubconjunto_combinado <- meu_data_frame[meu_data_frame$idade > 25 & meu_data_frame$idade < 30, ]
subconjunto_combinado nome idade salario meio_de_transporte genero
3 Carol 28 5500 onibus F
5 João 27 2000 carro MPodemos acessar a classe individualmente de uma coluna do nosso data.frame utilizando class().
Podemos acessar a estrutura dos nossos dados utilizando a função str().
str(meu_data_frame)'data.frame': 8 obs. of 5 variables:
$ nome : chr "Alice" "Bob" "Carol" "Ana" ...
$ idade : num 25 30 28 20 27 50 60 45
$ salario : num 5000 6000 5500 8000 2000 3500 10000 3800
$ meio_de_transporte: chr "onibus" "bicicleta" "onibus" "carro" ...
$ genero : chr "F" "M" "F" "F" ...As dimensões de um data.frame podem ser dadas por dim().
dim(meu_data_frame)[1] 8 5Para sabermos o número de observações em um data.frame podemos utilizar a função nrow().
nrow(meu_data_frame)[1] 8Para obtermos o número de colunas em um data.frame podemos utilizar a função ncol().
ncol(meu_data_frame)[1] 5
3.4.6 Função summary()
A função summary() é usada para obter um resumo estatístico das variáveis em um Data Frame. Ela fornece estatísticas como média, mediana, mínimo, máximo e quartis para cada coluna numérica.
summary(meu_data_frame) nome idade salario meio_de_transporte
Length:8 Min. :20.00 Min. : 2000 Length:8
Class :character 1st Qu.:26.50 1st Qu.: 3725 Class :character
Mode :character Median :29.00 Median : 5250 Mode :character
Mean :35.62 Mean : 5475
3rd Qu.:46.25 3rd Qu.: 6500
Max. :60.00 Max. :10000
genero
Length:8
Class :character
Mode :character
3.4.7 Função by()
A função by() é usada para aplicar uma função a subconjuntos de um Data Frame, com base em uma ou mais variáveis. Ela é útil para realizar operações em grupos de dados.
# Exemplo de uso da função by()
resultado <- by(meu_data_frame$salario, meu_data_frame$idade, mean)
resultadomeu_data_frame$idade: 20
[1] 8000
------------------------------------------------------------
meu_data_frame$idade: 25
[1] 5000
------------------------------------------------------------
meu_data_frame$idade: 27
[1] 2000
------------------------------------------------------------
meu_data_frame$idade: 28
[1] 5500
------------------------------------------------------------
meu_data_frame$idade: 30
[1] 6000
------------------------------------------------------------
meu_data_frame$idade: 45
[1] 3800
------------------------------------------------------------
meu_data_frame$idade: 50
[1] 3500
------------------------------------------------------------
meu_data_frame$idade: 60
[1] 10000resultado <- by(meu_data_frame$salario, meu_data_frame$genero, median)
resultadomeu_data_frame$genero: F
[1] 6750
------------------------------------------------------------
meu_data_frame$genero: M
[1] 36503.4.8 Resumo
3.4.8.1 Funções para Explorar Data Frames
3.4.8.2 Manipulação de Data Frames
- Adição de colunas:
meu_data_frame$nova_coluna <- valores - Remoção de colunas:
meu_data_frame$coluna_a_ser_removida <- NULL - Filtragem de linhas:
subconjunto <- meu_data_frame[meu_data_frame$idade > 25, ] - Ordenação:
ordenado <- meu_data_frame[order(meu_data_frame$idade), ]
3.5 Fatores
Fatores são uma estrutura de dados especial em R usada para representar variáveis categóricas, ou seja, variáveis que assumem um conjunto limitado e definido de valores. Os fatores são especialmente úteis para armazenar informações categóricas de maneira eficiente e para realizar análises estatísticas em dados categóricos.
3.5.1 Criação de Fatores
Você pode criar um fator em R usando a função factor(). É necessário fornecer um vetor de valores categóricos e, opcionalmente, os níveis que esses valores podem assumir.
# Exemplo de criação de fator
genero <- factor(c("Masculino", "Feminino", "Masculino", "Feminino"))
# Exenplo com diferentes níveis
estadiamento_doenca <- factor(c("Estágio I", "Estágio II", "Estágio I", "Estágio III", "Estágio IV"),
levels = c("Estágio I", "Estágio II", "Estágio III", "Estágio IV"))3.5.2 Transformação em fatores
Muitas vezes podemos estar interessados em transformar uma variável em um fator, para isso, utilizamos a função as.factor.
meu_data_frame$genero[1] "F" "M" "F" "F" "M" "M" "F" "M"meu_data_frame$genero = as.factor(meu_data_frame$genero)
meu_data_frame$genero[1] F M F F M M F M
Levels: F M3.5.3 Níveis de Fatores
Os níveis de um fator são os valores únicos que a variável categórica pode assumir. Se você não fornecer os níveis explicitamente, o R inferirá os níveis a partir dos valores presentes. Além disso, os níveis serão ordenados em ordem alfanumérica, caso omitidos. É importante passarmos os níveis (levels) quando lidamos com variáveis ordinais.
3.5.4 Acessando Níveis e Valores de Fatores
Você pode acessar os níveis de um fator usando a função levels() e os valores do fator como um vetor usando o fator diretamente. Para sabermos a quantidade de níveis de um fator podemos utilizar a função nlevels()
# Acessar níveis de um fator
niveis_cores <- levels(cores)
niveis_cores[1] "Vermelho" "Verde" "Azul" "Amarelo" # Acessar o número de níveis de um fator
n_niveis_cores <- nlevels(cores)
n_niveis_cores[1] 4# Acessar valores do fator
valores_cores <- cores
valores_cores[1] Vermelho Verde Azul
Levels: Vermelho Verde Azul Amarelo3.6 Tabelas de Dupla Entrada
Tabelas de dupla entrada, também conhecidas como tabelas de contingência, util para analisar a relação entre duas variáveis categóricas. Elas mostram a frequência ou contagem de ocorrências conjuntas dessas variáveis e são frequentemente usadas para entender associações e padrões nos dados.
3.6.1 Criando Tabelas de Dupla Entrada
Para criar uma tabela de dupla entrada em R, você pode usar a função table().
# Exemplo de criação de tabela de dupla entrada
sexo <- c("Masculino", "Feminino", "Masculino", "Masculino", "Feminino")
cidade <- c("A", "B", "A", "B", "A")
tabela_contingencia <- table(sexo, cidade)
tabela_contingencia cidade
sexo A B
Feminino 1 1
Masculino 2 1tabela_contingencia2 <- table(meu_data_frame$meio_de_transporte, meu_data_frame$genero)
tabela_contingencia2
F M
bicicleta 0 2
carro 1 1
onibus 3 1Visualizando Tabelas de Dupla Entrada:
Você pode visualizar a tabela de dupla entrada diretamente ou usar a função ftable() para obter uma exibição mais formatada.
3.6.2 Analisando Tabelas de Dupla Entrada
Você pode usar várias funções para analisar e obter informações úteis a partir de tabelas de dupla entrada.
- Marginais: Obtém as marginais (somas das linhas e colunas) da tabela.
marginais_linhas <- margin.table(tabela_contingencia, 1) # Somas das linhas
marginais_colunas <- margin.table(tabela_contingencia, 2) # Somas das colunas-
Teste Qui-Quadrado:
chisq.test()realiza o teste qui-quadrado para avaliar a independência das variáveis.
qui_quadrado <- chisq.test(tabela_contingencia)Warning in chisq.test(tabela_contingencia): Chi-squared approximation may be
incorrectprint(qui_quadrado)
Pearson's Chi-squared test with Yates' continuity correction
data: tabela_contingencia
X-squared = 0, df = 1, p-value = 1-
Proporções Relativas:
prop.table()calcula proporções relativas dentro das categorias.
proporcoes_relativas_linha <- prop.table(tabela_contingencia, margin = 1) # Proporções por linha
proporcoes_relativas_linha cidade
sexo A B
Feminino 0.5000000 0.5000000
Masculino 0.6666667 0.3333333proporcoes_relativas_coluna <- prop.table(tabela_contingencia, margin = 2) # Proporções por linha
proporcoes_relativas_coluna cidade
sexo A B
Feminino 0.3333333 0.5000000
Masculino 0.6666667 0.50000003.6.3 Lendo dados disponíveis no R
Para vermos os banco de dados disponíveis no R podemos utilizar a função data(), e para ler um deles basta chamar seu nome como argumento da função, por exemplo: data(USArrests).
3.6.4 Lendo dados externos
Na UFPR Virtual vocês encontram três conjuntos de dados sobre as queimadas no Brazil durante o ano de 2024. Salve esses arquivos na pasta do curso, dentro de um pasta data/FireWatch.
Para lermos esses dados podemos utilizar a função read.csv(), que lê arquivos .csv, e passar o caminho do arquivo como argumento da função.
# Lendo os dados de queimadas
Queimadas_Q1 <- read.csv("data/FireWatch/Dataset_FireWatch_Brazil_Q1_2024.csv")
head(Queimadas_Q1) data municipio estado bioma
1 2024-01-01 VALE DO ANARI RONDÔNIA Amazônia
2 2024-01-01 SÃO GABRIEL DA CACHOEIRA AMAZONAS Amazônia
3 2024-01-01 MANAQUIRI AMAZONAS Amazônia
4 2024-01-01 JUTAÍ AMAZONAS Amazônia
5 2024-01-01 AUTAZES AMAZONAS Amazônia
6 2024-01-01 IRANDUBA AMAZONAS Amazônia
avg_numero_dias_sem_chuva avg_precipitacao avg_risco_fogo avg_frp
1 0.0 1698.00 0 13.00
2 0.2 206.80 0 81.40
3 0.0 60.00 0 27.00
4 2.0 776.00 0 211.00
5 0.0 2.22 0 97.67
6 0.0 0.00 0 55.50str(Queimadas_Q1)'data.frame': 43753 obs. of 8 variables:
$ data : chr "2024-01-01" "2024-01-01" "2024-01-01" "2024-01-01" ...
$ municipio : chr "VALE DO ANARI" "SÃO GABRIEL DA CACHOEIRA" "MANAQUIRI" "JUTAÍ" ...
$ estado : chr "RONDÔNIA" "AMAZONAS" "AMAZONAS" "AMAZONAS" ...
$ bioma : chr "Amazônia" "Amazônia" "Amazônia" "Amazônia" ...
$ avg_numero_dias_sem_chuva: num 0 0.2 0 2 0 0 0 0 7.84 5.44 ...
$ avg_precipitacao : num 1698 206.8 60 776 2.22 ...
$ avg_risco_fogo : num 0 0 0 0 0 0 0 18 100 100 ...
$ avg_frp : num 13 81.4 27 211 97.7 ... data municipio estado bioma avg_numero_dias_sem_chuva
1 2024-04-01 NOVO ARIPUANÃ AMAZONAS Amazônia 0.00
2 2024-04-01 BARREIRINHA AMAZONAS Amazônia 0.00
3 2024-04-01 MANAUS AMAZONAS Amazônia 1.00
4 2024-04-01 PARINTINS AMAZONAS Amazônia 0.00
5 2024-04-01 ITACOATIARA AMAZONAS Amazônia 1.25
6 2024-04-01 CAREIRO DA VÁRZEA AMAZONAS Amazônia 0.00
avg_precipitacao avg_risco_fogo avg_frp
1 5007.00 0 6
2 2849.00 0 57
3 1506.00 0 16
4 1056.00 0 33
5 1322.25 0 53
6 2367.00 0 25str(Queimadas_Q2)'data.frame': 48979 obs. of 8 variables:
$ data : chr "2024-04-01" "2024-04-01" "2024-04-01" "2024-04-01" ...
$ municipio : chr "NOVO ARIPUANÃ" "BARREIRINHA" "MANAUS" "PARINTINS" ...
$ estado : chr "AMAZONAS" "AMAZONAS" "AMAZONAS" "AMAZONAS" ...
$ bioma : chr "Amazônia" "Amazônia" "Amazônia" "Amazônia" ...
$ avg_numero_dias_sem_chuva: num 0 0 1 0 1.25 0 2 0 0 1.33 ...
$ avg_precipitacao : num 5007 2849 1506 1056 1322 ...
$ avg_risco_fogo : num 0 0 0 0 0 0 0 0 0 100 ...
$ avg_frp : num 6 57 16 33 53 25 90 23 75 537 ... data municipio estado bioma avg_numero_dias_sem_chuva
1 2024-09-24 CAAPIRANGA AMAZONAS Amazônia 0
2 2024-09-24 NOVA OLINDA DO NORTE AMAZONAS Amazônia 0
3 2024-09-24 DOM ELISEU PARÁ Amazônia 0
4 2024-09-24 NOVO ARIPUANÃ AMAZONAS Amazônia 0
5 2024-09-24 ELDORADO DO CARAJÁS PARÁ Amazônia 0
6 2024-09-24 JATOBÁ MARANHÃO Cerrado 0
avg_precipitacao avg_risco_fogo avg_frp
1 0 0 11.00
2 0 0 18.89
3 0 0 19.24
4 0 0 46.17
5 0 0 14.93
6 0 0 29.64str(Queimadas_Q3)'data.frame': 78517 obs. of 8 variables:
$ data : chr "2024-09-24" "2024-09-24" "2024-09-24" "2024-09-24" ...
$ municipio : chr "CAAPIRANGA" "NOVA OLINDA DO NORTE" "DOM ELISEU" "NOVO ARIPUANÃ" ...
$ estado : chr "AMAZONAS" "AMAZONAS" "PARÁ" "AMAZONAS" ...
$ bioma : chr "Amazônia" "Amazônia" "Amazônia" "Amazônia" ...
$ avg_numero_dias_sem_chuva: num 0 0 0 0 0 0 0 0 0 0 ...
$ avg_precipitacao : num 0 0 0 0 0 0 0 0 0 0 ...
$ avg_risco_fogo : num 0 0 0 0 0 0 0 0 0 0 ...
$ avg_frp : num 11 18.9 19.2 46.2 14.9 ...Como os três bancos são muito parecidos, podemos uní-los em um único banco de dados. Para isso, utilizamos a função rbind().
# Unindo os três bancos de dados
Queimadas <- rbind(Queimadas_Q1, Queimadas_Q2, Queimadas_Q3)
head(Queimadas) data municipio estado bioma
1 2024-01-01 VALE DO ANARI RONDÔNIA Amazônia
2 2024-01-01 SÃO GABRIEL DA CACHOEIRA AMAZONAS Amazônia
3 2024-01-01 MANAQUIRI AMAZONAS Amazônia
4 2024-01-01 JUTAÍ AMAZONAS Amazônia
5 2024-01-01 AUTAZES AMAZONAS Amazônia
6 2024-01-01 IRANDUBA AMAZONAS Amazônia
avg_numero_dias_sem_chuva avg_precipitacao avg_risco_fogo avg_frp
1 0.0 1698.00 0 13.00
2 0.2 206.80 0 81.40
3 0.0 60.00 0 27.00
4 2.0 776.00 0 211.00
5 0.0 2.22 0 97.67
6 0.0 0.00 0 55.50str(Queimadas)'data.frame': 171249 obs. of 8 variables:
$ data : chr "2024-01-01" "2024-01-01" "2024-01-01" "2024-01-01" ...
$ municipio : chr "VALE DO ANARI" "SÃO GABRIEL DA CACHOEIRA" "MANAQUIRI" "JUTAÍ" ...
$ estado : chr "RONDÔNIA" "AMAZONAS" "AMAZONAS" "AMAZONAS" ...
$ bioma : chr "Amazônia" "Amazônia" "Amazônia" "Amazônia" ...
$ avg_numero_dias_sem_chuva: num 0 0.2 0 2 0 0 0 0 7.84 5.44 ...
$ avg_precipitacao : num 1698 206.8 60 776 2.22 ...
$ avg_risco_fogo : num 0 0 0 0 0 0 0 18 100 100 ...
$ avg_frp : num 13 81.4 27 211 97.7 ...dim(Queimadas)[1] 171249 8Podemos salvar esse banco de dados em um arquivo .csv utilizando a função write.csv().
write.csv(Queimadas, file = "data/FireWatch/Dataset_FireWatch_Brazil_2024.csv", row.names = FALSE)3.7 Exercício
Para os dados de Queimadas faça o que se pede.
- Imprima na tela as 9 primeiras observações.
- Imprima as últimas 3 observações.
- Quantas observações temos?
- Quantas variáveis temos?
- Apresente o sumário dos dados.
- Apresente a estrutura dos dados.
- Quantos biomas estão sendo afetados?
- Qual a média de
avg_numero_dias_sem_chuvapara osestados da região sul e da região norte?
3.8 Estruturas alternativas ao Data Frame
Embora data.frames sejam estruturas muito poderosas para análise de dados, outras estruturas são mais modernas e permitem maior performance para análise de dados em termos de velocidade de processamento e até mesmo na facilidade da sintaxe. Duas alternativas são: data.table e tibble. Veremos as duas em detalhes a seguir.
3.8.1 data.table: Manipulação Eficiente de Grandes Conjuntos de Dados
O pacote data.table é uma biblioteca poderosa no R, projetada especificamente para manipulação eficiente de grandes conjuntos de dados. Ele oferece um conjunto de recursos que melhoram consideravelmente o desempenho e a flexibilidade das operações em relação às estruturas de dados convencionais.
3.8.1.1 Principais Características do data.table
Sintaxe Otimizada: Uma das características principais do “data.table” é sua sintaxe otimizada. A operação básica do “data.table” usa a notação
[i, j, by], ondeifiltra linhas,jseleciona colunas ebyagrupa resultados. Isso permite que você realize várias operações complexas em uma única linha de código.Eficiência em Memória: O
data.tablerealiza muitas operações diretamente na memória, evitando a cópia excessiva de dados, minimizando o consumo de memória e melhorando o desempenho.Chaves e Indexação: As chaves são um conceito fundamental no
data.table. Elas permitem que você especifique quais colunas serão usadas para ordenar e indexar o conjunto de dados. Isso acelera significativamente operações de junção e seleção.Compatibilidade com Sintaxe de Base R: Embora tenha sua própria sintaxe otimizada, o
data.tabletambém é compatível com a sintaxe de base R, o que facilita a transição para os usuários familiarizados com o R padrão.
3.8.1.2 Criando e Manipulando Data.Tables
Para criar um data.table, você pode usar a função data.table(). Vamos explorar exemplos mais detalhados.
library(data.table)
# Criar um data.table
meu_data_table <- data.table(
nome = c("Alice", "Bob", "Carol", "Ana", "João", "Carlos", "Patrícia", "Leonardo"),
idade = c(25, 30, 28, 20, 27, 50, 60, 45),
salario = c(5000, 6000, 5500, 8000, 2000, 3500, 10000, 3800 ),
meio_de_transporte = c('onibus', 'bicicleta', 'onibus', 'carro', 'carro', 'onibus', 'onibus', 'bicicleta'))
meu_data_table nome idade salario meio_de_transporte
<char> <num> <num> <char>
1: Alice 25 5000 onibus
2: Bob 30 6000 bicicleta
3: Carol 28 5500 onibus
4: Ana 20 8000 carro
5: João 27 2000 carro
6: Carlos 50 3500 onibus
7: Patrícia 60 10000 onibus
8: Leonardo 45 3800 bicicletaclass(meu_data_table)[1] "data.table" "data.frame"Para importarmos um data.table podemos utilizar a função fread(), epara salvarmos, podemos utilizar a função fwrite().
# Importar um data.table e comparando o tempo de importação com o read.csv
system.time(Queimadas <- fread("data/FireWatch/Dataset_FireWatch_Brazil_2024.csv")) user system elapsed
0.113 0.010 0.030 system.time(Queimadas <- read.csv("data/FireWatch/Dataset_FireWatch_Brazil_2024.csv")) user system elapsed
0.873 0.040 0.251 3.8.1.3 Sintaxe e Operações
A sintaxe básica do “data.table” envolve o uso das notações [i, j, by].
# Selecionar colunas e filtrar linhas
resultado <- meu_data_table[idade > 25, .(nome, salario)]
resultado nome salario
<char> <num>
1: Bob 6000
2: Carol 5500
3: João 2000
4: Carlos 3500
5: Patrícia 10000
6: Leonardo 3800# Agregar dados
agregado <- meu_data_table[, .(media_salario = mean(salario)),]
agregado media_salario
<num>
1: 5475# Agregar dados por idade
agregado_idade <- meu_data_table[, .(media_salario = mean(salario)), by = idade]
agregado_idade idade media_salario
<num> <num>
1: 25 5000
2: 30 6000
3: 28 5500
4: 20 8000
5: 27 2000
6: 50 3500
7: 60 10000
8: 45 3800# Agregar dados por meio_de_transporte
agregado_mt <- meu_data_table[, .(media_salario = mean(salario)), by = meio_de_transporte]
agregado_mt meio_de_transporte media_salario
<char> <num>
1: onibus 6000
2: bicicleta 4900
3: carro 50003.8.2 Tibble: Uma Abordagem Moderna para Manipulação de Dados
No ambiente estatístico e analítico do R, a manipulação e análise de dados são atividades cruciais. O pacote “tibble” oferece uma abordagem moderna e conveniente para trabalhar com conjuntos de dados, aprimorando muitos dos aspectos do tradicional “data.frame”. O tibble faz parte do tidyverse, e foi projetado para atender às necessidades de análise de dados eficiente, mantendo a coerência dos tipos de dados e melhorando a experiência geral do usuário.
3.8.2.1 Principais Características do Tibble
-
Sintaxe Intuitiva para Criação: A criação de um “tibble” é similar ao data.frame e data.table, oferecendo uma sintaxe intuitiva e direta. Você pode criar um “tibble” usando a função
tibble()e atribuir colunas com nomes claros. Em Tibble você pode utilizar espaços para nomear variáveis.
Loading required package: tibbleLoading required package: magrittrLoading required package: dplyr
Attaching package: 'dplyr'The following objects are masked from 'package:data.table':
between, first, lastThe following objects are masked from 'package:stats':
filter, lagThe following objects are masked from 'package:base':
intersect, setdiff, setequal, unionmeu_tibble <- tibble(
nome = c("Alice", "Bob", "Carol", "Ana", "João", "Carlos", "Patrícia", "Leonardo"),
idade = c(25, 30, 28, 20, 27, 50, 60, 45),
salario = c(5000, 6000, 5500, 8000, 2000, 3500, 10000, 3800 ),
meio_de_transporte = c('onibus', 'bicicleta', 'onibus', 'carro', 'carro', 'onibus', 'onibus', 'bicicleta'))
meu_tibble# A tibble: 8 × 4
nome idade salario meio_de_transporte
<chr> <dbl> <dbl> <chr>
1 Alice 25 5000 onibus
2 Bob 30 6000 bicicleta
3 Carol 28 5500 onibus
4 Ana 20 8000 carro
5 João 27 2000 carro
6 Carlos 50 3500 onibus
7 Patrícia 60 10000 onibus
8 Leonardo 45 3800 bicicleta glimpse(meu_tibble)Rows: 8
Columns: 4
$ nome <chr> "Alice", "Bob", "Carol", "Ana", "João", "Carlos", "…
$ idade <dbl> 25, 30, 28, 20, 27, 50, 60, 45
$ salario <dbl> 5000, 6000, 5500, 8000, 2000, 3500, 10000, 3800
$ meio_de_transporte <chr> "onibus", "bicicleta", "onibus", "carro", "carro", …2 . Manipulação de Colunas: A adição, renomeação e remoção de colunas são tarefas simples com o “tibble”. Você pode usar o operador $ para acessar as colunas e o operador %>% para encadear operações.
meu_tibble$nova_coluna <- c(1, 2, 3, 4, 5, 6, 7, 8)
meu_tibble# A tibble: 8 × 5
nome idade salario meio_de_transporte nova_coluna
<chr> <dbl> <dbl> <chr> <dbl>
1 Alice 25 5000 onibus 1
2 Bob 30 6000 bicicleta 2
3 Carol 28 5500 onibus 3
4 Ana 20 8000 carro 4
5 João 27 2000 carro 5
6 Carlos 50 3500 onibus 6
7 Patrícia 60 10000 onibus 7
8 Leonardo 45 3800 bicicleta 8meu_tibble <- mutate(meu_tibble, `minha coluna` = 1:8)
meu_tibble <- rename(meu_tibble, idade_anos = idade)
meu_tibble# A tibble: 8 × 6
nome idade_anos salario meio_de_transporte nova_coluna `minha coluna`
<chr> <dbl> <dbl> <chr> <dbl> <int>
1 Alice 25 5000 onibus 1 1
2 Bob 30 6000 bicicleta 2 2
3 Carol 28 5500 onibus 3 3
4 Ana 20 8000 carro 4 4
5 João 27 2000 carro 5 5
6 Carlos 50 3500 onibus 6 6
7 Patrícia 60 10000 onibus 7 7
8 Leonardo 45 3800 bicicleta 8 8meu_tibble_sem_salario <- select(meu_tibble, -salario)
meu_tibble_sem_salario# A tibble: 8 × 5
nome idade_anos meio_de_transporte nova_coluna `minha coluna`
<chr> <dbl> <chr> <dbl> <int>
1 Alice 25 onibus 1 1
2 Bob 30 bicicleta 2 2
3 Carol 28 onibus 3 3
4 Ana 20 carro 4 4
5 João 27 carro 5 5
6 Carlos 50 onibus 6 6
7 Patrícia 60 onibus 7 7
8 Leonardo 45 bicicleta 8 83.8.2.2 Operações e Uso do Tibble
O “tibble” se integra perfeitamente com as operações do tidyverse, tornando a manipulação de dados mais eficaz e legível. Podemos usar operações como filtragem, ordenação e agregação de forma simples e concisa.
# Filtrar e ordenar
resultado <- filter(meu_tibble, idade_anos > 25)
arrange(resultado, desc(salario))# A tibble: 6 × 6
nome idade_anos salario meio_de_transporte nova_coluna `minha coluna`
<chr> <dbl> <dbl> <chr> <dbl> <int>
1 Patrícia 60 10000 onibus 7 7
2 Bob 30 6000 bicicleta 2 2
3 Carol 28 5500 onibus 3 3
4 Leonardo 45 3800 bicicleta 8 8
5 Carlos 50 3500 onibus 6 6
6 João 27 2000 carro 5 5# Agregar por idade e calcular média de salários
agregado_por_idade <- group_by(meu_tibble, idade_anos)
summarize(agregado_por_idade, media_salario = mean(salario))# A tibble: 8 × 2
idade_anos media_salario
<dbl> <dbl>
1 20 8000
2 25 5000
3 27 2000
4 28 5500
5 30 6000
6 45 3800
7 50 3500
8 60 100003.9 Listas
Listas são estruturas de dados muito versáteis em R, que podem conter qualquer tipo de objeto, incluindo vetores, matrizes, data frames, funções e até outras listas. As listas são usadas para armazenar e organizar dados de diferentes tipos e estruturas, e são amplamente utilizadas em programação e análise de dados.
3.9.1 Criando Listas
Para criar uma lista em R, você pode usar a função list(). Cada elemento da lista é separado por vírgulas e pode ser qualquer objeto R.
# Exemplo de criação de lista
minha_lista <- list(
vetor = c(1, 2, 3, 4, 5),
matriz = matrix(1:9, nrow = 3),
data_frame = data.frame(
nome = c("Alice", "Bob", "Carol"),
idade = c(25, 30, 28)
),
lista_aninhada = list(
vetor_aninhado = c(10, 20, 30),
matriz_aninhada = matrix(1:4, nrow = 2)
)
)
minha_lista$vetor
[1] 1 2 3 4 5
$matriz
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
$data_frame
nome idade
1 Alice 25
2 Bob 30
3 Carol 28
$lista_aninhada
$lista_aninhada$vetor_aninhado
[1] 10 20 30
$lista_aninhada$matriz_aninhada
[,1] [,2]
[1,] 1 3
[2,] 2 43.9.2 Acessando Elementos de Listas
Os elementos de uma lista podem ser acessados usando colchetes [[]] ou o operador $.
# Acessar elementos da lista
elemento1 <- minha_lista[[1]] # Acessar o primeiro elemento
elemento2 <- minha_lista$data_frame # Acessar o data frame
elemento3 <- minha_lista$lista_aninhada$vetor_aninhado # Acessar o vetor aninhado3.9.3 Adicionando Elementos a Listas
Você pode adicionar novos elementos a uma lista atribuindo um valor a um novo índice.
# Adicionar elementos a uma lista
minha_lista$nova_lista <- list(novo_vetor = c(1, 2, 3), nova_matriz = matrix(1:4, nrow = 2))
minha_lista$vetor
[1] 1 2 3 4 5
$matriz
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
$data_frame
nome idade
1 Alice 25
2 Bob 30
3 Carol 28
$lista_aninhada
$lista_aninhada$vetor_aninhado
[1] 10 20 30
$lista_aninhada$matriz_aninhada
[,1] [,2]
[1,] 1 3
[2,] 2 4
$nova_lista
$nova_lista$novo_vetor
[1] 1 2 3
$nova_lista$nova_matriz
[,1] [,2]
[1,] 1 3
[2,] 2 4