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

A **single return value of a function** in Python refers to returning a single object or value from a function. This type of return value has been used in previous sections.

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

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

The function `add_numbers` takes two arguments, adds them, and returns a **single value** — their sum. In this example, the result is stored in the variable `result` and printed to the console.




The `join()` function in Python combines elements of an iterable, such as a list, into a single string, using a specified separator. <br>For example, `", ".join(["a", "b"])` returns `"a, b"`.

Note

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

The `strip()` method removes leading and trailing whitespace by default, or any characters you specify, from both the start and end of the string.
For example, `" text ".strip()` returns `"text"` without spaces, and `"a,b,c,".strip(",")` removes commas from the ends, returning `"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

Gain a solid understanding of how functions shape Python programming. Master defining and calling functions, working with arguments, handling return values, and creating flexible, efficient code using recursion and lambda expressions.

Explore what functions are and why they're essential in Python. Learn how to create functions, define arguments, handle return values, and use built-in functions effectively.

Learn how positional and optional arguments work in Python. Build adaptable functions that handle different inputs and improve flexibility in your code.

Understand how to work with arbitrary and keyword arguments to handle variable input sizes. Learn how these techniques make your functions more dynamic and organized.

Discover how return values represent a function's output. Learn to return single or multiple values, use None, and explore generators for more advanced data flow control.

Unlock advanced function concepts with recursion and lambda functions. Learn how recursion solves repetitive problems and how lambda expressions create concise, one-line functions.

Single Return Value

Solution