¡Gran trabajo dominando **variables**, **tipos de datos**, **slicing** y **concatenación**! 

Ahora, apliquemos tus nuevas habilidades a un escenario realista que involucra organizar el inventario de una nueva tienda de comestibles.

import unittest
import sys
from io import StringIO
from contextlib import redirect_stdout
import importlib
import inspect
import user_code

class TestUserCode(unittest.TestCase):
    def test_candy1_declared(self):
        self._testMethodName = 'candy1 is declared'
        try:
            import user_code
        except ImportError:
            self.fail("user_code.py not found.")
        self.assertTrue(hasattr(user_code, 'candy1'), "Expected 'candy1' to be defined.")

    def test_candy1_correct(self):
        self._testMethodName = 'candy1 equals "Bubblegum"'
        import user_code
        self.assertEqual(user_code.candy1, "Bubblegum", f"Expected candy1 to equal 'Bubblegum', but got '{user_code.candy1}'.")

    def test_candy1_slicing_used(self):
        self._testMethodName = 'candy1 was sliced from items using slicing'
        import user_code
        try:
            source = inspect.getsource(user_code)
        except Exception as e:
            self.fail(f"Could not retrieve source code: {e}")
        self.assertRegex(source, r'candy1\s*=\s*items\s*\[.*\]', "Expected 'candy1' to be assigned using slicing from 'items'.")

    def test_candy2_declared(self):
        self._testMethodName = 'candy2 is declared'
        import user_code
        self.assertTrue(hasattr(user_code, 'candy2'), "Expected 'candy2' to be defined.")

    def test_candy2_correct(self):
        self._testMethodName = 'candy2 equals "Chocolate"'
        import user_code
        self.assertEqual(user_code.candy2, "Chocolate", f"Expected candy2 to equal 'Chocolate', but got '{user_code.candy2}'.")

    def test_candy2_slicing_used(self):
        self._testMethodName = 'candy2 was sliced from items using slicing'
        import user_code
        try:
            source = inspect.getsource(user_code)
        except Exception as e:
            self.fail(f"Could not retrieve source code: {e}")
        self.assertRegex(source, r'candy2\s*=\s*items\s*\[.*\]', "Expected 'candy2' to be assigned using slicing from 'items'.")

    def test_dry_goods_declared(self):
        self._testMethodName = 'dry_goods is declared'
        import user_code
        self.assertTrue(hasattr(user_code, 'dry_goods'), "Expected 'dry_goods' to be defined.")

    def test_dry_goods_correct(self):
        self._testMethodName = 'dry_goods equals "Pasta"'
        import user_code
        self.assertEqual(user_code.dry_goods, "Pasta", f"Expected dry_goods to equal 'Pasta', but got '{user_code.dry_goods}'.")

    def test_dry_goods_slicing_used(self):
        self._testMethodName = 'dry_goods was sliced from items using slicing'
        import user_code
        try:
            source = inspect.getsource(user_code)
        except Exception as e:
            self.fail(f"Could not retrieve source code: {e}")
        self.assertRegex(source, r'dry_goods\s*=\s*items\s*\[.*\]', "Expected 'dry_goods' to be assigned using slicing from 'items'.")

    def test_category1_declared(self):
        self._testMethodName = 'category1 is declared'
        import user_code
        self.assertTrue(hasattr(user_code, 'category1'), "Expected 'category1' to be defined.")

    def test_category1_correct(self):
        self._testMethodName = 'category1 equals "Candy Aisle"'
        import user_code
        self.assertEqual(user_code.category1, "Candy Aisle", f"Expected category1 to equal 'Candy Aisle', but got '{user_code.category1}'.")

    def test_category1_slicing_used(self):
        self._testMethodName = 'category1 was sliced from categories using slicing'
        import user_code
        try:
            source = inspect.getsource(user_code)
        except Exception as e:
            self.fail(f"Could not retrieve source code: {e}")
        self.assertRegex(source, r'category1\s*=\s*categories\s*\[.*\]', "Expected 'category1' to be assigned using slicing from 'categories'.")

    def test_category2_declared(self):
        self._testMethodName = 'category2 is declared'
        import user_code
        self.assertTrue(hasattr(user_code, 'category2'), "Expected 'category2' to be defined.")

    def test_category2_correct(self):
        self._testMethodName = 'category2 equals "Pasta Aisle"'
        import user_code
        self.assertEqual(user_code.category2, "Pasta Aisle", f"Expected category2 to equal 'Pasta Aisle', but got '{user_code.category2}'.")

    def test_category2_slicing_used(self):
        self._testMethodName = 'category2 was sliced from categories using slicing'
        import user_code
        try:
            source = inspect.getsource(user_code)
        except Exception as e:
            self.fail(f"Could not retrieve source code: {e}")
        self.assertRegex(source, r'category2\s*=\s*categories\s*\[.*\]', "Expected 'category2' to be assigned using slicing from 'categories'.")

    def test_bubblegum_price_declared(self):
        self._testMethodName = 'bubblegum_price is declared'
        import user_code
        self.assertTrue(hasattr(user_code, 'bubblegum_price'), "Expected 'bubblegum_price' to be defined.")

    def test_bubblegum_price_correct(self):
        self._testMethodName = 'bubblegum_price equals "$1.50"'
        import user_code
        self.assertEqual(user_code.bubblegum_price, "$1.50", f"Expected bubblegum_price to equal '$1.50', but got '{user_code.bubblegum_price}'.")

    def test_chocolate_price_declared(self):
        self._testMethodName = 'chocolate_price is declared'
        import user_code
        self.assertTrue(hasattr(user_code, 'chocolate_price'), "Expected 'chocolate_price' to be defined.")

    def test_chocolate_price_correct(self):
        self._testMethodName = 'chocolate_price equals "$2.00"'
        import user_code
        self.assertEqual(user_code.chocolate_price, "$2.00", f"Expected chocolate_price to equal '$2.00', but got '{user_code.chocolate_price}'.")

    def test_pasta_price_declared(self):
        self._testMethodName = 'pasta_price is declared'
        import user_code
        self.assertTrue(hasattr(user_code, 'pasta_price'), "Expected 'pasta_price' to be defined.")

    def test_pasta_price_correct(self):
        self._testMethodName = 'pasta_price equals "$5.40"'
        import user_code
        self.assertEqual(user_code.pasta_price, "$5.40", f"Expected pasta_price to equal '$5.40', but got '{user_code.pasta_price}'.")

    def test_print_statements(self):
        self._testMethodName = 'print statements are correct'
        importlib.reload(user_code)
        captured_output = StringIO()
        try:
            with redirect_stdout(captured_output):
                importlib.reload(user_code)
        except Exception as e:
            self.fail(f"Error when running user_code.py: {e}")
        output = captured_output.getvalue().strip()
        expected_statements = [
            "We have Bubblegum for $1.50 in the Candy Aisle",
            "We have Chocolate for $2.00 in the Candy Aisle",
            "We have Pasta for $5.40 in the Pasta Aisle"
        ]
        for statement in expected_statements:
            self.assertIn(statement, output, f"Expected the output to contain '{statement}'.")

if __name__ == '__main__':
    unittest.main()

test_main.py

Python es un lenguaje de programación de alto nivel, interpretado y de propósito general. A diferencia de lenguajes como HTML, CSS y JavaScript, que se utilizan principalmente en el desarrollo web, Python ofrece versatilidad en múltiples dominios, incluyendo el desarrollo de software, la ciencia de datos y el desarrollo back-end. Este curso te guiará a través de los conceptos fundamentales de Python, equipándote con las habilidades para crear tus propias funciones al finalizar el programa.

En esta sección, explorarás los fundamentos de Python, te familiarizarás
con tu espacio de trabajo, realizarás operaciones matemáticas simples y mostrarás tus hallazgos.

En esta sección, descubrirás cómo guardar elementos como números y texto
en la memoria del ordenador y recuperarlos por nombre. Además, obtendrás una introducción a la manipulación de texto
en Python.

En esta sección, explorarás el tipo de dato booleano y aprenderás cómo se utiliza
para desarrollar programas que reaccionan a ciertas condiciones.

En esta sección, continuarás aprendiendo sobre los tipos de datos y descubrirás
cómo organizar varios atributos en una sola variable usando lists, tuples y dictionaries.

En esta sección, aprenderás a crear loops en Python, una habilidad esencial
para iterar a través de listas, tuplas y diccionarios.

Para concluir este curso introductorio, explorarás algunas funciones integradas
y luego comenzarás a desarrollar las tuyas propias.

¿Cuál de estos es una forma correcta de crear una variable?

Intenta adivinar qué hará este código.

Dada la cadena `"Banana"`, ¿qué código recupera su primer carácter?

¿Cuál será la salida del siguiente código?

Desafío: Proyecto Final de Ordenación de Inventario

Instrucciones de Código

Requisitos de Salida

Solución