Summary  
This chapter covers how to use built-in tuple methods `count()` to determine how many times a value appears and `index()` to find the position of the first occurrence in an immutable sequence.

General domain of usage  
Retail inventory management

## Metodi delle tuple

Sebbene **le tuple non supportino metodi che ne modificano il contenuto**, offrono comunque alcuni metodi integrati utili per gestirle e utilizzarle in modo efficace. Ecco i due metodi integrati che puoi utilizzare con le tuple:

- `count()`: restituisce il numero di volte in cui un valore specificato appare nella tupla;
- `index()`: cerca nella tupla un valore specificato e restituisce la posizione dell'indice in cui è stato trovato per la prima volta.

Gli stessi metodi possono essere utilizzati anche con le **liste**.

Nota

# Example tuple containing a mix of integers and strings
fruits = ("apple", "banana", "cherry", "apple", "banana", "cherry", "apple")

# Use the `count()` method to determine how many times "apple" appears in the tuple
apple_count = fruits.count("apple")
print("Number of times 'apple' appears:", apple_count)

# Use the `index()` method to find the first occurrence of "cherry" in the tuple
cherry_index = fruits.index("cherry")
print("The first occurrence of 'cherry' is at index:", cherry_index)

Esaminiamo un altro esempio che mostra come utilizzare i metodi delle tuple in esercizi pratici.

# Tuple containing store departments
store_departments = ("Produce", "Deli", "Bakery", "Produce", "Seafood", "Deli", "Produce")

# Use count() to find how many times "Produce" appears
produce_count = store_departments.count("Produce")
print("'Produce' appears:", produce_count)

# Use index() to find the first index of "Seafood"
seafood_index = store_departments.index("Seafood")
print("The first occurrence of 'Seafood' is at index:", seafood_index)


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_count_produce(self):
        import user_code
        importlib.reload(user_code)
        produce_count = getattr(user_code, 'produce_count', None)
        _dynamic_test(
            self,
            produce_count == 3,
            "Correctly counted the number of 'Produce' departments (3)",
            f"Expected 3 occurrences of 'Produce', got {produce_count}"
        )

    def test_index_bakery(self):
        import user_code
        importlib.reload(user_code)
        bakery_index = getattr(user_code, 'first_bakery_index', None)
        _dynamic_test(
            self,
            bakery_index == 1,
            "Correctly found the first index of 'Bakery' (1)",
            f"Expected first 'Bakery' at index 1, got {bakery_index}"
        )

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 normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else 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.

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"?

Metodi delle Tuple

Metodi delle tuple

Soluzione