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

Sortering af data er en almindelig operation, når man arbejder med lister i Python. Funktionen `sorted` er en indbygget højere-ordens funktion, der gør det muligt at sortere enhver iterabel og returnerer en ny sorteret liste, mens de oprindelige data forbliver uændrede. Du kan bruge `sorted` med eller uden brugerdefineret sorteringslogik. Som standard arrangerer `sorted` elementerne i stigende rækkefølge, men du kan styre sorteringsrækkefølgen og kriterierne ved hjælp af dens valgfrie parametre.

De vigtigste parametre for `sorted` er:
- `iterable`: de data, du vil sortere;
- `key`: en valgfri funktion, der bestemmer værdien, der skal sorteres efter for hvert element;
- `reverse`: en boolesk værdi, der, hvis den sættes til `True`, sorterer dataene i faldende rækkefølge.

Antag, at du har en liste med tal og ønsker at sortere dem i stigende rækkefølge. Du kan blot kalde `sorted(numbers)`. Hvis du vil sortere tallene i faldende rækkefølge, kan du angive `reverse=True`.



numbers = [9, 5, 2, 1]

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

Du kan også bruge parameteren `key` til at sortere mere komplekse datastrukturer, såsom lister af tupler eller ordbøger, ved at angive en funktion, der udtrækker sammenligningsværdien fra hvert element.

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

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

Du kan give enhver funktion til `key`-parameteren, inklusive en **lambda-funktion** eller en tidligere defineret funktion. Dette gør `sorted` til en **højere-ordens funktion**, da den accepterer en anden funktion som argument. Sortering er ikke begrænset til tal eller strenge; du kan sortere komplekse objekter, så længe du angiver en passende `key`-funktion.

Den oprindelige iterable ændres ikke af `sorted`, den returnerer altid en ny liste. Hvis du vil sortere en liste på stedet, skal du i stedet bruge metoden `list.sort()`.

Bemærk

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

Bliv fortrolig med pakning/udpaking, fleksible funktionsargumenter, højere-ordens funktioner, lambdaer, variabelscope, closures, iteratorer og dekoratører. Udviklet til kursister, der har gennemført et introduktionskursus i Python og ønsker at skrive mere effektiv, udtryksfuld og kraftfuld kode.

Udforsk kunsten at pakke og udpakke lister, tupler og ordbøger for at skrive mere udtryksfuld og effektiv Python-kode.

Dyk ned i verdenen af højereordensfunktioner, overførsel af funktioner som argumenter og skrivning af korte anonyme funktioner med lambda.

Opdag hemmelighederne bag variabelscope, og lær hvordan indlejrede funktioner og closures muliggør effektiv indkapsling.

Dyk ned i Pythons iterationsprotokol, brugerdefinerede iteratorer og generatorfunktioner for effektiv databehandling.

Grundlæggende om Sorted

Løsning