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

## Metodi delle liste

Python offre **diversi metodi** che puoi utilizzare per **manipolare le liste**. Questi metodi rendono **semplice modificare**, cercare e gestire le liste in modo efficace.

Esploriamo alcuni dei **metodi più comunemente utilizzati**:


- `append()`: **aggiunge** un elemento alla fine della lista;
- `remove()`: **rimuove** la prima occorrenza di un elemento dalla lista;
- `sort()`: **ordina** gli elementi della lista in ordine crescente (o decrescente).



Per utilizzare i **metodi delle liste** in Python, è necessario invocarli su un **oggetto lista** utilizzando la **notazione a punto**. Questo comporta l'aggiunta del nome del metodo al nome della lista seguito da parentesi, come mostrato qui: `list_name.append("new element")`. 

Nota


Il prossimo esempio mostrerà **come applicare vari metodi delle liste** utilizzando la notazione a punto.

Immagina di dover aggiornare l'inventario del tuo negozio **aggiungendo** nuovi articoli e **rimuovendo** quelli obsoleti.

Ecco come puoi farlo utilizzando i metodi delle liste:

# 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 è 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 Liste

Metodi delle liste

Soluzione