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

Tietojen lajittelu on yleinen toimenpide, kun käsitellään listoja Pythonissa. `sorted`-funktio on sisäänrakennettu korkeamman asteen funktio, jonka avulla voit lajitella minkä tahansa iteroitavan ja saat uuden lajitellun listan, jolloin alkuperäinen data säilyy muuttumattomana. Voit käyttää `sorted`-funktiota joko oletuslajittelulla tai määrittämällä oman lajittelulogiikan. Oletuksena `sorted` järjestää alkiot nousevaan järjestykseen, mutta voit hallita lajittelujärjestystä ja -kriteerejä valinnaisilla parametreilla.

Tärkeimmät parametrit `sorted`-funktiolle ovat:
- `iterable`: data, jonka haluat lajitella;
- `key`: valinnainen funktio, joka määrittää, minkä arvon perusteella kukin alkio lajitellaan;
- `reverse`: totuusarvo, joka asettamalla `True` lajitellaan data laskevaan järjestykseen.

Oletetaan, että sinulla on lista numeroita ja haluat lajitella ne nousevaan järjestykseen. Voit yksinkertaisesti kutsua `sorted(numbers)`. Jos haluat lajitella numerot laskevaan järjestykseen, voit antaa parametrin `reverse=True`.



numbers = [9, 5, 2, 1]

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

Voit myös käyttää `key`-parametria lajitellaksesi monimutkaisempia tietorakenteita, kuten tuplejen tai sanakirjojen listoja, määrittämällä funktion, joka poimii vertailuarvon kustakin alkiosta.

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

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

Voit välittää minkä tahansa funktion `key`-parametriin, mukaan lukien **lambda-funktion** tai aiemmin määritellyn funktion. Tämä tekee `sorted`-funktiosta **korkeamman asteen funktion**, koska se ottaa toisen funktion argumenttina. Lajittelu ei rajoitu vain numeroihin tai merkkijonoihin; voit lajitella monimutkaisia olioita, kunhan määrität sopivan `key`-funktion.

Alkuperäinen iteroitava ei muutu `sorted`-funktion käytössä, vaan se palauttaa aina uuden listan. Jos haluat lajitella listan paikan päällä, käytä `list.sort()`-metodia.

Huomio

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

Hallitse pakkaus- ja purkutekniikat, joustavat funktioargumentit, korkeamman asteen funktiot, lambda-lausekkeet, muuttujien näkyvyysalueet, sulkeumat, iteraattorit ja dekorointifunktiot. Suunniteltu oppijoille, jotka ovat suorittaneet Pythonin peruskurssin ja haluavat kirjoittaa tehokkaampaa, ilmeikkäämpää ja monipuolisempaa koodia.

Tutustu listojen, tuplien ja sanakirjojen pakkaamisen ja purkamisen taitoon kirjoittaaksesi ilmeikkäämpää ja tehokkaampaa Python-koodia.

Syvenny korkeamman asteen funktioiden maailmaan, funktioiden välittämiseen argumentteina ja tiiviiden anonyymien funktioiden kirjoittamiseen lambda-avainsanalla.

Selvitä muuttujien näkyvyyden salaisuudet ja opi, kuinka sisäkkäiset funktiot ja sulut mahdollistavat tehokkaan kapseloinnin.

Syvenny Pythonin iteraatioprotokollaan, mukautettuihin iteraattoreihin ja generaattorifunktioihin tehokasta datankäsittelyä varten.

Sorted-Funktion Perusteet

Ratkaisu