Tratamento de dados com pandas

Um dado ausente significa que um valor é desconhecido ou indisponível. O pandas armazena um marcador especial em seu lugar. Detecte o marcador antes de calcular totais ou decidir quais linhas podem ser usadas.

Reconheça os marcadores

O marcador depende do tipo de dados. Colunas de ponto flutuante usam NaN, colunas de data e hora usam NaT, e tipos com suporte a valores ausentes, como "Int64", "boolean" e "string", usam pd.NA. O pandas 3 infere colunas de texto como str, com NaN para texto ausente. O None do Python também é reconhecido como ausente. Use import pandas as pd e import numpy as np nos exemplos.

df.isna() produz uma tabela booleana com as mesmas linhas e colunas de df. Um True marca uma lacuna; df.notna() marca valores presentes. Os nomes alternativos isnull() e notnull() fazem o mesmo. Não compare uma coluna com np.nan: NaN é diferente até de si mesmo, então s == np.nan não detecta as lacunas.

Conte células e linhas afetadas

Considere estas leituras meteorológicas:

Um True booleano conta como 1, então df.isna().sum() fornece 0 cidades ausentes, 2 temperaturas e 2 leituras de chuva ausentes. df.isna().mean() fornece as proporções 0,0, 0,5 e 0,5. A proporção de cada coluna usa as quatro linhas como denominador.

Para encontrar linhas afetadas, use df.isna().any(axis=1). Ele retorna False, True, True, True; a soma fornece 3. Já df.isna().sum().sum() fornece 4 células ausentes. Kyiv contribui com duas células, mas apenas uma linha afetada. Use a medida que responde à sua pergunta.

Reconheça códigos ocultos de valores ausentes

Um instrumento pode registrar uma leitura indisponível como -999, "-" ou "unknown". Esses são valores comuns até que você os converta. Após confirmar o significado do código, use df.replace([-999, "unknown"], np.nan). Durante o carregamento de CSV, na_values=[-999, "unknown"] adiciona esses códigos aos marcadores reconhecidos. Campos vazios em CSV e strings comuns como "NA", "n/a" e "NULL" já são reconhecidos por padrão.

Uma leitura de chuva igual a zero pode significar que não choveu, então substituir todos os zeros destruiria observações reais. Além disso, uma string vazia criada na memória, "", e uma string contendo espaços não são consideradas ausentes por isna(). Inspecione o texto armazenado e também as contagens de marcadores. Para incluir categorias ausentes em uma tabela de frequências, use value_counts(dropna=False).

Verifique cálculos e tipos de dados

Para s = pd.Series([4, np.nan, 8]), s.mean() é 6,0: ele usa os dois valores conhecidos. s.count() é 2, enquanto len(s) é 3. Dividir s.sum() por len(s) fornece 4,0 e trata incorretamente a lacuna como zero. A maioria das estatísticas ignora lacunas por padrão; uma coluna inteiramente ausente tem soma 0, mas média NaN.

Uma lacuna também pode alterar o armazenamento. pd.Series([3, None, 5]) torna-se float64, contendo 3,0, NaN e 5,0. Informar dtype="Int64" mantém valores inteiros com <NA> para a lacuna. O I maiúsculo identifica o tipo inteiro do pandas com suporte a valores ausentes.

Remover uma linha elimina seus valores conhecidos junto com suas lacunas. Preencher uma lacuna mantém a linha, mas introduz uma estimativa. Escolha com base no significado da observação e nas colunas necessárias à análise.

Controle quais linhas são removidas

df.dropna() remove toda linha com algum valor ausente. Na tabela meteorológica, apenas Lima permanece. Restrinja a decisão com subset ou exija um número mínimo de células presentes com thresh.

axis="columns" remove colunas com lacunas e mantém apenas city neste caso. Em uma tabela com muitas colunas, a regra padrão para linhas pode descartar grande parte dos dados, pois uma lacuna em qualquer coluna é suficiente. Compare len(df) antes e depois da remoção.

Atribua o resultado

Aprenda a forma com reatribuição: df = df.dropna(). Por padrão, métodos de limpeza retornam um novo objeto. O pandas 3.1 descontinua inplace=True em métodos como dropna, drop_duplicates e rename.

Para uma coluna, escreva df["temp_c"] = df["temp_c"].fillna(0). Uma chamada encadeada como df["temp_c"].fillna(0, inplace=True) nunca atualiza o DataFrame original sob a cópia na escrita do pandas 3. A atribuição torna o destino explícito.

Preencha com um valor compatível

Um dicionário por coluna permite fornecer valores adequados a uma tabela com tipos mistos: df.fillna({"rain_mm": 0, "city": "Unknown"}). Colunas omitidas do dicionário mantêm suas lacunas. Um escalar como 0 é conveniente para uma tabela inteiramente numérica cujas colunas o aceitam. Preencher texto com um número é incompatível; o pandas 3.1 emite um aviso e uma versão futura rejeitará essa operação.

As temperaturas conhecidas são 18,0 e 31,0. A média delas é 24,5, então df["temp_c"].fillna(df["temp_c"].mean()) coloca 24,5 nas duas lacunas. Um valor extremo pode deslocar muito a média; a mediana é menos sensível. Antes de preencher, mantenha um indicador com df["temp_missing"] = df["temp_c"].isna() para que valores estimados e observados continuem distinguíveis.

A imputação pela média reduz a dispersão aparente da coluna. Um valor fixo distante pode aumentá-la. Preencher chuva com 0 afirma que não choveu, o que é inadequado para um sensor que estava desligado.

Use leituras vizinhas quando a ordem importar

ffill() leva o último valor conhecido para a frente; bfill() leva o próximo valor conhecido para trás. Para 12,0, NaN, NaN, NaN, 15,0, o preenchimento para a frente fornece quatro valores 12,0 seguidos de 15,0. ffill(limit=1) preenche apenas a primeira lacuna dessa sequência. Uma lacuna inicial não tem valor anterior e permanece ausente. Use ffill() diretamente; fillna(method="ffill") foi removido no pandas 3.

interpolate() estima valores entre posições vizinhas. Para 10, NaN, NaN, 16, a interpolação linear fornece 10, 12, 14, 16. Ela é adequada para medições que mudam gradualmente em uma ordem significativa. Propagar ou interpolar valores entre cidades sem relação imporia uma relação que as linhas não têm.

Após qualquer operação, execute novamente isna().sum() e verifique as contagens de linhas. Uma chamada de método bem-sucedida informa que o código foi executado; essas verificações mostram o que mudou.

Duas linhas podem parecer iguais sem descrever o mesmo evento. Antes de remover duplicatas, decida quais valores identificam um registro. Um identificador de pedido pode identificar um pedido; cliente e data, por si só, podem identificar várias compras legítimas.

Marque as cópias extras

df.duplicated() retorna um valor booleano por linha. Por padrão, ele compara todas as colunas, mantém a primeira ocorrência e marca as cópias posteriores como True. Somar o resultado conta as cópias extras, não todos os membros dos grupos repetidos.

Considere seis linhas de pedidos com os identificadores 101, 102, 102, 103, 104, 104. As duas linhas de 102 são idênticas. As duas linhas de 104 têm pesos registrados diferentes, 0,5 kg e 0,8 kg. Comparando todas as colunas, há uma cópia extra: df.duplicated().sum() é 1. df.drop_duplicates() mantém cinco linhas porque as duas linhas diferentes de 104 não são cópias exatas.

Compare as colunas que definem a identidade

df.duplicated(subset=["order_id"]) compara apenas os identificadores. Ele marca o segundo 102 e o segundo 104, fornecendo duas cópias extras. Os valores das outras colunas não afetam mais essa decisão. Inspecione os pesos divergentes antes de escolher qual registro de pedido manter.

df.drop_duplicates(subset="order_id", keep="last") mantém a versão de 0,8 kg do pedido 104 nessa ordem. Manter a última linha não significa, por si só, manter o registro mais recente. Estabeleça essa ordem primeiro:

latest = df.sort_values("updated").drop_duplicates(
    subset="customer_id", keep="last"
)

Ordenar por updated coloca registros mais antigos antes dos mais recentes. A verificação de duplicatas compara então apenas customer_id, de modo que horários de atualização diferentes não impedem que duas linhas sejam reconhecidas como versões do mesmo cliente.

Separe valores de linha de rótulos de índice

Esses métodos comparam valores, ignorando rótulos de índice. Linhas idênticas com rótulos 4 e 9 ainda contam como duplicatas. Valores ausentes em posições correspondentes são considerados iguais nessa verificação. Para testar os próprios rótulos repetidos, use df.index.duplicated().

A comparação exata também preserva diferenças de maiúsculas, minúsculas e caracteres em branco. Os valores “ Lisbon”, “lisbon” e “LISBON ” são distintos. Limpe com .str.strip().str.lower() antes de verificar duplicatas quando essas grafias representarem a mesma cidade. Caso contrário, nunique() contará três nomes para um lugar.

Verifique a unicidade onde a relação exigir

Uma tabela de consulta deve ter uma linha por chave de consulta quando cada registro precisar receber um conjunto de informações. lookup["customer_id"].is_unique verifica esse requisito. Identificadores de clientes repetidos em uma tabela de pedidos são normais porque um cliente pode fazer vários pedidos.

Se uma chave de consulta se repetir, uma junção posterior repetirá cada pedido correspondente para cada linha de consulta correspondente. Remover duplicatas dos pedidos descartaria compras reais sem corrigir a tabela de consulta. Verifique a chave pretendida na tabela correta, inspecione registros conflitantes e compare a contagem de linhas após a remoção.

Uma substituição edita valores correspondentes, uma consulta transforma valores e uma renomeação altera rótulos. Essas tarefas podem parecer semelhantes no código, mas produzem resultados diferentes quando um valor está ausente de um dicionário.

Substitua valores exatos

s.replace("N/A", np.nan) altera apenas células iguais a "N/A". Uma lista pode indicar vários valores antigos: s.replace(["-", "?"], np.nan). Um dicionário fornece substituições distintas, como s.replace({"M": "male", "F": "female"}). Valores sem correspondência permanecem como estavam.

Para uma tabela inteira, um dicionário aninhado restringe a alteração a uma coluna: df.replace({"status": {0: "open", 1: "closed"}}). Isso evita alterar zeros e uns não relacionados em outras partes. Atribua o resultado retornado para manter a alteração.

replace busca correspondências em células inteiras. Com “Main St” e “St”, s.replace("St", "Street") altera apenas “St”. Para editar partes de uma string, use s.str.replace("St", "Street", regex=False), que também produz “Main Street”.

Transforme valores com uma consulta

Para os códigos “PT”, “JP” e “KE”, compare o mesmo dicionário em dois métodos:

Um dicionário passado a map define as saídas disponíveis. Uma chave ausente não tem saída e torna-se um valor ausente. Verifique isna().sum() depois para tornar visível uma consulta incompleta.

map também aceita uma função: s.map(lambda x: x * 1000) converte valores em quilômetros para metros. Para essa operação aritmética, s * 1000 é mais simples e rápido porque opera sobre a coluna inteira. DataFrame.map aplica uma função célula por célula; ele substitui o método applymap, que foi removido.

Converta texto em números

astype solicita um tipo de dados, como "float64", "Int64" ou "category". Ele gera um erro se um valor não puder ser convertido. Para os textos "12", "7.5" e "n/a", pd.to_numeric(s, errors="coerce") produz 12,0, 7,5 e NaN. A coerção de tipo preserva números que podem ser interpretados, mas exige a inspeção das falhas.

A formatação pode impedir a conversão mesmo quando o número é válido. Para “1,200” e “950”, primeiro remova o separador de milhares:

cleaned = s.str.replace(",", "", regex=False)
numbers = pd.to_numeric(cleaned, errors="coerce")
failed = s.notna() & numbers.isna()

Aqui, failed marca valores que estavam presentes antes da conversão, mas se tornaram ausentes. Comparar apenas as contagens de valores ausentes fornece um total útil; a máscara também localiza o texto original a ser inspecionado. Remova unidades conhecidas de textos de medições da mesma forma cuidadosa antes de convertê-los.

Renomeie os rótulos

df.rename(columns={"Qty": "quantity"}) altera um cabeçalho de coluna, deixando suas células inalteradas. df.rename(columns=str.lower) coloca todos os cabeçalhos em minúsculas. Uma sequência como df.columns.str.strip().str.lower().str.replace(" ", "_", regex=False) transforma “Total KG ” em total_kg; atribua-a a df.columns.

Use replace ou map para valores dentro de uma coluna. Use rename para os rótulos pelos quais você seleciona esses valores.

Algumas análises precisam de medições exatas, enquanto outras precisam de grupos ou escalas numéricas comparáveis. Mantenha claro o significado original: a discretização cria categorias, o escalonamento altera a escala numérica e a limitação substitui valores extremos.

Coloque valores em intervalos

pd.cut(ages, [18, 30, 45, 65]) usa os intervalos (18, 30], (30, 45] e (45, 65]. O parêntese exclui o extremo esquerdo; o colchete de fechamento inclui o extremo direito. As idades 19, 25 e 30 entram no primeiro intervalo, 41 no segundo e 64 no terceiro. A idade 18 torna-se ausente porque está no extremo esquerdo excluído.

include_lowest=True inclui esse valor mínimo no primeiro intervalo. Já right=False cria intervalos fechados à esquerda, como [18, 30), então 30 entra no segundo intervalo. Valores fora de todos os intervalos permanecem ausentes. Teste os limites exatos e também valores típicos entre eles.

Deve haver um rótulo por intervalo, um a menos que o número de limites. Com labels=["18-30", "31-45", "46-65"] e include_lowest=True, as seis idades acima fornecem as contagens 4, 1 e 1. Esses rótulos descrevem idades em números inteiros; os limites dos intervalos continuam determinando a atribuição.

Escolha limites ou tamanhos dos grupos

Para 2, 4, 6, 8, 10, 12, 14, 16, qcut fornece dois valores por grupo de quartil. Grupos com contagens iguais não precisam cobrir amplitudes numéricas iguais.

Escalone sem criar grupos

O escalonamento mínimo-máximo usa (x - x.min()) / (x.max() - x.min()). Para 10, 20, 40, a amplitude é 30: os resultados são 0, aproximadamente 0,333 e 1. Tanto o mínimo quanto o máximo são necessários; dividir apenas pelo máximo é uma operação diferente. Uma coluna constante tem amplitude zero, então essa expressão não pode fornecer uma dispersão escalonada útil para ela.

A padronização usa (x - x.mean()) / x.std(). Para 10, 20, 30, a média é 20 e o desvio padrão amostral padrão do pandas é 10. Subtrair 20 e dividir por 10 fornece os escores z -1, 0 e 1. Um escore z descreve a distância da média em unidades de desvio padrão, não um rótulo de intervalo.

Limite e codifique

pd.Series([5, 12, 250, 8]).clip(upper=100) fornece 5, 12, 100, 8. Diferentemente de um filtro, clip mantém a linha e substitui o número extremo. Inspecione valores grandes com describe() ou um filtro antes de limitá-los: uma medição grande real ainda é um dado.

pd.get_dummies(s) cria uma coluna indicadora booleana por categoria. Com vermelho, verde, vermelho, azul, cada linha é True apenas na coluna de sua cor. Use dtype=int para zeros e uns. Valores ausentes produzem indicadores todos falsos, a menos que dummy_na=True adicione uma coluna de valores ausentes. Para regressão por mínimos quadrados ordinários com intercepto, drop_first=True remove uma coluna de categoria redundante; outros modelos podem manter todas as categorias. Com uma categoria por linha, o conjunto completo de indicadores soma a constante 1 do intercepto, criando dependência linear.

Para células que contêm várias etiquetas, s.str.get_dummies(sep="|") divide um valor como “Action|Comedy” em indicadores separados. Intervalos criados por discretização também podem ser passados a get_dummies, produzindo uma coluna para cada faixa.

Uma pessoa vê a mesma cidade em “ Lisbon”, “lisbon” e “LISBON ”. O pandas vê três strings diferentes. Limpar uma coluna de texto fornece um conjunto consistente de valores para comparação em contagens, verificações de duplicatas e junções posteriores.

Aplique métodos de strings a uma Series

"Lima ".strip() do Python funciona em uma string. Para uma coluna, use o acessor .str: s.str.strip() remove caracteres em branco das extremidades de cada valor não ausente. s.lower() gera um AttributeError porque a própria Series não tem um método lower. Use s.str.lower().

O pandas 3 normalmente infere texto como tipo str, substituindo o antigo padrão object. O tipo str contém texto e valores ausentes, com NaN para texto ausente. Métodos de strings funcionam nos dois tipos. Atribua texto a uma coluna str; converta primeiro um número em texto se ele pertencer à coluna como texto.

Combine operações de limpeza compatíveis e atribua o resultado:

df["city"] = df["city"].str.strip().str.lower()

As três grafias de Lisboa tornam-se “lisbon”. strip() remove caracteres em branco das extremidades, não espaços dentro de um nome. upper() coloca todas as letras em maiúsculas, enquanto title() coloca a primeira letra de cada palavra em maiúscula, transformando “new york” em “New York”. Escolha uma forma consistente para chaves e contagens.

Divida strings estruturadas

Para “Silva, Ana” e “Tanaka, Yui”, s.str.split(", ") retorna listas como ["Silva", "Ana"]. Acrescente expand=True para produzir colunas separadas. Obtenha uma parte de cada lista com .str[0] ou .str.get(1).

Se apenas o primeiro separador deve dividir um valor, use n=1. Dividir “a,b,c” nas vírgulas com n=1 fornece “a” e “b,c”. Sem limite, fornece três partes. Corresponda exatamente ao separador, incluindo qualquer espaço que faça parte do formato.

Pesquise e filtre

s.str.contains("lis", case=False) procura texto em qualquer posição, ignorando maiúsculas e minúsculas. s.str.startswith("ID") verifica o início; s.str.endswith(".csv") verifica o fim. Os resultados booleanos podem selecionar linhas:

mask = df["city"].str.contains("san", case=False, na=False)
selected = df[mask]

Para o tipo str do pandas 3, texto ausente fornece False nesses testes de pesquisa. Escrever na=False também deixa claro o tratamento pretendido ao usar dados de strings com suporte a valores ausentes. contains interpreta um padrão de expressão regular por padrão; acrescente regex=False para texto literal que contenha caracteres especiais.

Substitua partes e construa novas strings

s.str.replace("kg", "", regex=False) remove “kg” onde quer que apareça. s.replace("kg", "") altera apenas células que são exatamente “kg”. Essa distinção importa para valores como “12 kg”.

str.replace trata seu texto de pesquisa literalmente por padrão. Para “3.5 kg”, .str.replace(".", "", regex=False) remove o ponto e fornece “35 kg”. Com regex=True, o ponto é um padrão para quase qualquer caractere e remove todos os caracteres neste exemplo de uma linha. Nunca use essa alteração para interpretar uma medição decimal.

s.str.len() conta caracteres; um valor ausente produz NaN e pode tornar o resultado uma coluna de ponto flutuante. s.str[:3] extrai os três primeiros caracteres. Para combinar colunas, df["first"] + " " + df["last"] une Ana e Silva como “Ana Silva”; str.cat é outro método de união. Cada operação retorna um resultado, então salve-o na coluna que pretende usar.

Uma expressão regular, ou regex, descreve um padrão em texto. Ela pode reconhecer uma quantidade mesmo quando o número de dígitos ou o espaçamento varia. Comece com um padrão pequeno cujas partes você consiga explicar.

Interprete os elementos do padrão

Escreva padrões Python como strings brutas, por exemplo, r"\d+", para que o Python preserve suas barras invertidas. Um ponto corresponde, por padrão, a qualquer caractere exceto uma quebra de linha. Escape-o como r"\." para encontrar um ponto literal. Para uma pesquisa de texto simples, regex=False evita completamente a interpretação como padrão.

Escolha quanto do texto deve corresponder

contains encontra um padrão em qualquer posição, match começa pelo início e fullmatch exige que o valor inteiro corresponda. Para “123a”, s.str.contains(r"\d+") e s.str.match(r"\d+") encontram correspondências, mas s.str.fullmatch(r"\d+") falha. Use o teste da string inteira ao verificar um código completo. case=False ou flags=re.IGNORECASE após import re permite ignorar maiúsculas e minúsculas onde houver suporte.

Capture uma medição

Considere “Rice 5 kg”, “Flour 2kg”, “Salt” e “Beans 12 kg, 3 kg”. O padrão r"(\d+)\s*kg" significa um ou mais dígitos capturados como um grupo, seguidos de zero ou mais espaços e depois “kg”.

quantity = s.str.extract(r"(\d+)\s*kg", expand=False)
quantity = pd.to_numeric(quantity)

As strings extraídas são “5”, “2”, um valor ausente e “12”. A conversão fornece os valores numéricos 5,0, 2,0, NaN e 12,0. extract obtém a primeira correspondência em cada linha, então a segunda quantidade na descrição de feijão não é incluída. Sem expand=False, um único grupo retorna um DataFrame de uma coluna.

Grupos nomeados identificam a saída. s.str.extract(r"(?P<year>\d{4})-(?P<month>\d{2})") encontra “2024-03” dentro de “Report 2024-03 final” e retorna as colunas de texto year e month. O padrão reconhece a estrutura dos dígitos; a conversão numérica é uma etapa separada.

Encontre todas as correspondências ou limpe por padrão

findall(r"\d+") fornece uma lista por linha, incluindo ["12", "3"] para o texto do feijão e [] para “Salt”. count(r"\d+") conta as correspondências. extractall fornece uma linha por correspondência com um nível extra de índice chamado match.

Com regex=True, s.str.replace(r"\s+", " ", regex=True) reduz sequências de caracteres em branco a um espaço. r"\D" significa um caractere que não é dígito, então removê-lo transforma “+351 912-345-678” em “351912345678”. As formas maiúsculas \S e \W também negam as classes de caracteres em branco e de caracteres de palavra.

A repetição é gulosa por padrão. Em "<b>x</b>", r"<.*>" vai do primeiro símbolo de abertura até o último símbolo de fechamento. Remover essa correspondência remove tudo. O padrão não guloso r"<.*?>" corresponde a cada tag separadamente e deixa “x”. Verifique saídas de exemplo antes de usar um padrão em uma coluna inteira.

Uma coluna com poucos valores repetidos muitas vezes pode usar o tipo de dados category. Ele armazena os rótulos distintos uma vez e representa cada linha com um pequeno código inteiro. O valor visível continua sendo o rótulo.

Entenda categorias e códigos

Para os tamanhos M, S, L, M, M, s.astype("category") infere as categorias L, M, S em ordem alfabética. Os códigos são 1, 2, 0, 1, 1. Use s.cat.categories para inspecionar os rótulos e s.cat.codes para inspecionar os identificadores. Um código 0 significa a primeira categoria armazenada; não é uma quantidade medida.

Rótulos repetidos podem economizar bastante memória. Com até 126 categorias, os códigos usam um byte cada; com 127 categorias, usam dois bytes. Em uma configuração com pandas 3.1 e PyArrow, três nomes de países repetidos em 3.000.000 de linhas usaram cerca de 3 MB como dados categóricos, cerca de 42 MB como str e cerca de 165 MB como object. O mecanismo de armazenamento de texto afeta esses números. Uma coluna com quase todos os valores únicos não se beneficia do armazenamento de uma lista de categorias mais um código por linha.

Defina uma ordem significativa

A ordem alfabética dos tamanhos coloca L antes de M, que vem antes de S. Defina explicitamente a ordem real dos tamanhos:

size_type = pd.CategoricalDtype(["S", "M", "L"], ordered=True)
sizes = s.astype(size_type)

Agora a ordenação segue S, M, L, comparações como sizes > "S" fazem sentido, e sizes.max() é “L” quando L ocorre. Para rótulos não ordenados, como países, testes de igualdade funcionam, mas comparações de maior que geram um TypeError. as_ordered() usa a sequência de categorias existente; inspecione-a antes de declarar que essa sequência tem significado.

Altere os rótulos permitidos

Você não pode atribuir “XL” a dados categóricos que permitem apenas S, M e L. Primeiro atribua o resultado ampliado, sizes = sizes.cat.add_categories("XL"), depois atribua o novo valor.

Converter texto para uma lista fixa de categorias pode transformar valores não listados em valores ausentes. O pandas 3.1 avisa que essa conversão com perda de dados passará a ser um erro. Verifique os valores de origem com value_counts() antes da conversão, especialmente após limpar grafias.

Os métodos .cat têm finalidades diferentes:

• rename_categories({"S": "small"}) altera um rótulo mantendo seus membros.
• remove_categories("L") remove um rótulo permitido e torna ausentes os valores L existentes.
• set_categories([...]) substitui a lista inteira de categorias.
• reorder_categories([...], ordered=True) altera a ordem sem alterar quais rótulos são permitidos.
• remove_unused_categories() remove rótulos sem membros no momento.

value_counts() exibe todas as categorias permitidas, incluindo as que têm zero observações. Com um tipo S/M/L contendo apenas S e M, L ainda aparece com contagem 0. Isso revela um grupo vazio para o qual dados de texto comuns não têm um rótulo armazenado.

Mantenha as categorias úteis nas etapas seguintes

cut produz intervalos categóricos, e get_dummies converte a participação em categorias em colunas indicadoras. Fornecer códigos de países não ordenados a um modelo como números imporia uma ordem e distâncias artificiais. Indicadores evitam essa interpretação.

Concatenar colunas categóricas com listas de categorias diferentes normalmente faz com que o tipo categórico se perca. Alinhe primeiro suas listas de categorias ou use pd.concat(..., union_categories=True) no pandas 3.1 quando a intenção for combinar as listas. Inspecione tanto o tipo de dados resultante quanto a ordem das categorias.

Uma junção associa linhas por valores de chave e coloca suas informações lado a lado. A chave deve descrever a mesma coisa nas duas tabelas, como o identificador do cliente em um pedido e o identificador do cliente em uma tabela de consulta.

Indique a chave e escolha a junção

Use orders.merge(customers, on="customer_id"). Sem on, o pandas usa todos os nomes de colunas compartilhados pelas duas tabelas. Uma coluna compartilhada sem relação com a chave, como date, poderia impedir correspondências válidas de clientes.

Suponha que os pedidos tenham os identificadores de clientes 10, 20, 20, 30, 50. A tabela de clientes tem uma linha para cada um dos identificadores 10, 20, 30, 40.

A junção interna é o padrão. Em uma junção à esquerda, os dados do cliente 50 estão ausentes. Uma junção à direita inclui o cliente 40 sem pedido, além dos dois pedidos de 20. Uma junção externa completa inclui as duas chaves sem correspondência. Uma junção cruzada não precisa de chave porque combina intencionalmente todas as linhas. O pandas 3 também oferece left_anti e right_anti para linhas sem chave correspondente no outro lado.

Verifique quantas correspondências uma linha pode ter

Duas linhas à esquerda para a chave 20 e três linhas à direita para a chave 20 produzem seis pares. A junção não escolhe uma única linha à direita. No exemplo, adicionar uma segunda linha de consulta de cliente para 20 aumenta o resultado da junção interna de quatro para seis linhas.

Expresse a relação pretendida com validate:

merged = orders.merge(
    customers, on="customer_id", how="left",
    validate="many_to_one"
)

Isso permite muitos pedidos por cliente, mas exige identificadores de clientes únicos à direita. Uma chave repetida à direita gera MergeError. one_to_one exige unicidade nos dois lados; one_to_many a exige à esquerda. many_to_many permite repetições nos dois lados e não verifica a unicidade.

Investigue linhas sem correspondência

Uma junção externa completa com indicator=True adiciona _merge. Aqui, suas contagens são quatro both, uma left_only e uma right_only. São linhas, não chaves distintas: pedidos repetidos podem produzir várias linhas both para um cliente.

Para contar chaves distintas sem correspondência do lado dos pedidos, use m.loc[m["_merge"] == "left_only", "customer_id"].nunique(). Inspecionar as linhas pode revelar entradas ausentes na tabela de consulta ou texto inconsistente.

Controle nomes e formatos das chaves

Se as chaves tiverem nomes diferentes, use left_on="customer_id", right_on="id". Ambas as colunas de chave permanecem disponíveis. Várias chaves podem ser associadas em conjunto com on=["city", "year"]; ambas devem coincidir.

Nomes compartilhados por colunas que não são chaves recebem _x e _y. Escolha sufixos significativos como suffixes=("_order", "_ship") para deixar as origens claras.

As chaves precisam ter tipos de dados compatíveis e valores iguais. O valor numérico 1 pode corresponder ao valor numérico 1,0, mas colunas de chave inteiras e de texto podem gerar um erro de junção. Converta seus formatos de forma consciente. “ana” e “Ana ” são diferentes como texto; padronize maiúsculas, minúsculas e espaços nas extremidades antes da junção quando identificarem a mesma pessoa.

Chaves ausentes também precisam de inspeção: o pandas associa chaves ausentes de um lado a chaves ausentes do outro. Se ambos os lados tiverem várias dessas linhas, essas correspondências também podem se multiplicar.

Um índice pode conter a chave que você deseja associar. O pandas usa esses rótulos ao unir tabelas, preencher valores ausentes ou somar duas Series. A posição da linha, por si só, não determina as correspondências.

Faça junções por rótulos de índice

left.join(right) associa os dois índices e usa uma junção à esquerda por padrão. Já merge usa uma junção interna por padrão. Você também pode escrever left.merge(right, left_index=True, right_index=True) quando ambas as chaves estiverem no índice.

Suponha que stations tenha os rótulos de índice A, B, C e as altitudes 120, 850, 15 m. Uma tabela de leituras tem os rótulos de índice de estação A, B, B, D. readings.join(stations) mantém quatro linhas e adiciona as altitudes 120, 850, 850 e NaN. As duas leituras de B recebem a altitude de B. Com how="inner", apenas as três leituras de A e B permanecem.

Se as leituras mantiverem identificadores de estação em uma coluna comum, use readings.join(stations, on="station"). A coluna esquerda corresponde ao índice direito. A forma equivalente com merge é readings.merge(stations, left_on="station", right_index=True, how="left").

Deixe explícita a localização da chave

set_index("station") move a coluna de estação para o índice. reset_index() a restaura como uma coluna comum. Essas operações permitem escolher um formato que facilite a inspeção da correspondência. left.join([t1, t2]) pode unir de uma vez várias tabelas que compartilham rótulos de índice.

Se ambas as tabelas unidas contiverem uma coluna que não é chave, como source, join gerará um ValueError, a menos que você diferencie os nomes. No pandas 3.1, escreva suffixes=("_left", "_right"); isso substitui os argumentos antigos lsuffix e rsuffix. Os sufixos mantêm ambas as versões sem decidir qual valor é o correto.

Preencha lacunas com uma fonte de reserva

a.combine_first(b) mantém os valores conhecidos de a, preenche suas lacunas com valores de b nos rótulos correspondentes e inclui rótulos encontrados apenas em b.

O resultado mantém 1 e 3 porque a primeira fonte já os conhece. Ele usa 20 para preencher a lacuna e adiciona o rótulo d com 40. Inverter a chamada altera qual fonte tem prioridade. Isso é útil quando uma fonte principal de dados deve ter prioridade sobre uma fonte de reserva, mesmo quando suas linhas estão em ordens diferentes.

Reconheça o alinhamento na aritmética

Considere x com a = 5 e b = 7; e y com b = 1 e c = 2. x + y fornece b = 8, com resultados ausentes em a e c porque falta um operando em cada caso. Ele não soma o primeiro valor de x ao primeiro valor de y.

x.add(y, fill_value=0) fornece zero para o lado ausente, produzindo a = 5, b = 8, c = 2. Use essa regra quando uma contribuição ausente deve contar como zero. O alinhamento por rótulos é a mesma ideia que organiza essas operações, mas suas regras para os valores diferem: join adiciona colunas, combine_first preenche lacunas e a aritmética calcula com valores correspondentes.

Arquivos mensais normalmente contêm mais linhas do mesmo tipo de observação. A concatenação reúne essas partes em uma tabela. Ela alinha rótulos no outro eixo; não procura valores correspondentes de chaves de clientes ou pedidos.

Empilhe linhas e alinhe colunas

pd.concat([jan, feb]) empilha linhas porque o padrão é axis=0. Suponha que janeiro tenha três viagens com as colunas trip e km, enquanto fevereiro tem duas viagens com trip, km e note. O resultado tem cinco linhas e três colunas. As células ausentes de note em janeiro tornam-se NaN.

join="outer" é o padrão: ele mantém a união dos nomes de colunas. join="inner" mantém apenas nomes compartilhados, então o resultado tem cinco linhas e as duas colunas trip e km. Ele ainda inclui as cinco observações; a configuração de join controla o outro eixo.

A ordem das colunas nas partes não determina a correspondência. Os nomes exatos determinam. Se uma parte usa km e a outra usa Km, o resultado contém duas colunas parcialmente vazias. Renomeie os cabeçalhos antes de concatenar.

Decida o que os rótulos de linha devem significar

Os índices originais permanecem por padrão. Com os índices iniciais 0, 1, 2 e 0, 1, o resultado repete os rótulos 0 e 1. result.loc[0] seleciona duas linhas. Use ignore_index=True quando esses números não tiverem significado e você quiser novos rótulos de 0 a 4.

Quando a identidade da origem importar, use um nível externo de índice:

result = pd.concat(
    [jan, feb], keys=["jan", "feb"], names=["month", "row"]
)

Agora result.loc["feb"] seleciona as duas linhas de fevereiro. keys preserva a origem em um MultiIndex. No pandas 3, combinar keys com ignore_index=True gera ValueError; escolha rótulos de origem ou um novo índice simples para essa operação.

Coloque colunas lado a lado

pd.concat([x, y], axis=1) alinha linhas por rótulo de índice. Para x com a = 1, b = 2 e y com b = 3, c = 4, o resultado tem as linhas a, b, c. A coluna x está ausente em c, e y está ausente em a. Com join="inner", apenas b permanece.

Verifique o armazenamento e reúna as partes com eficiência

Uma coluna que mistura valores numéricos e texto pode se tornar do tipo object. Se dados comuns int64 do NumPy receberem uma lacuna, eles se tornam float64; o tipo "Int64" do pandas com suporte a valores ausentes pode manter inteiros com <NA>. Alinhe os tipos de dados antes de combinar quando a coluna tiver um tipo definido.

DataFrame.append foi removido no pandas 2.0. Para muitos arquivos, reúna DataFrames em uma lista e chame pd.concat uma vez após o laço. Reconstruir um resultado crescente em cada iteração copia repetidamente os dados acumulados e fica lento.

Verifique se o comprimento de uma concatenação de linhas é igual à soma dos comprimentos das entradas. Depois, inspecione nomes de colunas, contagens de valores ausentes e tipos de dados.

Um MultiIndex fornece vários rótulos a cada linha. Uma linha de vendas pode ser identificada tanto pela cidade quanto pelo ano, escritos como uma tupla, por exemplo, ("Osaka", 2024). Cada rótulo tem um nível, e a ordem desses níveis importa para a seleção.

Construa e nomeie o índice

df.set_index(["city", "year"]) move essas colunas para o índice. pd.MultiIndex.from_product([["Lima", "Osaka"], [2024, 2025]], names=["city", "year"]) constrói todas as combinações dos rótulos fornecidos. A concatenação com keys também adiciona um nível.

Para os exemplos, sales tem estes pares de índice e valores:

Após definir os dois níveis de índice, df.index.names é ["city", "year"]. rename_axis(["town", "yr"]) altera os nomes dos níveis sem alterar seus valores.

Selecione um rótulo externo ou uma tupla completa

df.loc["Osaka"] seleciona as duas linhas de Osaka. O nível da cidade selecionada é removido, deixando 2024 e 2025 como índice. df.loc[("Lima", 2025), "sales"] seleciona uma célula e retorna 95.

Um único rótulo passado a loc pesquisa o nível mais externo. Portanto, df.loc[2024] procura uma cidade chamada 2024 e gera KeyError nessa tabela. Para selecionar um ano entre cidades, use df.xs(2024, level="year"). Ele retorna 120 de Osaka e 80 de Lima, com cidade como índice restante.

Para uma seleção mais geral, df.loc[pd.IndexSlice[:, 2025], :] mantém todas as cidades no ano de 2025. Os dois-pontos na primeira posição significam todos os rótulos daquele nível; os dois-pontos finais selecionam todas as colunas.

Ordene antes de fatiar intervalos

A seleção por rótulo exato não exige que todo o índice esteja ordenado, mas fatiar um intervalo de rótulos exige ordenação apropriada. Use df.sort_index() antes de df.loc["Lima":"Osaka"]. Um MultiIndex não ordenado pode gerar UnsortedIndexError para essa fatia.

sort_index() ordena todos os níveis em sua ordem atual, de modo que as cidades vêm primeiro e os anos dentro de cada cidade. sort_index(level="year") ordena pelo nível indicado. swaplevel("city", "year") coloca o ano na posição externa; em seguida, use sort_index() para agrupar e ordenar a nova disposição. Trocar apenas as posições dos níveis não ordena as linhas.

Mova os rótulos de volta para as colunas

reset_index() restaura ambos os níveis como colunas. reset_index(level="year") restaura apenas o ano e mantém a cidade como índice. Essas operações permitem preparar uma tabela para junção ou gravação sem perder seus valores de identificação.

As colunas também podem ter vários níveis. Uma remodelagem com valores de vendas e pessoal pode produzir os rótulos de coluna ("sales", 2024) e ("staff", 2025). df["sales"] seleciona todas as colunas sob o rótulo de nível superior sales.

Para obter um total por cidade, df.groupby(level="city")["sales"].sum() fornece Lima 175 e Osaka 255. Use agrupamento para esse resumo; o antigo argumento sum(level="city") foi removido no pandas 2.0.

stack e unstack alteram onde os rótulos ficam. Os valores mantêm sua combinação de identificação, mas a tabela pode revelar combinações que não tinham observação.

Empilhe rótulos de colunas no índice

Suponha que um DataFrame largo tenha as cidades Osaka e Lima como índice e os anos 2024 e 2025 como colunas. Osaka tem os valores 120 e 135; Lima tem 80 e 95. Nomeie os eixos city e year para manter seu significado visível.

long = wide.stack() move os rótulos de ano para um novo nível mais interno do índice. Com essas colunas de um único nível, o resultado é uma Series contendo quatro valores:

• ("Osaka", 2024) fornece 120.
• ("Osaka", 2025) fornece 135.
• ("Lima", 2024) fornece 80.
• ("Lima", 2025) fornece 95.

Os rótulos de cidade se repetem porque cada cidade agora tem uma linha por ano. O empilhamento não somou os valores nem criou medições adicionais.

Desempilhe um nível do índice em colunas

long.unstack() move o nível mais interno do índice, ano, para as colunas e recupera a disposição larga. long.unstack("city") move cidade, produzindo anos como linhas e cidades como colunas. Uma posição numérica de nível, como unstack(0), pode selecionar o mesmo nível, mas um nome torna a intenção mais fácil de ler.

Se a entrada tiver colunas hierárquicas, empilhar um nível pode deixar outro nível como colunas. Para colunas como ("sales", 2024) e ("staff", 2024), stack("year") retorna um DataFrame com colunas de vendas e pessoal. Empilhar todos os níveis de coluna retorna uma Series.

Mantenha combinações ausentes visíveis

Agora suponha que a Series longa não tenha uma entrada para Lima em 2025. O desempilhamento cria uma tabela retangular de cidades por anos, portanto introduz NaN nessa posição. Valores inteiros comuns tornam-se números de ponto flutuante quando essa célula ausente exige um marcador de ausência desse tipo.

unstack(fill_value=0) pode preencher com zero uma combinação recém-ausente. Use-o apenas se ausência significar zero, como nenhuma venda registrada em um conjunto completo de eventos de vendas. Uma observação ausente de sensor é desconhecida e deve permanecer ausente.

stack() do pandas 3 mantém células ausentes. Empilhar a tabela incompleta de 2 por 2 retorna, portanto, quatro entradas, incluindo NaN. Acrescente .dropna() se quiser apenas os três valores conhecidos. Remover lacunas altera quais combinações permanecem representadas, então verifique o comprimento do resultado.

Resolva combinações duplicadas primeiro

O desempilhamento precisa de um único valor para cada combinação completa de índices. Duas entradas com o rótulo ("Lima", 2025) disputam a mesma célula de saída e geram ValueError: Index contains duplicate entries, cannot reshape.

Use long.index.duplicated() para inspecionar rótulos completos repetidos ou verifique as colunas de chave correspondentes antes de definir o índice. Decida se as linhas são cópias acidentais ou observações separadas que devem ser combinadas. Removê-las ou agregá-las é uma decisão sobre os dados; unstack não escolhe uma regra para você.

No formato longo, colunas de identificação acompanham uma coluna de valor. No formato largo, as medições são distribuídas em colunas, como uma coluna por ano. Escolha o formato que facilite a próxima tarefa: tabelas longas são adequadas para filtragem e agrupamento, enquanto tabelas largas permitem comparações lado a lado.

Transforme pares únicos em células com pivot

Uma tabela longa com as colunas city, year e sales torna-se larga com df.pivot(index="city", columns="year", values="sales"). Rótulos de cidade formam linhas, anos formam colunas e vendas preenchem as células. Isso equivale a df.set_index(["city", "year"])["sales"].unstack().

As vendas de Osaka em 2024 e 2025, de 120 e 135, tornam-se duas células em uma linha. Os valores 80 e 95 de Lima formam a segunda linha. Trocar os argumentos index e columns transpõe essa disposição. Omitir values remodela todas as colunas de dados restantes e pode criar colunas hierárquicas, como um nível de vendas e um de pessoal acima dos anos.

Decida se repetições são erros ou observações

pivot reorganiza valores e não pode combiná-los. Duas linhas de Lima em 2025 exigiriam dois valores em uma célula de saída, portanto geram ValueError. Conte pares repetidos com df.duplicated(subset=["city", "year"]).sum().

Se observações separadas devem ser combinadas, use pivot_table com uma agregação escolhida. Para os valores 95 e 105 em Lima em 2025, sua média padrão fornece 100,0. Com aggfunc="sum", a célula é 200. Se cada par deveria ter aparecido uma vez, mantenha pivot para que ele revele um erro nos dados em vez de resumi-lo sem aviso.

Transforme colunas de medição em linhas com melt

Suponha que um CSV forneça as colunas city, 2023, 2024 e 2025. Os valores de Osaka são 110, 120, 135; os de Lima são 70, 80, 95. Transforme as colunas de ano:

long = wide.melt(
    id_vars="city", var_name="year", value_name="sales"
)

id_vars permanece e se repete. Cada rótulo de coluna de medição torna-se um valor de ano; cada célula torna-se um valor de vendas. Duas linhas e três colunas de medição produzem seis linhas longas, incluindo uma como Osaka, “2023”, 110. Células de medição ausentes também se tornam linhas, a menos que você as remova depois.

Como esses rótulos de coluna vieram de texto CSV, os anos resultantes são texto. Use long["year"] = long["year"].astype(int) antes de fazer operações aritméticas com eles. Rótulos de coluna inteiros na entrada já forneceriam valores inteiros de ano.

Controle o que é transformado e restaure a forma

value_vars=["2024", "2025"] limita a transformação a essas colunas. Esquecer id_vars pode colocar nomes de cidades na mesma coluna de valores que as medições. Sempre distinga identificadores das colunas que contêm valores.

Sem nomes explícitos, a coluna de valores chama-se value. A coluna de variáveis herda wide.columns.name ou se chama variable se esse nome estiver vazio. var_name e value_name explícitos tornam o resultado mais fácil de usar.

Aplique pivot às seis linhas com index="city", columns="year", values="sales" para restaurar as três colunas de ano. Após a operação, cidade é o índice e o eixo das colunas chama-se year. reset_index() restaura cidade como coluna, e rename_axis(columns=None) remove o nome do eixo das colunas. Verifique tanto a forma quanto os rótulos antes de unir ou salvar a tabela.