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

Gegevens sorteren is een veelvoorkomende bewerking bij het werken met lijsten in Python. De functie `sorted` is een ingebouwde hogere-orde functie waarmee je elke iterable kunt sorteren en een nieuwe gesorteerde lijst terugkrijgt, terwijl de oorspronkelijke data ongewijzigd blijft. Je kunt `sorted` gebruiken met of zonder aangepaste sorteervolgorde. Standaard rangschikt `sorted` de elementen in oplopende volgorde, maar je kunt de sorteervolgorde en criteria bepalen met de optionele parameters.

De belangrijkste parameters voor `sorted` zijn:
- `iterable`: de gegevens die je wilt sorteren;
- `key`: een optionele functie die bepaalt op welke waarde elk element wordt gesorteerd;
- `reverse`: een Booleaanse waarde die, indien ingesteld op `True`, de gegevens in aflopende volgorde sorteert.

Stel dat je een lijst met getallen hebt en deze in oplopende volgorde wilt sorteren. Je kunt eenvoudig `sorted(numbers)` aanroepen. Als je de getallen in aflopende volgorde wilt sorteren, kun je `reverse=True` meegeven.



numbers = [9, 5, 2, 1]

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

Je kunt ook de parameter `key` gebruiken om complexere datastructuren te sorteren, zoals lijsten van tuples of dictionaries, door een functie op te geven die de vergelijkingswaarde uit elk element haalt.

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

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

Je kunt elke functie doorgeven aan de parameter `key`, waaronder een **lambda-functie** of een eerder gedefinieerde functie. Dit maakt van `sorted` een **hogere-orde functie**, omdat het een andere functie als argument accepteert. Sorteren is niet beperkt tot getallen of strings; je kunt complexe objecten sorteren zolang je een geschikte `key`-functie opgeeft.

Het originele iterabele wordt niet gewijzigd door `sorted`, deze retourneert altijd een nieuwe lijst. Als je een lijst direct wilt sorteren, gebruik dan de methode `list.sort()`.

Opmerking

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

Beheers het inpakken/uitpakken, flexibele functieargumenten, hogere-orde functies, lambda's, variabele scope, closures, iterators en decorators. Ontworpen voor cursisten die een inleidende Python-cursus hebben afgerond en efficiëntere, expressievere en krachtigere code willen schrijven.

Ontdek de kunst van het inpakken en uitpakken van lijsten, tuples en dictionaries om expressievere en efficiëntere Python-code te schrijven.

Verdiep je in de wereld van hogere-orde functies, het doorgeven van functies als argumenten en het schrijven van beknopte anonieme functies met lambda.

Ontrafel de mysteries van variabele scope en ontdek hoe geneste functies en closures krachtige encapsulatie mogelijk maken.

Verdiep u in het iteratieprotocol van Python, aangepaste iterators en generatorfuncties voor efficiënte gegevensverwerking.

Gesorteerde Basisprincipes

Oplossing