Summary  
This chapter covers the use of sets as unordered collections of unique elements, showing how to create them with curly braces or the set() function, how duplicates are automatically ignored, and why set elements must be immutable to avoid TypeErrors.

General domain of usage  
Data deduplication

In this video, you will explore Python sets—unordered collections of unique elements. Learn how sets differ from lists and tuples by enforcing uniqueness and being mutable, while only allowing immutable elements like numbers, strings, or tuples. Discover two main ways to create sets: using curly braces `{}` and the `set()` function. The video highlights key properties: sets remove duplicate entries automatically, their elements are unordered, and they can store diverse data types. See practical examples, such as creating sets from strings and lists, and understand why sets cannot contain mutable types like lists or dictionaries. The video also covers common mistakes, like passing multiple arguments to `set()`, and demonstrates the correct ways to initialize sets with real movie titles. By the end, you will have a clear understanding of how to define and use sets effectively in Python.
-- 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.

**Set** Pythonissa on **järjestämätön kokoelma yksilöllisiä alkioita**. Toisin kuin listat tai tuplet, setit **eivät salli päällekkäisiä alkioita**, mikä tekee niistä ihanteellisia esimerkiksi duplikaattien poistoon tai matemaattisiin joukko-operaatioihin. Setit ovat **muokattavia** (mutable), eli niiden alkioita voi lisätä tai poistaa, mutta **joukon sisällä olevien tietojen täytyy olla muuttumattomia** (esim. numerot, merkkijonot tai tuplet). Esimerkiksi settiä voi käyttää poistamaan päällekkäiset sähköpostiosoitteet käyttäjälistasta varmistaakseen, että jokainen osoite on yksilöllinen.

Set ei voi sisältää sanakirjoja tai listoja, koska molemmat ovat muokattavia tietotyyppejä.

Huomio

Pythonissa setin voi luoda kahdella pääasiallisella tavalla:
1. Käyttämällä aaltosulkeita `{}` ja erottamalla alkiot **pilkuilla**;
2. Käyttämällä `set()`-funktiota.

Tärkeimmät asiat seteistä:
 - **Muokattavuus:** settiin voi lisätä tai siitä voi poistaa alkioita, mutta setin sisällä olevien alkioiden täytyy olla muuttumattomia;
 - **Päällekkäiset alkiot:**
joukkoon lisätyt päällekkäiset alkiot poistetaan automaattisesti;
 - **Järjestämättömyys:**
alkioiden järjestys setissä ei ole taattu ja voi vaihdella;
 - **Monipuoliset tietotyypit:**
setit voivat sisältää eri tietotyyppejä, kuten **merkkijonoja**, **kokonaislukuja** tai **tupleja**.

Määritellään set käyttämällä `set()`-funktiota:

# Creating a set which contains strings
movie_set = set("Interstellar")
print(movie_set)

Seuraavaksi määritellään joukko suosittuja elokuvia käyttämällä aaltosulkeita:

# Creating a set of movies using curly braces
movies = {"Inception", "Interstellar", "Tenet", "Dunkirk", "Tenet"}
print(movies)

Kaksoiskappaleet, kuten `"Tenet"`, poistetaan automaattisesti, kun joukko luodaan.

### Rajoitukset joukkojen luomisessa
`set()`-funktion syntaksilla on tietyt vaatimukset. Jos yrität antaa useita argumentteja suoraan, esimerkiksi:
``` python
set("Tenet", "Dunkirk", "Inception")
```
Törmäät `TypeError`-virheeseen, koska `set()`-funktio odottaa **yhtä iteroitavaa** argumenttina, ei useita erillisiä arvoja.

Jos haluat luoda joukon, jossa on useita alkioita, sinun tulee antaa ne yhtenä iteroitavana:

# Using a list `[]`
movies = set(["Tenet", "Dunkirk", "Inception"])
print(movies)

# Using a tuple `(,)`
movies = set(("Tenet", "Dunkirk", "Inception"))
print(movies)

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

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

    def test_nolan_movies_contains_correct_values(self):
        import user_code
        expected_movies = {"Inception", "The Dark Knight", "Interstellar", "Tenet"}
        _dynamic_test(
            self,
            user_code.nolan_movies == expected_movies,
            f"The `nolan_movies` contains `{expected_movies}`.",
            f"Expected `nolan_movies` to contain `{expected_movies}`, but got `{user_code.nolan_movies}`."
        )

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.

Järjestämättömien Kokoelmien Määrittely

Rajoitukset joukkojen luomisessa

Ratkaisu