Summary  
This chapter covers how to create immutable sequences in Python using tuples, including literal definitions (single-element, empty), and converting iterables or lists into tuples with the tuple() function.

General domain of usage  
Data organization

In Python is een tuple een datastructuur die bestaat uit een reeks waarden tussen haakjes, waarbij de elementen gescheiden zijn door komma's. Tuples lijken op lijsten, maar het belangrijkste verschil is dat tuples **onveranderlijke** datastructuren zijn.

**Onveranderlijke** datastructuren kunnen na creatie niet meer worden aangepast. Tuples kunnen, net als lijsten, elk aantal elementen bevatten en het gegevenstype van elk element kan verschillen. Het is belangrijk om te weten dat een tuple met slechts één element wordt gedefinieerd met een komma na het element, zoals hieronder weergegeven:

single_movie = ("Inception",)  # Single-element tuple
print(single_movie)

Zonder de komma zal Python de haakjes interpreteren als gewone groepering en niet als een tuple.

Opmerking

not_a_tuple = ("Inception")
print(type(not_a_tuple))

empty_tuple = ()
print(empty_tuple)
print(type(empty_tuple))

### Een tuple maken met de functie `tuple()`
De functie `tuple()` zet een iterable om in een tuple. Bijvoorbeeld, je kunt een string omzetten in een tuple van zijn karakters:

movie_title = tuple("Inception")
print(movie_title)

### Een tuple maken van een lijst
Je kunt de functie `tuple()` ook gebruiken om een tuple te maken van een lijst:

movie_list = ["Inception", "Interstellar", "Tenet"]
movies_tuple = tuple(movie_list)
print(movies_tuple)

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

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

    def test_movies_about_space_contains_correct_values(self):
        import user_code
        expected_movies = {
            '2001: A Space Odyssey',
            'Interstellar',
            'Star Wars: Episode IV - A New Hope',
            'Gravity',
            'The Martian'
        }
        _dynamic_test(
            self,
            set(user_code.space_movies) == expected_movies,
            "The `space_movies` contains the correct movie titles.",
            f"Expected `space_movies` to contain {expected_movies}, but got {set(user_code.space_movies)}."
        )

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

test_main.py

Ontdek de fundamentele datastructuren van de programmeertaal Python, waaronder lijsten, woordenboeken, tuples en sets, en leer hoe u deze effectief kunt toepassen om programmeeruitdagingen uit de praktijk op te lossen.

Wat is een lijst? Een lijst is een geordende collectie die kan worden aangepast. Het staat ook dubbele elementen toe.

Wat is een dictionary? Een dictionary is een geordende, wijzigbare collectie die geen dubbele items toestaat. Het bestaat uit key:value-paren, die worden gebruikt om de structuur te optimaliseren.

Wat is een tuple? Een tuple is een geordende verzameling die niet kan worden gewijzigd. Een tuple kan dubbele elementen bevatten. Hoewel het lijkt op een lijst, kunnen de waarden in een tuple van elk type zijn en worden ze geïndexeerd door gehele getallen. Hoewel het niet verplicht is, is het gebruikelijk om de waarden van een tuple tussen haakjes te plaatsen, wat het in Python overzichtelijker maakt.

Wat is een set? In Python is een set een ongeordende verzameling die zowel itereerbaar als muteerbaar is, zonder herhaalde elementen. Hoewel de volgorde van items in een set niet vastligt, kan deze verschillende elementen bevatten. Een belangrijk voordeel van het gebruik van sets ten opzichte van lijsten is de zeer efficiënte methode om te bepalen of een element zich in de set bevindt.

Een Tuple Maken in Python: Het Definiëren van Onveranderlijke Datastructuren

Een lege tuple maken

Een tuple maken met de functie `tuple()`

Een tuple maken van een lijst

Oplossing

Een Tuple Maken in Python: Het Definiëren van Onveranderlijke Datastructuren

Een lege tuple maken

Een tuple maken met de functie tuple()

Een tuple maken van een lijst

Oplossing

Een tuple maken met de functie `tuple()`