Summary  
This chapter explains how to define and use anonymous single-expression functions inline using the `lambda` keyword for concise, on-the-spot functionality.

General domain of usage  
Functional programming tasks such as mapping or filtering data collections.

Lambda functions are anonymous functions, meaning they don't have a name. They are created using the `lambda` keyword and are often used to define short functions where you can specify a function on the spot.

The basic syntax of a lambda function is as follows:

```python
lambda arguments: expression
```

- `lambda`: the keyword indicating the start of a lambda function definition;
- `arguments`: the list of arguments the function takes;
- `expression`: the expression executed when the function is called. The result of the expression is returned as the function's value.

The key feature of lambda functions is their concise syntax. They are convenient when you need to define a simple function without writing a lot of code.

square = lambda x: x**2
result = square(5)
print(result) 

import unittest

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 TestApplyTax(unittest.TestCase):
    def test_apply_tax_single_value(self):
        """Checks tax deduction on a single price"""
        import user_code
        try:
            result = user_code.apply_tax(200)
            expected_output = 174.0
            condition = result == expected_output
            failure_message = f"For input `200`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `apply_tax` is not defined."
        _dynamic_test(self, condition, "The function correctly calculates tax for a single price.", failure_message)
    
    def test_apply_tax_zero(self):
        """Checks that tax deduction on zero returns zero"""
        import user_code
        try:
            result = user_code.apply_tax(0)
            expected_output = 0.0
            condition = result == expected_output
            failure_message = f"For input `0`, expected `{expected_output}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `apply_tax` is not defined."
        _dynamic_test(self, condition, "The function correctly handles zero input.", failure_message)

    def test_negative_price(self):
        """Checks that negative prices are handled correctly and return 0"""
        import user_code
        result = user_code.apply_tax(-123)
        expected_output = 0
        condition = result == expected_output
        failure_message = f"For input `-123`, expected `{expected_output}`, but got `{result}`."
        _dynamic_test(self, condition, "The function correctly handles negative values.", failure_message)
    
    def test_apply_tax_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'apply_tax'),
            "The `apply_tax` variable is declared.",
            "Expected `apply_tax` to be declared."
        )
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.

Lambda Functions in Python

解答