Ottimo lavoro nel padroneggiare **variabili**, **tipi di dati**, **slicing** e **concatenazione**! 

Ora, applichiamo le tue nuove competenze a uno scenario realistico che coinvolge l'organizzazione di un nuovo inventario di un negozio di alimentari.

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


def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True)
    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 as e:
        return ""

class TestUserCode(unittest.TestCase):
    def normalize_text(self, text):
        text = text.lower()
        text = re.sub(r'\s+', ' ', text)
        return text.strip()

    def test_candy1_declared_and_correct(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'candy1') and self.normalize_text(user_code.candy1) == self.normalize_text("Bubblegum"),
            "candy1 is declared and equals 'Bubblegum'",
            f"Expected candy1 to be 'Bubblegum', but got '{getattr(user_code, 'candy1', None)}'"
        )

    def test_candy1_slicing_used(self):
        try:
            source = strip_comments_from_source(user_code)
            _dynamic_test(
                self,
                re.search(r'candy1\s*=\s*items\s*\[.*\]', source),
                "candy1 is sliced from items string",
                "Expected candy1 to be assigned using slicing from 'items'"
            )
        except Exception as e:
            self.fail(f"Could not retrieve source code: {e}")

    def test_candy2_declared_and_correct(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'candy2') and self.normalize_text(user_code.candy2) == self.normalize_text("Chocolate"),
            "candy2 is declared and equals 'Chocolate'",
            f"Expected candy2 to be 'Chocolate', but got '{getattr(user_code, 'candy2', None)}'"
        )

    def test_candy2_slicing_used(self):
        try:
            source = strip_comments_from_source(user_code)
            _dynamic_test(
                self,
                re.search(r'candy2\s*=\s*items\s*\[.*\]', source),
                "candy2 is sliced from items string",
                "Expected candy2 to be assigned using slicing from 'items'"
            )
        except Exception as e:
            self.fail(f"Could not retrieve source code: {e}")

    def test_dry_goods_declared_and_correct(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'dry_goods') and self.normalize_text(user_code.dry_goods) == self.normalize_text("Pasta"),
            "dry_goods is declared and equals 'Pasta'",
            f"Expected dry_goods to be 'Pasta', but got '{getattr(user_code, 'dry_goods', None)}'"
        )

    def test_dry_goods_slicing_used(self):
        try:
            source = strip_comments_from_source(user_code)
            _dynamic_test(
                self,
                re.search(r'dry_goods\s*=\s*items\s*\[.*\]', source),
                "dry_goods is sliced from items string",
                "Expected dry_goods to be assigned using slicing from 'items'"
            )
        except Exception as e:
            self.fail(f"Could not retrieve source code: {e}")

    def test_print_bubblegum_statement(self):
        f = StringIO()
        with redirect_stdout(f):
            try:
                importlib.reload(user_code)
            except Exception as e:
                self.fail(f"Error when running user_code.py: {e}")
        output = self.normalize_text(f.getvalue())
        expected = self.normalize_text("We have Bubblegum for $1.50 in the Candy Aisle")
        _dynamic_test(
            self,
            expected in output,
            "Bubblegum print statement is correct",
            f"Expected output to contain '{expected}'"
        )

    def test_print_chocolate_statement(self):
        f = StringIO()
        with redirect_stdout(f):
            try:
                importlib.reload(user_code)
            except Exception as e:
                self.fail(f"Error when running user_code.py: {e}")
        output = self.normalize_text(f.getvalue())
        expected = self.normalize_text("We have Chocolate for $2.00 in the Candy Aisle")
        _dynamic_test(
            self,
            expected in output,
            "Chocolate print statement is correct",
            f"Expected output to contain '{expected}'"
        )

    def test_print_pasta_statement(self):
        f = StringIO()
        with redirect_stdout(f):
            try:
                importlib.reload(user_code)
            except Exception as e:
                self.fail(f"Error when running user_code.py: {e}")
        output = self.normalize_text(f.getvalue())
        expected = self.normalize_text("We have Pasta for $5.40 in the Pasta Aisle")
        _dynamic_test(
            self,
            expected in output,
            "Pasta print statement is correct",
            f"Expected output to contain '{expected}'"
        )

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

test_main.py

Python è un linguaggio di programmazione di alto livello, interpretato e di uso generale. Distinto da linguaggi come HTML, CSS e JavaScript, che sono principalmente utilizzati nello sviluppo web, Python vanta versatilità in diversi domini, tra cui lo sviluppo software, la scienza dei dati e lo sviluppo back-end. Questo corso ti guiderà attraverso i concetti fondamentali di Python, dotandoti delle competenze per creare le tue funzioni entro la conclusione del programma.

In questa sezione, esplorerai i fondamenti di Python, familiarizzerai
con il tuo ambiente di lavoro, eseguirai semplici operazioni matematiche e mostrerai i tuoi risultati.

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

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

In questa sezione, continuerai a imparare sui tipi di dati e scoprirai
come organizzare vari attributi in una singola variabile utilizzando liste, tuple e dizionari.

In questa sezione, imparerai a creare loop in Python — una competenza essenziale
per iterare attraverso liste, tuple e dizionari.

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

Quale di questi è un modo corretto per creare una variabile?

Prova a indovinare cosa farà questo codice.

Data la stringa `"Banana"`, quale codice recupera il suo primo carattere?

Cosa c'è di sbagliato in questa espressione?

Quale sarà l'output del seguente codice?

Sfida: Progetto Finale Ordinamento Inventory

Requisiti di Output

Soluzione

Awesome!

Sfida: Progetto Finale Ordinamento Inventory

Requisiti di Output

Soluzione