Summary  
Demonstrates how functions return a single value or object, showing how to capture that return in a variable and use printing to display results.

General domain of usage  
String manipulation

Ein **einzelner Rückgabewert einer Funktion** in Python bezeichnet das Zurückgeben eines einzelnen Objekts oder Werts aus einer Funktion. Dieser Rückgabewert-Typ wurde in den vorherigen Abschnitten verwendet.

def add_numbers(a, b):
    return a + b

result = add_numbers(3, 5)
print(result)  # outputs: 8

Die Funktion `add_numbers` nimmt zwei Argumente entgegen, addiert sie und gibt einen **einzelnen Wert** zurück – ihre Summe. In diesem Beispiel wird das Ergebnis in der Variablen `result` gespeichert und auf der Konsole ausgegeben.




Die Funktion `join()` in Python verbindet Elemente eines Iterables, wie zum Beispiel einer Liste, zu einem einzigen String unter Verwendung eines angegebenen Trennzeichens. <br>Beispielsweise ergibt `", ".join(["a", "b"])` den Wert `"a, b"`.

Hinweis

# Example of join()
words = ["red", "green", "blue"]
combined = ", ".join(words)
print(combined)

Die Methode `strip()` entfernt standardmäßig führende und nachfolgende Leerzeichen oder beliebige von dir angegebene Zeichen sowohl am Anfang als auch am Ende des Strings.
Zum Beispiel gibt `" text ".strip()` den Wert `"text"` ohne Leerzeichen zurück, und `"a,b,c,".strip(",")` entfernt Kommas an den Enden und ergibt `"a,b,c"`.

# Example of strip()
raw_text = ",a,b,c,"
cleaned_text = raw_text.strip(',')
print(cleaned_text)

import unittest
import re

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)

class TestMergeShoppingLists(unittest.TestCase):
    def test_empty_lists(self):
        """Checks that merging empty lists returns an empty string"""
        import user_code
        try:
            result = user_code.merge_shopping_lists()
            expected_output = ""
            condition = result == expected_output
            failure_message = f"For input `()`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `merge_shopping_lists` is not defined."
        _dynamic_test(self, condition, "The function correctly handles empty input.", failure_message)
    
    def test_single_list(self):
        """Checks that a single list is correctly converted to a string"""
        import user_code
        try:
            result = user_code.merge_shopping_lists(["Bread", "Milk", "Eggs"])
            expected_output = "Bread, Milk, Eggs"
            condition = result == expected_output
            failure_message = f"For input `(['Bread', 'Milk', 'Eggs'])`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `merge_shopping_lists` is not defined."
        _dynamic_test(self, condition, "The function correctly processes a single list.", failure_message)
    
    def test_multiple_lists(self):
        """Checks that multiple lists are correctly merged"""
        import user_code
        try:
            result = user_code.merge_shopping_lists(["Bread", "Milk"], ["Eggs", "Juice"], ["Meat"])
            expected_output = "Bread, Milk, Eggs, Juice, Meat"
            condition = result == expected_output
            failure_message = f"For input `(['Bread', 'Milk'], ['Eggs', 'Juice'], ['Meat'])`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `merge_shopping_lists` is not defined."
        _dynamic_test(self, condition, "The function correctly merges multiple lists.", failure_message)
    
    def test_lists_with_empty_strings(self):
        """Checks that lists with empty strings are correctly handled"""
        import user_code
        try:
            result = user_code.merge_shopping_lists(["Bread", ""], ["Eggs"], [""])
            expected_output = "Bread, , Eggs"
            condition = result == expected_output
            failure_message = f"For input `(['Bread', ''], ['Eggs'], [''])`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `merge_shopping_lists` is not defined."
        _dynamic_test(self, condition, "The function correctly handles lists with empty strings.", failure_message)
    
    def test_code_uses_join(self):
        """Checks that the function uses the join() method."""
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'\.join\s*\(', user_code_source),
            "The function correctly uses the join() method.",
            "Expected the join() method to be used in the function."
        )

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

test_main.py

Erwerben Sie ein fundiertes Verständnis dafür, wie Funktionen die Python-Programmierung prägen. Beherrschen Sie das Definieren und Aufrufen von Funktionen, das Arbeiten mit Argumenten, das Verwalten von Rückgabewerten sowie das Erstellen flexibler und effizienter Codes mithilfe von Rekursion und Lambda-Ausdrücken.

Erkunden Sie, was Funktionen sind und warum sie in Python unverzichtbar sind. Lernen Sie, wie man Funktionen erstellt, Argumente definiert, Rückgabewerte verarbeitet und eingebaute Funktionen effektiv nutzt.

Erfahren Sie, wie Positions- und optionale Argumente in Python funktionieren. Entwicklung anpassungsfähiger Funktionen, die verschiedene Eingaben verarbeiten und die Flexibilität Ihres Codes verbessern.

Verstehen, wie mit beliebigen und Schlüsselwortargumenten gearbeitet wird, um variable Eingabegrößen zu verarbeiten. Erfahren, wie diese Techniken Ihre Funktionen dynamischer und organisierter machen.

Erfahren Sie, wie Rückgabewerte die Ausgabe einer Funktion darstellen. Lernen Sie, einzelne oder mehrere Werte zurückzugeben, None zu verwenden und Generatoren für eine fortgeschrittene Steuerung des Datenflusses zu nutzen.

Erschließen Sie fortgeschrittene Funktionskonzepte mit Rekursion und Lambda-Funktionen. Lernen Sie, wie Rekursion wiederkehrende Probleme löst und wie Lambda-Ausdrücke prägnante, einzeilige Funktionen erstellen.

Einzelner Rückgabewert

Lösung