Usando Tuplas em Python

Introdução

Neste laboratório, você obterá uma compreensão abrangente das tuplas (tuples) em Python. Você aprenderá a criar tuplas, acessar seus elementos usando indexação e fatiamento (slicing), e explorará sua natureza imutável. Você também praticará o uso de operadores de tuplas, desempacotamento (unpacking) e funções nativas (built-in functions) comuns para trabalhar eficientemente com dados de tuplas.

Criar e Acessar Tuplas

Neste passo, você aprenderá a criar tuplas e a acessar seus elementos. Tuplas são coleções ordenadas e imutáveis de itens, o que significa que seu conteúdo não pode ser alterado após a criação.

Primeiro, localize o explorador de arquivos (file explorer) no lado esquerdo do WebIDE. Encontre e abra o arquivo chamado tuple_basics.py. Escreveremos nosso código neste arquivo.

Vamos começar criando alguns tipos diferentes de tuplas. Adicione o seguinte código a tuple_basics.py:

## Create an empty tuple
empty_tuple = ()
print("Empty tuple:", empty_tuple)
print("Type of empty_tuple:", type(empty_tuple))

## Create a tuple with a single element (note the trailing comma)
single_element_tuple = (50,)
print("\nSingle element tuple:", single_element_tuple)
print("Type of single_element_tuple:", type(single_element_tuple))

## Create a tuple with multiple elements
fruits = ("apple", "banana", "cherry")
print("\nFruits tuple:", fruits)

## Create a tuple from a list using the tuple() constructor
numbers_list = [1, 2, 3, 4]
numbers_tuple = tuple(numbers_list)
print("\nTuple from list:", numbers_tuple)

Após adicionar o código, salve o arquivo (você pode usar o atalho Ctrl+S). Em seguida, abra o terminal na parte inferior do WebIDE e execute o script com o seguinte comando:

python tuple_basics.py

Você deverá ver a seguinte saída, que confirma a criação e os tipos das suas tuplas:

Empty tuple: ()
Type of empty_tuple: <class 'tuple'>

Single element tuple: (50,)
Type of single_element_tuple: <class 'tuple'>

Fruits tuple: ('apple', 'banana', 'cherry')

Tuple from list: (1, 2, 3, 4)

Agora, vamos aprender a acessar os elementos dentro de uma tupla. Você pode usar a indexação (começando em 0) para obter um único elemento e o fatiamento (slicing) para obter uma sub-sequência de elementos.

Adicione o seguinte código ao final do seu arquivo tuple_basics.py:

## Define a sample tuple for accessing elements
my_tuple = ('p', 'y', 't', 'h', 'o', 'n')
print("\nOriginal tuple:", my_tuple)

## Access elements using indexing
print("First element (index 0):", my_tuple[0])
print("Last element (index -1):", my_tuple[-1])

## Access elements using slicing
print("Elements from index 1 to 3:", my_tuple[1:4])
print("Elements from index 2 to the end:", my_tuple[2:])
print("Reverse the tuple:", my_tuple[::-1])

Salve o arquivo novamente e execute o script a partir do terminal:

python tuple_basics.py

A saída completa incluirá agora os resultados do acesso aos elementos da tupla:

Empty tuple: ()
Type of empty_tuple: <class 'tuple'>

Single element tuple: (50,)
Type of single_element_tuple: <class 'tuple'>

Fruits tuple: ('apple', 'banana', 'cherry')

Tuple from list: (1, 2, 3, 4)

Original tuple: ('p', 'y', 't', 'h', 'o', 'n')
First element (index 0): p
Last element (index -1): n
Elements from index 1 to 3: ('y', 't', 'h')
Elements from index 2 to the end: ('t', 'h', 'o', 'n')
Reverse the tuple: ('n', 'o', 'h', 't', 'y', 'p')

Você agora criou com sucesso tuplas e acessou seus elementos.

Compreender a Imutabilidade da Tupla

Uma característica chave das tuplas é a sua imutabilidade. Isso significa que, uma vez que uma tupla é criada, você não pode alterar, adicionar ou remover seus elementos. Neste passo, você verá o que acontece quando tenta modificar uma tupla e aprenderá a maneira correta de realizar uma "modificação" criando uma nova tupla.

Abra o arquivo tuple_modification.py no explorador de arquivos.

Primeiro, vamos tentar alterar um elemento em uma tupla diretamente. Adicione o seguinte código a tuple_modification.py. A linha que tenta a modificação está comentada.

my_tuple = ('a', 'b', 'c', 'd', 'e')
print("Original tuple:", my_tuple)

## The following line will cause a TypeError because tuples are immutable.
## You can uncomment it to see the error for yourself.
## my_tuple[0] = 'f'

Se você executasse o código com a penúltima linha descomentada, o Python pararia e exibiria um TypeError: 'tuple' object does not support item assignment.

Como não podemos modificar uma tupla no local (in place), a solução é criar uma nova tupla com as alterações desejadas. Podemos fazer isso usando fatiamento (slicing) e concatenação (+).

Adicione o seguinte código ao final de tuple_modification.py para ver como "substituir" um elemento:

## "Modify" a tuple by creating a new one
## Concatenate a new single-element tuple ('f',) with a slice of the original tuple
modified_tuple = ('f',) + my_tuple[1:]

print("New 'modified' tuple:", modified_tuple)
print("Original tuple is unchanged:", my_tuple)

Da mesma forma, você pode "excluir" um elemento criando uma nova tupla que o exclua. Adicione este código ao seu arquivo:

## "Delete" an element by creating a new tuple
## Concatenate the slice before the element with the slice after the element
tuple_after_deletion = my_tuple[:2] + my_tuple[3:] ## Excludes element at index 2 ('c')

print("\nNew tuple after 'deletion':", tuple_after_deletion)

Salve o arquivo e execute-o a partir do terminal:

python tuple_modification.py

A saída demonstrará que criamos novas tuplas enquanto a original permanece intacta:

Original tuple: ('a', 'b', 'c', 'd', 'e')
New 'modified' tuple: ('f', 'b', 'c', 'd', 'e')
Original tuple is unchanged: ('a', 'b', 'c', 'd', 'e')

New tuple after 'deletion': ('a', 'b', 'd', 'e')

Este passo destaca a natureza imutável das tuplas e a prática padrão para contornar essa limitação.

Usar Operadores de Tupla e Desempacotamento (Unpacking)

Python fornece vários operadores úteis para trabalhar com tuplas. Você também aprenderá sobre o desempacotamento de tuplas (tuple unpacking), um recurso poderoso para atribuir elementos de uma tupla a variáveis.

Abra o arquivo tuple_operators.py no explorador de arquivos.

Vamos explorar os operadores de concatenação (+), repetição (*) e pertinência (in). Adicione o seguinte código a tuple_operators.py:

tuple1 = (1, 2, 3)
tuple2 = ('a', 'b', 'c')

## Concatenation (+)
concatenated_tuple = tuple1 + tuple2
print("Concatenated:", concatenated_tuple)

## Repetition (*)
repeated_tuple = tuple1 * 3
print("Repeated:", repeated_tuple)

## Membership (in)
is_present = 'b' in tuple2
print("\nIs 'b' in tuple2?", is_present)

is_absent = 5 in tuple1
print("Is 5 in tuple1?", is_absent)

Salve o arquivo e execute-o a partir do terminal:

python tuple_operators.py

Você verá os resultados dessas operações:

Concatenated: (1, 2, 3, 'a', 'b', 'c')
Repeated: (1, 2, 3, 1, 2, 3, 1, 2, 3)

Is 'b' in tuple2? True
Is 5 in tuple1? False

Em seguida, vamos explorar o desempacotamento de tuplas (tuple unpacking). Isso permite que você atribua os elementos de uma tupla a múltiplas variáveis em uma única linha legível. O número de variáveis deve corresponder ao número de elementos na tupla.

Adicione o seguinte código ao final de tuple_operators.py:

## Tuple unpacking
person_info = ("Alice", 30, "Engineer")
name, age, profession = person_info

print("\nOriginal info tuple:", person_info)
print("Unpacked Name:", name)
print("Unpacked Age:", age)
print("Unpacked Profession:", profession)

Salve o arquivo novamente e execute o script:

python tuple_operators.py

A saída agora incluirá as variáveis desempacotadas:

Concatenated: (1, 2, 3, 'a', 'b', 'c')
Repeated: (1, 2, 3, 1, 2, 3, 1, 2, 3)

Is 'b' in tuple2? True
Is 5 in tuple1? False

Original info tuple: ('Alice', 30, 'Engineer')
Unpacked Name: Alice
Unpacked Age: 30
Unpacked Profession: Engineer

O desempacotamento de tuplas é especialmente útil para funções que retornam múltiplos valores, pois frequentemente os retornam em uma tupla.

Aplicar Funções e Métodos Integrados (Built-in)

Neste passo final, você aprenderá a usar funções e métodos integrados comuns que operam em tuplas. As tuplas possuem dois métodos principais, count() e index(), e podem ser usadas com muitas funções de propósito geral.

Abra o arquivo tuple_functions.py no explorador de arquivos.

Vamos começar com os métodos da tupla. count() retorna o número de vezes que um elemento aparece, e index() retorna o índice da primeira ocorrência de um elemento.

Adicione o seguinte código a tuple_functions.py:

my_tuple = (1, 5, 2, 8, 5, 3, 5, 9)
print("Tuple:", my_tuple)

## count() method
count_of_5 = my_tuple.count(5)
print("Count of 5:", count_of_5)

## index() method
index_of_8 = my_tuple.index(8)
print("Index of 8:", index_of_8)

Agora, vamos usar algumas funções integradas que são muito úteis com tuplas, como len(), max(), min(), sum() e sorted().

Adicione o seguinte código ao final de tuple_functions.py:

number_tuple = (10, 5, 20, 15, 30, 5)
print("\nNumber tuple:", number_tuple)

## len() function
print("Length:", len(number_tuple))

## max() and min() functions
print("Maximum value:", max(number_tuple))
print("Minimum value:", min(number_tuple))

## sum() function (for numeric tuples)
print("Sum of elements:", sum(number_tuple))

## sorted() function (returns a new sorted list)
sorted_list = sorted(number_tuple)
print("Sorted list from tuple:", sorted_list)

Note que a função sorted() retorna uma nova lista, e não uma tupla. Se você precisar de uma tupla ordenada, pode converter o resultado de volta usando tuple(sorted_list).

Salve o arquivo e execute-o a partir do terminal:

python tuple_functions.py

Sua saída deve ser parecida com esta:

Tuple: (1, 5, 2, 8, 5, 3, 5, 9)
Count of 5: 3
Index of 8: 3

Number tuple: (10, 5, 20, 15, 30, 5)
Length: 6
Maximum value: 30
Minimum value: 5
Sum of elements: 85
Sorted list from tuple: [5, 5, 10, 15, 20, 30]

Você aprendeu agora a usar métodos e funções importantes para inspecionar e analisar tuplas.

Resumo

Neste laboratório, você adquiriu uma base sólida no uso de tuplas em Python. Você aprendeu a criar tuplas de várias maneiras e como acessar seus elementos usando indexação e fatiamento (slicing). Você explorou o conceito central da imutabilidade das tuplas e praticou a criação de novas tuplas para realizar "modificações". Você também se familiarizou com operadores comuns de tuplas como + e *, a conveniência do desempacotamento de tuplas (tuple unpacking) e a utilidade de métodos integrados (count(), index()) e funções (len(), max(), sorted()) para trabalhar com dados de tuplas.