Summary  
Lambda functions are anonymous, single-expression functions defined with the `lambda` keyword for concise, on-the-spot function definitions.  

General domain of usage  
Functional programming (e.g., using lambdas in map, filter, or as callbacks)

Funções lambda são funções anônimas, ou seja, não possuem nome. Elas são criadas utilizando a palavra-chave `lambda` e são frequentemente usadas 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.

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

Você terá uma compreensão sólida da importância das funções em Python, independentemente da sua área na ciência da computação. Abordaremos a criação de funções, definição de argumentos, manipulação de valores de retorno e exploraremos seu uso em Python.

Serão abordados o conceito de função em Python e algumas técnicas básicas para criar funções: o que são os argumentos da função, qual é o valor de retorno da função, o que constitui o corpo da função e como utilizar a função no código.

Aprenda a definir funções em Python utilizando argumentos posicionais e opcionais. Domine a flexibilidade de criar funções que se adaptam a diferentes cenários de entrada.

Aprenda a trabalhar com argumentos arbitrários e argumentos nomeados em Python para lidar com quantidades variáveis de entradas. Entenda como os argumentos arbitrários gerenciam entradas posicionais flexíveis e como os argumentos nomeados organizam argumentos nomeados em um dicionário para um design de funções eficiente.

O valor de retorno de uma função é o resultado direto da execução da função, que pode ser utilizado no programa. Existem vários tipos de valores de retorno de funções - abordaremos os mais comumente utilizados.

Explore o poder da recursão e das funções lambda em Python. Compreenda como a recursão permite que uma função chame a si mesma para resolver problemas complexos e como as funções lambda oferecem uma forma concisa de definir funções anônimas para tarefas simples.

Funções Lambda

Solução

Awesome!

Funções Lambda

Solução