freeCodeCamp/guide/portuguese/python/data-structures/tuples/index.md

title	localeTitle
The Tuples	As tuplas

As tuplas

Uma tupla é uma sequência de objetos Python. As tuplas são imutáveis, o que significa que não podem ser modificadas após a criação, ao contrário das listas.

Criação:

Uma tuple vazia é criada usando um par de parênteses, () :

    >>> empty_tuple = () 
    >>> print(empty_tuple) 
    () 
    >>> type(empty_tuple) 
    <class 'tuple'> 
    >>> len(empty_tuple) 
    0 

Uma tuple com elementos é criada ao separar os elementos com vírgulas (os parêntesis circundantes, () são opcionais com exceções):

    >>> tuple_1 = 1, 2, 3       # Create tuple without round brackets. 
    >>> print(tuple_1) 
    (1, 2, 3) 
    >>> type(tuple_1) 
    <class 'tuple'> 
    >>> len(tuple_1) 
    3 
    >>> tuple_2 = (1, 2, 3)     # Create tuple with round brackets. 
    >>> print(tuple_2) 
    (1, 2, 3) 
    >>> tuple_3 = 1, 2, 3,      # Trailing comma is optional. 
    >>> print(tuple_3) 
    (1, 2, 3) 
    >>> tuple_4 = (1, 2, 3,)    # Trailing comma in round brackets is also optional. 
    >>> print(tuple_4) 
    (1, 2, 3) 

Uma tuple com um único elemento deve ter a vírgula final (com ou sem colchetes):

    >>> not_tuple = (2)    # No trailing comma makes this not a tuple. 
    >>> print(not_tuple) 
    2 
    >>> type(not_tuple) 
    <class 'int'> 
    >>> a_tuple = (2,)     # Single element tuple. Requires trailing comma. 
    >>> print(a_tuple) 
    (2,) 
    >>> type(a_tuple) 
    <class 'tuple'> 
    >>> len(a_tuple) 
    1 
    >>> also_tuple = 2,    # Round brackets omitted. Requires trailing comma. 
    >>> print(also_tuple) 
    (2,) 
    >>> type(also_tuple) 
    <class 'tuple'> 

Colchetes são necessários em casos de ambigüidade (se a tupla fizer parte de uma expressão maior):

Note que na verdade é a vírgula que faz uma tupla, não os parênteses. Os parênteses são opcionais, exceto no caso da tupla vazia, ou quando são necessários para evitar ambigüidade sintática. Por exemplo, f(a, b, c) é uma chamada de função com três argumentos, enquanto f((a, b, c)) é uma chamada de função com uma 3-tupla como o único argumento.

    >>> print(1,2,3,4,)          # Calls print with 4 arguments: 1, 2, 3, and 4 
    1 2 3 4 
    >>> print((1,2,3,4,))        # Calls print with 1 argument: (1, 2, 3, 4,) 
    (1, 2, 3, 4) 
    >>> 1, 2, 3 == (1, 2, 3)     # Equivalent to 1, 2, (3 == (1, 2, 3)) 
    (1, 2, False) 
    >>> (1, 2, 3) == (1, 2, 3)   # Use surrounding round brackets when ambiguous. 
    True 

Uma tuple também pode ser criada com o construtor da tuple :

    >>> empty_tuple = tuple() 
    >>> print(empty_tuple) 
    () 
    >>> tuple_from_list = tuple([1,2,3,4]) 
    >>> print(tuple_from_list) 
    (1, 2, 3, 4) 
    >>> tuple_from_string = tuple("Hello campers!") 
    >>> print(tuple_from_string) 
    ('H', 'e', 'l', 'l', 'o', ' ', 'c', 'a', 'm', 'p', 'e', 'r', 's', '!') 
    >>> a_tuple = 1, 2, 3 
    >>> b_tuple = tuple(a_tuple)    # If the constructor is called with a tuple for 
    the iterable, 
    >>> a_tuple is b_tuple          # the tuple argument is returned. 
    True 

Acessando elementos de uma tuple :

Elementos de tuples são acessados ​​e indexados da mesma maneira que as lists .

    >>> my_tuple = 1, 2, 9, 16, 25 
    >>> print(my_tuple) 
    (1, 2, 9, 16, 25) 

Zero indexado

    >>> my_tuple[0] 
    1 
    >>> my_tuple[1] 
    2 
    >>> my_tuple[2] 
    9 

Envolva a indexação

    >>> my_tuple[-1] 
    25 
    >>> my_tuple[-2] 
    16 

Embalagem e Desembalagem:

A declaração t = 12345, 54321, 'hello!' é um exemplo de empacotamento de tupla: os valores 12345 , 54321 e 'hello!' são embalados juntos em uma tupla. A operação inversa também é possível:

    >>> x, y, z = t 

Isso é chamado, apropriadamente, de descompactação de seqüência e funciona para qualquer sequência do lado direito. A descompactação de sequências requer que haja tantas variáveis ​​no lado esquerdo do sinal de igual quanto há elementos na sequência. Observe que a atribuição múltipla é realmente apenas uma combinação de empacotamento de tupla e descompactação de sequência.

    >>> t = 1, 2, 3    # Tuple packing. 
    >>> print(t) 
    (1, 2, 3) 
    >>> a, b, c = t    # Sequence unpacking. 
    >>> print(a) 
    1 
    >>> print(b) 
    2 
    >>> print(c) 
    3 
    >>> d, e, f = 4, 5, 6    # Multiple assignment combines packing and unpacking. 
    >>> print(d) 
    4 
    >>> print(e) 
    5 
    >>> print(f) 
    6 
    >>> a, b = 1, 2, 3       # Multiple assignment requires each variable (right) 
    have a matching element (left). 
    Traceback (most recent call last): 
      File "<stdin>", line 1, in <module> 
    ValueError: too many values to unpack (expected 2) 

Imutável:

tuples são contêineres imutáveis, garantindo que os objetos que contêm não serão alterados. Ele não garante que os objetos que contém não mudará:

    >>> a_list = [] 
    >>> a_tuple = (a_list,)    # A tuple (immutable) with a list (mutable) element. 
    >>> print(a_tuple) 
    ([],) 
 
    >>> a_list.append("Hello campers!") 
    >>> print(a_tuple)         # Element of the immutable is mutated. 
    (['Hello campers!'],) 

Usos:

Funções só podem retornar um único valor, no entanto, uma tuple heterogênea pode ser usada para retornar vários valores de uma função. Um exemplo é a função de enumerate interna que retorna um iterável de tuples heterogêneas:

    >>> greeting = ["Hello", "campers!"] 
    >>> enumerator = enumerate(greeting) 
    >>> enumerator.next() 
    >>> enumerator.__next__() 
    (0, 'Hello') 
    >>> enumerator.__next__() 
    (1, 'campers!') 

Mais Inforamtion:

Documentos em Python - Tuplas