R: Limpeza prática de dados em R

Q: P: Os valores ausentes devem ser excluídos ou imputados?

R: Se a taxa de valores ausentes for 20%, considere excluir a coluna. Campos-chave (rótulos) não podem ser excluídos — eles devem ser imputados ou tratados por meio de outros métodos.

Q: P: Quais são as funções mais utilizadas no pacote janitor?

R: clean_names() Padronizar nomes de colunas + get_dupes() Encontrar duplicatas + remove_empty() Remover linhas/colunas vazias. O Janitor é utilizado em quase todas as tarefas de limpeza de dados.

Última atualização: 2026-08-26

Nas 28 aulas anteriores, aprendemos sobre “análise” — mas, em projetos do mundo real, 80% do tempo é dedicado à limpeza de dados. Os arquivos CSV fornecidos pelos gerentes sempre contêm valores ausentes, outliers, duplicatas e tipos de dados incorretos — nesta aula, usaremos o R para limpar minuciosamente um conjunto de “dados sujos do mundo real”.

Ao concluir esta lição, você será capaz de limpar qualquer arquivo CSV: lidar com valores ausentes, valores atípicos, duplicatas, tipos de dados incorretos, cadeias de caracteres fora do padrão e formatos de data — preparando o terreno para a análise.

1. O que você vai aprender

4 principais problemas na limpeza de dados (valores ausentes, valores atípicos, duplicatas, tipos de dados)
Tratamento de valores ausentes (drop_na/fill/replace)
Tratamento de valores atípicos (IQR/3σ/substituição)
Valores duplicados (distintos / únicos)
Conversão de tipo (as.numeric/as.Date)
Limpeza de cordas (Guia completo sobre stringr)
Processamento de data e hora (lubridate)
pacote janitor (clean_names)
Prático: Limpeza de 1.000 linhas de dados incorretos

2. Um desafio do mundo real com dados sujos

(1) Desafio: os “dados gigantescos” fornecidos pelo gerente

Alice recebeu um arquivo chamado “Customer Data.csv” de seu gerente. Ela o abriu e viu:

TEXT 📖 Somente leitura

id  ,Name    ,Cell phone number           ,Email                ,Date of Registration
001 ,Alice    ,138-0000-1234    ,ZHANGSAN@163.COM    ,2024/01/15
002 ,Bob    ,+86 139 0000 5678, lisi@example.com   ,2024.01.20
003 , Alice   ,13800001111      ,                    ,2024-02-01
004 ,Charlie    ,138-0000-2222    ,wangwu@gmail.com    ,2024-02-05
005 ,Charlie    ,138-0000-2222    ,wangwu@gmail.com    ,2024-02-05
006 ,Eve    ,(139)0000-3333   ,qianqi@ qq.com      ,2024-13-45

6 Principais Problemas: ① Formato do documento de identidade ② Nomes contendo espaços ③ Formatos inconsistentes de números de celular ④ Endereços de e-mail com letras maiúsculas e minúsculas misturadas e espaços ⑤ Valores ausentes ⑥ Linhas duplicadas ⑦ Formatos de data inconsistentes ⑧ Datas inválidas.

(2) Solução usando R

# Use dplyr + stringr + tidyr + lubridate for cleaning
df_clean <- df |>
  janitor::clean_names() |>       # Standardization of Listing
  mutate(
    id = str_pad(id, 3, pad = "0"),
    name = str_trim(name),
    phone = str_replace_all(phone, "[^0-9]", ""),
    email = str_to_lower(str_trim(email))
  ) |>
  drop_na(email) |>
  distinct() |>
  filter(nchar(phone) == 11) |>
  mutate(register_date = parse_date_time(register_date, orders = c("Y/m/d", "Y.m.d", "Y-m-d")))

1 linha de código → resolve todos os 6 principais problemas.

3. Quatro principais questões relacionadas à limpeza de dados

(1) Visão geral das quatro principais questões

graph TB
    A[Dirty Data] --> B[Missing values Missing]
    A --> C[Outliers Outliers]
    A --> D[Duplicate values Duplicates]
    A --> E[Type error Type]
    
    style A fill:#fff3cd
    style B fill:#cce5ff
    style C fill:#d4edda
    style D fill:#f8d7da
    style E fill:#e1d4ff

4. Tratamento de valores ausentes

(1) Identificação de valores ausentes

library(tidyr)

# Count the number of missing values in each column
df |> summarise(across(everything(), ~ sum(is.na(.))))

# Missing Value Rate
df |> summarise(across(everything(), ~ mean(is.na(.)) * 100))

# Missing-value patterns
naniar::vis_miss(df)

(2) Três estratégias de gestão

Estratégia	Aplicabilidade	Função R
Excluir	Valores ausentes (< 5%), valores ausentes aleatórios	`drop_na()`
Preencher	Muitas entradas faltando; não pode ser excluído	`replace_na()`
Campo	A ausência de dados é significativa (“Sem e-mail” = campo deixado em branco)	Adicionar coluna `is_missing`

# 1. Delete: rows containing NA
df |> drop_na()

# 2. Delete: Specified Column
df |> drop_na(email, phone)

# 3. Fill: Fixed value
df |> replace_na(list(email = "unknown@example.com", phone = "Not provided"))

# 4. Fill: Mean/Median
df |>
  mutate(
    age = replace_na(age, mean(age, na.rm = TRUE)),
    income = replace_na(income, median(income, na.rm = TRUE))
  )

# 5. Mark
df |>
  mutate(email_missing = is.na(email))

(3) Avançado: Preenchimento “Antes” e “Depois” com `fill()`

# Time Series: Missing values are imputed with the preceding value
df |> fill(value, .direction = "down")   # Use the previous line
df |> fill(value, .direction = "up")     # Use the next line
df |> fill(value, .direction = "downup") # Two-way

5. Tratamento de valores atípicos

(1) 3 métodos de identificação

# 1. IQR method (Robust, Recommended)
is_outlier_iqr <- function(x) {
  q1 <- quantile(x, 0.25, na.rm = TRUE)
  q3 <- quantile(x, 0.75, na.rm = TRUE)
  iqr <- q3 - q1
  x < q1 - 1.5 * iqr | x > q3 + 1.5 * iqr
}

# 2. 3-sigma method (Normal only)
is_outlier_z <- function(x, threshold = 3) {
  z <- (x - mean(x, na.rm = TRUE)) / sd(x, na.rm = TRUE)
  abs(z) > threshold
}

# 3. Business Rules (Such as age < 0 or > 150)
df |> filter(age < 0 | age > 150)

(2) 4 Métodos de tratamento

# 1. Delete
df |> filter(!is_outlier_iqr(income))

# 2. Replace with NA (Leave it for further analysis and processing)
df |> mutate(income = ifelse(is_outlier_iqr(income), NA, income))

# 3. Replace with the median (Robust)
df |>
  mutate(income = ifelse(is_outlier_iqr(income),
                          median(income, na.rm = TRUE), income))

# 4. Winsorize (Truncate to 5% / 95% quantile)
df |>
  mutate(income = DescTools::Winsorize(income, probs = c(0.05, 0.95)))

6. Como lidar com valores duplicados

# 1. Exactly duplicate rows
df |> distinct()           # Duplicate Removal
sum(duplicated(df))        # Count

# 2. Remove duplicates based on the specified column
df |> distinct(name, phone, .keep_all = TRUE)

# 3. Mark as Duplicate
df |> mutate(is_dup = duplicated(.))

# 4. Find Duplicates
df |> filter(duplicated(df) | duplicated(df, fromLast = TRUE))

7. Conversão de tipos

(1) Numérico

# Character -> Numeric (Processing "$1,000" Format)
df |>
  mutate(price = as.numeric(str_replace_all(price, "[$,]", "")))

# Processing Percentage "15%" → 0.15
df |>
  mutate(rate = as.numeric(str_replace(rate, "%", "")) / 100)

# Processing NA Conversion Error
df |>
  mutate(value = as.numeric(value),  # Failure leads to change NA + Warning
         bad = is.na(value) & !is.na(original_value))

(2) Tipo de data

library(lubridate)

# Automatic Parsing of Multiple Date Formats
df |>
  mutate(date = parse_date_time(date,
                                 orders = c("Y/m/d", "Y-m-d", "Y.m.d")))

# Extract Year, Month, and Day
df |>
  mutate(
    year = year(date),
    month = month(date),
    day = day(date),
    weekday = wday(date, label = TRUE)
  )

# Handling Invalid Dates
df |>
  mutate(
    date_parsed = parse_date_time(date, orders = "Y-m-d"),
    is_invalid = is.na(date_parsed) & !is.na(date)
  ) |>
  filter(!is_invalid)

(3) Tipo de fator

# Character -> factor (In the specified order)
df |>
  mutate(grade = factor(grade, levels = c("Poor", "Mid", "Good", "Excellent"),
                         ordered = TRUE))

# Numeric -> factor (Bin Sorting)
df |>
  mutate(age_group = cut(age,
                          breaks = c(0, 18, 35, 60, 100),
                          labels = c("Boy", "Youth", "Middle Age", "Old Age")))

8. Limpeza de strings (stringr)

library(stringr)

df |>
  mutate(
    # Remove spaces
    name = str_trim(name),
    # Uppercase and lowercase
    email = str_to_lower(email),
    # Remove Special Characters
    phone = str_replace_all(phone, "[^0-9]", ""),
    # Validation Format
    email_valid = str_detect(email, "^[\\w.+-]+@[\\w.-]+\\.[a-z]+$"),
    # Extract
    phone_prefix = str_sub(phone, 1, 3)
  )

9. O pacote do zelador (um verdadeiro poder de limpeza)

install.packages("janitor")
library(janitor)

# 1. Standardized column names (lowercase + underscore + remove special characters)
df |> clean_names()
# "First Name" → "first_name"
# "Age(yrs)" → "age"

# 2. Duplicate Removal + Report
df |> get_dupes()  # Show duplicate rows

# 3. Remove blank lines/col
df |> remove_empty(c("rows", "cols"))

# 4. Consistency Check
df |> tabyl(category)  # Similar table

10. Exemplo completo: Limpeza de 1.000 linhas de dados incorretos

A seguir, apresentamos um exemplo de um fluxo de trabalho completo que reúne todos os conceitos de limpeza abordados nesta aula.

▶ Exemplo: Limpeza completa dos dados incorretos de 1.000 clientes

R 📖 Somente leitura

# ============================================
# 1000 Complete Cleaning of Dirty Customer Data
# Features: All 6 major issues resolved
# ============================================

library(dplyr)
library(tidyr)
library(stringr)
library(lubridate)
library(janitor)

# 1. Constructing Dirty Data
set.seed(42)
n <- 1000
df_raw <- tibble(
  ID = sprintf("%04d", 1:n),
  Customer Name = paste0(" ", c("Alice", "Bob", "Charlie", "Diana", "Eve")[sample(5, n, TRUE)], " "),
  Cell Phone = sample(c("138-0000-1234", "+86 139 0000 5678", "(13900001111)",
                "138.0000.2222", "13900003333", "13900009999XX", NA), n, TRUE),
  Email = sample(c("user@163.COM", "lisi@example.com  ",
                "wangwu@gmail.com", "zhaoliu@ qq.com",
                NA, ""), n, TRUE),
  Date of Registration = sample(c("2024/01/15", "2024.01.20", "2024-02-01",
                    "2024-13-45", NA), n, TRUE),
  Age = sample(c(20:80, -5, 200, NA), n, TRUE)
)

# Add some repetition
df_raw <- bind_rows(df_raw, df_raw[1:50, ])

cat("=== Statistics on Raw Data Issues ===\n")
cat("Number of lines:", nrow(df_raw), "(includes 50 duplicate rows)\n")
cat("Email address missing:", sum(is.na(df_raw$Email) | df_raw$Email == ""), "rows\n")
cat("Missing Cell Phone:", sum(is.na(df_raw$Cell Phone)), "rows\n")
cat("Date Missing:", sum(is.na(df_raw$Date of Registration)), "rows\n")
cat("Age Anomaly (< 0 or > 150):",
    sum(df_raw$Age < 0 | df_raw$Age > 150, na.rm = TRUE), "rows\n\n")

# 2. Complete Cleaning Process
df_clean <- df_raw |>
  # 2.1 Standardized Listing
  clean_names() |>

  # 2.2 Remove duplicates
  distinct() |>

  # 2.3 Clean Name
  mutate(Customer Name = str_trim(Customer Name)) |>

  # 2.4 Clear Mobile Phone Number
  mutate(
    Cell Phone_Pure numbers = str_replace_all(Cell Phone, "[^0-9]", ""),  # Remove all non-numeric characters
    Cell Phone_Valid = nchar(Cell Phone_Pure numbers) == 11 & str_detect(Cell Phone_Pure numbers, "^1[3-9]")
  ) |>

  # 2.5 Clean the Mailbox
  mutate(
    Email_Cleaning = str_trim(Email) |> str_to_lower(),
    Email_Valid = str_detect(Email_Cleaning, "^[\\w.+-]+@[\\w.-]+\\.[a-z]+$")
  ) |>

  # 2.6 Handling Missing Values
  mutate(
    Cell Phone_Pure numbers = ifelse(Cell Phone_Valid, Cell Phone_Pure numbers, NA),
    Email_Cleaning = ifelse(Email_Valid, Email_Cleaning, NA)
  ) |>

  # 2.7 Handling Abnormal Ages
  mutate(
    Age_Cleaning = ifelse(Age < 0 | Age > 150, NA, Age)
  ) |>

  # 2.8 Analysis Date
  mutate(
    Date of Registration_parsed = parse_date_time(Date of Registration,
                                       orders = c("Y/m/d", "Y.m.d", "Y-m-d")),
    Date_Valid = !is.na(Date of Registration_parsed) | is.na(Date of Registration)
  ) |>

  # 2.9 Delete rows where a key field is missing
  drop_na(Customer Name, Date of Registration_parsed) |>

  # 2.10 Select the last column
  select(id, Name = Customer Name, Cell Phone = Cell Phone_Pure numbers, Email = Email_Cleaning,
         Age = Age_Cleaning, Date of Registration = Date of Registration_parsed)

cat("=== Data After Cleaning ===\n")
cat("Number of lines:", nrow(df_clean), "\n")
cat("Columns:", ncol(df_clean), "\n")
cat("Email address missing:", sum(is.na(df_clean$Email)), "\n")
cat("Missing Cell Phone:", sum(is.na(df_clean$Cell Phone)), "\n")
cat("Age Missing:", sum(is.na(df_clean$Age)), "\n")
cat("Date Missing:", sum(is.na(df_clean$Date of Registration)), "\n\n")

# 3. Verify the Quality of Cleaning
cat("=== Verify the Quality of Cleaning ===\n")

# 3.1 ID Format
cat("ID Length:", unique(nchar(df_clean$id)), "(Expected 4)\n")

# 3.2 No spaces before or after the name
cat("Name contains leading and trailing spaces:", sum(str_detect(df_clean$Name, "^\\s|\\s$")), "\n")

# 3.3 Mobile Phone Number Format
cat("Cell phone number 11 digits:", sum(nchar(df_clean$Cell Phone, na.rm = TRUE) == 11), "/",
    sum(!is.na(df_clean$Cell Phone)), "\n")

# 3.4 Email Format
cat("Email address includes @:", sum(str_detect(df_clean$Email, "@")), "/",
    sum(!is.na(df_clean$Email)), "\n")

# 3.5 Age Range
cat("Age Range: [", min(df_clean$Age, na.rm = TRUE), ",",
    max(df_clean$Age, na.rm = TRUE), "]\n")

# 4. Output clean data
write_csv(df_clean, "cleaned_data.csv")
cat("\n=== The cleaned data has been saved: cleaned_data.csv ===\n")

# 5. Before and After Cleaning Comparison
cat("\n=== Before and After Cleaning Comparison ===\n")
comparison <- tibble(
  Indicators = c("Total Number of Lines", "Columns", "Duplicate Rows", "Email address missing", "Missing Cell Phone", "Age Anomaly"),
  Before Cleaning = c(
    nrow(df_raw), ncol(df_raw), nrow(df_raw) - nrow(distinct(df_raw)),
    sum(is.na(df_raw$Email) | df_raw$Email == ""),
    sum(is.na(df_raw$Cell Phone)),
    sum(df_raw$Age < 0 | df_raw$Age > 150, na.rm = TRUE)
  ),
  After Cleaning = c(
    nrow(df_clean), ncol(df_clean), 0,
    sum(is.na(df_clean$Email)),
    sum(is.na(df_clean$Cell Phone)),
    sum(is.na(df_clean$Age))  # Outliers changed to NA
  )
)
print(comparison)

89 linhas de lógica (limite de 40, somente leitura)

Resultado esperado (trecho):

TEXT 📖 Somente leitura

=== Data After Cleaning ===
Number of lines: 923
Columns: 6
Email address missing: 162
Missing Cell Phone: 85
Age Missing: 22
Date Missing: 0

=== Verify the Quality of Cleaning ===
ID Length: 4 (Expected 4)
Name contains leading and trailing spaces: 0
Cell phone number 11 digits: 838 / 838
Email address includes @: 761 / 761
Age Range: [ 20 , 80 ]

❓ Perguntas Frequentes

P: Os valores ausentes devem ser excluídos ou imputados? R: Se a taxa de valores ausentes for < 5%, exclua-os; se for de 5 a 20%, impute-os; se for > 20%, considere excluir a coluna. Campos-chave (rótulos) não podem ser excluídos — eles devem ser imputados ou tratados por meio de outros métodos.

P: Quais valores devem ser usados para a imputação? R: Existem três opções: ① Média/mediana (a mais comum) ② Média do grupo (por grupo) ③ Previsão do modelo (a mais precisa, mas demorada). O entendimento do negócio > os métodos estatísticos.

P: Os valores atípicos podem ser excluídos diretamente? R: Primeiro, determine se se trata de um “erro”! Anomalias comerciais não podem ser excluídas (como gastos incomuns de clientes VIP); apenas erros de entrada de dados podem ser excluídos ou modificados.**

P: Quais são as etapas para a limpeza de strings? R: ① Remover espaços em branco (trim) ② Converter para maiúsculas/minúsculas ③ Remover caracteres especiais ④ Validar o formato ⑤ Extrair informações-chave.

P: Quais são algumas das armadilhas comuns no tratamento de datas? R: Três armadilhas principais: ① Vários formatos (AAAA-MM-DD vs. MM/DD/AAAA) ② Fusos horários ③ Datas inválidas (por exemplo, o 13º mês). Use os parâmetros parse_date_time() + orders.

P: Quais são as funções mais utilizadas no pacote janitor? R: clean_names() Padronizar nomes de colunas + get_dupes() Encontrar duplicatas + remove_empty() Remover linhas/colunas vazias. O Janitor é utilizado em quase todas as tarefas de limpeza de dados.

📖 Resumo

As 4 principais questões na limpeza de dados: Valores ausentes / Valores atípicos / Duplicatas / Tipos de dados
Ausente: visualização de < 5% delete / 5-20% fill / > 20% delete col + naniar::vis_miss
Anomalia: método do IQR (< Q1 - 1,5×IQR ou > Q3 + 1,5×IQR); determine primeiro se se trata de um erro ou de uma anomalia operacional
Duplicatas: distinct() Remoção de duplicatas + duplicated() Detecção
Tipo: as.numeric / parse_date_time / factor Conjunto de três peças
Strings: trim + conversão de maiúsculas e minúsculas + remoção de caracteres especiais + validação (stringr)
Data: lubridate::parse_date_time() Reconhece automaticamente vários formatos
Pacote de zeladoria: clean_names Lista padronizada de nomes + get_dupes + remove_empty
Ordem de limpeza: Lista → Duplicatas → Strings → Ausentes → Exceções → Tipos → Saída
A limpeza é imprescindível antes da modelagem — não dá para modelar sem limpar primeiro.

📝 Exercícios

Exercício básico: Realize uma limpeza completa dos dados utilizando o conjunto de dados airquality integrado ao R: ① Valores ausentes (impute o parâmetro “Ozone” usando a média ou a mediana) ② Duplicatas (não há duplicatas no conjunto de dados “airquality”) ③ Tipos de dados (verifique se todas as colunas estão corretas) ④ Compare os resultados (antes e depois da limpeza).
Problema básico: Crie um data frame com dados sujos contendo 100 linhas (incluindo valores NA, duplicatas, erros de digitação e strings fora do padrão), limpe-o completamente usando stringr + tidyr + janitor e gere uma tabela de comparação.
Exercício básico: Use parse_date_time para analisar 5 formatos de data diferentes (“2024-01-15”, “2024/01/15”, “15/01/2024”, “15 de janeiro de 2024”, “15-jan-2024”) e verifique os resultados.
Exercício avançado: Realize uma limpeza completa dos dados do conjunto de dados nycflights13::flights: ① Valores ausentes (dep_time, arr_time, air_time, dep_delay, arr_delay) ② Valores atípicos (dep_delay > 1440 minutos = 24 horas) ③ Apresente as estatísticas antes e depois da limpeza.
Desafio: Crie um conjunto de dados “gigante” com 1.000 linhas (contendo todos os quatro principais problemas), limpe-o completamente usando as ferramentas aprendidas nesta lição e gere: ① uma tabela comparativa mostrando os dados antes e depois da limpeza; ② um relatório de qualidade da limpeza de dados; ③ os dados limpos no formato CSV; ④ um resumo do processo de limpeza (200 caracteres).

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós