Summary  
This chapter explains how to access elements in an unordered set by checking membership with the in keyword and iterating through all elements with a for loop, since sets do not support indexing.

General domain of usage  
Organizing and querying a collection of movie titles.

Explore how to access elements in a Python set. Learn why sets are unordered collections, which means you cannot use indexes to retrieve elements like you would with lists or tuples. Discover how to check if an item exists in a set using the **in** keyword, and see how this returns a boolean value. Watch practical examples that show how to verify membership for specific items in a set. Finally, see how to process each element in a set by iterating with a **for** loop, noting that the order of iteration is unpredictable. This video uses real-world examples, such as checking for movie titles in a set, to demonstrate these essential set operations.
-- 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.

Koska joukot ovat **järjestämättömiä**, niiden alkioihin ei voi viitata indeksin avulla kuten listojen tai tuplien tapauksessa. Voit kuitenkin:

- Tarkistaa alkion olemassaolon käyttämällä `in`-avainsanaa;
- Käydä läpi joukon alkiot `for`-silmukalla.

### Jäsenyyden tarkistaminen `in`-avainsanalla
`in`-avainsanalla voit tarkistaa, löytyykö tietty alkio joukosta:

# 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

Tässä esimerkissä käytetään `in`-avainsanaa tarkistamaan, löytyvätkö tietyt elokuvat `movies`-joukosta, ja tallennetaan tulos totuusarvomuuttujiin `is_inception_present` ja `is_avatar_present`.

### Joukon läpikäynti `for`-silmukalla
Joukon alkiot voidaan käydä läpi `for`-silmukalla, jolloin jokaista alkiota käsitellään erikseen. Koska joukot ovat järjestämättömiä, läpikäynnin järjestys on ennalta-arvaamaton.


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

Jokainen joukon alkio käydään läpi kerran iteraation aikana.
Alkioiden järjestys tulosteessa voi vaihdella.

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

Tutustu Python-ohjelmointikielen keskeisiin tietorakenteisiin, kuten listoihin, sanakirjoihin, tuplisiin ja joukkoihin, sekä niiden tehokkaaseen hyödyntämiseen todellisten ohjelmointiongelmien ratkaisemisessa.

Mikä on lista? Lista on järjestetty kokoelma, jota voidaan muokata. Se sallii myös päällekkäiset alkiot.

Mikä on sanakirja? Sanakirja on järjestetty kokoelma, jota voidaan muokata, mutta se ei salli päällekkäisiä merkintöjä. Se koostuu avain:arvo-pareista, joita käytetään rakenteen optimointiin.

Mikä on tuple? Tuple on järjestetty kokoelma, jota ei voi muuttaa. Se voi sisältää päällekkäisiä alkioita. Vaikka se muistuttaa listaa, tuplen arvot voivat olla mitä tahansa tyyppiä ja ne indeksoidaan kokonaisluvuilla. Vaikka se ei ole pakollista, on tavallista sulkea tuplen arvot sulkuihin, mikä tekee niistä helpommin ymmärrettäviä Pythonissa.

Mikä on joukko? Pythonissa joukko on järjestämätön kokoelma, joka on iteroitava ja muokattavissa, eikä siinä ole toistuvia alkioita. Vaikka joukon alkioiden järjestys ei ole kiinteä, se voi sisältää erilaisia alkioita. Merkittävä etu joukkojen käyttämisessä listoihin verrattuna on niiden erittäin tehokas tapa selvittää, kuuluuko alkio joukkoon.

Joukon Alkioiden Käsitteleminen

Jäsenyyden tarkistaminen `in`-avainsanalla

Joukon läpikäynti `for`-silmukalla

Ratkaisu

Joukon Alkioiden Käsitteleminen

Jäsenyyden tarkistaminen in-avainsanalla

Joukon läpikäynti for-silmukalla

Ratkaisu

Jäsenyyden tarkistaminen `in`-avainsanalla

Joukon läpikäynti `for`-silmukalla