Skip to content

Ordenación en Python: guía completa de sorted(), list.sort() y ordenación personalizada

Soren Atelier
Name
Soren Atelier

Updated on

Ordenar datos es una de las operaciones más fundamentales en programación, pero elegir entre la función sorted() de Python y el método list.sort() suele confundir a los desarrolladores. Ya sea que estés clasificando puntuaciones de estudiantes, organizando precios de productos o procesando listados de archivos, entender los mecanismos de ordenación de Python ahorra tiempo y evita bugs. Esta guía explora cada aspecto de la ordenación en Python, desde listas básicas de números hasta comparaciones personalizadas complejas, con ejemplos prácticos que puedes implementar de inmediato.

📚

    sorted() vs list.sort(): la diferencia crítica

    Python ofrece dos mecanismos principales de ordenación que parecen similares, pero se comportan de forma fundamentalmente distinta. La función sorted() crea y devuelve una nueva lista ordenada, dejando la original sin cambios. El método list.sort() modifica la lista in-place y devuelve None.

    # sorted() returns a new list
numbers = [3, 1, 4, 1, 5]
sorted_nums = sorted(numbers)
print(sorted_nums)  # [1, 1, 3, 4, 5]
print(numbers)      # [3, 1, 4, 1, 5] - original unchanged
 
# list.sort() modifies in place
numbers = [3, 1, 4, 1, 5]
result = numbers.sort()
print(numbers)      # [1, 1, 3, 4, 5] - original modified
print(result)       # None

    Esta distinción importa por eficiencia de memoria y preservación de datos. Usa sorted() cuando necesitas conservar la lista original o cuando ordenas secuencias inmutables como tuplas. Usa list.sort() cuando trabajas con listas grandes donde crear una copia consumiría demasiada memoria.

    # sorted() works with any iterable
tuple_data = (42, 17, 93, 8)
sorted_list = sorted(tuple_data)  # Returns [8, 17, 42, 93]
 
# list.sort() only works on lists
# tuple_data.sort()  # AttributeError: 'tuple' object has no attribute 'sort'

    Ordenación básica: números, strings y tipos mixtos

    El comportamiento de ordenación por defecto de Python usa el orden natural. Los números se ordenan numéricamente, los strings alfabéticamente, y las listas con tipos mixtos requieren un manejo explícito.

    # Numeric sorting
integers = [42, -7, 0, 93, 15]
print(sorted(integers))  # [-7, 0, 15, 42, 93]
 
floats = [3.14, 2.71, 1.41, 9.81]
print(sorted(floats))    # [1.41, 2.71, 3.14, 9.81]
 
# String sorting (lexicographic order)
words = ['zebra', 'apple', 'mango', 'banana']
print(sorted(words))     # ['apple', 'banana', 'mango', 'zebra']
 
# Mixed types cause errors in Python 3
mixed = [3, 'apple', 1.5]
# sorted(mixed)  # TypeError: '<' not supported between instances

    Para strings numéricos que deberían ordenarse numéricamente en lugar de alfabéticamente, conviértelos durante la ordenación:

    # String numbers sort alphabetically
string_nums = ['10', '2', '100', '21']
print(sorted(string_nums))  # ['10', '100', '2', '21']
 
# Convert to int for numeric sorting
print(sorted(string_nums, key=int))  # ['2', '10', '21', '100']

    Orden inverso con reverse=True

    Tanto sorted() como list.sort() aceptan un parámetro reverse que invierte el orden de ordenación. Este parámetro es False por defecto para orden ascendente.

    scores = [88, 92, 75, 95, 82]
 
# Descending order using reverse=True
print(sorted(scores, reverse=True))  # [95, 92, 88, 82, 75]
 
# In-place descending sort
scores.sort(reverse=True)
print(scores)  # [95, 92, 88, 82, 75]
 
# Reverse alphabetical order
names = ['Alice', 'David', 'Bob', 'Charlie']
print(sorted(names, reverse=True))  # ['David', 'Charlie', 'Bob', 'Alice']

    El parámetro key: lógica de ordenación personalizada

    El parámetro key acepta una función que transforma cada elemento antes de compararlo. Esto permite ordenar por atributos específicos, valores calculados o criterios complejos sin modificar los datos originales.

    # Sort by string length
words = ['python', 'is', 'awesome', 'for', 'data']
print(sorted(words, key=len))  # ['is', 'for', 'data', 'python', 'awesome']
 
# Sort by absolute value
numbers = [-5, -2, 3, -8, 1]
print(sorted(numbers, key=abs))  # [1, -2, 3, -5, -8]
 
# Sort case-insensitive
names = ['alice', 'Bob', 'CHARLIE', 'david']
print(sorted(names, key=str.lower))  # ['alice', 'Bob', 'CHARLIE', 'david']

    Funciones lambda para ordenación inline

    Las funciones lambda ofrecen una sintaxis concisa para funciones key simples. Son ideales para transformaciones de un solo uso donde definir una función aparte sería verboso.

    # Sort tuples by second element
pairs = [(1, 'b'), (3, 'a'), (2, 'd'), (4, 'c')]
print(sorted(pairs, key=lambda x: x[1]))
# [(3, 'a'), (1, 'b'), (4, 'c'), (2, 'd')]
 
# Sort strings by last character
words = ['python', 'java', 'ruby', 'go']
print(sorted(words, key=lambda s: s[-1]))
# ['java', 'go', 'ruby', 'python']
 
# Sort by distance from target value
target = 50
values = [45, 62, 38, 55, 48]
print(sorted(values, key=lambda x: abs(x - target)))
# [48, 45, 55, 38, 62]

    Ordenar por múltiples criterios

    Cuando la ordenación requiere múltiples prioridades, devuelve una tupla desde la función key. Python compara tuplas elemento por elemento, proporcionando una ordenación multinivel natural.

    # Sort students by grade (descending), then name (ascending)
students = [
    ('Alice', 85),
    ('Bob', 92),
    ('Charlie', 85),
    ('David', 92)
]
 
sorted_students = sorted(students, key=lambda x: (-x[1], x[0]))
print(sorted_students)
# [('Bob', 92), ('David', 92), ('Alice', 85), ('Charlie', 85)]
 
# Sort dates by year (descending), then month (ascending)
dates = ['2024-03', '2023-12', '2024-01', '2023-08']
print(sorted(dates, key=lambda d: (-int(d[:4]), int(d[5:]))))
# ['2024-01', '2024-03', '2023-08', '2023-12']

    operator.itemgetter y operator.attrgetter

    El módulo operator ofrece alternativas optimizadas a las funciones lambda para patrones comunes de ordenación. Estas funciones se ejecutan más rápido que las lambdas y mejoran la legibilidad del código.

    from operator import itemgetter, attrgetter
 
# Sort by specific dictionary keys
data = [
    {'name': 'Alice', 'age': 30, 'score': 85},
    {'name': 'Bob', 'age': 25, 'score': 92},
    {'name': 'Charlie', 'age': 30, 'score': 78}
]
 
# Sort by age, then score
sorted_data = sorted(data, key=itemgetter('age', 'score'))
print([d['name'] for d in sorted_data])  # ['Bob', 'Charlie', 'Alice']
 
# Sort by tuple elements
records = [(1, 'b', 300), (2, 'a', 100), (1, 'a', 200)]
print(sorted(records, key=itemgetter(0, 1)))
# [(1, 'a', 200), (1, 'b', 300), (2, 'a', 100)]

    Para atributos de objetos, usa attrgetter:

    from operator import attrgetter
 
class Employee:
    def __init__(self, name, salary, department):
        self.name = name
        self.salary = salary
        self.department = department
 
    def __repr__(self):
        return f'{self.name}({self.department}, ${self.salary})'
 
employees = [
    Employee('Alice', 75000, 'Engineering'),
    Employee('Bob', 65000, 'Marketing'),
    Employee('Charlie', 75000, 'Engineering')
]
 
# Sort by department, then salary (descending)
sorted_emps = sorted(employees, key=attrgetter('department'))
print(sorted_emps)

    Ordenar diccionarios

    Los diccionarios en sí son desordenados (aunque Python 3.7+ preserva el orden de inserción), pero puedes ordenar sus claves, valores o items.

    # Sort dictionary by keys
data = {'zebra': 3, 'apple': 1, 'mango': 2}
sorted_keys = sorted(data.keys())
print(sorted_keys)  # ['apple', 'mango', 'zebra']
 
# Create new dict with sorted keys
sorted_dict = {k: data[k] for k in sorted_keys}
print(sorted_dict)  # {'apple': 1, 'mango': 2, 'zebra': 3}
 
# Sort by values
sorted_by_value = sorted(data.items(), key=lambda x: x[1])
print(sorted_by_value)  # [('apple', 1), ('mango', 2), ('zebra', 3)]
 
# Convert back to dictionary
sorted_dict = dict(sorted_by_value)

    Para tipos de valor complejos:

    # Sort dictionary by nested values
products = {
    'laptop': {'price': 999, 'stock': 5},
    'phone': {'price': 599, 'stock': 12},
    'tablet': {'price': 399, 'stock': 8}
}
 
# Sort by price
by_price = sorted(products.items(), key=lambda x: x[1]['price'])
print([(name, info['price']) for name, info in by_price])
# [('tablet', 399), ('phone', 599), ('laptop', 999)]
 
# Sort by stock (descending)
by_stock = sorted(products.items(), key=lambda x: -x[1]['stock'])
print([(name, info['stock']) for name, info in by_stock])
# [('phone', 12), ('tablet', 8), ('laptop', 5)]

    Ordenar listas de tuplas

    Las tuplas se ordenan de forma natural comparando elementos de izquierda a derecha. Personaliza este comportamiento con funciones key.

    # Default tuple sorting (compares element by element)
tuples = [(1, 'z'), (2, 'a'), (1, 'a'), (2, 'z')]
print(sorted(tuples))
# [(1, 'a'), (1, 'z'), (2, 'a'), (2, 'z')]
 
# Sort by second element only
print(sorted(tuples, key=lambda x: x[1]))
# [(2, 'a'), (1, 'a'), (1, 'z'), (2, 'z')]
 
# Sort by sum of numeric elements
coord_distances = [(1, 2), (3, 1), (2, 2), (1, 3)]
print(sorted(coord_distances, key=sum))
# [(1, 2), (2, 2), (1, 3), (3, 1)]

    Ordenar listas de diccionarios

    Ordenar diccionarios dentro de listas requiere especificar qué clave se usará para la comparación.

    people = [
    {'name': 'Alice', 'age': 30, 'city': 'New York'},
    {'name': 'Bob', 'age': 25, 'city': 'San Francisco'},
    {'name': 'Charlie', 'age': 30, 'city': 'Austin'}
]
 
# Sort by age
by_age = sorted(people, key=lambda x: x['age'])
print([p['name'] for p in by_age])  # ['Bob', 'Alice', 'Charlie']
 
# Sort by age (descending), then name (ascending)
by_age_name = sorted(people, key=lambda x: (-x['age'], x['name']))
print([f"{p['name']} ({p['age']})" for p in by_age_name])
# ['Alice (30)', 'Charlie (30)', 'Bob (25)']
 
# Using itemgetter (more efficient)
from operator import itemgetter
by_city = sorted(people, key=itemgetter('city'))
print([p['city'] for p in by_city])
# ['Austin', 'New York', 'San Francisco']

    Ordenar listas de objetos

    Las clases personalizadas requieren funciones key que extraigan atributos comparables.

    class Product:
    def __init__(self, name, price, rating):
        self.name = name
        self.price = price
        self.rating = rating
 
    def __repr__(self):
        return f'{self.name}(${self.price}, {self.rating}★)'
 
products = [
    Product('Laptop', 999, 4.5),
    Product('Phone', 599, 4.8),
    Product('Tablet', 399, 4.2),
    Product('Monitor', 299, 4.7)
]
 
# Sort by price
by_price = sorted(products, key=lambda p: p.price)
print(by_price)
 
# Sort by rating (descending)
by_rating = sorted(products, key=lambda p: -p.rating)
print(by_rating)
 
# Sort by value score (rating / price * 100)
by_value = sorted(products, key=lambda p: (p.rating / p.price) * 100, reverse=True)
print(by_value)

    Alternativamente, implementa el método __lt__ (less than) para el comportamiento de ordenación por defecto:

    class Student:
    def __init__(self, name, gpa):
        self.name = name
        self.gpa = gpa
 
    def __lt__(self, other):
        return self.gpa > other.gpa  # Higher GPA comes first
 
    def __repr__(self):
        return f'{self.name}({self.gpa})'
 
students = [Student('Alice', 3.8), Student('Bob', 3.9), Student('Charlie', 3.7)]
print(sorted(students))  # [Bob(3.9), Alice(3.8), Charlie(3.7)]

    Ordenación de strings sin distinguir mayúsculas/minúsculas

    Las comparaciones de strings distinguen mayúsculas/minúsculas por defecto, haciendo que las letras mayúsculas se ordenen antes que las minúsculas. Usa str.lower() o str.casefold() para ordenación case-insensitive.

    # Case-sensitive sorting (default)
words = ['apple', 'Banana', 'cherry', 'Date']
print(sorted(words))  # ['Banana', 'Date', 'apple', 'cherry']
 
# Case-insensitive sorting
print(sorted(words, key=str.lower))  # ['apple', 'Banana', 'cherry', 'Date']
 
# Using casefold for Unicode handling
international = ['café', 'CAFÉ', 'Apple', 'apple']
print(sorted(international, key=str.casefold))

    Garantía de ordenación estable y algoritmo Timsort

    Python usa el algoritmo Timsort, que garantiza una ordenación estable. La estabilidad significa que los elementos con claves iguales conservan su orden relativo original.

    # Stable sort preserves original order for equal elements
data = [
    ('Alice', 85),
    ('Bob', 92),
    ('Charlie', 85),  # Same score as Alice
    ('David', 92)     # Same score as Bob
]
 
# Sort by score only - original order preserved for ties
by_score = sorted(data, key=lambda x: x[1])
print(by_score)
# [('Alice', 85), ('Charlie', 85), ('Bob', 92), ('David', 92)]
# Alice appears before Charlie (both 85) because she came first

    Esta estabilidad permite ordenación en múltiples pasadas:

    # Multi-pass sorting using stability
records = [
    {'name': 'Alice', 'dept': 'HR', 'salary': 60000},
    {'name': 'Bob', 'dept': 'IT', 'salary': 75000},
    {'name': 'Charlie', 'dept': 'HR', 'salary': 65000},
    {'name': 'David', 'dept': 'IT', 'salary': 70000}
]
 
# First sort by salary
records.sort(key=lambda x: x['salary'], reverse=True)
# Then sort by department (stable, so salary order preserved within dept)
records.sort(key=lambda x: x['dept'])
 
for r in records:
    print(f"{r['dept']}: {r['name']} (${r['salary']})")
# HR: Charlie ($65000)
# HR: Alice ($60000)
# IT: Bob ($75000)
# IT: David ($70000)

    Comparación de rendimiento: métodos de ordenación

    La ordenación de Python tiene complejidad temporal O(n log n) en el peor caso, lo que la hace eficiente para la mayoría de datasets. Diferentes enfoques encajan mejor en distintos escenarios:

    MethodTime ComplexitySpaceUse Case
    list.sort()O(n log n)O(1)In-place sorting, large lists
    sorted()O(n log n)O(n)Preserve original, sort any iterable
    heapq.nsmallest(k, items)O(n log k)O(k)Top k elements from large dataset
    heapq.nlargest(k, items)O(n log k)O(k)Bottom k elements from large dataset
    bisect.insort(list, item)O(n)O(1)Maintain sorted list with insertions
    import heapq
 
# When you only need top 3 scores from 1 million records
scores = list(range(1000000))
top_3 = heapq.nlargest(3, scores)  # Much faster than sorted()[-3:]
print(top_3)  # [999999, 999998, 999997]
 
# When you need bottom 5 values
bottom_5 = heapq.nsmallest(5, scores)
print(bottom_5)  # [0, 1, 2, 3, 4]

    Para mantener una lista ordenada con inserciones frecuentes:

    import bisect
 
# Maintain sorted list efficiently
sorted_list = []
for value in [5, 2, 8, 1, 9, 3]:
    bisect.insort(sorted_list, value)
 
print(sorted_list)  # [1, 2, 3, 5, 8, 9]

    functools.cmp_to_key para funciones de comparación heredadas

    Python 2 usaba funciones de comparación que devolvían -1, 0 o 1. Python 3 requiere funciones key, pero functools.cmp_to_key convierte funciones de comparación antiguas.

    from functools import cmp_to_key
 
# Custom comparison: sort by remainder when divided by 3
def compare_mod3(x, y):
    return (x % 3) - (y % 3)
 
numbers = [10, 11, 12, 13, 14, 15]
sorted_nums = sorted(numbers, key=cmp_to_key(compare_mod3))
print(sorted_nums)  # [12, 15, 10, 13, 11, 14]
# Groups: [12,15] (mod 0), [10,13] (mod 1), [11,14] (mod 2)
 
# Complex comparison: version strings
def compare_versions(v1, v2):
    parts1 = list(map(int, v1.split('.')))
    parts2 = list(map(int, v2.split('.')))
 
    for p1, p2 in zip(parts1, parts2):
        if p1 != p2:
            return p1 - p2
    return len(parts1) - len(parts2)
 
versions = ['1.10.2', '1.9.0', '1.10.15', '2.0.0', '1.10']
sorted_versions = sorted(versions, key=cmp_to_key(compare_versions))
print(sorted_versions)  # ['1.9.0', '1.10', '1.10.2', '1.10.15', '2.0.0']

    Ordenar con valores None

    Los valores None provocan errores de comparación cuando se mezclan con otros tipos. Manéjalos explícitamente colocándolos al principio o al final.

    # None values cause errors
data = [3, None, 1, 5, None, 2]
# sorted(data)  # TypeError: '<' not supported between 'NoneType' and 'int'
 
# Place None values at the end
sorted_data = sorted(data, key=lambda x: (x is None, x))
print(sorted_data)  # [1, 2, 3, 5, None, None]
 
# Place None values at the beginning
sorted_data = sorted(data, key=lambda x: (x is not None, x))
print(sorted_data)  # [None, None, 1, 2, 3, 5]
 
# Replace None with specific value for sorting
sorted_data = sorted(data, key=lambda x: x if x is not None else float('-inf'))
print(sorted_data)  # [None, None, 1, 2, 3, 5]

    Para diccionarios con claves potencialmente ausentes:

    records = [
    {'name': 'Alice', 'score': 85},
    {'name': 'Bob'},  # Missing score
    {'name': 'Charlie', 'score': 92},
    {'name': 'David'}  # Missing score
]
 
# Sort with default value for missing keys
sorted_records = sorted(records, key=lambda x: x.get('score', 0))
print([r['name'] for r in sorted_records])
# ['Bob', 'David', 'Alice', 'Charlie']

    Ejemplo del mundo real: ranking de rendimiento de estudiantes

    Este ejemplo demuestra múltiples técnicas de ordenación combinadas para crear un sistema de ranking integral:

    class StudentRecord:
    def __init__(self, name, test_scores, attendance, extra_credit=0):
        self.name = name
        self.test_scores = test_scores
        self.attendance = attendance
        self.extra_credit = extra_credit
 
    @property
    def average_score(self):
        return sum(self.test_scores) / len(self.test_scores) if self.test_scores else 0
 
    @property
    def final_grade(self):
        base = self.average_score * 0.8 + self.attendance * 0.2
        return min(100, base + self.extra_credit)
 
    def __repr__(self):
        return f'{self.name}: {self.final_grade:.1f}'
 
students = [
    StudentRecord('Alice', [85, 90, 88], 95, 5),
    StudentRecord('Bob', [92, 88, 95], 80, 0),
    StudentRecord('Charlie', [78, 82, 80], 100, 10),
    StudentRecord('David', [90, 92, 88], 90, 2),
    StudentRecord('Eve', [85, 85, 85], 95, 0)
]
 
# Rank by final grade (highest first), then name
rankings = sorted(students, key=lambda s: (-s.final_grade, s.name))
 
print("Student Rankings:")
for rank, student in enumerate(rankings, 1):
    print(f"{rank}. {student}")

    Ejemplo del mundo real: procesamiento de listados de archivos

    Ordenar metadatos de archivos requiere manejar varios tipos de datos y lógica de ordenación personalizada:

    import os
from datetime import datetime
 
class FileInfo:
    def __init__(self, path):
        self.name = os.path.basename(path)
        self.path = path
        self.size = os.path.getsize(path)
        self.modified = os.path.getmtime(path)
        self.extension = os.path.splitext(path)[1].lower()
 
    def __repr__(self):
        size_kb = self.size / 1024
        mod_time = datetime.fromtimestamp(self.modified).strftime('%Y-%m-%d %H:%M')
        return f'{self.name} ({size_kb:.1f} KB, {mod_time})'
 
# Simulate file information
files = [
    FileInfo('/data/report.pdf'),
    FileInfo('/data/summary.txt'),
    FileInfo('/data/analysis.xlsx'),
    FileInfo('/data/backup.pdf'),
]
 
# Sort by extension, then size (largest first)
by_type_size = sorted(files, key=lambda f: (f.extension, -f.size))
 
# Sort by modification time (most recent first)
by_recent = sorted(files, key=lambda f: -f.modified)
 
# Sort by size, handling different units
def format_size(bytes_size):
    if bytes_size < 1024:
        return f"{bytes_size} B"
    elif bytes_size < 1024 * 1024:
        return f"{bytes_size/1024:.1f} KB"
    else:
        return f"{bytes_size/(1024*1024):.1f} MB"
 
by_size = sorted(files, key=lambda f: f.size, reverse=True)
for f in by_size:
    print(f"{f.name}: {format_size(f.size)}")

    Ordenación interactiva de datos con PyGWalker

    Cuando trabajas con datasets grandes que requieren exploración visual y ordenación interactiva, PyGWalker transforma DataFrames de pandas en interfaces estilo Tableau. En lugar de escribir lógica de ordenación compleja, puedes arrastrar y soltar columnas para ordenar, filtrar y analizar datos visualmente:

    import pandas as pd
import pygwalker as pyg
 
# Create sample sales data
sales_data = pd.DataFrame({
    'product': ['Laptop', 'Phone', 'Tablet', 'Monitor', 'Keyboard'] * 100,
    'region': ['North', 'South', 'East', 'West', 'Central'] * 100,
    'revenue': [999, 599, 399, 299, 49] * 100,
    'units_sold': [50, 120, 80, 95, 200] * 100,
    'date': pd.date_range('2024-01-01', periods=500)
})
 
# Launch interactive visualization
pyg.walk(sales_data)

    PyGWalker permite:

    • Ordenación por múltiples columnas con feedback visual
    • Filtrado dinámico combinado con ordenación
    • Ordenar por campos calculados sin escribir código
    • Exportar vistas ordenadas como gráficos o tablas

    Este enfoque funciona especialmente bien al explorar datasets desconocidos o al presentar hallazgos a stakeholders no técnicos que necesitan entender patrones de datos sin ejecutar código Python.

    FAQ

    ¿Cuál es la diferencia entre sorted() y list.sort() en Python?

    La función sorted() devuelve una nueva lista ordenada y funciona con cualquier iterable, dejando el original sin cambios. El método list.sort() modifica la lista in-place, devuelve None y solo funciona con objetos list. Usa sorted() para preservar los datos originales u ordenar secuencias que no son listas como tuplas; usa list.sort() por eficiencia de memoria al ordenar listas grandes.

    ¿Cómo ordeno una lista en orden descendente en Python?

    Añade el parámetro reverse=True a sorted() o list.sort(). Por ejemplo: sorted([3, 1, 4], reverse=True) devuelve [4, 3, 1]. Esto funciona con cualquier tipo de dato que tenga un orden natural, incluidos números, strings y fechas.

    ¿Puedo ordenar un diccionario por valor en Python?

    Los diccionarios en sí no tienen orden en el sentido tradicional, pero puedes ordenar sus items por valor usando sorted() con una función key: sorted(dict.items(), key=lambda x: x[1]). Esto devuelve una lista de tuplas ordenada por valor. Si lo necesitas, convierte el resultado de nuevo a diccionario con dict(sorted(...)), aunque esto solo preserva el orden en Python 3.7+.

    ¿Cómo ordeno una lista de diccionarios por una clave específica?

    Usa sorted() con una función lambda que extraiga la clave: sorted(list_of_dicts, key=lambda x: x['keyname']). Para mejor rendimiento, usa operator.itemgetter: sorted(list_of_dicts, key=itemgetter('keyname')). Ambos enfoques funcionan para ordenar por una o múltiples claves.

    ¿Cuál es la complejidad temporal de la función sort de Python?

    sorted() y list.sort() usan el algoritmo Timsort, que tiene complejidad temporal O(n log n) en el peor caso y O(n) en el mejor caso para datos parcialmente ordenados. La complejidad espacial es O(n) para sorted() (crea una lista nueva) y O(1) para list.sort() (in-place). Para encontrar los top k elementos en datasets grandes, heapq.nlargest() ofrece complejidad O(n log k).

    ¿Cómo manejo valores None al ordenar?

    Los valores None causan errores de comparación cuando se mezclan con otros tipos. Usa una función key que los coloque al principio o al final: sorted(data, key=lambda x: (x is None, x)) pone los None al final, mientras que sorted(data, key=lambda x: (x is not None, x)) los pone al principio. Para diccionarios con claves ausentes, usa x.get('key', default_value) para proporcionar un valor de respaldo.

    ¿La ordenación de Python es estable?

    Sí. La ordenación de Python es estable por garantía: los elementos con claves iguales mantienen su orden relativo original. Esto permite ordenación en múltiples pasadas donde ordenas por un criterio y luego por otro, preservando el primer orden en empates. La estabilidad está garantizada por el algoritmo Timsort usado en Python.

    Conclusión

    Las capacidades de ordenación de Python ofrecen herramientas potentes para organizar datos de forma eficiente. La distinción entre sorted() y list.sort() guía decisiones conscientes de memoria, mientras que el parámetro key y las funciones lambda habilitan una lógica de ordenación personalizada sofisticada. Entender la ordenación estable, el orden por múltiples criterios y las características de rendimiento te permite elegir el enfoque adecuado para cada escenario.

    Ya sea que estés clasificando rendimiento estudiantil, procesando metadatos de archivos o analizando métricas de negocio, estas técnicas de ordenación forman la base de los flujos de trabajo de manipulación de datos. Para exploración visual e interacción con la ordenación, PyGWalker amplía estas capacidades con interfaces de arrastrar y soltar que complementan la ordenación programática.

    Domina estos patrones de ordenación para escribir código más limpio, mejorar el rendimiento y manejar desafíos complejos de organización de datos con confianza.

    📚