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.
