Técnicas Básicas para Copiar Elementos de Tuplas
Nesta etapa, exploraremos técnicas básicas para copiar elementos de uma tupla para outra. Como as tuplas são imutáveis, copiar na verdade significa criar uma nova tupla com os mesmos elementos ou elementos selecionados.
Vamos criar um novo arquivo para experimentar com essas técnicas:
- Crie um novo arquivo chamado
tuple_copying_basics.py no diretório /home/labex/project
- Adicione o seguinte código ao arquivo:
## Crie uma tupla de exemplo para trabalhar
original_tuple = (1, 2, 3, 4, 5)
print("Original tuple:", original_tuple)
## Método 1: Usando o operador de slice [:]
slice_copy = original_tuple[:]
print("\nMethod 1 - Using slice operator [:]")
print("Copy:", slice_copy)
print("Is it the same object?", original_tuple is slice_copy)
print("Do they have the same values?", original_tuple == slice_copy)
## Método 2: Usando o construtor tuple()
constructor_copy = tuple(original_tuple)
print("\nMethod 2 - Using tuple() constructor")
print("Copy:", constructor_copy)
print("Is it the same object?", original_tuple is constructor_copy)
print("Do they have the same values?", original_tuple == slice_copy)
## Método 3: Usando tuple unpacking (apenas para tuplas menores)
a, b, c, d, e = original_tuple
unpacking_copy = (a, b, c, d, e)
print("\nMethod 3 - Using tuple unpacking")
print("Copy:", unpacking_copy)
print("Is it the same object?", original_tuple is unpacking_copy)
print("Do they have the same values?", original_tuple == unpacking_copy)
## Método 4: Usando o operador + com tupla vazia
plus_copy = () + original_tuple
print("\nMethod 4 - Using + operator")
print("Copy:", plus_copy)
print("Is it the same object?", original_tuple is plus_copy)
print("Do they have the same values?", original_tuple == plus_copy)
- Salve o arquivo e execute-o com o seguinte comando:
python3 /home/labex/project/tuple_copying_basics.py
Você deve ver uma saída semelhante a esta:
Original tuple: (1, 2, 3, 4, 5)
Method 1 - Using slice operator [:]
Copy: (1, 2, 3, 4, 5)
Is it the same object? False
Do they have the same values? True
Method 2 - Using tuple() constructor
Copy: (1, 2, 3, 4, 5)
Is it the same object? False
Do they have the same values? True
Method 3 - Using tuple unpacking
Copy: (1, 2, 3, 4, 5)
Is it the same object? False
Do they have the same values? True
Method 4 - Using + operator
Copy: (1, 2, 3, 4, 5)
Is it the same object? False
Do they have the same values? True
Frequentemente, você pode querer copiar apenas elementos específicos ou transformar elementos durante a cópia. Vamos explorar essas técnicas:
- Crie um novo arquivo chamado
tuple_selective_copying.py com o seguinte conteúdo:
original_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print("Original tuple:", original_tuple)
## Copiando uma fatia (subconjunto) da tupla
partial_copy = original_tuple[2:7] ## Elementos do índice 2 a 6
print("\nPartial copy (indexes 2-6):", partial_copy)
## Copiando com passo
step_copy = original_tuple[::2] ## Cada segundo elemento
print("Copy with step of 2:", step_copy)
## Copiando em ordem inversa
reverse_copy = original_tuple[::-1]
print("Reversed copy:", reverse_copy)
## Transformando elementos durante a cópia usando uma expressão geradora
doubled_copy = tuple(x * 2 for x in original_tuple)
print("\nCopy with doubled values:", doubled_copy)
## Copiando apenas números pares
even_copy = tuple(x for x in original_tuple if x % 2 == 0)
print("Copy with only even numbers:", even_copy)
## Criando uma nova tupla combinando partes da tupla original
first_part = original_tuple[:3]
last_part = original_tuple[-3:]
combined_copy = first_part + last_part
print("\nCombined copy (first 3 + last 3):", combined_copy)
- Salve o arquivo e execute-o:
python3 /home/labex/project/tuple_selective_copying.py
Saída esperada:
Original tuple: (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
Partial copy (indexes 2-6): (3, 4, 5, 6, 7)
Copy with step of 2: (1, 3, 5, 7, 9)
Reversed copy: (10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
Copy with doubled values: (2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
Copy with only even numbers: (2, 4, 6, 8, 10)
Combined copy (first 3 + last 3): (1, 2, 3, 8, 9, 10)
Esses exemplos mostram várias maneiras de criar novas tuplas a partir das existentes. Lembre-se:
- Fatiamento (
[start:end], [::step]) é uma maneira fácil de criar uma nova tupla com um subconjunto de elementos
- Expressões geradoras são úteis para transformar elementos ao copiá-los
- Concatenação de tuplas com o operador
+ permite combinar tuplas
Na próxima etapa, compararemos o desempenho desses métodos e exploraremos técnicas mais avançadas.
