Ordenar Listas

Ordenar uma lista é uma das operações mais comuns em Python. Python oferece duas ferramentas integradas para isso: a função sorted(), que retorna uma nova lista ordenada sem alterar a original, e o método list.sort(), que reordena a lista no próprio lugar. Ambas aceitam um sinalizador reverse para ordem decrescente e um parâmetro key para lógica de ordenação personalizada.

Este capítulo aborda:

• sorted() — ordena qualquer iterável em uma nova lista
• list.sort() — ordena uma lista no próprio lugar
• Ordenação em ordem crescente e decrescente
• O parâmetro key — ordena por comprimento, campo ou qualquer critério personalizado
• Ordenação sem distinção entre maiúsculas e minúsculas
• Ordenação de listas de dicionários e objetos personalizados
• Ordenação por múltiplas chaves
• operator.itemgetter como alternativa eficiente ao lambda

Para uma revisão dos fundamentos de listas, consulte os capítulos Python Lists e List Methods.

A Função sorted()

sorted() recebe qualquer iterável (lista, tupla, string, …) e retorna uma nova lista ordenada. O iterável original permanece inalterado.

Sintaxe:

sorted(iterable, *, key=None, reverse=False)

• iterable — a sequência a ser ordenada
• key — uma função opcional de um argumento aplicada a cada elemento antes da comparação (padrão: compara os elementos diretamente)
• reverse — defina como True para ordenar em ordem decrescente (padrão: False)

Ordenar uma lista de strings

Ordenar uma lista de números

Listas numéricas são ordenadas por magnitude, não por representação como string (portanto, 10 não vem antes de 9).

nums = [3, 1, 4, 1, 5, 9, 2, 6]
print(sorted(nums))
# [1, 1, 2, 3, 4, 5, 6, 9]

Ordenar em ordem decrescente com reverse=True

Passe reverse=True para obter os maiores valores primeiro.

nums = [3, 1, 4, 1, 5, 9, 2, 6]
print(sorted(nums, reverse=True))
# [9, 6, 5, 4, 3, 2, 1, 1]

O Método list.sort()

list.sort() reordena a lista no próprio lugar e sempre retorna None. Use-o quando você não precisa mais da ordem original e deseja evitar o consumo de memória de uma segunda lista.

Sintaxe:

list.sort(*, key=None, reverse=False)

Os parâmetros são idênticos aos de sorted().

Ordenar uma lista no próprio lugar

Ordenar em ordem decrescente

sort() retorna None — um erro comum

Um erro frequente é atribuir o resultado de sort() a uma variável:

fruits = ['banana', 'apple', 'cherry']
result = fruits.sort()   # sort() modifies fruits, returns None
print(result)            # None  ← not the sorted list!
print(fruits)            # ['apple', 'banana', 'cherry']  ← fruits was modified

Se você precisar tanto do resultado ordenado quanto da ordem original, use sorted().

sorted() vs list.sort() — Quando Usar Cada Um

Use sorted() quando precisar que o original permaneça inalterado ou ao ordenar uma tupla ou outro iterável.

Use list.sort() quando tiver uma lista, quiser ordená-la no próprio lugar e a eficiência de memória for importante.

Ordenação com o Parâmetro key

O parâmetro key aceita um callable de um argumento. Python o chama uma vez para cada elemento e usa o valor retornado para as comparações. Isso evita duplicação de dados e torna a ordenação flexível.

Ordenar por comprimento da string

words = ['banana', 'apple', 'cherry', 'kiwi']
print(sorted(words, key=len))
# ['kiwi', 'apple', 'banana', 'cherry']

len é passado diretamente — nenhum lambda é necessário ao usar uma função integrada que recebe um argumento.

Ordenar uma lista de tuplas por um campo específico

O lambda lambda x: x[1] extrai o segundo elemento (o número) de cada tupla, fazendo com que Python compare números em vez de tuplas inteiras.

Ordenar uma lista de dicionários

students = [
    {'name': 'Charlie', 'grade': 85},
    {'name': 'Alice',   'grade': 92},
    {'name': 'Bob',     'grade': 78},
]

by_grade = sorted(students, key=lambda s: s['grade'])
for s in by_grade:
    print(s['name'], s['grade'])
# Bob 78
# Charlie 85
# Alice 92

Para ordenar em ordem decrescente (nota mais alta primeiro), adicione reverse=True:

by_grade_desc = sorted(students, key=lambda s: s['grade'], reverse=True)
for s in by_grade_desc:
    print(s['name'], s['grade'])
# Alice 92
# Charlie 85
# Bob 78

Ordenação sem distinção entre maiúsculas e minúsculas

Por padrão, a ordenação em Python é sensível a maiúsculas e minúsculas: todas as letras maiúsculas vêm antes das minúsculas porque possuem pontos de código Unicode menores. Use key=str.lower para ordenar sem considerar o caso.

words = ['Banana', 'apple', 'Cherry', 'date']
print(sorted(words))             # case-sensitive (uppercase first)
# ['Banana', 'Cherry', 'apple', 'date']

print(sorted(words, key=str.lower))  # case-insensitive
# ['apple', 'Banana', 'Cherry', 'date']

Usando operator.itemgetter e operator.attrgetter

O módulo operator fornece alternativas mais rápidas ao lambda para padrões de chave comuns.

operator.itemgetter — para sequências e dicionários

import operator

fruits = [('apple', 10), ('banana', 5), ('cherry', 20)]
print(sorted(fruits, key=operator.itemgetter(1)))
# [('banana', 5), ('apple', 10), ('cherry', 20)]

operator.itemgetter(1) é equivalente a lambda x: x[1], mas é implementado em C e executa mais rapidamente em listas grandes.

operator.attrgetter — para objetos

import operator

class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade
    def __repr__(self):
        return f'Student({self.name!r}, {self.grade})'

students = [Student('Charlie', 85), Student('Alice', 92), Student('Bob', 78)]
print(sorted(students, key=operator.attrgetter('grade')))
# [Student('Bob', 78), Student('Charlie', 85), Student('Alice', 92)]

Ordenação por Múltiplas Chaves

Retorne uma tupla da função key para ordenar por múltiplos critérios. Python compara tuplas elemento a elemento, portanto empates na primeira chave passam para a segunda.

# Sort by grade ascending, then by name alphabetically when grades tie
data = [('Alice', 85), ('Bob', 92), ('Charlie', 85), ('Dave', 78)]
result = sorted(data, key=lambda x: (x[1], x[0]))
print(result)
# [('Dave', 78), ('Alice', 85), ('Charlie', 85), ('Bob', 92)]

Alice e Charlie têm nota 85, portanto são ordenados alfabeticamente — Alice antes de Charlie.

Estabilidade da Ordenação

A ordenação em Python é estável: elementos que se comparam como iguais mantêm sua ordem relativa original. Isso significa que você pode ordenar uma lista por uma chave, depois ordenar o resultado por outra chave, e a ordem da primeira ordenação é preservada dentro de empates da segunda chave.

# Sort by grade, then (stably) by name — same result as the tuple key above
data = [('Alice', 85), ('Bob', 92), ('Charlie', 85), ('Dave', 78)]
step1 = sorted(data, key=lambda x: x[0])   # sort by name first
step2 = sorted(step1, key=lambda x: x[1])  # then sort by grade
print(step2)
# [('Dave', 78), ('Alice', 85), ('Charlie', 85), ('Bob', 92)]

Essa técnica — chamada de transformação de Schwartzian — às vezes é mais legível do que uma chave composta.

Conclusão

As funções sorted() e list.sort() do Python oferecem ordenação de listas rápida e flexível com código mínimo. Use sorted() quando precisar de uma nova lista ou estiver ordenando um iterável que não seja uma lista; use list.sort() quando quiser modificar uma lista no próprio lugar. O parâmetro key lida com quase qualquer critério de ordenação — desde ordenar por comprimento ou um campo de dicionário até comparações sem distinção entre maiúsculas e minúsculas. Para grandes conjuntos de dados, prefira operator.itemgetter ou operator.attrgetter em vez de lambda para melhor desempenho.

Leitura relacionada:

• Python Lists — criação, indexação e fatiamento de listas
• List Methods — referência completa dos métodos de lista
• List Comprehension — construção concisa de listas
• Loop Lists — iteração sobre listas

Prática