Skip to content

Pandas Sort Values: Guia completo para ordenar DataFrames em Python

Soren Atelier
Name
Soren Atelier

Updated on

Dados não ordenados são difíceis de analisar. Você percorre milhares de linhas tentando encontrar as maiores vendas, as datas mais recentes ou as menores taxas de erro -- e perde padrões que seriam óbvios se os dados estivessem ordenados. Ordenar uma lista Python funciona para casos simples, mas DataFrames têm múltiplas colunas, tipos mistos e valores ausentes que listas não conseguem lidar.

Pandas sort_values() ordena qualquer DataFrame por uma ou mais colunas, com controle total sobre ordem crescente/decrescente, posicionamento de nulos e estabilidade. Este guia cobre todos os padrões de ordenação que você encontrará no trabalho real com dados.

📚

    Ordenação básica com sort_values()

    Ordenar por uma única coluna

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
    'score': [85, 92, 78, 95, 88],
    'age': [25, 30, 22, 28, 35]
})
 
# Ordenar por score (crescente por padrão)
sorted_df = df.sort_values('score')
print(sorted_df)
#       name  score  age
# 2  Charlie     78   22
# 0    Alice     85   25
# 4      Eve     88   35
# 1      Bob     92   30
# 3    Diana     95   28

    Ordenar de forma decrescente

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
    'score': [85, 92, 78, 95, 88],
    'age': [25, 30, 22, 28, 35]
})
 
# Maiores pontuações primeiro
sorted_df = df.sort_values('score', ascending=False)
print(sorted_df)
#       name  score  age
# 3    Diana     95   28
# 1      Bob     92   30
# 4      Eve     88   35
# 0    Alice     85   25
# 2  Charlie     78   22

    Ordenar no local

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'score': [85, 92, 78]
})
 
# Modificar df diretamente (nenhuma cópia criada)
df.sort_values('score', inplace=True)
print(df)
#       name  score
# 2  Charlie     78
# 0    Alice     85
# 1      Bob     92

    Ordenação por múltiplas colunas

    Ordenar por várias colunas

    import pandas as pd
 
df = pd.DataFrame({
    'department': ['Sales', 'Engineering', 'Sales', 'Engineering', 'Sales'],
    'name': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
    'salary': [70000, 85000, 65000, 90000, 70000]
})
 
# Ordenar primeiro por departamento, depois por salário dentro de cada departamento
sorted_df = df.sort_values(['department', 'salary'])
print(sorted_df)
#     department     name  salary
# 1  Engineering      Bob   85000
# 3  Engineering    Diana   90000
# 2        Sales  Charlie   65000
# 0        Sales    Alice   70000
# 4        Sales      Eve   70000

    Misto crescente/decrescente

    import pandas as pd
 
df = pd.DataFrame({
    'department': ['Sales', 'Engineering', 'Sales', 'Engineering', 'Sales'],
    'name': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
    'salary': [70000, 85000, 65000, 90000, 70000]
})
 
# Departamento crescente, salário decrescente
sorted_df = df.sort_values(
    ['department', 'salary'],
    ascending=[True, False]
)
print(sorted_df)
#     department     name  salary
# 3  Engineering    Diana   90000
# 1  Engineering      Bob   85000
# 0        Sales    Alice   70000
# 4        Sales      Eve   70000
# 2        Sales  Charlie   65000

    Tratamento de valores ausentes (NaN)

    Por padrão, os valores NaN vão para o final independentemente da ordem de classificação. Use na_position para controlar:

    import pandas as pd
import numpy as np
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'Diana'],
    'score': [85, np.nan, 78, np.nan]
})
 
# NaN no final (padrão)
print(df.sort_values('score'))
#       name  score
# 2  Charlie   78.0
# 0    Alice   85.0
# 1      Bob    NaN
# 3    Diana    NaN
 
# NaN no início
print(df.sort_values('score', na_position='first'))
#       name  score
# 1      Bob    NaN
# 3    Diana    NaN
# 2  Charlie   78.0
# 0    Alice   85.0

    Ordenar por índice com sort_index()

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'score': [85, 92, 78]
}, index=[2, 0, 1])
 
# Ordenar por índice
print(df.sort_index())
#      name  score
# 0     Bob     92
# 1  Charlie    78
# 2   Alice     85
 
# Ordenar por nomes de colunas (axis=1)
df2 = pd.DataFrame({
    'c': [1, 2], 'a': [3, 4], 'b': [5, 6]
})
print(df2.sort_index(axis=1))
#    a  b  c
# 0  3  5  1
# 1  4  6  2

    Redefinir índice após ordenação

    Após a ordenação, o índice original é preservado. Para obter um índice sequencial limpo:

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'score': [85, 92, 78]
})
 
sorted_df = df.sort_values('score').reset_index(drop=True)
print(sorted_df)
#       name  score
# 0  Charlie     78
# 1    Alice     85
# 2      Bob     92

    Use drop=True para descartar o índice antigo. Sem ele, o índice antigo se torna uma coluna.

    Ordem de classificação personalizada

    Usando tipos categóricos

    import pandas as pd
 
df = pd.DataFrame({
    'priority': ['Medium', 'High', 'Low', 'High', 'Medium'],
    'task': ['Task A', 'Task B', 'Task C', 'Task D', 'Task E']
})
 
# Definir ordem personalizada
priority_order = pd.CategoricalDtype(['Low', 'Medium', 'High'], ordered=True)
df['priority'] = df['priority'].astype(priority_order)
 
sorted_df = df.sort_values('priority')
print(sorted_df)
#   priority    task
# 2      Low  Task C
# 0   Medium  Task A
# 4   Medium  Task E
# 1     High  Task B
# 3     High  Task D

    Usando o parâmetro key

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['alice', 'Bob', 'CHARLIE', 'diana'],
    'score': [85, 92, 78, 95]
})
 
# Ordenação sem distinção entre maiúsculas e minúsculas
sorted_df = df.sort_values('name', key=lambda x: x.str.lower())
print(sorted_df)
#       name  score
# 0    alice     85
# 1      Bob     92
# 2  CHARLIE     78
# 3    diana     95

    Comparação de métodos

    MétodoFinalidadeModifica o original?Retorna
    sort_values(col)Ordenar por valores da colunaNão (exceto inplace=True)DataFrame ordenado
    sort_values([col1, col2])Ordenar por múltiplas colunasNão (exceto inplace=True)DataFrame ordenado
    sort_index()Ordenar por índice de linhaNão (exceto inplace=True)DataFrame ordenado
    nsmallest(n, col)Obter n menores valoresNãoSubconjunto de DataFrame
    nlargest(n, col)Obter n maiores valoresNãoSubconjunto de DataFrame
    rank()Atribuir classificações aos valoresNãoSeries de classificações

    Dicas de desempenho

    nlargest() e nsmallest() para Top-N

    Quando você precisa apenas das primeiras ou últimas N linhas, nlargest() e nsmallest() são mais rápidos que ordenar todo o DataFrame:

    import pandas as pd
import numpy as np
 
# DataFrame grande
df = pd.DataFrame({
    'id': range(1_000_000),
    'value': np.random.randn(1_000_000)
})
 
# Mais rápido: encontrar apenas o top 10
top_10 = df.nlargest(10, 'value')
 
# Mais lento: ordena tudo, depois fatia
top_10_slow = df.sort_values('value', ascending=False).head(10)

    Ordenação estável vs instável

    import pandas as pd
 
df = pd.DataFrame({
    'group': ['A', 'B', 'A', 'B'],
    'value': [1, 1, 2, 2],
    'order': [1, 2, 3, 4]
})
 
# Ordenação estável (padrão) preserva a ordem original para empates
stable = df.sort_values('value', kind='mergesort')  # Padrão
 
# Ordenação instável (mais rápida para grandes conjuntos de dados)
unstable = df.sort_values('value', kind='quicksort')

    Exemplos práticos

    Ordenar datas

    import pandas as pd
 
df = pd.DataFrame({
    'event': ['Launch', 'Meeting', 'Deadline', 'Review'],
    'date': pd.to_datetime(['2026-03-15', '2026-01-10', '2026-02-28', '2026-01-05'])
})
 
# Ordem cronológica
print(df.sort_values('date'))
#      event       date
# 3   Review 2026-01-05
# 1  Meeting 2026-01-10
# 2 Deadline 2026-02-28
# 0   Launch 2026-03-15

    Ordenar com GroupBy

    import pandas as pd
 
df = pd.DataFrame({
    'store': ['A', 'A', 'B', 'B', 'A', 'B'],
    'product': ['X', 'Y', 'X', 'Y', 'Z', 'Z'],
    'revenue': [100, 250, 150, 300, 200, 175]
})
 
# Produto com maior receita por loja
top_per_store = (df.sort_values('revenue', ascending=False)
                   .groupby('store')
                   .head(1))
print(top_per_store)
#   store product  revenue
# 3     B       Y      300
# 1     A       Y      250

    Exploração visual de dados ordenados

    Depois de ordenar seu DataFrame para encontrar padrões, PyGWalker (opens in a new tab) permite explorar os mesmos dados através de gráficos interativos de arrastar e soltar no Jupyter -- sem código adicional:

    import pygwalker as pyg
 
walker = pyg.walk(sorted_df)

    Perguntas frequentes

    Como ordeno um DataFrame por coluna no pandas?

    Use df.sort_values('column_name') para ordem crescente ou df.sort_values('column_name', ascending=False) para decrescente. Para múltiplas colunas, passe uma lista: df.sort_values(['col1', 'col2']).

    Como ordeno por múltiplas colunas com ordens diferentes?

    Passe uma lista de booleanos para ascending: df.sort_values(['col1', 'col2'], ascending=[True, False]). Isso ordena col1 crescente e col2 decrescente.

    Para onde vão os valores NaN ao ordenar?

    Por padrão, os valores NaN são colocados no final independentemente da direção da ordenação. Use na_position='first' para colocá-los no início: df.sort_values('col', na_position='first').

    Qual é a diferença entre sort_values e sort_index?

    sort_values() ordena por valores da coluna. sort_index() ordena pelo índice da linha (ou índice da coluna com axis=1). Use sort_values para ordenar dados e sort_index quando precisar de linhas ordenadas pelos rótulos do índice.

    Como ordeno um DataFrame no local sem criar uma cópia?

    Passe inplace=True: df.sort_values('col', inplace=True). Isso modifica o DataFrame original e retorna None. Porém, o estilo moderno do pandas prefere a reatribuição: df = df.sort_values('col').

    Conclusão

    sort_values() é a ferramenta principal para ordenar DataFrames no pandas. Use um nome de coluna único para ordenações simples, uma lista para ordenações multicoluna e o parâmetro ascending para controlar a direção. Trate valores ausentes com na_position, use nlargest()/nsmallest() para consultas Top-N e CategoricalDtype para ordenações personalizadas. Lembre-se de que a ordenação retorna um novo DataFrame por padrão -- use reset_index(drop=True) se quiser um índice sequencial limpo depois.

    📚