Summary  
This chapter covers how to declare and initialize Python lists as ordered, mutable collections that can hold elements of any type, including creating both prefilled and empty lists.

General domain of usage  
Data organization

Datastructuren zijn essentiële hulpmiddelen voor het organiseren van gegevens, waardoor efficiëntere toegang mogelijk is afhankelijk van de specifieke behoeften van een programma. Ze vormen de basis van elke programmeertaal en zijn centraal bij het bouwen van functionele en effectieve programma's. In Python behoren **lijsten**, **tuples**, **woordenboeken** en **sets** tot de belangrijkste datastructuren, elk met unieke eigenschappen en mogelijkheden.

### Inzicht in Python-lijsten
Python-lijsten zijn **geordende verzamelingen** die **mutabel** zijn en elementen van elk gegevenstype kunnen bevatten. In Python wordt een lijst aangemaakt door de items tussen vierkante haken te plaatsen. Hier is een voorbeeld:

# City name, population, area, is a major metropolitan
city_info = ["New York", 8419600, 468.9, True]

print(city_info)

Zoals te zien is, kan een lijst een mix van verschillende items bevatten of zelfs volledig leeg zijn. Bekijk het volgende voorbeeld:

```python
cities = []
```

Om een lege lijst te initialiseren, wijs je eenvoudig lege vierkante haken toe aan een variabele.

import unittest
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_travel_wishlist_is_list(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.travel_wishlist, list),
            "The `travel_wishlist` is of type `list`.",
            "Expected `travel_wishlist` to be of type `list`."
        )

    def test_travel_wishlist_correct_elements(self):
        import user_code
        expected_cities = {"London", "Tokyo", "Berlin"}
        actual_cities = set(user_code.travel_wishlist)
        _dynamic_test(
            self,
            actual_cities == expected_cities,
            "The `travel_wishlist` list contains the correct cities.",
            f"Expected `travel_wishlist` to contain {expected_cities}, but got {actual_cities}."
        )

    def test_travel_wishlist_has_exactly_three_elements(self):
        import user_code
        _dynamic_test(
            self,
            len(user_code.travel_wishlist) == 3,
            "The `travel_wishlist` list contains exactly 3 elements.",
            f"Expected `travel_wishlist` to have 3 elements, but got {len(user_code.travel_wishlist)}."
        )

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.

Lijsten Maken in Python: Declareren en Initialiseren van Lijsten

Inzicht in Python-lijsten

Oplossing