Il sistema del tuo supermercato è progettato per tracciare l'inventario degli articoli sugli scaffali utilizzando le **tuple**, poiché le tuple garantiscono che i dati siano **immutabili** una volta impostati.

Tuttavia, il negozio deve **monitorare alcuni articoli** e tenere traccia delle loro quantità o posizioni per facilitare il rifornimento o la riorganizzazione.

Il tuo compito è analizzare e gestire i dati dell'inventario utilizzando le tuple per determinare alcune metriche e agire in base a criteri specifici.

import unittest
import importlib
import io
import re
from contextlib import redirect_stdout
import inspect
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.strip()
            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 TestFruitShelfTuple(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_apple_count(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'apple_count') and user_code.apple_count == 3,
            "apple_count is correct (3)",
            f"Expected apple_count to be 3, got {getattr(user_code, 'apple_count', None)}"
        )

    def test_banana_index(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'banana_index') and user_code.banana_index == 2,
            "banana_index is correct (2)",
            f"Expected banana_index to be 2, got {getattr(user_code, 'banana_index', None)}"
        )

    def test_grape_count_logic(self):
        importlib.reload(user_code)
        grape_count = user_code.shelf.count("grapes")
        _dynamic_test(
            self,
            grape_count == 1,
            "grape_count is correct and equals 1",
            f"Expected grape count to be 1, got {grape_count}"
        )

    def test_oranges_in_shelf(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            "oranges" in user_code.shelf,
            "'oranges' is present in shelf",
            "'oranges' expected in shelf, but not found"
        )

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

        expected_fragments = [
            self.normalize_text("Number of Apples: 3"),
            self.normalize_text("First Banana Index: 2"),
            self.normalize_text("Apples need to be restocked."),
            self.normalize_text("Grapes need to be restocked."),
            self.normalize_text("Oranges are at index: 1"),
        ]

        for expected in expected_fragments:
            _dynamic_test(
                self,
                expected in output,
                f"Output includes: {expected}",
                f"Expected output to include '{expected}', but got: '{output}'"
            )

    def test_in_operator_used(self):
        source = strip_comments_from_source(user_code)
        found = re.search(r'\s+in\s+', source)
        _dynamic_test(
            self,
            found is not None,
            "'in' operator is used to check for 'oranges'",
            "Expected use of 'in' to check for 'oranges'"
        )


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.

Quale sarà l'output del seguente codice?

Come si può accedere al terzo elemento di questa lista?

Quale sarà il risultato di questo codice?



Come si sostituisce "green" con "yellow"?

Sfida: Operazioni con Tuple

Requisiti di output

Soluzione