Summary  
This chapter explains how to use list methods—append to add items, remove to delete items, and sort to order elements—via dot notation to manipulate list data.  

General domain of usage  
Inventory management

## List Methods

Python provides **several methods** that you can use to **manipulate lists**. These methods make it **easy to modify**, search, and manage lists effectively. 

Let's explore some of the **most commonly used methods**:


- `append()`: **adds** an item to the end of the list;
- `remove()`: **removes** the first occurrence of an item from the list;
- `sort()`: **sorts** the items of the list in ascending (or descending) order.



To use **list methods** in Python, you must invoke them on a **list object** using **dot notation**. This involves appending the method name to the list name followed by parentheses, as shown here: `list_name.append("new element")`. 

Note


The next example will demonstrate **how to apply various list methods** using dot notation.

Imagine you need to update your store's inventory by **adding** new items and **removing** outdated ones. 

Here's how you can do it using list methods:

# Creating an inventory
inventory = ["carrots", "bananas", "apples"]

# Adding a new item
inventory.append("oranges")

# Removing an outdated item
inventory.remove("bananas")

# Sorting the inventory
inventory.sort()

# Checking the result
print("Updated inventory:", inventory)


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

class TestTask(unittest.TestCase):
    def setUp(self):
        self.module_name = "user_code"

    def test_apples_added(self):
        import user_code
        importlib.reload(user_code)
        inventory = getattr(user_code, 'inventory', None)
        _dynamic_test(
            self,
            isinstance(inventory, list) and "apples" in inventory,
            "'apples' was successfully added to the inventory.",
            f"'apples' was not found in the inventory: {inventory}",
        )

    def test_bread_removed(self):
        import user_code
        importlib.reload(user_code)
        inventory = getattr(user_code, 'inventory', None)
        _dynamic_test(
            self,
            isinstance(inventory, list) and "bread" not in inventory,
            "'bread' was successfully removed from the inventory.",
            f"'bread' was still found in the inventory: {inventory}",
        )

    def test_inventory_sorted(self):
        import user_code
        importlib.reload(user_code)
        inventory = getattr(user_code, 'inventory', None)
        expected = sorted(["milk", "eggs", "cheese", "apples"])
        expected.remove("bread") if "bread" in expected else None
        expected.append("apples") if "apples" not in expected else None
        expected = sorted(["milk", "eggs", "cheese", "apples"])
        _dynamic_test(
            self,
            isinstance(inventory, list) and inventory == sorted(inventory),
            "Inventory is sorted in alphabetical order.",
            f"Inventory is not sorted alphabetically: {inventory}",
        )

    def test_inventory_final_content(self):
        import user_code
        importlib.reload(user_code)
        inventory = getattr(user_code, 'inventory', None)
        expected = sorted(["milk", "eggs", "cheese", "apples"])
        _dynamic_test(
            self,
            isinstance(inventory, list) and inventory == expected,
            f"Inventory is correct: {expected}",
            f"Inventory does not match expected: {inventory} vs {expected}",
        )

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

List Methods

List Methods

解答