Кортежі у

Про концепцію Кортежі

Кортеж - це незмінна колекція елементів у послідовності.

Як і більшість колекцій (див. вбудовані list, dict і set), tuples можуть містити будь-які (або кілька) типи даних, зокрема інші tuples. Елементи кортежу можна перебирати за допомогою конструкції for item in <tuple>. Якщо потрібні й індекс елемента, і його значення, можна скористатися конструкцією for index, item in enumerate(<tuple>).

Як і в будь-якій послідовності, до елементів усередині tuples можна звертатися через запис у дужках, використовуючи 0-based index з лівого боку або -1-based index з правого боку. Кортежі можна копіювати повністю або частково за допомогою зрізу або <tuple>.copy(), і вони підтримують усі звичайні операції над послідовностями. Оскільки кортежі незмінні, вони не підтримують операції над змінними послідовностями.

Порівняно з іншими типами колекцій кортежі займають дуже мало памʼяті, а доступ за індексом триває сталий час (O(1)). Однак після створення їх не можна змінити в розмірі, посортувати чи якось перетворити, тож вони менш гнучкі, коли дані треба часто змінювати чи оновлювати. Якщо потрібні часті оновлення чи розширення, кращою структурою даних можуть бути list, collections.deque або array.array.

Створення кортежів

Кортежі можна утворювати різними способами: або через конструктор класу tuple, або через оголошення (<element_1>, <element_2>) (літерал tuple).

Використання конструктора tuple() без аргументів або з ітерованим обʼєктом:

>>> 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,)

Рядки тексту (англ. string) є ітерованими, тож використання одного str як аргументу конструктора tuple() може дати несподіваний результат:

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

В інших ітерованих обʼєктах елементи так само додаються по одному:

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

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

Типово ітерація для dict відбувається за ключами. Щоб кортеж, створений зі словника, містив і ключі, і значення, можна скористатися <dict>.items(), який повертає ітератор із кортежів (key, value).

>>> 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() приймає як аргументи лише ітеровані обʼєкти (або нічого), кортеж з одного елемента набагато простіше створити через літерал.

>>> no_elements = ()
()

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

Зауважимо, що загалом для створення літерала tuple круглі дужки не потрібні, достатньо лише ком. Однак запис (<element_1>, <element_2>) у більшості випадків вважається зрозумілішим. Дужки також потрібні в неоднозначних випадках, наприклад для порожнього кортежу, кортежу з одного елемента або коли функція приймає кортеж як аргумент.

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

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

Елементами tuple можуть бути й інші структури даних, зокрема інші tuples.

>>> 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"))

Кортежі можна зʼєднувати за допомогою оператора +, який розпаковує кожен кортеж і створює новий, обʼєднаний кортеж.

>>> 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')

Доступ до даних

До елементів усередині кортежів (як і в інших типах послідовностей, str і list) можна звертатися через запис у дужках. Індекси можуть іти від left --> right (починаючи з нуля) або від right --> left (починаючи з -1). Кортежі також можна копіювати повністю або частково через зріз або за допомогою <tuple>.copy().

>>> 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

Перебір елементів

Елементи всередині кортежів можна перебирати в циклі за допомогою синтаксису for item in <tuple>. Якщо потрібні й індекси, і значення, можна скористатися for index, item in enumerate(<tuple>).

>>> 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.

Кортежі як однорідна інформація

Кортежі часто використовують як записи, які містять організаційно або концептуально однорідні дані й розглядаються як єдина одиниця інформації, навіть якщо окремі елементи мають різнорідні типи даних.

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

Кортежі також використовують, коли потрібні однорідні незмінні послідовності даних для hashability, зберігання в set або створення ключів у словнику.

Зауважимо: хоч tuples у більшості випадків і незмінні, оскільки вони можуть містити будь-яку структуру даних чи обʼєкт, вони можуть стати змінними, якщо хоч один їхній елемент має змінний тип. Якщо використати змінний тип даних усередині tuple, то сам tuple, що його містить, стане нехешованим.

>>> 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'

Розширені кортежі та споріднені типи даних

Кортежі часто використовують як записи, але до даних усередині них можна дістатися лише за позицією/індексом. Клас namedtuple() із модуля collections розширює базову функціональність кортежів, дозволяючи звертатися до елементів за назвою. Крім того, можна пристосувати dataclass, щоб отримати схожу функціональність іменованих атрибутів, хоча в неї є свої переваги й недоліки.