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)

Las funciones lambda son funciones anónimas, lo que significa que no tienen un nombre. Se crean utilizando la palabra clave `lambda` y suelen emplearse para definir funciones cortas donde se puede especificar una función en el momento.

La sintaxis básica de una función lambda es la siguiente:

```python
lambda arguments: expression
```

- `lambda`: palabra clave que indica el inicio de la definición de una función lambda;
- `arguments`: lista de argumentos que recibe la función;
- `expression`: expresión que se ejecuta cuando se llama a la función. El resultado de la expresión se devuelve como valor de la función.

La característica principal de las funciones lambda es su sintaxis concisa. Son convenientes cuando se necesita definir una función simple sin escribir mucho 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

Tendrás una comprensión sólida de la importancia de las funciones en Python, independientemente de tu área en ciencias de la computación. Cubriremos la creación de funciones, la definición de argumentos, el manejo de valores de retorno y exploraremos su uso en Python.

Se analizará qué es una función en Python y algunas técnicas básicas para crear funciones: cuáles son los argumentos de la función, cuál es el valor de retorno de la función, cuál es el cuerpo de la función y cómo utilizar la función en el código.

Aprenda a definir funciones en Python utilizando argumentos posicionales y opcionales. Domine la flexibilidad de crear funciones que se adaptan a diferentes escenarios de entrada.

Aprenda a trabajar con argumentos arbitrarios y argumentos de palabras clave en Python para manejar cantidades variables de entradas. Comprenda cómo los argumentos arbitrarios gestionan entradas posicionales flexibles y cómo los argumentos de palabras clave organizan argumentos nombrados en un diccionario para un diseño eficiente de funciones.

El valor de retorno de una función es el resultado directo de la ejecución de la función, que podemos utilizar en el programa. Existen varios tipos de valores de retorno de funciones; consideraremos los más comúnmente utilizados.

Explora el poder de la recursión y las funciones lambda en Python. Comprende cómo la recursión permite que una función se llame a sí misma para resolver problemas complejos, y cómo las funciones lambda ofrecen una forma concisa de definir funciones anónimas para tareas simples.

Funciones Lambda

Solución

Awesome!

Funciones Lambda

Solución