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

Data structures are essential tools for organizing data, allowing for more efficient access depending on the specific needs of a program. They form the foundation of any programming language and are central to building functional and effective programs. In Python, the main data structures include **lists**, **tuples**, **dictionaries**, and **sets**, each offering unique features and capabilities.

### Understanding Python Lists
Python lists are **ordered collections** that are **mutable** and may contain elements of any data type. In Python, a list is created by putting the items inside square brackets. Here's an example:

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

print(city_info)

As shown, a list can contain a mix of different items or even be completely empty. Take a look at the following example:

```python
cities = []
```

To initialize an empty list, simply assign empty square brackets to a variable.

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 echte programmeeruitdagingen op te lossen.

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

Wat is een woordenboek? Een woordenboek is een geordende verzameling die kan worden gewijzigd, maar het staat geen dubbele invoer toe. 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. Het kan dubbele elementen bevatten. Hoewel het vergelijkbaar is met een lijst, kunnen de waarden in een tuple van elk type zijn en worden 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 gemakkelijker te begrijpen zijn in Python.

Wat is een set? In Python is een `set` een ongeordende verzameling die zowel `iterable` als `mutable` is, zonder herhaalde elementen. Hoewel de volgorde van items in een set niet vastligt, kan het een verscheidenheid aan elementen bevatten. Een belangrijk voordeel van het gebruik van sets boven lijsten is hun zeer efficiënte methode om te bepalen of een element binnen de set bestaat.

Creating Lists in Python: Declaring and Initializing Lists

Understanding Python Lists

Oplossing