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

Funções lambda são funções anônimas, ou seja, não possuem nome. Elas são criadas usando a palavra-chave `lambda` e são frequentemente utilizadas para definir funções curtas, onde é possível especificar uma função diretamente no local de uso.

A sintaxe básica de uma função lambda é a seguinte:

```python
lambda arguments: expression
```

- `lambda`: palavra-chave que indica o início da definição de uma função lambda;
- `arguments`: lista de argumentos que a função recebe;
- `expression`: expressão executada quando a função é chamada. O resultado da expressão é retornado como valor da função.

A principal característica das funções lambda é sua sintaxe concisa. Elas são convenientes quando é necessário definir uma função simples sem escrever muito código.

## Argumentos únicos e múltiplos

Uma função lambda pode receber um ou mais argumentos:

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

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

## Lógica condicional em funções lambda

É possível usar uma expressão ternária para adicionar lógica condicional dentro de uma lambda:

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

## Uso de lambda com funções embutidas

Um caso de uso comum é combinar funções lambda com funções embutidas como `map()` e `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]

Você também pode usar `max()` dentro de uma lambda para lidar com casos extremos diretamente na expressão:

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

Funções lambda são mais adequadas para lógicas curtas e de expressão única. Se a função exigir múltiplas linhas ou lógica complexa, uma função regular `def` é a escolha mais apropriada.

Nota

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

Adquira uma compreensão sólida de como as funções moldam a programação em Python. Domine a definição e chamada de funções, o trabalho com argumentos, o tratamento de valores de retorno e a criação de código flexível e eficiente utilizando recursão e expressões lambda.

Explore o que são funções e por que elas são essenciais em Python. Aprenda a criar funções, definir argumentos, manipular valores de retorno e usar funções embutidas de forma eficaz.

Aprenda como os argumentos posicionais e opcionais funcionam em Python. Desenvolva funções adaptáveis que lidam com diferentes entradas e aumentam a flexibilidade do seu código.

Compreensão de como trabalhar com argumentos arbitrários e argumentos nomeados para lidar com tamanhos de entrada variáveis. Aprendizado de como essas técnicas tornam suas funções mais dinâmicas e organizadas.

Descubra como os valores de retorno representam a saída de uma função. Aprenda a retornar valores únicos ou múltiplos, utilizar None e explorar geradores para um controle de fluxo de dados mais avançado.

Desbloqueie conceitos avançados de funções com recursão e funções lambda. Aprenda como a recursão resolve problemas repetitivos e como as expressões lambda criam funções concisas em uma única linha.

Funções Lambda

Argumentos únicos e múltiplos

Lógica condicional em funções lambda

Uso de lambda com funções embutidas

Solução