Summary  
Demonstrates using a set’s add() method to insert single elements into a set collection.

General domain of usage  
Managing a list of unique favorite movies.

Du kan også tilføje elementer til et set. Til dette formål findes der en specifik metode, `add()`. Det er vigtigt at bemærke, at du med denne metode kun kan tilføje **ét element** ad gangen. Hvis du for eksempel vil tilføje 4 elementer, skal du bruge denne metode 4 gange. Lad os se et eksempel.

# Creating an empty set
favorite_movies = set()
print("Initial set:", favorite_movies)  # Output - Initial set: set()

# Adding movies to the set
favorite_movies.add("Inception")
favorite_movies.add("Interstellar")
favorite_movies.add("Tenet")
favorite_movies.add("Dunkirk")

print("Updated set:", favorite_movies)  # Output - Updated set: {'Interstellar', 'Dunkirk', 'Inception', 'Tenet'}

Metoden `add()` egner sig bedst til at tilføje **enkeltstående** elementer.

import unittest
import importlib
import ast

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 AddCallVisitor(ast.NodeVisitor):
    def __init__(self):
        self.add_calls = 0
    def visit_Call(self, node):
        # Check for method calls: something.add(...)
        if isinstance(node.func, ast.Attribute):
            if node.func.attr == 'add':
                self.add_calls += 1
        self.generic_visit(node)

class TestUserCode(unittest.TestCase):
    def test_tarantino_movies_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'tarantino_movies'),
            "The `tarantino_movies` set is declared.",
            "Expected `tarantino_movies` to be declared."
        )

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

    def test_tarantino_movies_contains_initial_movies(self):
        import user_code
        initial_movies = {
            'Pulp Fiction',
            'Kill Bill: Vol. 1',
            'Kill Bill: Vol. 2',
            'Inglourious Basterds',
            'Django Unchained'
        }
        _dynamic_test(
            self,
            initial_movies.issubset(user_code.tarantino_movies),
            f"The `tarantino_movies` contains the initial movies: {initial_movies}.",
            f"Expected `tarantino_movies` to contain the initial movies: {initial_movies}, but got {user_code.tarantino_movies}."
        )

    def test_tarantino_movies_contains_new_movies(self):
        import user_code
        new_movies = {'Reservoir Dogs', 'Once Upon a Time in Hollywood'}
        _dynamic_test(
            self,
            new_movies.issubset(user_code.tarantino_movies),
            f"The `tarantino_movies` contains the newly added movies: {new_movies}.",
            f"Expected `tarantino_movies` to contain the newly added movies: {new_movies}, but got {user_code.tarantino_movies}."
        )

    def test_add_method_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        try:
            tree = ast.parse(user_code_source)
            visitor = AddCallVisitor()
            visitor.visit(tree)
            add_call_count = visitor.add_calls
        except Exception as e:
            _dynamic_test(
                self,
                False,
                "",
                f"Error during AST parsing: {e}"
            )
            return
        _dynamic_test(
            self,
            add_call_count >= 2,
            "The `add()` method is called at least twice to add new movies.",
            f"Expected the `add()` method to be called at least twice, but found only {add_call_count} call(s)."
        )

if __name__ == '__main__':
    unittest.main()


test_main.py

Udforsk de grundlæggende datastrukturer i programmeringssproget Python, herunder lister, ordbøger, tupler og mængder, og lær hvordan de anvendes effektivt til at løse virkelige programmeringsudfordringer.

Hvad er en liste? En liste er en ordnet samling, der kan ændres. Den tillader også duplikerede elementer.

Hvad er et dictionary? Et dictionary er en ordnet samling, der kan ændres, men ikke tillader dublerede elementer. Det består af nøgle:værdi-par, som bruges til at optimere dets struktur.

Hvad er et tuple? Et tuple er en ordnet samling, der ikke kan ændres. Det kan indeholde duplikerede elementer. Selvom det ligner en liste, kan værdierne i et tuple være af enhver type og er indekseret med heltal. Selvom det ikke er obligatorisk, er det almindeligt at omslutte værdierne i et tuple med parenteser, hvilket gør dem lettere at forstå i Python.

Hvad er et set? I Python er et set en uordnet samling, der både er itererbar og muterbar, uden gentagne elementer. Selvom rækkefølgen af elementer i et set ikke er fastlagt, kan det indeholde forskellige typer elementer. En vigtig fordel ved at bruge sets frem for lister er deres meget effektive metode til at afgøre, om et element findes i settet.

Tilføjelse af Enkelt Elementer til et Set

Tilføjelse af Enkelt Elementer til et Set

Løsning