Summary  
This chapter covers how to modify lists in Python by assigning new values to individual elements or ranges using indexing, slicing, and negative indices, demonstrating list mutability.

General domain of usage  
Travel itinerary management (e.g., updating a list of cities to visit)

In this video, you will explore the concept of list mutability in Python. Discover what it means for a list to be 'mutable'—that is, the ability to change, add, or remove elements after the list is created. You'll learn how to update list items by replacing single or multiple elements using indexing and slicing, including the use of negative indices to target items from the end of the list. The video demonstrates these concepts with practical examples, such as updating a list of cities by replacing specific cities or swapping out several at once. You'll also see how to update numerical values in a list, like adjusting daily temperatures, by directly modifying elements with indexing. By the end of this video, you'll understand how to confidently modify lists in Python, making your code more flexible and dynamic

-- video metadata (use this info when making a video) --

Cut all examples of code to a minimum. Show only the essential code. Show code no longer than 10 lines. Remove all possible pieces to demonstrate some code feature. You may show not full code that will not start, but still demonstrates some feature theoritacally.
If code is longer than 8 lines, move code output  blocks to second column.

I Python er lister **mutable** (foranderlige), hvilket betyder, at indholdet af en liste kan ændres, tilføjes eller fjernes efter oprettelsen. På grund af denne foranderlighed er lister meget fleksible og et kraftfuldt værktøj til håndtering af dynamiske data.

### Hvad betyder "mutable"?
Mutable betyder, at datastrukturen kan opdateres uden at oprette et nyt objekt. For eksempel kan værdien af et eksisterende element ændres, flere elementer kan udskiftes, eller nye kan indsættes og gamle fjernes direkte i den samme liste.

Forestil dig, at du har en liste over byer, du planlægger at besøge, men planerne ændrer sig. Du kan nemt opdatere eller udskifte elementer i listen:

cities = ["Paris", "Tokyo", "New York", "Berlin", "Sydney"]

# Replacing the third city
cities[2] = "Rome"
print(cities)  # Output: ['Paris', 'Tokyo', 'Rome', 'Berlin', 'Sydney']

# Replacing the last two cities with new ones
cities[-2:] = ["Dubai", "Cape Town"]
print(cities)  # Output: ['Paris', 'Tokyo', 'Rome', 'Dubai', 'Cape Town']

I dette eksempel:

1. Byen "New York" blev udskiftet på indeks 2 med "Rome";
2. Ved hjælp af negativ indeksering blev de to sidste byer ("Berlin" og "Sydney") udskiftet med "Dubai" og "Cape Town".

Du kan også foretage flere ændringer på én gang:

cities = ["Paris", "Tokyo", "New York", "Berlin", "Sydney"]

# Replacing multiple cities in the middle
cities[1:3] = ["Seoul", "Bangkok", "Mumbai"]

print(cities)  # Output: ['Paris', 'Seoul', 'Bangkok', 'Mumbai', 'Berlin', 'Sydney']

Her bliver "Tokyo" og "New York" erstattet med tre byer: "Seoul", "Bangkok" og "Mumbai". Dette demonstrerer, hvor fleksibel listemutabilitet kan være til håndtering af data.

# List of daily temperatures in degrees Celsius
temperatures = [22, 25, 19, 23, 27]

# Increasing the temperature on the second day by 2 degrees
temperatures[1] = temperatures[1] + 2
print(temperatures)  # Output: [22, 27, 19, 23, 27]

# Setting the last day's temperature to 30 degrees directly
temperatures[-1] = 30
print(temperatures)  # Output: [22, 27, 19, 23, 30]

Koden ovenfor demonstrerer, hvordan man opdaterer numeriske værdier, der er gemt i en liste, ved direkte at ændre specifikke elementer ved hjælp af indeksering.

import unittest
import importlib
from contextlib import redirect_stdout
import io

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)

class TestUserCode(unittest.TestCase):
    
    def test_travel_wishlist_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'travel_wishlist'),
            "The `travel_wishlist` list is declared.",
            "Expected `travel_wishlist` to be declared."
        )

    def test_discount_applied_correctly(self):
        import user_code
        expected_costs = [
            2000 * 0.8,
            3000 * 0.8,
            2500 * 0.8
        ]
        actual_costs = [city[2] for city in user_code.travel_wishlist]
        _dynamic_test(
            self,
            actual_costs == expected_costs,
            f"The travel costs are correctly discounted: {actual_costs}.",
            f"Expected travel costs after discount to be {expected_costs}, but got {actual_costs}."
        )

    def test_discount_using_indexing(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()

        _dynamic_test(
            self,
            '[2]' in user_code_source,
            "The discount is applied using indexing.",
            "Expected the discount to be applied using indexing."
        )

if __name__ == '__main__':
    unittest.main()


test_main.py

Udforsk de grundlæggende datastrukturer i programmeringssproget Python, herunder lister, ordbøger, tupler og mængder, og lær hvordan de anvendes effektivt til at løse virkelige programmeringsudfordringer.

Hvad er en liste? En liste er en ordnet samling, der kan ændres. Den tillader også duplikerede elementer.

Hvad er et dictionary? Et dictionary er en ordnet samling, der kan ændres, men ikke tillader dublerede elementer. Det består af nøgle:værdi-par, som bruges til at optimere dets struktur.

Hvad er et tuple? Et tuple er en ordnet samling, der ikke kan ændres. Det kan indeholde duplikerede elementer. Selvom det ligner en liste, kan værdierne i et tuple være af enhver type og er indekseret med heltal. Selvom det ikke er obligatorisk, er det almindeligt at omslutte værdierne i et tuple med parenteser, hvilket gør dem lettere at forstå i Python.

Hvad er et set? I Python er et set en uordnet samling, der både er itererbar og muterbar, uden gentagne elementer. Selvom rækkefølgen af elementer i et set ikke er fastlagt, kan det indeholde forskellige typer elementer. En vigtig fordel ved at bruge sets frem for lister er deres meget effektive metode til at afgøre, om et element findes i settet.

Ændring af Lister

Hvad betyder "mutable"?

Løsning