Pandas & NumPy Academy · Aula

Combinando e limpando colunas de texto

Concatene várias colunas em uma única cadeia de texto, remova espaços em branco e normalize rótulos de categorias inconsistentes.

Aula 4 de 413 etapas

Combinando e limpando colunas de texto é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Pandas & NumPy Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Pandas & NumPy Academy inclui 4 aulas no total.

Concatenando colunas de texto

Uma tarefa comum de preparação de dados é criar uma única cadeia de caracteres combinando valores de várias colunas — por exemplo, criar um nome completo a partir do nome e do sobrenome ou um endereço a partir da rua, da cidade e do país. No Pandas, você concatena colunas de texto usando o operador + em duas Séries (ou em uma Série e uma cadeia literal), depois de converter as colunas numéricas em cadeias de caracteres com .astype(str).

import pandas as pd

df = pd.DataFrame({
    'first_name': ['Alice', 'Bob', 'Carol'],
    'last_name': ['Smith', 'Jones', 'White']
})

df['full_name'] = df['first_name'] + ' ' + df['last_name']
print(df['full_name'].tolist())
# ['Alice Smith', 'Bob Jones', 'Carol White']

Concatenando com colunas que não são de texto

Ao combinar uma coluna numérica com uma coluna de texto, você precisa primeiro converter a coluna numérica em cadeia de caracteres usando .astype(str). O operador + do Python gera um TypeError se você tentar somar uma Série de cadeias de caracteres e uma Série de inteiros. Essa é uma fonte comum de confusão ao criar chaves compostas ou rótulos a partir de colunas de tipos mistos.

import pandas as pd

df = pd.DataFrame({
    'product': ['Widget', 'Gadget'],
    'version': [3, 5]
})

# Must convert int to str before concatenating
df['label'] = df['product'] + ' v' + df['version'].astype(str)
print(df['label'].tolist())
# ['Widget v3', 'Gadget v5']

str.cat() para concatenar com separador

Series.str.cat(others, sep=) é a forma nativa do Pandas de concatenar várias Series com um separador, tratando os valores NaN de forma adequada. Por padrão, um NaN em qualquer coluna faz com que o resultado dessa linha seja NaN. Passe na_rep='?' (ou qualquer string) para substituir NaN por um marcador em vez de propagá-lo.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'city': ['NYC', 'LA', None],
    'state': ['NY', None, 'TX'],
    'country': ['USA', 'USA', 'USA']
})

# Join with ', ' — NaN rows produce NaN by default
df['location'] = df['city'].str.cat(
    [df['state'], df['country']],
    sep=', ',
    na_rep='N/A'
)
print(df['location'].tolist())
# ['NYC, NY, USA', 'LA, N/A, USA', 'N/A, TX, USA']

Normalização de rótulos de categorias inconsistentes

As colunas de categorias do mundo real frequentemente têm rótulos inconsistentes causados por erros de digitação, variações de maiúsculas e minúsculas ou abreviações diferentes (por exemplo, 'US', 'USA', 'United States'). A correção padrão consiste em criar um dicionário de mapeamento que associe cada variante à forma canônica e, em seguida, aplicá-lo com .map() ou .replace().

import pandas as pd

df = pd.DataFrame({
    'country': ['US', 'USA', 'United States', 'uk', 'UK', 'United Kingdom']
})

canonical = {
    'US': 'United States', 'USA': 'United States', 'United States': 'United States',
    'uk': 'United Kingdom', 'UK': 'United Kingdom', 'United Kingdom': 'United Kingdom'
}

df['country_clean'] = df['country'].map(canonical)
print(df['country_clean'].tolist())
# ['United States', 'United States', 'United States',
#  'United Kingdom', 'United Kingdom', 'United Kingdom']

Remoção de espaços e padronização de maiúsculas e minúsculas

Antes de comparar ou agrupar colunas de texto, sempre remova os espaços em branco e normalize maiúsculas e minúsculas como primeira etapa da limpeza. Dois valores que parecem iguais para uma pessoa (' Active' e 'active') são tratados como diferentes pelo Pandas devido ao espaço inicial e à diferença entre maiúsculas e minúsculas. Uma cadeia de duas etapas — primeiro strip e depois lower — detecta os dois problemas.

import pandas as pd

df = pd.DataFrame({
    'status': ['  Active', 'INACTIVE', 'active ', ' Pending  ', 'ACTIVE']
})

df['status_clean'] = df['status'].str.strip().str.lower()
print(df['status_clean'].value_counts())
# active      3
# inactive    1
# pending     1

Correspondência aproximada para corrigir erros de digitação

Quando erros de digitação impedem a correspondência exata, a correspondência aproximada calcula pontuações de similaridade entre strings. A biblioteca rapidfuzz (ou a clássica fuzzywuzzy) oferece correspondência aproximada vetorizada. Um fluxo de trabalho típico consiste em, para cada valor sujo e único, encontrar o valor canônico mais próximo acima de um limite de similaridade e criar um mapa de correções.

# Conceptual example (requires: pip install rapidfuzz)
from rapidfuzz import process

canonical_cities = ['New York', 'Los Angeles', 'Chicago', 'Houston']
dirty_values = ['New Yrok', 'Los Angelas', 'Chicagoo']

for dirty in dirty_values:
    best, score, _ = process.extractOne(dirty, canonical_cities)
    print(f'{dirty!r} -> {best!r} (score={score:.0f}%)')
# 'New Yrok'   -> 'New York'    (score=91%)
# 'Los Angelas'-> 'Los Angeles' (score=96%)
# 'Chicagoo'   -> 'Chicago'     (score=94%)

Divisão de células com vários valores usando explode()

Às vezes, uma célula contém vários valores separados por um delimitador (por exemplo, 'python,sql,pandas'). Divida a coluna para obter listas e, em seguida, chame .explode() para criar uma linha por valor. Isso converte uma célula ampla e compactada em um formato longo e organizado, no qual cada linha tem exatamente um valor — algo necessário para operações de groupby e junção nesses valores.

import pandas as pd

df = pd.DataFrame({
    'user_id': [1, 2, 3],
    'skills': ['python,sql', 'java,kotlin,sql', 'python']
})

df['skills'] = df['skills'].str.split(',')
exploded = df.explode('skills')
print(exploded)
#    user_id   skills
# 0        1   python
# 0        1      sql
# 1        2     java
# 1        2   kotlin
# 1        2      sql
# 2        3   python

Tratamento de diferentes codificações em textos

Dados de texto de fontes diferentes podem apresentar problemas de codificação — caracteres incomuns, como \xa0 (espaço inseparável), \u2019 (apóstrofo curvo) ou caracteres acentuados corrompidos. Use .str.encode('ascii', errors='replace').str.decode('ascii') para uma limpeza rápida que retenha apenas ASCII, ou .str.normalize('NFKD') para decompor os acentos antes de removê-los.

import pandas as pd
import unicodedata

df = pd.DataFrame({'name': ['Caf\u00e9', 'na\u00efve', 'r\u00e9sum\u00e9']})

# Normalize and strip accents (NFKD decomposition + ascii encoding)
df['name_ascii'] = (
    df['name']
    .str.normalize('NFKD')
    .str.encode('ascii', errors='ignore')
    .str.decode('ascii')
)
print(df)
#       name name_ascii
# 0     Cafe       Cafe
# 1    naive      naive
# 2   resume     resume

Criação de chaves compostas

Em muitos conjuntos de dados, é necessário criar uma chave composta a partir de várias colunas para identificar exclusivamente uma linha em junções ou na remoção de duplicatas. Combinar colunas de texto limpas (com espaços removidos, em minúsculas e normalizadas) em uma única string de chave garante correspondências consistentes entre fontes de dados nas quais a mesma entidade pode estar grafada de forma ligeiramente diferente.

import pandas as pd

df = pd.DataFrame({
    'first': ['  Alice', 'BOB', ' Carol'],
    'last': ['Smith ', 'JONES', 'White  '],
    'dob': ['1990-01-15', '1985-07-22', '1992-11-30']
})

df['match_key'] = (
    df['first'].str.strip().str.lower() + '|' +
    df['last'].str.strip().str.lower() + '|' +
    df['dob']
)
print(df['match_key'].tolist())
# ['alice|smith|1990-01-15', 'bob|jones|1985-07-22', 'carol|white|1992-11-30']

Imposição de uma lista canônica de categorias

Após a limpeza, valide se todos os valores de uma coluna de texto categórica pertencem a um conjunto canônico conhecido. Qualquer valor que não pertença ao conjunto pode indicar uma nova categoria legítima ou um erro nos dados. Registre ou sinalize os valores desconhecidos para análise manual em vez de descartá-los silenciosamente, para que nada passe despercebido.

import pandas as pd

df = pd.DataFrame({
    'status': ['active', 'inactive', 'active', 'archived', 'unknown_status']
})

canonical = {'active', 'inactive', 'archived'}

unknown = df[~df['status'].isin(canonical)]['status'].unique()
print('Unknown statuses:', unknown.tolist())
# ['unknown_status']

# Flag unknown rows
df['status_valid'] = df['status'].isin(canonical)
print(df)

Fluxo completo de limpeza de texto

Aqui está um fluxo completo de limpeza de texto que aplica todas as técnicas desta lição: remover espaços em branco, normalizar maiúsculas e minúsculas, corrigir abreviações, remover caracteres especiais e validar com base em uma lista canônica. Esse é o tipo de função reutilizável que você adicionaria a qualquer módulo de ingestão de dados.

import pandas as pd

def clean_category_column(series, canonical_map, canonical_set):
    cleaned = (
        series
        .str.strip()
        .str.lower()
        .map(lambda x: canonical_map.get(x, x))  # fix known variants
    )
    unknown = cleaned[~cleaned.isin(canonical_set)]
    if not unknown.empty:
        print('Warning: unknown values:', unknown.unique().tolist())
    return cleaned

cmap = {'eng': 'engineering', 'hr': 'human_resources', 'mktg': 'marketing'}
cset = {'engineering', 'human_resources', 'marketing', 'finance'}

df = pd.DataFrame({'dept': ['Eng', 'HR', 'Marketing', 'MKTG', 'Legal']})
df['dept_clean'] = clean_category_column(df['dept'], cmap, cset)
print(df)

Verificação rápida

Teste sua compreensão sobre a combinação e a limpeza de colunas de texto.

Recapitulação da lição

Nesta lição, você aprendeu a concatenar colunas com o operador + depois de converter números em strings, usar str.cat(sep=) para juntar valores com um delimitador e tratar NaN, aplicar um mapa canônico com .map() para normalizar rótulos inconsistentes e usar explode() para expandir células com valores em listas em várias linhas. Imponha conjuntos canônicos para detectar problemas de qualidade dos dados logo no início. A seguir, você aprenderá a ordenar DataFrames pelos valores das colunas.

Grátis para começar

Aprenda Python com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
30
Aulas
120

Perguntas Frequentes

A aula “Combinando e limpando colunas de texto” é grátis?

Sim — o texto completo de “Combinando e limpando colunas de texto” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Pandas & NumPy Academy, atualize para CoddyKit PRO. O curso de Pandas & NumPy Academy inclui 4 aulas no total.

O que vou aprender em “Combinando e limpando colunas de texto”?

Concatene várias colunas em uma única cadeia de texto, remova espaços em branco e normalize rótulos de categorias inconsistentes. Você pratica Pandas & NumPy Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Pandas & NumPy Academy?

Nenhuma experiência prévia é necessária. Pandas & NumPy Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Combinando e limpando colunas de texto”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Pandas & NumPy Academy?

Sim. Cada aula de Pandas & NumPy Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. O acessador .str
  2. Dividindo e substituindo textos
  3. Correspondência de padrões com expressões regulares
  4. Combinando e limpando colunas de texto
← Voltar para Pandas & NumPy Academy