Summary  
This chapter covers the use of anonymous one-line functions (lambda) to define concise operations with single or multiple arguments, inline conditional logic, and integration with higher-order functions like map, filter, and max.

General domain of usage  
Data transformation and filtering

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.

## Single and Multiple Arguments

A lambda function can take one or more arguments:

# Single argument
square = lambda x: x**2
print(square(5))  # 25

# Multiple arguments
add = lambda x, y: x + y
print(add(3, 5))  # 8

## Conditional Logic in Lambda Functions

You can use a ternary expression to add conditional logic inside a lambda:

is_even = lambda x: "even" if x % 2 == 0 else "odd"
print(is_even(4))  # "even"
print(is_even(7))  # "odd"

## Using Lambda with Built-in Functions

A common use case is combining lambda functions with built-in functions like `map()` and `filter()`:


prices = [100, 200, 300]

# Apply 10% discount to each price
discounted = list(map(lambda price: price * 0.9, prices))
print(discounted)  # [90.0, 180.0, 270.0]

# Keep only prices above 150
expensive = list(filter(lambda price: price > 150, prices))
print(expensive)  # [200, 300]

You can also use `max()` inside a lambda to handle edge cases directly within the expression:

safe_value = lambda x: max(x, 0)  # Returns 0 if x is negative
print(safe_value(-5))  # 0
print(safe_value(10))  # 10

Lambda functions are best suited for short, single-expression logic. If your function requires multiple lines or complex logic, a regular `def` function is a better choice.

Note

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.

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.

Lambda Functions

Single and Multiple Arguments

Conditional Logic in Lambda Functions

Using Lambda with Built-in Functions

Solution