R Select(), Filter(), Arrange(), Pipeline com exemplo

⚡ Resumo Inteligente

Select, Filter e Arrange em R são os três verbos do dplyr que reduzem um data frame às colunas, linhas e ordem desejadas. Este passo a passo encadeia esses verbos com o operador pipe em um conjunto de dados de tempos de viagem com 205 linhas.

  • 📋 Seleção de coluna: select(df, A, B) mantém as colunas nomeadas, select(df, A:C) mantém um intervalo e select(df, -C) remove uma.
  • 🔎 Filtragem de linhas: filter(df, condition) mantém as linhas correspondentes, e as condições combinam-se com o símbolo "&" para AND ou com a barra vertical para OR.
  • 🔣 Ordenação: A função arrange() ordena as linhas em ordem crescente por padrão, e a função desc() inverte qualquer coluna individual.
  • 🔗 Pipe Operator: O operador %>% passa cada resultado diretamente para o próximo verbo, de modo que nenhum objeto intermediário polua o ambiente.
  • 🧹 Funções auxiliares: starts_with(), contains() e where() selecionam colunas por padrão ou tipo em vez de por nome.
  • 📐 A ordem dos verbos importa: Filtre no início para reduzir o volume de dados, depois selecione e, por fim, organize, o que torna cada etapa posterior mais barata.

R Selecionar Filtro Organizar Pipeline

O que é dplyr em R?

dplyr é o pacote de manipulação de dados do tidyverse. Ele substitui a notação de colchetes do base. R Com um pequeno conjunto de verbos, cada um nomeado de acordo com a ação que realiza e cada um recebendo o quadro de dados como seu primeiro argumento. Essa forma consistente é o que permite que os verbos sejam encadeados.

Verbo atua em O que ele faz
select () colunas Mantém ou descarta variáveis
filtro() Linhas de altura Mantém as linhas que correspondem a uma condição.
arranjo() Linhas de altura Reordena as linhas por uma ou mais colunas.
mutate () colunas Cria ou modifica uma variável
resumir() Mesa inteira Agrupa várias linhas em uma única estatística.
agrupar_por() Mesa inteira Divide os dados para que os verbos posteriores sejam executados por grupo.

Este tutorial aborda os três primeiros verbos, além do verbo "pipe". tutorial de função agregada Este artigo aborda detalhadamente as funções group_by() e summarise().

Conjunto de dados usado neste tutorial

A biblioteca dplyr contém verbos valiosos para navegar dentro do conjunto de dados. Neste tutorial, você usará o conjunto de dados de tempos de viagem. Este conjunto de dados registra as viagens que um motorista faz entre sua casa e seu local de trabalho. Existem quatorze variáveis ​​no conjunto de dados, incluindo:

  • DayOfWeek: Identifique o dia da semana em que o motorista usa seu carro
  • Distância: A distância total da viagem
  • MaxSpeed: A velocidade máxima da viagem
  • TotalTime: a duração em minutos da viagem

O conjunto de dados contém 205 observações, e os trajetos ocorreram a partir de Monday para sexta-feira.

Primeiro de tudo, você precisa:

  • carregar o conjunto de dados
  • verifique a estrutura dos dados.

Uma função útil do dplyr é glimpse(). Ela desempenha a mesma função que a função str() do R base, mas imprime uma linha por variável com o tipo e os primeiros valores, o que facilita bastante a análise em um conjunto de dados extenso.

library(dplyr) 
PATH <- "https://raw.githubusercontent.com/guru99-edu/R-Programming/master/travel_times.csv"
df <- read.csv(PATH)
glimpse(df)

Saída:

## Observations: 205
## Variables: 14
## $ X              <int> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, ...
## $ Date           <fctr> 1/6/2012, 1/6/2012, 1/4/2012, 1/4/2012, 1/3/20...
## $ StartTime      <fctr> 16:37, 08:20, 16:17, 07:53, 18:57, 07:57, 17:3...
## $ DayOfWeek      <fctr> Friday, Friday, Wednesday, Wednesday, Tuesday,...
## $ GoingTo        <fctr> Home, GSK, Home, GSK, Home, GSK, Home, GSK, GS...
## $ Distance       <dbl> 51.29, 51.63, 51.27, 49.17, 51.15, 51.80, 51.37...
## $ MaxSpeed       <dbl> 127.4, 130.3, 127.4, 132.3, 136.2, 135.8, 123.2...
## $ AvgSpeed       <dbl> 78.3, 81.8, 82.0, 74.2, 83.4, 84.5, 82.9, 77.5,...
## $ AvgMovingSpeed <dbl> 84.8, 88.9, 85.8, 82.9, 88.1, 88.8, 87.3, 85.9,...
## $ FuelEconomy    <fctr> , , , , , , -, -, 8.89, 8.89, 8.89, 8.89, 8.89...
## $ TotalTime      <dbl> 39.3, 37.9, 37.5, 39.8, 36.8, 36.8, 37.2, 37.9,...
## $ MovingTime     <dbl> 36.3, 34.9, 35.9, 35.6, 34.8, 35.0, 35.3, 34.3,...
## $ Take407All     <fctr> No, No, No, No, No, No, No, No, No, No, No, No...
## $ Comments       <fctr> , , , , , , , , , , , , , , , Put snow tires o...	

A variável "Comments" claramente precisa ser analisada mais detalhadamente: as primeiras observações estão todas vazias.

sum(df$Comments =="")

Code Explicação

  • sum(df$Comments == “”): Conta as observações iguais a uma string vazia na coluna Comments de df

Saída:

## [1] 181

Com os dados carregados, comece com o verbo que remove os espaços em branco das colunas.

select ()

Começaremos com o verbo select(). Não precisamos necessariamente de todas as variáveis, e uma boa prática é selecionar apenas as variáveis ​​que você achar relevantes.

Temos 181 observações faltantes, quase 90% do conjunto de dados. Se você decidir excluí-los, não poderá continuar a análise.

A outra possibilidade é eliminar a variável Comment com o verbo select().

Podemos selecionar variáveis ​​de diferentes maneiras com select(). Observe que o primeiro argumento é o conjunto de dados.

- `select(df, A, B ,C)`: Select the variables A, B and C from df dataset.
- `select(df, A:C)`: Select all variables from A to C from df dataset.
- `select(df, -C)`: Exclude C from the dataset from df dataset.	

Você pode usar a terceira forma para excluir a variável Comentários.

step_1_df <- select(df, -Comments)
dim(df)

Saída:

## [1] 205  14
dim(step_1_df)

Saída:

## [1] 205  13

O conjunto de dados original possui 14 recursos, enquanto o step_1_df possui 13.

Funções auxiliares select() em R

Nomear todas as colunas torna-se impraticável quando um conjunto de dados possui dezenas de variáveis. O dplyr inclui funções auxiliares que selecionam colunas por padrão ou por tipo.

Helper Seleciona colunas que Exemplo
começa_com() Comece com uma corda selecionar(df, começa_com(“Média”))
termina_com() Termine com uma string selecionar(df, termina_com(“Tempo”))
contém () Conter uma string em algum lugar selecionar(df, contém(“Velocidade”))
fósforos() Combinar uma expressão regular selecionar(df, correspondências(“^Máx|^Média”))
onde() Satisfazer um teste de tipo selecionar(df, onde(é.numérico))
tudo() Ainda não foram nomeados. selecionar(df, TotalTime, tudo())
# Keep only the timing columns
df %>% select(ends_with("Time"))

# Keep every numeric column
df %>% select(where(is.numeric))

# Move TotalTime to the front, keep the rest in place
df %>% select(TotalTime, everything())

Mais dois verbos combinam naturalmente com select(). Use rename(novo_nome = nome_antigo) para renomear uma coluna sem removê-la.ping os outros, e relocate() para mover colunas sem listá-las todas.

filtro()

O verbo `filter()` mantém as observações que satisfazem uma condição. O `filter()` funciona exatamente como o `select()`, você passa primeiro o dataframe e depois uma condição, separados por vírgula:

filter(df, condition)
arguments:
- df: dataset used to filter the data
- condition:  Condition used to filter the data	

Um critério

Primeiro de tudo, você pode contar o número de observações dentro de cada nível de uma variável fatorial.

table(step_1_df$GoingTo)

Code Explicação

  • `table()`: Conta o número de observações por nível. Espera uma variável do tipo `factor` ou `character`.
  • tabela(step_1_df$GoingTo): Contar o número de viagens para cada destino

Saída:

## 
##  GSK Home 
##  105  100	

A função table() indica que 105 viagens vão para a GSK e 100 para casa.

Podemos filtrar os dados para retornar um conjunto de dados com 105 observações e outro com 100 observações.

# Select observations where GoingTo == Home
select_home <- filter(df, GoingTo == "Home")
dim(select_home)

Saída:

## [1] 100  14
# Select observations where GoingTo == GSK (work)
select_work <- filter(df, GoingTo == "GSK")
dim(select_work)

Saída:

## [1] 105  14

Critérios múltiplos

Podemos filtrar um conjunto de dados com mais de um critério. Por exemplo, você pode...tract as observações onde o destino é Casa e a viagem ocorreu em uma quarta-feira.

select_home_wed <- filter(df, GoingTo == "Home" & DayOfWeek == "Wednesday")
dim(select_home_wed)

Saída:

## [1] 23 14

23 observações corresponderam a este critério.

Condições comuns do filtro() e Operatores em R

A função `filter()` mantém todas as linhas para as quais a condição é avaliada como VERDADEIRA. As linhas que são avaliadas como NÃO VALORIZADO são descartadas, comportamento que surpreende a maioria dos iniciantes.

Operator Significado Exemplo
== Igual a filtrar(df, GoingTo == “Home”)
!= Diferente de filter(df, DayOfWeek != “Monday")
& E, ambos devem manter filter(df, Distance > 50 & MaxSpeed ​​> 130)
| OU, qualquer um dos dois pode ter filtro(df, DiaDaSemana == “Monday” | DiaDaSemana == “Sexta-feira”)
%em% Corresponde a qualquer valor em um vetor filtro(df, DiaDaSemana %em% c(“Monday", "Sexta-feira"))
entre() Pertence a um intervalo numérico filtrar(df, entre(Distância, 48, 52))
é.na() É um valor ausente filtrar(df, is.na(FuelEconomy))

Três hábitos previnem a maioria dos erros da função filter().

  • Use %in% em vez de OR encadeado. filtro(df, DiaDaSemana %em% c(“Monday”, “Sexta-feira”)) é mais curto e muito mais difícil de digitar errado do que duas comparações == unidas por uma barra vertical.
  • Nunca teste um valor ausente com ==. A expressão x == NA retorna NA, não TRUE, então a linha é descartada silenciosamente. Use is.na(x) em vez disso.
  • Vírgulas significam "E". filter(df, a, b) é idêntico a filter(df, a & b), razão pela qual o exemplo anterior neste tutorial funciona de qualquer maneira.

O cano Operator em dplyr

A criação de um conjunto de dados requer muitas operações, como:

  • importador
  • fusão
  • selecionando
  • filtragem
  • e assim por diante

A biblioteca dplyr vem com um operador prático, %>%, chamado tuboIsso torna a manipulação de dados mais limpa, rápida e menos propensa a erros.

Este operador é um código que executa etapas sem salvar as etapas intermediárias no disco rígido. Se você voltar ao nosso exemplo acima, poderá selecionar as variáveis ​​de interesse e filtrá-las. Temos três etapas:

  • Passo 1: Importar dados: Importe os dados GPS
  • Etapa 2: Selecione os dados: selecione GoingTo e DayOfWeek
  • Etapa 3: Filtrar dados: retornar apenas para casa e quarta-feira

Podemos usar a maneira mais difícil de fazer isso:

# Step 1
step_1 <- read.csv(PATH)

# Step 2 
step_2 <- select(step_1, GoingTo, DayOfWeek)

# Step 3 
step_3 <- filter(step_2, GoingTo == "Home", DayOfWeek == "Wednesday")

head(step_3)

Saída:

##   GoingTo DayOfWeek
## 1    Home Wednesday
## 2    Home Wednesday
## 3    Home Wednesday
## 4    Home Wednesday
## 5    Home Wednesday
## 6    Home Wednesday	

Essa não é uma maneira conveniente de encadear muitas operações. Cada resultado intermediário permanece no ambiente, e os nomes rapidamente perdem o sentido.

Em vez disso, use o operador de pipe %>%. Você nomeia o dataframe uma única vez no início e todas as etapas subsequentes derivam dele.

Sintaxe básica do pipeline

New_df <- df %>%
step 1 %>%
step 2 %>%
...
arguments
- New_df: Name of the new data frame 
- df: Data frame used to compute the step
- step: Instruction for each step
- Note: the last instruction does not need a trailing `%>%`, because nothing follows it
- Note: assigning the result to a new object is optional. Without it, the output prints in the console.

Você pode criar seu primeiro pipe seguindo as etapas enumeradas acima.

# Create the data frame filter_home_wed.It will be the object return at the end of the pipeline
filter_home_wed <- 

#Step 1
read.csv(PATH) %>% 

#Step 2
select(GoingTo, DayOfWeek) %>% 

#Step 3
filter(GoingTo == "Home",DayOfWeek == "Wednesday")
identical(step_3, filter_home_wed)

Saída:

## [1] TRUE

Os dois objetos são idênticos, portanto o pipe produziu exatamente o mesmo resultado em uma única instrução legível.

arranjo()

De acordo com o relatório tutorial anterior, você aprenderá como classificar os valores com a função sort(). A biblioteca dplyr tem sua função de classificação. Funciona perfeitamente com o pipeline. O verbo organizar() pode reordenar uma ou mais linhas, em ordem crescente (padrão) ou decrescente.

- `arrange(A)`: Ascending sort of variable A
- `arrange(A, B)`: Ascending sort of variable A and B
- `arrange(desc(A), B)`: Descending sort of variable A and ascending sort of B

Podemos classificar a distância por destino.

# Sort by destination and distance
step_2_df <- step_1_df %>%
    arrange(GoingTo, Distance)
head(step_2_df)

Saída:

##     X       Date StartTime DayOfWeek GoingTo Distance MaxSpeed AvgSpeed
## 1 193  7/25/2011     08:06    Monday     GSK    48.32    121.2     63.4
## 2 196  7/21/2011     07:59  Thursday     GSK    48.35    129.3     81.5
## 3 198  7/20/2011     08:24 Wednesday     GSK    48.50    125.8     75.7
## 4 189  7/27/2011     08:15 Wednesday     GSK    48.82    124.5     70.4
## 5  95 10/11/2011     08:25   Tuesday     GSK    48.94    130.8     85.7
## 6 171  8/10/2011     08:13 Wednesday     GSK    48.98    124.8     72.8
##   AvgMovingSpeed FuelEconomy TotalTime MovingTime Take407All
## 1           78.4        8.45      45.7       37.0         No
## 2           89.0        8.28      35.6       32.6        Yes
## 3           87.3        7.89      38.5       33.3        Yes
## 4           77.8        8.45      41.6       37.6         No
## 5           93.2        7.81      34.3       31.5        Yes
## 6           78.8        8.54      40.4       37.3         No

Verbos em R: Guia Rápido

A tabela abaixo lista todos os verbos usados ​​neste tutorial, com a sintaxe e o que cada chamada retorna:

Verbo Objetivo Code Explicação
vislumbre verifique a estrutura de um df
glimpse(df)
Mesmo propósito que str(), mais fácil de ler
select () Selecione/exclua as variáveis
select(df, A, B ,C)
Selecione as variáveis ​​A, B e C
select(df, A:C)
Selecione todas as variáveis ​​de A a C
select(df, -C)
Excluir C
filtro() Mantenha as linhas que correspondam a uma ou mais condições.
filter(df, condition1)
Uma condição
filter(df, condition1 & condition2)
Duas condições combinadas com "E"
arranjo() Classifique o conjunto de dados com uma ou mais variáveis
arrange(A)
Tipo ascendente de variável A
arrange(A, B)
Tipo ascendente de variável A e B
arrange(desc(A), B)
Tipo descendente de variável A e tipo ascendente de B
%>% Crie um pipeline entre cada etapa
step 1 %>% step 2 %>% step 3

Perguntas Frequentes

O operador pipe %>% do magrittr é fornecido com o dplyr e suporta sintaxe de marcador de posição com um ponto. O operador pipe nativo |> foi introduzido no R 4.1 e não requer nenhum pacote. Ambos passam o resultado da esquerda para o primeiro argumento à direita.

Não. Cada verbo do dplyr retorna um novo data frame e deixa a entrada intacta. Você precisa atribuir o resultado a um objeto ou encadeá-lo para que a alteração seja mantida.

Uma comparação com NA retorna NA em vez de TRUE, e filter() mantém apenas as linhas que são TRUE. Use is.na() para selecionar valores ausentes deliberadamente ou drop_na() do pacote tidyr para removê-los.

A engenharia de recursos para modelos de IA consiste principalmente em filtrar linhas, selecionar colunas e ordenar. O dplyr expressa essas etapas como fluxos de trabalho legíveis que os revisores podem auditar, o que é importante quando um conjunto de dados de treinamento precisa ser reproduzível.

Sim. Assistentes de IA podem traduzir a seleção por colchetes em chamadas de `select()` e `filter()` e explicar o operador pipe. Sempre execute ambas as versões e compare as dimensões, pois o R base e o dplyr tratam valores ausentes de forma diferente.

Resuma esta postagem com: