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.

In Python zijn lijsten **mutabel**, wat betekent dat de inhoud van een lijst na het aanmaken kan worden aangepast, toegevoegd of verwijderd. Door deze mutabiliteit zijn lijsten zeer flexibel en een krachtig hulpmiddel voor het beheren van dynamische gegevens.

### Wat betekent "mutabel"?
Mutabel betekent dat de datastructuur kan worden bijgewerkt zonder een nieuw object te maken. Je kunt bijvoorbeeld de waarde van een bestaand item wijzigen, meerdere elementen vervangen of zelfs direct nieuwe elementen verwijderen en invoegen in dezelfde lijst.

Stel je hebt een lijst met steden die je van plan bent te bezoeken, maar de plannen veranderen. Je kunt eenvoudig items in de lijst bijwerken of vervangen:

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']

In dit voorbeeld:

1. De stad "New York" is op index 2 vervangen door "Rome";
2. Met behulp van negatieve indexering zijn de laatste twee steden ("Berlin" en "Sydney") vervangen door "Dubai" en "Cape Town".

Je kunt ook meerdere wijzigingen in één stap uitvoeren:

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']

Hier worden "Tokyo" en "New York" vervangen door drie steden: "Seoul", "Bangkok" en "Mumbai". Dit toont aan hoe flexibel de mutabiliteit van lijsten kan zijn voor het beheren van gegevens.

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

De bovenstaande code laat zien hoe numerieke waarden in een lijst kunnen worden bijgewerkt door specifieke elementen direct te wijzigen met behulp van indexering.

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

Verken de fundamentele datastructuren van de programmeertaal Python, waaronder lijsten, woordenboeken, tuples en sets, en ontdek hoe deze effectief kunnen worden toegepast om praktische programmeeruitdagingen op te lossen.

Wat is een lijst? Een lijst is een geordende collectie die kan worden aangepast. Het staat ook dubbele elementen toe.

Wat is een dictionary? Een dictionary is een geordende, wijzigbare collectie die geen dubbele items toestaat. Het bestaat uit sleutel:waarde-paren, die worden gebruikt om de structuur te optimaliseren.

Wat is een tuple? Een tuple is een geordende verzameling die niet kan worden gewijzigd. Een tuple kan dubbele elementen bevatten. Hoewel het lijkt op een lijst, kunnen de waarden in een tuple van elk type zijn en worden ze geïndexeerd door gehele getallen. Hoewel het niet verplicht is, is het gebruikelijk om de waarden van een tuple tussen haakjes te plaatsen, waardoor ze in Python gemakkelijker te begrijpen zijn.

Wat is een set? In Python is een set een ongeordende verzameling die zowel itereerbaar als muteerbaar is, zonder herhaalde elementen. Hoewel de volgorde van items in een set niet vastligt, kan deze verschillende elementen bevatten. Een belangrijk voordeel van het gebruik van sets ten opzichte van lijsten is de zeer efficiënte methode om te bepalen of een element zich in de set bevindt.

Lijsten Wijzigen

Wat betekent "mutabel"?

Oplossing