Summary  
This chapter explains how to use the append() method to dynamically add elements to the end of a list.  

General domain of usage  
Building or growing lists of data in iterative processes.

De `append()`-methode in Python wordt gebruikt om een element aan het einde van een lijst toe te voegen. Dit is een handige manier om een lijst dynamisch uit te breiden zonder een nieuwe lijst te hoeven maken.

Stel je voor dat je een lijst hebt met steden die je wilt bezoeken. Je hebt er al een paar opgeschreven, maar naarmate je plannen veranderen, wil je meer steden toevoegen zonder de bestaande te vervangen.
```python
travel_wishlist = ["Paris", "Tokyo", "New York", "Rome"]
```
De lijst bevat momenteel **vier** steden. Stel dat je nu nog een stad wilt toevoegen, bijvoorbeeld "Sydney".
Hier zie je hoe dat kan:

travel_wishlist = ['Paris', 'Tokyo', 'New York', 'Rome']

# Adding a new city to the travel wishlist
travel_wishlist.append("Sydney")

print(travel_wishlist) # Output: ['Paris', 'Tokyo', 'New York', 'Rome', 'Sydney']

Zoals je ziet, is "Sydney" aan het einde van de lijst toegevoegd zonder de bestaande items te beïnvloeden.

- De lijst groeit **met één element** elke keer dat je `append()` gebruikt;
- Je kunt niet alleen strings toevoegen, maar ook **variabelen**, **getallen** of zelfs andere **lijsten**;
- Dezelfde logica geldt voor **integers**, **floats** of elk ander **object**.

Opmerking

Met de methode `append()` kun je efficiënt je lijst bijwerken zonder deze opnieuw te maken. Deze methode is bovendien bijzonder praktisch in `for`-lussen, waarbij je een lijst dynamisch kunt opbouwen of uitbreiden door elementen iteratief toe te voegen op basis van voorwaarden of berekeningen.

import unittest
from contextlib import redirect_stdout
import io
import importlib

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_cities_added_to_list(self):
        import user_code
        expected_cities = ['Paris', 'Tokyo', 'Berlin', 'New York']
        _dynamic_test(
            self,
            user_code.travel_wishlist == expected_cities,
            f"The cities were added correctly to the list: {user_code.travel_wishlist}.",
            f"Expected travel_wishlist to be {expected_cities}, but got {user_code.travel_wishlist}."
        )

    def test_append_method_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        
        _dynamic_test(
            self,
            ".append(" in user_code_source,
            "The `append` method is used to add cities.",
            "Expected the `append` method to be used to add cities."
        )

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


test_main.py

Ontdek de fundamentele datastructuren van de programmeertaal Python, waaronder lijsten, woordenboeken, tuples en sets, en leer hoe u deze effectief kunt toepassen om programmeeruitdagingen uit de praktijk 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 key:value-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, wat het in Python overzichtelijker maakt.

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.

De Append()-Methode Gebruiken: Elementen aan Lijsten Toevoegen

Oplossing