Summary  
Techniques for adding elements to an immutable tuple by converting it to a list and back or by concatenating it with another tuple.

General domain of usage  
Managing and transforming collections in code

För att lägga till element i en tuple kan du använda samma metod som är effektiv för borttagning. Eftersom tuples är oföränderliga kan vi inte direkt lägga till ett element utan att få ett felmeddelande. Det finns dock lösningar för att lägga till nya element i en tuple.

# Original tuple of movies
movies = ("Inception", "Interstellar", "Tenet")

# Convert the tuple to a list
movies_list = list(movies)

# Add a new movie to the list
movies_list.append("Dunkirk")

# Convert the list back to a tuple
movies = tuple(movies_list)

print("After:", movies)

Ett annat sätt att lägga till ett element i en tuple är genom att sammanfoga den med en annan tuple. Detta har vi tittat på i några tidigare kapitel. Om du vill lägga till ett eller flera element, skapa helt enkelt en ny tuple med dessa element och kombinera den med den ursprungliga tuplen.

# Original tuple of movies
movies = ("Inception", "Interstellar", "Tenet")

# Create a new tuple with the movie to add
new_movies = ("Dunkirk",)

# Concatenate the tuples
movies += new_movies

print(movies)

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

    def test_animal_movies_is_tuple(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.animal_movies, tuple),
            "The `animal_movies` is of type `tuple`.",
            "Expected `animal_movies` to be of type `tuple`."
        )

    def test_animal_movies_contains_correct_values(self):
        import user_code
        expected_values = ('The Lion King', 'Jurassic Park', 'Finding Nemo', 'Dumbo', 'Zootopia')
        _dynamic_test(
            self,
            user_code.animal_movies == expected_values,
            f"The `animal_movies` contains `{expected_values}`.",
            f"Expected `animal_movies` to contain `{expected_values}`, but got `{user_code.animal_movies}`."
        )

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

test_main.py

Utforska de grundläggande datastrukturerna i programmeringsspråket Python, inklusive listor, ordböcker, tupler och mängder, och lär dig hur dessa kan tillämpas effektivt för att lösa verkliga programmeringsproblem.

Vad är en lista? En lista är en ordnad samling som kan modifieras. Den tillåter även dubbletter av element.

Vad är ett dictionary? Ett dictionary är en ordnad samling som kan ändras, men tillåter inte dubbletter. Det består av nyckel:värde-par, vilka används för att optimera dess struktur.

Vad är en tuple? En tuple är en ordnad samling som inte kan ändras. Den kan innehålla dubbletter. Även om den liknar en lista kan värdena i en tuple vara av vilken typ som helst och indexeras med heltal. Det är vanligt, men inte obligatoriskt, att omsluta tuple-värden med parenteser för att göra dem lättare att förstå i Python.

Vad är en mängd? I Python är en mängd en oordnad samling som är både itererbar och muterbar, utan upprepade element. Även om ordningen på objekten i en mängd inte är fast, kan den innehålla olika typer av element. En viktig fördel med att använda mängder istället för listor är deras mycket effektiva metod för att avgöra om ett element finns i mängden.

Lägga till Objekt i en Tuple: Alternativa Metoder med Listor

Lösning