0Pricing
Pandas & NumPy Academy · Aula

Dividindo e substituindo textos

Divida textos em várias colunas com .str.split(expand=True) e substitua partes do texto com .str.replace().

Dividindo e substituindo textos é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 2 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.

Dividindo cadeias de caracteres em uma lista

.str.split(sep) divide cada cadeia de caracteres de uma Série em todas as ocorrências do separador e retorna uma Série de listas. Sem expand=True, cada elemento é uma lista Python, o que é útil para contar tokens ou realizar outro processamento no nível da lista. O separador pode ser uma cadeia literal ou um padrão de expressão regular.

import pandas as pd

df = pd.DataFrame({'tags': ['python,data,pandas', 'ml,ai', 'sql,db,query']})

# Split into a list of strings
df['tag_list'] = df['tags'].str.split(',')
print(df['tag_list'])
# 0    [python, data, pandas]
# 1                  [ml, ai]
# 2         [sql, db, query]

# Count tags per row
df['tag_count'] = df['tag_list'].str.len()
print(df['tag_count'].tolist())  # [3, 2, 3]

expand=True para dividir em colunas

Passar expand=True para .str.split() retorna um DataFrame em vez de uma Série de listas; cada token dividido se torna sua própria coluna (colunas 0, 1, 2, …). Essa é a forma padrão de ampliar uma coluna delimitada — por exemplo, dividir um nome completo como 'first last' em colunas separadas para nome e sobrenome.

import pandas as pd

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

# Split into two columns
name_parts = df['full_name'].str.split(' ', expand=True)
name_parts.columns = ['first_name', 'last_name']
df = pd.concat([df, name_parts], axis=1)
print(df)
#     full_name first_name last_name
# 0  Alice Smith      Alice     Smith
# 1    Bob Jones        Bob     Jones
# 2  Carol White      Carol     White

Limitando a quantidade de divisões com n=

O parâmetro n limita a quantidade máxima de divisões. .str.split(sep, n=1) divide no máximo uma vez, criando no máximo duas partes. Isso é útil quando você precisa apenas do primeiro componente de uma cadeia de caracteres e o restante pode permanecer junto — por exemplo, para extrair o domínio de um e-mail dividindo-o em '@'.

import pandas as pd

df = pd.DataFrame({'email': ['alice@example.com', 'bob@work.org', 'carol@test.net']})

# Split at '@', keep only the first split
parts = df['email'].str.split('@', n=1, expand=True)
df['username'] = parts[0]
df['domain'] = parts[1]
print(df[['username', 'domain']])
#   username       domain
# 0    alice  example.com
# 1      bob     work.org
# 2    carol     test.net

rsplit() para divisão pelo lado direito

.str.rsplit(sep, n=1) divide a cadeia de caracteres começando pelo lado direito. Isso é útil quando você quer o último componente — por exemplo, para extrair a extensão de um arquivo de um caminho dividindo-o no último ponto. Combinado com expand=True, cria duas colunas: tudo antes do último separador e tudo depois dele.

import pandas as pd

df = pd.DataFrame({'filepath': ['data/raw/sales.csv', 'data/clean/orders.xlsx', 'reports/q1.pdf']})

# Split on the last '/' to separate directory from filename
parts = df['filepath'].str.rsplit('/', n=1, expand=True)
df['directory'] = parts[0]
df['filename'] = parts[1]
print(df[['directory', 'filename']])
#     directory    filename
# 0    data/raw   sales.csv
# 1  data/clean  orders.xlsx
# 2     reports       q1.pdf

.str.replace() para substituição de substrings

.str.replace(pat, repl) substitui ocorrências de um padrão em cada cadeia de caracteres. Por padrão, pat é tratado como uma expressão regular; portanto, passe regex=False para substituir uma cadeia literal. A substituição pode ser uma cadeia fixa ou uma referência retroativa de expressão regular. Use sempre esse recurso para substituições vetorizadas, em vez de um laço Python.

import pandas as pd

df = pd.DataFrame({'price': ['$1,200.50', '$800.00', '$3,450.75']})

# Remove dollar sign and commas
df['price_clean'] = (
    df['price']
    .str.replace('$', '', regex=False)  # literal $
    .str.replace(',', '', regex=False)  # literal comma
)
df['price_float'] = df['price_clean'].astype(float)
print(df)
#       price price_clean  price_float
# 0  $1,200.50    1200.50       1200.5
# 1    $800.00     800.00        800.0
# 2  $3,450.75    3450.75       3450.75

Substituindo com padrões de expressão regular

Quando você passa regex=True (o padrão), o padrão é uma expressão regular, e a substituição pode incluir referências retroativas, como r'\1', para fazer referência a grupos capturados. Isso permite transformações de texto avançadas, como reformatar datas, normalizar números de telefone ou extrair dados estruturados de texto livre.

import pandas as pd

df = pd.DataFrame({'date': ['01-15-2024', '03-20-2024', '07-04-2024']})

# Reformat from MM-DD-YYYY to YYYY-MM-DD using groups
df['date_iso'] = df['date'].str.replace(
    r'(\d{2})-(\d{2})-(\d{4})',
    r'\3-\1-\2',
    regex=True
)
print(df)
#          date   date_iso
# 0  01-15-2024  2024-01-15
# 1  03-20-2024  2024-03-20
# 2  07-04-2024  2024-07-04

Contando as substituições realizadas

Às vezes, você quer verificar quantos valores foram realmente modificados por uma substituição. Compare a Série original com a Série substituída para contar as linhas em que ocorreu uma alteração. Essa etapa de validação confirma que o padrão de substituição encontrou as correspondências esperadas e ajuda a identificar erros de expressão regular antecipadamente.

import pandas as pd

df = pd.DataFrame({'text': ['foo bar', 'hello foo', 'world', 'foo foo']})

original = df['text'].copy()
df['text'] = df['text'].str.replace('foo', 'baz', regex=False)

changed = (df['text'] != original).sum()
print(f'{changed} rows were modified')  # 3
print(df['text'].tolist())
# ['baz bar', 'hello baz', 'world', 'baz baz']

Substituindo vários padrões com um laço

Quando você precisa aplicar muitas substituições (por exemplo, padronizar dezenas de abreviações), percorra um dicionário de mapeamento e aplique cada substituição em sequência. Isso é mais fácil de manter do que uma única expressão regular complexa com alternâncias. Crie o mapeamento a partir de regras de negócio ou de uma tabela de consulta.

import pandas as pd

df = pd.DataFrame({'dept': ['Eng', 'Engg', 'HR', 'Human Resources', 'Mktg', 'Marketing']})

# Standardisation map
substitutions = {
    'Engg': 'Engineering',
    'Eng': 'Engineering',
    'Human Resources': 'HR',
    'Mktg': 'Marketing'
}

for old, new in substitutions.items():
    df['dept'] = df['dept'].str.replace(old, new, regex=False)

print(df['dept'].tolist())
# ['Engineering', 'Engineering', 'HR', 'HR', 'Marketing', 'Marketing']

Reunindo as partes divididas

Depois de dividir, talvez você precise recombinar as partes. Para uma Série de listas, use .str.join(separator) para concatenar os elementos da lista em uma única cadeia de caracteres por linha. Para unir valores entre colunas, use a concatenação padrão de cadeias com + e .astype(str).

import pandas as pd

df = pd.DataFrame({'parts': [['alpha', 'beta'], ['foo', 'bar', 'baz']]})

# Join list elements with a hyphen
df['joined'] = df['parts'].str.join('-')
print(df['joined'])
# 0     alpha-beta
# 1  foo-bar-baz

Normalizando espaços em branco

Uma tarefa comum de limpeza de texto é compactar vários espaços consecutivos em um único espaço. Isso costuma acontecer em textos extraídos da web, quando o espaçamento do HTML ou a ação de copiar e colar adiciona espaços em branco extras. O padrão de expressão regular r'\s+' corresponde a um ou mais caracteres de espaço em branco e substitui todos por um único espaço; em seguida, .str.strip() remove qualquer espaço no início ou no fim.

import pandas as pd

df = pd.DataFrame({'address': ['123  Main   St', '  456 Oak  Ave  ', '789 Pine St']})

df['address_clean'] = (
    df['address']
    .str.replace(r'\s+', ' ', regex=True)
    .str.strip()
)
print(df['address_clean'].tolist())
# ['123 Main St', '456 Oak Ave', '789 Pine St']

Prática: analisando uma coluna de cadeias estruturadas

Veja um exemplo realista em que uma única coluna contém dados estruturados, como 'Alice:25:Engineer'. Dividimos pelo delimitador, nomeamos as colunas resultantes e convertemos cada uma para seu tipo apropriado — um pipeline completo de análise e conversão de tipos usando apenas .str.split() e astype().

import pandas as pd

df = pd.DataFrame({'record': ['Alice:25:Engineer', 'Bob:34:Manager', 'Carol:28:Analyst']})

parts = df['record'].str.split(':', expand=True)
parts.columns = ['name', 'age', 'role']
parts['age'] = parts['age'].astype(int)

result = pd.concat([df, parts], axis=1)
print(result)
#              record   name  age      role
# 0  Alice:25:Engineer  Alice   25  Engineer
# 1    Bob:34:Manager    Bob   34   Manager
# 2  Carol:28:Analyst  Carol   28   Analyst

Verificação rápida

Teste sua compreensão da divisão e substituição de cadeias de caracteres.

Resumo da lição

Nesta lição, você aprendeu que str.split(sep, expand=True) amplia uma coluna delimitada em várias colunas, n= limita a quantidade de divisões, str.rsplit() divide começando pela direita e str.replace() substitui padrões (com suporte a expressões regulares). Encadeie operações de divisão e substituição com strip e lower para criar pipelines completos de normalização de texto. A seguir, usaremos padrões de expressão regular para extrair e encontrar substrings.

Perguntas Frequentes

A aula “Dividindo e substituindo textos” é grátis?

Sim — o texto completo de “Dividindo e substituindo textos” é 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 “Dividindo e substituindo textos”?

Divida textos em várias colunas com .str.split(expand=True) e substitua partes do texto com .str.replace(). 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 2 de 4.

Quanto tempo leva a aula “Dividindo e substituindo textos”?

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