Summary  
This chapter introduces how to declare and assign variables to store and access different data types (integers, floats, strings, booleans) using simple assignment in code.

General domain of usage  
Grocery store inventory management.

**Ottimo lavoro** nel padroneggiare i tipi di dati! Successivamente, esploreremo **come memorizzare i dati all'interno delle variabili**, proprio come organizzare la tua spesa nei giusti contenitori. Questo rende i tuoi dati **facili da accedere** e manipolare — fondamentale per qualsiasi progetto di codifica efficiente.

Guarda Alex mentre dimostra come memorizzare i dati nelle variabili:

Mettiamolo in pratica. Qui, stiamo assegnando **vari tipi di dati** a variabili, ciascuna rappresentante diversi aspetti di un articolo di drogheria.


# Storing different types of data in variables
item_name = "Banana"
item_price = 0.50
item_quantity = 100
in_stock = True

print("Item:", item_name)
print("Price: $", item_price)
print("Quantity:", item_quantity)
print("In stock:", in_stock)

Questo esempio mostra quanto sia facile **accedere e visualizzare i dati** una volta che sono memorizzati nelle variabili. Nota come ogni tipo di variabile (`string`, `float`, `integer`, `boolean`) abbia uno scopo specifico nella nostra analogia della spesa.

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


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)


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

    def test_item_name_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'item_name'),
            'item_name is declared',
            'Expected item_name to be defined.'
        )

    def test_item_name_correct(self):
        _dynamic_test(
            self,
            user_code.item_name == "Eggs",
            "item_name equals 'Eggs'",
            f"Expected item_name to equal 'Eggs', but got {user_code.item_name}."
        )

    def test_item_price_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'item_price'),
            'item_price is declared',
            'Expected item_price to be defined.'
        )

    def test_item_price_correct(self):
        _dynamic_test(
            self,
            user_code.item_price == 3.99,
            'item_price equals 3.99',
            f"Expected item_price to equal 3.99, but got {user_code.item_price}."
        )

    def test_item_stock_quantity_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'item_stock_quantity'),
            'item_stock_quantity is declared',
            'Expected item_stock_quantity to be defined.'
        )

    def test_item_stock_quantity_correct(self):
        _dynamic_test(
            self,
            user_code.item_stock_quantity == 120,
            'item_stock_quantity equals 120',
            f"Expected item_stock_quantity to equal 120, but got {user_code.item_stock_quantity}."
        )

    def test_in_stock_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'in_stock'),
            'in_stock is declared',
            'Expected in_stock to be defined.'
        )

    def test_in_stock_correct(self):
        _dynamic_test(
            self,
            user_code.in_stock is True,
            'in_stock equals True',
            f"Expected in_stock to equal True, but got {user_code.in_stock}."
        )


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?

Memorizzare Dati in Variabili

Soluzione