Ainda temos algumas funções do capítulo anterior para abordar, então vamos praticar com elas.

Lembre-se da função `zip()`, que é especialmente útil ao trabalhar com **múltiplas listas relacionadas**. Essa função permite gerenciar diferentes propriedades de itens simultaneamente, como ordenar produtos **mantendo seus atributos associados**.

import unittest
import importlib
import io
import re
import inspect
from contextlib import redirect_stdout
import user_code


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)


def strip_comments_from_source(module):
    try:
        source = inspect.getsource(module)
        lines = source.split('\\n')
        cleaned = []
        for line in lines:
            stripped = line.rstrip()
            if stripped.startswith('#'):
                continue
            if '#' in line:
                line = line.split('#')[0]
            if line.strip():
                cleaned.append(line)
        return '\\n'.join(cleaned)
    except Exception:
        return ""


class TestSortedProductOutput(unittest.TestCase):

    def normalize_text(self, text):
        text = text.lower()
        text = re.sub(r'\s+', ' ', text)
        text = re.sub(r'\s*([,:?\[\]\(\)])\s*', r'\1', text)
        return text.strip()

    def test_combined_list_correct(self):
        importlib.reload(user_code)
        expected = [
            ("Banana", 1.20, 50),
            ("Apple", 0.50, 100),
            ("Mango", 2.50, 25),
            ("Cherry", 1.75, 40)
        ]
        _dynamic_test(
            self,
            user_code.combined_list == expected,
            "combined_list is correctly zipped from products, prices, and quantities_sold",
            f"Expected combined_list = {expected}, got {user_code.combined_list}"
        )

    def test_sorted_products_correct(self):
        importlib.reload(user_code)
        expected = [
            ("Apple", 0.50, 100),
            ("Banana", 1.20, 50),
            ("Cherry", 1.75, 40),
            ("Mango", 2.50, 25)
        ]
        _dynamic_test(
            self,
            user_code.sorted_products == expected,
            "sorted_products is correctly sorted by product name",
            f"Expected sorted_products = {expected}, got {user_code.sorted_products}"
        )

    def test_output_format(self):
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = self.normalize_text(f.getvalue())

        expected_lines = [
            "Product: Apple, Price: 0.5, Quantity Sold: 100",
            "Product: Banana, Price: 1.2, Quantity Sold: 50",
            "Product: Cherry, Price: 1.75, Quantity Sold: 40",
            "Product: Mango, Price: 2.5, Quantity Sold: 25"
        ]

        for line in expected_lines:
            expected = self.normalize_text(line)
            _dynamic_test(
                self,
                expected in output,
                f"Output includes line: {line}",
                f"Expected output: '{line}' not found."
            )

    def test_zip_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            'zip(' in source,
            "'zip()' is used to combine the lists",
            "Expected use of 'zip()' not found in code"
        )

    def test_sorted_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            'sorted(' in source,
            "'sorted()' is used to sort the combined list",
            "Expected use of 'sorted()' not found in code"
        )


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

test_main.py

Python é uma linguagem de programação de alto nível, interpretada e de uso geral. Diferenciando-se de linguagens como HTML, CSS e JavaScript, que são utilizadas principalmente no desenvolvimento web, Python destaca-se por sua versatilidade em diversos domínios, incluindo desenvolvimento de software, ciência de dados e desenvolvimento back-end. Este curso irá guiá-lo pelos conceitos fundamentais de Python, capacitando-o a criar suas próprias funções ao final do programa.

Nesta seção, você explorará os fundamentos do Python, se familiarizará com o ambiente de trabalho, realizará operações matemáticas simples e exibirá os resultados.

Nesta seção, você descobrirá como armazenar itens como números e textos na memória do computador e recuperá-los pelo nome. Além disso, você terá uma introdução à manipulação de texto em Python.

Nesta seção, você explorará o tipo de dado booleano e aprenderá como ele é utilizado para desenvolver programas que reagem a determinadas condições.

Nesta seção, você continuará aprendendo sobre tipos de dados e descobrirá
como organizar vários atributos em uma única variável utilizando listas, tuplas e dicionários.

Nesta seção, você aprenderá como criar laços de repetição em Python — uma habilidade essencial para iterar por listas, tuplas e dicionários.

Para concluir este curso introdutório, você explorará algumas funções embutidas
e começará a desenvolver as suas próprias!

Desafio: Funções Zip e Sort

Instruções do Código

Requisitos de Saída

Solução