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

## Tuple Methods

While **tuples do not support methods that alter their content**, they still provide a few built-in methods to help manage and utilize them effectively. Here are the two built-in methods you can use with tuples:

- `count()`: returns the number of times a specified value appears in the tuple;
- `index()`: searches the tuple for a specified value and returns the index position of where it was first found.

The same methods can also be used with **lists**.

Note

# 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)

Let's look on another example, that demonstrates how to use tuple methods on the hands on tasks.

# 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 is a high-level, interpreted, general-purpose programming
language. Distinguished from languages such as HTML, CSS, and JavaScript, which are mainly
utilized in web development, Python boasts versatility across multiple domains, including
software development, data science, and back-end development. This course will guide you
through Python's fundamental concepts, equipping you with the skills to create your own
functions by the conclusion of the program.

In this section, you will explore the fundamentals of Python, get acquainted
with your workspace, perform simple math operations, and display your findings.

In this section, you'll discover how to save items such as numbers and text
in computer memory and retrieve them by name. Additionally, you'll gain an introduction to text
manipulation in Python.

In this section, you'll explore the boolean data type and learn how it is used
to develop programs that react to certain conditions.

In this section, you will continue learning about data types and discover
how to organize various attributes in a single variable using lists, tuples, and dictionaries.

In this section, you'll learn how to create loops in Python — an essential skill
for iterating through lists, tuples, and dictionaries.

To conclude this introductory course, you will explore some built-in
functions and then begin to develop your own!

How can you access the third element in this list?

How would you change "green" to "yellow"?

Tuple Methods

Tuple Methods

解答