Einige Funktionen aus dem vorherigen Kapitel sind noch offen, daher folgt nun eine Übung dazu.

Erinnere dich an die Funktion `zip()`, die besonders nützlich ist, wenn mit **mehreren zusammengehörigen Listen** gearbeitet wird. Diese Funktion ermöglicht es, verschiedene Eigenschaften von Elementen gleichzeitig zu verwalten, beispielsweise Produkte zu sortieren **und dabei deren zugehörige Attribute beizubehalten**.

import unittest
import importlib
import io
import re
import inspect
from contextlib import redirect_stdout
import user_code


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 strip_comments_from_source(module):
    try:
        source = inspect.getsource(module)
        lines = source.split('\\n')
        cleaned = []
        for line in lines:
            stripped = line.rstrip()
            if stripped.startswith('#'):
                continue
            if '#' in line:
                line = line.split('#')[0]
            if line.strip():
                cleaned.append(line)
        return '\\n'.join(cleaned)
    except Exception:
        return ""


class TestSortedProductOutput(unittest.TestCase):

    def normalize_text(self, text):
        text = text.lower()
        text = re.sub(r'\s+', ' ', text)
        text = re.sub(r'\s*([,:?\[\]\(\)])\s*', r'\1', text)
        return text.strip()

    def test_combined_list_correct(self):
        importlib.reload(user_code)
        expected = [
            ("Banana", 1.20, 50),
            ("Apple", 0.50, 100),
            ("Mango", 2.50, 25),
            ("Cherry", 1.75, 40)
        ]
        _dynamic_test(
            self,
            user_code.combined_list == expected,
            "combined_list is correctly zipped from products, prices, and quantities_sold",
            f"Expected combined_list = {expected}, got {user_code.combined_list}"
        )

    def test_sorted_products_correct(self):
        importlib.reload(user_code)
        expected = [
            ("Apple", 0.50, 100),
            ("Banana", 1.20, 50),
            ("Cherry", 1.75, 40),
            ("Mango", 2.50, 25)
        ]
        _dynamic_test(
            self,
            user_code.sorted_products == expected,
            "sorted_products is correctly sorted by product name",
            f"Expected sorted_products = {expected}, got {user_code.sorted_products}"
        )

    def test_output_format(self):
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = self.normalize_text(f.getvalue())

        expected_lines = [
            "Product: Apple, Price: 0.5, Quantity Sold: 100",
            "Product: Banana, Price: 1.2, Quantity Sold: 50",
            "Product: Cherry, Price: 1.75, Quantity Sold: 40",
            "Product: Mango, Price: 2.5, Quantity Sold: 25"
        ]

        for line in expected_lines:
            expected = self.normalize_text(line)
            _dynamic_test(
                self,
                expected in output,
                f"Output includes line: {line}",
                f"Expected output: '{line}' not found."
            )

    def test_zip_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            'zip(' in source,
            "'zip()' is used to combine the lists",
            "Expected use of 'zip()' not found in code"
        )

    def test_sorted_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            'sorted(' in source,
            "'sorted()' is used to sort the combined list",
            "Expected use of 'sorted()' not found in code"
        )


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

test_main.py

Python ist eine hochentwickelte, interpretierte, universell einsetzbare Programmiersprache. Im Gegensatz zu Sprachen wie HTML, CSS und JavaScript, die hauptsächlich in der Webentwicklung verwendet werden, zeichnet sich Python durch Vielseitigkeit in verschiedenen Bereichen wie Softwareentwicklung, Data Science und Back-End-Entwicklung aus. Dieser Kurs führt Sie durch die grundlegenden Konzepte von Python und vermittelt Ihnen die Fähigkeiten, eigene Funktionen zu erstellen.

In diesem Abschnitt werden die Grundlagen von Python behandelt.
Sie lernen Ihre Arbeitsumgebung kennen, führen einfache mathematische Operationen durch und geben Ihre Ergebnisse aus.

In diesem Abschnitt erfahren Sie, wie Sie Elemente wie Zahlen und Text im Computerspeicher speichern und sie anhand ihres Namens abrufen können. Zusätzlich erhalten Sie eine Einführung in die Textmanipulation in Python.

In diesem Abschnitt werden Sie den booleschen Datentyp untersuchen und erfahren, wie er verwendet wird,
um Programme zu entwickeln, die auf bestimmte Bedingungen reagieren.

In diesem Abschnitt werden Sie weiterhin Datentypen kennenlernen und erfahren,
wie verschiedene Attribute in einer einzigen Variablen mithilfe von Listen, Tupeln und Dictionaries organisiert werden können.

In diesem Abschnitt lernen Sie, wie man Schleifen in Python erstellt — eine grundlegende Fähigkeit
zum Iterieren durch Listen, Tupel und Dictionaries.

Zum Abschluss dieses Einführungskurses werden einige eingebaute Funktionen untersucht und anschließend eigene entwickelt.

Herausforderung: Zip- und Sortierfunktionen

Code-Anweisungen

Ausgabebedingungen

Lösung

Herausforderung: Zip- und Sortierfunktionen

Code-Anweisungen

Ausgabebedingungen

Lösung