Tuple-ök ebben a kurzusban:

A(z) Tuple-ök fogalomról

A tuple elemek módosíthatatlan gyűjteménye, meghatározott sorrendben.

A legtöbb gyűjteményhez hasonlóan (lásd a beépített list, dict és set típust), a tuples bármilyen (vagy többféle) adattípust tárolhat, beleértve más tuples-öket is. A tuple elemein a for item in <tuple> szerkezettel lehet végigiterálni. Ha az elem indexére és értékére is szükség van, a for index, item in enumerate(<tuple>) használható.

Mint bármely szekvencia esetében, a tuples elemei is elérhetők zárójeles indexeléssel: balról egy 0-based index számmal, jobbról egy -1-based index számmal. A tuple-ök egészben vagy részben szeleteléssel vagy a <tuple>.copy() használatával másolhatók, és minden gyakori szekvenciaműveletet támogatnak. Mivel módosíthatatlanok, a tuples nem támogatják a módosítható szekvenciaműveleteket.

A tuple-ök nagyon kevés memóriát foglalnak más gyűjteménytípusokhoz képest, és index használatakor állandó (O(1)) elérési idejük van. Létrehozásuk után azonban nem méretezhetők át, nem rendezhetők és nem módosíthatók, ezért kevésbé rugalmasak, ha gyakran kell változtatni vagy frissíteni az adatokat. Ha gyakori frissítésre vagy bővítésre van szükség, egy list, collections.deque vagy array.array jobb adatszerkezet lehet.

A tuple létrehozása

A tuple-ök többféleképpen létrehozhatók: a tuple osztály konstruktorával vagy a (<element_1>, <element_2>) (tuple literál) deklarációval.

A tuple() konstruktor használata üresen vagy iterálható objektummal:

>>> no_elements = tuple()
()

# The constructor *requires* an iterable, so single elements must be passed in a list or another tuple.
>>> one_element = tuple([16])
(16,)

A stringek iterálhatók, ezért ha egyetlen str-t adunk a tuple() konstruktor argumentumaként, meglepő eredményt kaphatunk:

# String elements (characters) are iterated through and added to the tuple
>>> multiple_elements_string = tuple("Timbuktu")
('T', 'i', 'm', 'b', 'u', 'k', 't', 'u')

Más iterálható objektumok elemei is egyenként kerülnek be:

>>> multiple_elements_list = tuple(["Parrot", "Bird", 334782])
("Parrot", "Bird", 334782)

>>> multiple_elements_set = tuple({2, 3, 5, 7, 11})
(2,3,5,7,11)

A dict alapértelmezett iterációja a kulcsokon megy végig. Ha egy szótárból készített tuple-ben a kulcsokat és az értékeket is szeretnéd szerepeltetni, használd a <dict>.items() metódust, amely (key, value) tuples elemekből álló iterátort ad vissza.

>>> source_data = {"fish": "gold", "monkey": "brown"}

>>> multiple_elements_dict_1 = tuple(source_data)
('fish', 'monkey')

>>> multiple_elements_dict_2 = tuple(source_data.items())
(('fish', 'gold'), ('monkey', 'brown'))

Tuple deklarálása literálként:

Mivel a tuple() konstruktor argumentumként csak iterálható objektumokat fogad el (vagy semmit), egy egyelemű tuple-t sokkal könnyebb literál szintaxissal létrehozni.

>>> no_elements = ()
()

>>> one_element = ("Guava",)
("Guava",)

Vedd figyelembe, hogy egy tuple literál létrehozásához általában nem kellenek zárójelek, csak vesszők. A (<element_1>, <element_2>) forma használata azonban a legtöbb esetben olvashatóbbnak számít. Zárójelekre kétértelmű esetekben is szükség van, például üres vagy egyelemű tuple esetén, vagy amikor egy függvény argumentumként tuple-t vár.

>>> elements_separated_with_commas = "Parrot", "Bird", 334782
("Parrot", "Bird", 334782)

>>> elements_with_commas_and_parentheses = ("Triangle", 60, 60, 60)
("Triangle", 60, 60, 60)

Más adatszerkezetek is szerepelhetnek tuple elemekként, beleértve más tuple-öket is.

>>> nested_data_structures = ({"fish": "gold", "monkey": "brown", "parrot" : "grey"}, ("fish", "mammal", "bird"))
({"fish": "gold", "monkey": "brown", "parrot" : "grey"}, ("fish", "mammal", "bird"))

>>> nested_data_structures_1 = (["fish", "gold", "monkey", "brown", "parrot", "grey"], ("fish", "mammal", "bird"))
(["fish", "gold", "monkey", "brown", "parrot", "grey"], ("fish", "mammal", "bird"))

A tuple-ök a + operátorral fűzhetők össze, amely kibontja az egyes tuple-öket, és egy új, egyesített tuple-t hoz létre.

>>> new_via_concatenate = ("George", 5) + ("cat", "Tabby")
("George", 5, "cat", "Tabby")

#likewise, using the multiplication operator * is the equivalent of using + n times
>>> first_group = ("cat", "dog", "elephant")

>>> multiplied_group = first_group * 3
('cat', 'dog', 'elephant', 'cat', 'dog', 'elephant', 'cat', 'dog', 'elephant')

Az adatok elérése

A tuple-ök belsejében lévő elemek (a többi szekvenciatípushoz, például a str és a list típushoz hasonlóan) zárójeles indexeléssel érhetők el. Az indexek left --> right (nullától indulva) vagy right --> left (-1-től indulva) irányban haladhatnak. A tuple-ök egészben vagy részben szeleteléssel vagy a <tuple>.copy() használatával is másolhatók.

>>> student_info = ("Alyssa", "grade 3", "female", 8)

#name is at index 0 or index -4
>>> student_name = student_info[0]
Alyssa

>>> student_name = student_info[-4]
Alyssa

#age is at index 3 or index -1
>>> student_age_1 = student_info[3]
8

>>> student_age_2 = student_info[-1]
8

Iteráció az elemek fölött

A tuple-ök belsejében lévő elemeken egy ciklusban a for item in <tuple> szintaxissal lehet végigiterálni. Ha az indexekre és az értékekre is szükség van, a for index, item in enumerate(<tuple>) használható.

>>> student_info = ("Alyssa", "grade 3", "female", 8)
>>> for item in student_info:
...   print(item)
...
Alyssa
grade 3
female
8

>>> for index, item in enumerate(student_info):
...  print("Index is: " + str(index) + ", value is: " + str(item) + ".")
...
Index is: 0, value is: Alyssa.
Index is: 1, value is: grade 3.
Index is: 2, value is: female.
Index is: 3, value is: 8.

Tuple-ök homogén információként

A tuple-öket gyakran rekordként használják olyan adatok tárolására, amelyek szervezetileg vagy fogalmilag homogének, és egyetlen információs egységként kezelik őket, még akkor is, ha az egyes elemek heterogén adattípusúak.

>>> student_info = ("Alyssa", "grade 3", "female", 8)

A tuple-öket akkor is használják, amikor homogén, módosíthatatlan adatszekvenciákra van szükség a hashability miatt, set-ben való tároláshoz vagy szótár kulcsainak létrehozásához.

Vedd figyelembe, hogy bár a tuples a legtöbb esetben módosíthatatlan, mivel bármilyen adatszerkezetet vagy objektumot tartalmazhatnak, módosíthatóvá válhatnak, ha bármelyik elemük módosítható típusú. Ha egy tuple-ön belül módosítható adattípust használsz, az azt körülvevő tuple nem lesz hash-elhető.

>>> cmyk_color_map = {
        (.69, .3, .48, .1) : ("Teal 700", (59, 178, 146), 0x3BB292),
        (0, .5, 1, 0) : ("Pantone 151", (247, 127, 1), 0xF77F01),
        (.37, .89, 0, .44) : ("Pantone 267", (89, 16, 142), 0x59108E),
        (0, 1, .46, .45) : ("Pantone 228", (140, 0, 76), 0x8C004C)
    }

>>> unique_rgb_colors = {
        (59, 178, 146),
        (247, 127, 1),
        (89, 16, 142),
        (140, 0, 76),
        (76, 0, 140)
     }

>>> teal_700 = hash((59, 178, 146))

>>> teal_700 = hash(("Pantone 228", [(140, 0, 76), 0x8C004C]))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Kiterjesztett tuple-ök és kapcsolódó adattípusok

A tuple-öket gyakran rekordként használják, de a bennük lévő adatokhoz csak pozíció/index alapján lehet hozzáférni. A collections modul namedtuple() osztálya kiterjeszti a tuple alapfunkcionalitását, lehetővé téve az elemek név szerinti elérését. Ezenkívül a felhasználók egy dataclass segítségével is nyújthatnak hasonló, névvel elérhető attribútumfunkcionalitást, bizonyos előnyökkel és hátrányokkal.