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.

Um **set** em Python é uma **coleção não ordenada de elementos únicos**. Diferente de listas ou tuplas, sets **não permitem elementos duplicados**, tornando-os ideais para operações como remoção de duplicatas ou realização de operações matemáticas de conjuntos. Sets são **mutáveis**, ou seja, seus elementos podem ser adicionados ou removidos, mas os **dados dentro do set devem ser imutáveis** (por exemplo, números, strings ou tuplas). Por exemplo, sets podem ser usados para remover entradas duplicadas de uma lista de e-mails de usuários para garantir que cada e-mail seja único.

Um set não pode conter dicionários ou listas porque ambos são tipos de dados mutáveis.

Nota

Existem duas principais formas de criar um set em Python:
1. Usando chaves `{}` com elementos separados por **vírgulas**;
2. Usando a função `set()`.

Aqui estão alguns pontos importantes sobre sets:
 - **Eles são mutáveis:** é possível adicionar ou remover elementos de um set, mas o próprio set deve conter elementos imutáveis;
 - **Elementos Duplicados:**
se elementos duplicados forem adicionados a um set, eles são automaticamente removidos;
 - **Não Ordenados:**
a ordem dos elementos em um set não é garantida e pode variar;
 - **Diversos Tipos de Dados:**
sets podem conter elementos de diferentes tipos de dados, como **strings**, **inteiros** ou **tuplas**.

Vamos definir um set usando a função `set()`: 

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

Em seguida, definição de um conjunto de filmes populares usando chaves:

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

Entradas duplicadas como `"Tenet"` são removidas automaticamente quando o conjunto é criado.

### Limitações ao Criar Conjuntos
A sintaxe para criar um conjunto usando a função `set()` possui requisitos específicos. Se você tentar passar múltiplos argumentos diretamente, como:
``` python
set("Tenet", "Dunkirk", "Inception")
```
Você encontrará um `TypeError`, pois a função `set()` espera um **único iterável** como argumento, e não múltiplos valores separados.

Para criar um conjunto com múltiplos elementos, é necessário fornecê-los como um único iterável:

# 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

Explore as estruturas de dados fundamentais da linguagem de programação Python, incluindo listas, dicionários, tuplas e conjuntos, e aprenda como aplicá-las de forma eficaz para resolver desafios de programação do mundo real.

O que é uma lista? Uma lista é uma coleção ordenada que pode ser modificada. Ela também permite elementos duplicados.

O que é um dicionário? Um dicionário é uma coleção ordenada que pode ser modificada, mas não permite entradas duplicadas. Ele consiste em pares chave:valor, que são utilizados para otimizar sua estrutura.

O que é uma tupla? Uma tupla é uma coleção ordenada que não pode ser alterada. Ela pode conter elementos duplicados. Embora seja semelhante a uma lista, os valores em uma tupla podem ser de qualquer tipo e são indexados por inteiros. Embora não seja obrigatório, é comum envolver os valores de uma tupla entre parênteses, facilitando a compreensão em Python.

O que é um conjunto? Em Python, um conjunto é uma coleção não ordenada que é iterável e mutável, sem elementos repetidos. Embora a ordem dos itens em um conjunto não seja fixa, ele pode incluir uma variedade de elementos. Um benefício importante de usar conjuntos em vez de listas é o método altamente eficiente para determinar se um elemento existe dentro do conjunto.

Definindo Coleções Não Ordenadas

Limitações ao Criar Conjuntos

Solução