Abbiamo ancora alcune funzioni dal capitolo precedente da esaminare, quindi esercitiamoci con esse.

Ricorda la funzione `zip()`, particolarmente utile quando si lavora con **liste multiple correlate**. Questa funzione consente di gestire contemporaneamente diverse proprietà degli elementi, come ad esempio ordinare prodotti **mantenendo i relativi attributi associati**.

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 è un linguaggio di programmazione di alto livello, interpretato e di uso generale. A differenza di linguaggi come HTML, CSS e JavaScript, principalmente utilizzati nello sviluppo web, Python si distingue per la sua versatilità in molteplici ambiti, tra cui lo sviluppo software, la data science e lo sviluppo back-end. Questo corso ti guiderà attraverso i concetti fondamentali di Python, fornendoti le competenze necessarie per creare le tue funzioni al termine del programma.

In questa sezione, verranno esplorati i fondamenti di Python, familiarizzazione con l'ambiente di lavoro, esecuzione di semplici operazioni matematiche e visualizzazione dei risultati.

In questa sezione scoprirai come salvare elementi come numeri e testo nella memoria del computer e recuperarli tramite un nome. Inoltre, riceverai un'introduzione alla manipolazione del testo in Python.

In questa sezione, esplorerai il tipo di dato booleano e apprenderai come viene utilizzato per sviluppare programmi che reagiscono a determinate condizioni.

In questa sezione continuerai ad approfondire i tipi di dati e scoprirai
come organizzare vari attributi in una singola variabile utilizzando liste, tuple e dizionari.

In questa sezione, apprenderai come creare cicli in Python — una competenza essenziale per iterare su liste, tuple e dizionari.

Per concludere questo corso introduttivo, esplorerai alcune funzioni integrate
e poi inizierai a sviluppare le tue.

Sfida: Funzioni Zip e Sort

Istruzioni per il codice

Requisiti di output

Soluzione

Sfida: Funzioni Zip e Sort

Istruzioni per il codice

Requisiti di output

Soluzione