Summary  
This chapter covers Python lists as ordered, mutable collections, demonstrating how to create, index, and manipulate them using methods like append, remove, and sort.

General domain of usage  
Inventory management (e.g., managing grocery store items)

Welcome to the exciting world of Python **lists**! In this chapter, we dive into how lists serve as a versatile tool for **managing collections of items**, essential for scenarios like organizing product inventories in a grocery store. Through practical applications and video demonstrations, you'll learn to **create**, **manipulate**, and **apply list methods** effectively.

Watch as Alex demonstrates how to create and manipulate lists in our grocery store case.


## Fundamentals of Lists 

Lists in Python are **highly flexible**, capable of storing a diverse range of objects, including numbers, strings, and even other lists. 

Here's how they work: 

### Creation 
Lists can be created by enclosing **comma-separated values** in square brackets `[]`. You can also convert iterable objects (like strings, sets, tuples) into lists using the `list()` constructor.

### Ordering
The elements in a list maintain a **specific order**, which does not change unless explicitly modified using list methods (more on list methods later!).

### Mutability (Changeability)
Lists are changeable, allowing you to **add**, **remove**, or **alter** elements after the list has been created.

### Allowing Duplicates
Since each element in a list is **indexed**, the same value can appear multiple times at different positions.

## Examples

Here's a simple example of a list containing different types of grocery items:

# A list showcasing various grocery categories
grocery_items = ["milk", "eggs", "cheese", "butter"]
print(grocery_items)

Similar to **string indexing**, elements inside of a list can also be accessed using index numbers:

Lists also have some **flexibility** since they are not restricted to a single data type. You can store a combination of different types of data within the same list. You can even store lists within a list:


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

class TestTask(unittest.TestCase):
    def test_fruits_list_exists_and_correct(self):
        import user_code
        importlib.reload(user_code)
        fruits = getattr(user_code, 'fruits', None)
        expected = ['apple', 'banana', 'cherry']
        _dynamic_test(
            self,
            isinstance(fruits, list) and fruits == expected,
            "'fruits' list exists and contains the correct elements in the right order",
            f"Expected 'fruits' to be {expected}, got {fruits}"
        )

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

Lists

Fundamentals of Lists

Creation

Ordering

Mutability (Changeability)

Allowing Duplicates

Examples

解答