Summary
This chapter explains how to use Python’s membership operators, `in` and `not in`, to test whether a value or substring exists within an iterable (like a string, list, or tuple), returning a Boolean result.

General domain of usage
Grocery store product categorization

Questo capitolo tratta gli **operatori di appartenenza** in Python, che permettono di verificare se un elemento o una sottostringa esiste all'interno di strutture dati come stringhe, liste o tuple. Gli operatori di appartenenza sono fondamentali per la ricerca e il filtraggio dei dati.

Gli **operatori di appartenenza** in Python, `in` e `not in`, consentono di verificare se un valore è presente all'interno di un **oggetto iterabile**. Un oggetto iterabile è qualsiasi struttura dati su cui è possibile iterare, come una stringa, una lista o una tupla.

- Utilizzare `in` per verificare se un elemento è presente in un iterabile;
- Utilizzare `not in` per verificare se un elemento è assente da un iterabile.

Entrambi gli operatori restituiscono sempre un valore **booleano**: `True` se la condizione è soddisfatta, `False` in caso contrario.

Ad esempio, è possibile verificare se una sottostringa è presente in una stringa, o se un elemento si trova in una lista o tupla. Questo rappresenta un modo semplice e diretto per testare l'appartenenza in Python.

itemName = "Strawberries"
in_name = "Straw" in itemName
print("Is 'Straw' in 'Strawberries'?", in_name) 

## Applicazione di esempio

Immagina di gestire le **descrizioni dei prodotti** o le **categorie** nel sistema del tuo negozio di alimentari. Potresti ricevere una lunga stringa di dettagli sui prodotti e avere la necessità di **verificare rapidamente la presenza di parole chiave specifiche** per categorizzare o evidenziare i prodotti in base alle preferenze dei clienti o ad attività promozionali:


# Product description from supplier
product_description = "Fresh organic milk from local farms, pasteurized and homogenized."

# Check if the "organic" and "local" keywords are in the product description
is_organic = "organic" in product_description
is_local = "local" in product_description

# Print the presence of these keywords to decide on marketing strategies
print("Is the product organic?", is_organic)
print("Is the product locally sourced?", is_local)

import unittest
import importlib
import io
from contextlib import redirect_stdout
import re
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 TestProductMembershipOnly(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_contains_raw_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'contains_raw') and user_code.contains_raw is True,
            "contains_raw is True as 'raw' is in the description",
            f"Expected contains_raw to be True, got {getattr(user_code, 'contains_raw', None)}"
        )

    def test_contains_Imported_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'contains_Imported') and user_code.contains_Imported is True,
            "contains_Imported is True as 'Imported' is in the description",
            f"Expected contains_Imported to be True, got {getattr(user_code, 'contains_Imported', None)}"
        )

    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("Contains 'raw': True"),
            self.normalize_text("Contains 'Imported': True")
        ]
        for expected in expected_fragments:
            _dynamic_test(
                self,
                expected in output,
                f"Print output includes: {expected}",
                f"Expected output to include: '{expected}', but got: '{output}'"
            )

    def test_only_membership_variables(self):
        importlib.reload(user_code)
        forbidden_vars = [
            'price_is_float',
            'count_is_int'
        ]
        for var in forbidden_vars:
            _dynamic_test(
                self,
                not hasattr(user_code, var),
                f"Variable {var} is not present in user code",
                f"Variable {var} should not be present in user code"
            )

    def test_membership_operator_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            re.search(r'\\bin\\b', source),
            "Membership operator 'in' used for both 'raw' and 'Imported'",
            "Expected use of 'in' operator for 'raw' and 'Imported'"
        )

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.

Operator di appartenenza

Applicazione di esempio

Soluzione