Summary  
The chapter explains how to use Python’s built-in `sorted` higher-order function to produce a new sorted list from any iterable—by default in ascending order or with `reverse=True`—and how to customize the sort order using the `key` parameter with functions like `len` or lambdas.  

General domain of usage  
Data processing and organization

La ordenación de datos es una operación común al trabajar con listas en Python. La función `sorted` es una función de orden superior incorporada que permite ordenar cualquier iterable y devuelve una nueva lista ordenada, dejando los datos originales sin cambios. Puedes usar `sorted` con o sin lógica de ordenación personalizada. Por defecto, `sorted` organiza los elementos en orden ascendente, pero puedes controlar el orden y los criterios de ordenación utilizando sus parámetros opcionales.

Los parámetros más importantes para `sorted` son:
- `iterable`: los datos que deseas ordenar;
- `key`: una función opcional que determina el valor por el cual se ordena cada elemento;
- `reverse`: un valor booleano que, si se establece en `True`, ordena los datos en orden descendente.

Supón que tienes una lista de números y deseas ordenarlos en orden ascendente. Simplemente puedes llamar a `sorted(numbers)`. Si deseas ordenar los números en orden descendente, puedes pasar `reverse=True`.



numbers = [9, 5, 2, 1]

# Sorting in reverse order
sorted_desc = sorted(numbers, reverse=True)
print(sorted_desc)  

También puedes usar el parámetro `key` para ordenar estructuras de datos más complejas, como listas de tuplas o diccionarios, especificando una función que extraiga el valor de comparación de cada elemento.

words = ["apple", "kiwi", "banana"]

# Sorting by the length of each string
sorted_words = sorted(words, key=len)
print(sorted_words)  

Se puede pasar cualquier función al parámetro `key`, incluyendo una **función lambda** o una función definida previamente. Esto convierte a `sorted` en una **función de orden superior**, ya que acepta otra función como argumento. La ordenación no se limita a números o cadenas; es posible ordenar objetos complejos siempre que se proporcione una función `key` adecuada.

El iterable original no se modifica con `sorted`, siempre devuelve una nueva lista. Si se desea ordenar una lista en el lugar, se debe utilizar el método `list.sort()` en su lugar.

Nota

import unittest
import user_code
import ast
import re   
import importlib
import csv
import importlib

class TestTask(unittest.TestCase):
    def test_sorted_pairs_exists_and_is_list(self):
        import user_code
        importlib.reload(user_code)
        result = getattr(user_code, 'sorted_pairs', None)
        _dynamic_test(
            self,
            isinstance(result, list),
            "sorted_pairs is a list.",
            f"sorted_pairs should be a list, got {type(result)}."
        )
    def test_sorted_pairs_correct_order(self):
        import user_code
        importlib.reload(user_code)
        result = getattr(user_code, 'sorted_pairs', None)
        expected = [(4, 1), (2, 2), (1, 3)]
        _dynamic_test(
            self,
            result == expected,
            "sorted_pairs is sorted by the second tuple element.",
            f"Expected {expected}, got {result}."
        )
    def test_sorted_pairs_with_other_data(self):
        code = ""
        with open("user_code.py", "r") as f:
            code = f.read()
        test_pairs = [(5, 10), (2, -1), (7, 5)]
        code = change_var(code, "pairs", repr(test_pairs))
        ns = {}
        exec(code, ns)
        actual = ns.get('sorted_pairs', None)
        expected = [(2, -1), (7, 5), (5, 10)]
        _dynamic_test(
            self,
            isinstance(actual, list) and actual == expected,
            "sorted_pairs sorts different input correctly.",
            f"Expected {expected}, got {actual}."
        )
    def test_get_second_element_function(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'get_second_element', None)
        _dynamic_test(
            self,
            callable(func),
            "get_second_element is defined and callable.",
            "get_second_element function is not defined or not callable."
        )
        if callable(func):
            result = func((99, 123))
            _dynamic_test(
                self,
                result == 123,
                "get_second_element returns the second element of the tuple.",
                f"Expected 123, got {result}."
            )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Domina el empaquetado/desempaquetado, argumentos flexibles en funciones, funciones de orden superior, lambdas, alcance de variables, closures, iteradores y decoradores. Diseñado para estudiantes que han completado un curso introductorio de Python y desean escribir código más eficiente, expresivo y potente.

Explora el arte de empaquetar y desempaquetar listas, tuplas y diccionarios para escribir código Python más expresivo y eficiente.

Adentrarse en el mundo de las funciones de orden superior, el paso de funciones como argumentos y la escritura de funciones anónimas concisas con lambda.

Descubre los misterios del alcance de las variables y aprende cómo las funciones anidadas y los closures permiten una encapsulación poderosa.

Profundización en el protocolo de iteración de Python, iteradores personalizados y funciones generadoras para el procesamiento eficiente de datos.

Fundamentos de Sorted

Solución