Summary  
This chapter explains how to verify membership in a set using the in keyword and how to iterate through all elements of an unordered set with a for loop.  

General domain of usage  
Managing a movie collection.

Omdat sets **ongeordend** zijn, kun je hun elementen niet op index benaderen zoals bij een lijst of tuple. Je kunt echter wel:

- Controleren of een element aanwezig is met het `in`-sleutelwoord;
- Door de elementen itereren met een `for`-lus.

### Lidmaatschap verifiëren met `in`
Het `in`-sleutelwoord maakt het mogelijk om te controleren of een specifiek element zich in een set bevindt:

# Define a set of favorite movies
movies = {"Inception", "Interstellar", "Tenet", "Dunkirk", "Memento"}

# Check if specific movies are in the set
is_inception_present = "Inception" in movies  # True
is_avatar_present = "Avatar" in movies        # False

# Print results
print(is_inception_present)  # Output: True
print(is_avatar_present)     # Output: False

In dit voorbeeld gebruiken we het `in`-sleutelwoord om te controleren of specifieke films aanwezig zijn in de set `movies` en slaan we het resultaat als een booleaanse waarde op in de variabelen `is_inception_present` en `is_avatar_present`.

### Itereren door een set met een `for`-lus
Je kunt door een set itereren met een `for`-lus om elk element afzonderlijk te verwerken. Omdat sets ongeordend zijn, is de iteratievolgorde onvoorspelbaar.


# Define a set of favorite movies
movies = {"Inception", "Interstellar", "Tenet", "Dunkirk", "Memento"}

# Iterate through the set and print each movie title
print("Movie collection:")
for movie in movies:
    print(movie)

Elk element in de set wordt één keer benaderd tijdens het itereren.
De volgorde van de elementen in de uitvoer kan variëren.

import unittest
import importlib
import re

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_movies_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'movies'),
            "The `movies` set is declared.",
            "Expected `movies` to be declared."
        )

    def test_movies_is_set(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.movies, set),
            "The `movies` is of type `set`.",
            "Expected `movies` to be of type `set`."
        )

    def test_is_first_movie_present_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'is_first_movie_present'),
            "The `is_first_movie_present` variable is declared.",
            "Expected `is_first_movie_present` to be declared."
        )

    def test_is_second_movie_present_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'is_second_movie_present'),
            "The `is_second_movie_present` variable is declared.",
            "Expected `is_second_movie_present` to be declared."
        )

    def test_is_third_movie_present_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'is_third_movie_present'),
            "The `is_third_movie_present` variable is declared.",
            "Expected `is_third_movie_present` to be declared."
        )

    def test_is_first_movie_present_correct(self):
        import user_code
        _dynamic_test(
            self,
            user_code.is_first_movie_present is True,
            "The `is_first_movie_present` is correctly set to `True`.",
            "Expected `is_first_movie_present` to be `True`, but got `False`."
        )

    def test_is_second_movie_present_correct(self):
        import user_code
        _dynamic_test(
            self,
            user_code.is_second_movie_present is False,
            "The `is_second_movie_present` is correctly set to `False`.",
            "Expected `is_second_movie_present` to be `False`, but got `True`."
        )

    def test_is_third_movie_present_correct(self):
        import user_code
        _dynamic_test(
            self,
            user_code.is_third_movie_present is True,
            "The `is_third_movie_present` is correctly set to `True`.",
            "Expected `is_third_movie_present` to be `True`, but got `False`."
        )

    def test_in_keyword_used_three_times(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        in_keyword_count = len(re.findall(r'in\s+movies', user_code_source))
        _dynamic_test(
            self,
            in_keyword_count == 3,
            "The `in` keyword is used exactly three times in the code.",
            f"Expected the `in` keyword to be used exactly three times, but found {in_keyword_count} occurrences."
        )

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.

Elementen in een Set Benaderen: Iteratie en Lidmaatschapstests

Lidmaatschap verifiëren met `in`

Itereren door een set met een `for`-lus

Oplossing

Elementen in een Set Benaderen: Iteratie en Lidmaatschapstests

Lidmaatschap verifiëren met in

Itereren door een set met een for-lus

Oplossing

Lidmaatschap verifiëren met `in`

Itereren door een set met een `for`-lus