Tuplas en

Acerca de Tuplas

Una tupla es una colección inmutable de elementos en secuencia.

Como la mayoría de las colecciones (mira los tipos integrados list, dict y set), las tuples pueden contener cualquier tipo (o varios tipos) de datos, incluidos otros tuples. Los elementos de una tupla se pueden recorrer con la construcción for item in <tuple>. Si necesitas tanto el índice como el valor del elemento, puedes usar for index, item in enumerate(<tuple>).

Como en cualquier secuencia, se puede acceder a los elementos de las tuples con notación de corchetes, usando un 0-based index desde la izquierda o un -1-based index desde la derecha. Las tuplas se pueden copiar total o parcialmente con notación de rebanadas o <tuple>.copy(), y admiten todas las operaciones comunes de secuencia. Como son inmutables, las tuples no admiten las operaciones de secuencia mutables.

Las tuplas ocupan muy poco espacio en memoria en comparación con otros tipos de colecciones y tienen un tiempo de acceso constante (O(1)) cuando se usa un índice. Sin embargo, no se pueden redimensionar, ordenar ni modificar una vez creadas, así que son menos flexibles cuando se necesitan cambios o actualizaciones frecuentes de los datos. Si se requieren actualizaciones o ampliaciones frecuentes, una list, un collections.deque o un array.array podrían ser una mejor estructura de datos.

Construcción de tuplas

Las tuplas se pueden formar de varias maneras, ya sea con el constructor de la clase tuple o con la declaración (<element_1>, <element_2>) (literal de tuple).

Usar el constructor tuple() vacío o con un iterable:

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

Los strings son iterables, así que usar un solo str como argumento del constructor tuple() puede dar resultados sorprendentes:

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

Otros iterables también van agregando sus elementos uno por uno:

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

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

La iteración predeterminada de dict es sobre las claves. Para incluir tanto las claves como los valores en una tupla creada a partir de un diccionario, usa <dict>.items(), que devuelve un iterador de tuples (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'))

Declarar una tupla como literal:

Como el constructor tuple() solo acepta iterables (o nada) como argumentos, es mucho más fácil crear una tupla de un solo elemento con el método literal.

>>> no_elements = ()
()

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

Ten en cuenta que, en general, los paréntesis no son obligatorios para crear un literal de tuple, solo las comas. Sin embargo, usar (<element_1>, <element_2>) se considera más legible en la mayoría de los casos. Los paréntesis también son obligatorios en casos de ambigüedad, como una tupla vacía o de un solo elemento, o cuando una función recibe una tupla como argumento.

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

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

Se pueden incluir otras estructuras de datos como elementos de una tuple, incluidas otras 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"))

Las tuplas se pueden concatenar con el operador más +, que desempaqueta cada tuple y crea una nueva tuple combinada.

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

Acceso a los datos

Se puede acceder a los elementos dentro de las tuplas (al igual que en los otros tipos de secuencia str y list) con notación de corchetes. Los índices pueden ir de left --> right (empezando en cero) o de right --> left (empezando en -1). Las tuplas también se pueden copiar total o parcialmente con notación de rebanadas o usando <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

Iteración sobre los elementos

Se puede iterar sobre los elementos dentro de las tuplas en un bucle con la sintaxis for item in <tuple>. Si necesitas tanto los índices como los valores, puedes usar 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.

Las tuplas como información homogénea

Las tuplas se usan a menudo como registros que contienen datos organizativa o conceptualmente homogéneos y que se tratan como una sola unidad de información, aunque los elementos individuales sean de tipos de datos heterogéneos.

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

Las tuplas también se usan cuando se necesitan secuencias inmutables y homogéneas de datos para la hashability, el almacenamiento en un set o la creación de claves en un diccionario.

Ten en cuenta que, aunque las tuples son inmutables en la mayoría de los casos, como pueden contener cualquier estructura de datos u objeto, pueden volverse mutables si alguno de sus elementos es de un tipo mutable. Usar un tipo de datos mutable dentro de una tuple hace que la tuple que lo contiene no se pueda usar como hash.

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

Tuplas extendidas y tipos de datos relacionados

Las tuplas se usan a menudo como registros, pero solo se puede acceder a los datos que contienen por posición o índice. La clase namedtuple() del módulo collections amplía la funcionalidad básica de las tuplas para permitir el acceso a los elementos por nombre. Además, puedes adaptar una dataclass para obtener una funcionalidad similar de atributos con nombre, con sus ventajas y desventajas.