Tuplas em

Sobre Tuplas

Uma tupla é uma coleção imutável de itens em sequência.

Como a maioria das coleções (veja os tipos embutidos list, dict e set), as tuples podem guardar qualquer tipo (ou vários tipos) de dado, incluindo outras tuples. Os elementos de uma tupla podem ser percorridos com a construção for item in <tuple>. Se você precisar tanto do índice quanto do valor do elemento, pode usar for index, item in enumerate(<tuple>).

Como qualquer sequência, os elementos dentro de tuples podem ser acessados por notação de colchetes, usando um número de índice com base em 0-based index a partir da esquerda ou um índice com base em -1-based index a partir da direita. As tuplas podem ser copiadas por completo ou em parte por meio da notação de fatiamento ou de <tuple>.copy(), e oferecem suporte a todas as operações comuns de sequência. Por serem imutáveis, as tuples não oferecem suporte a operações de sequência mutáveis.

As tuplas ocupam muito pouco espaço de memória em comparação com outros tipos de coleção e têm tempo de acesso constante (O(1)) ao usar um índice. No entanto, elas não podem ser redimensionadas, ordenadas ou alteradas depois de criadas, então são menos flexíveis quando mudanças ou atualizações frequentes nos dados são necessárias. Se atualizações ou expansões frequentes forem necessárias, uma list, uma collections.deque ou um array.array pode ser uma estrutura de dados melhor.

Construção de tuplas

As tuplas podem ser formadas de várias maneiras, usando o construtor da classe tuple ou a declaração (<element_1>, <element_2>) (literal de tuple).

Usando o construtor tuple() vazio ou com um iterável:

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

Strings são iteráveis, então usar um único str como argumento do construtor tuple() pode ter resultados surpreendentes:

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

Outros iteráveis também têm seus elementos adicionados um a um:

>>> 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 iteração padrão de um dict é sobre as chaves. Para incluir tanto chaves quanto valores em uma tupla criada a partir de um dicionário, use <dict>.items(), que retorna um 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'))

Declarando uma tupla como literal:

Como o construtor tuple() só aceita iteráveis (ou nada) como argumentos, é muito mais fácil criar uma tupla de um único elemento pelo método literal.

>>> no_elements = ()
()

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

Observe que, em geral, os parênteses não são obrigatórios para criar um literal de tuple, apenas as vírgulas. No entanto, usar (<element_1>, <element_2>) é considerado mais legível na maioria das situações. Os parênteses também são obrigatórios em casos de ambiguidade, como uma tupla vazia ou de um único item, ou quando uma função recebe uma 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)

Outras estruturas de dados podem ser incluídas como elementos de tuple, incluindo outras 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"))

As tuplas podem ser concatenadas usando o operador de soma +, que desempacota cada tuple, criando uma nova 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')

Acessando dados

Os elementos dentro de tuplas (como nos outros tipos de sequência str e list) podem ser acessados por notação de colchetes. Os índices podem ir da left --> right (começando em zero) ou da right --> left (começando em -1). As tuplas também podem ser copiadas por completo ou em parte por meio da notação de fatiamento ou de <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

Iteração sobre os elementos

É possível iterar sobre os elementos dentro de tuplas em um laço, usando a sintaxe for item in <tuple>. Se você precisar tanto dos índices quanto dos valores, pode 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.

Tuplas como informação homogênea

As tuplas são frequentemente usadas como registros que contêm dados organizacionalmente ou conceitualmente homogêneos e tratados como uma única unidade de informação, mesmo que os elementos individuais sejam de tipos de dados heterogêneos.

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

As tuplas também são usadas quando sequências homogêneas e imutáveis de dados são necessárias para hashability, para armazenamento em um set ou para a criação de chaves em um dicionário.

Observe que, embora as tuples sejam, na maioria dos casos, imutáveis, como podem conter qualquer estrutura de dados ou objeto, elas podem se tornar mutáveis se algum de seus elementos for um tipo mutável. Usar um tipo de dado mutável dentro de uma tuple torna a tuple que a contém não hashable.

>>> 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 estendidas e tipos de dados relacionados

As tuplas são frequentemente usadas como registros, mas os dados dentro delas só podem ser acessados por posição/índice. A classe namedtuple() do módulo collections estende a funcionalidade básica das tuplas para permitir o acesso aos elementos por nome. Além disso, é possível adaptar uma dataclass para oferecer uma funcionalidade semelhante de atributos nomeados, com alguns prós e contras.