Tupla Python
Tupla Python
Neste artigo, você aprenderá tudo sobre tuplas Python. Mais especificamente, o que são tuplas, como criá-las, quando usá-las e vários métodos com os quais você deve estar familiarizado.
Vídeo:listas e tuplas do Python
Uma tupla em Python é semelhante a uma lista. A diferença entre os dois é que não podemos alterar os elementos de uma tupla uma vez que ela é atribuída, enquanto podemos alterar os elementos de uma lista.
Criando uma Tupla
Uma tupla é criada colocando todos os itens (elementos) entre parênteses
() , separados por vírgulas. Os parênteses são opcionais, no entanto, é uma boa prática usá-los. Uma tupla pode ter qualquer número de itens e eles podem ser de diferentes tipos (integer, float, list, string, etc.).
# Different types of tuples
# Empty tuple
my_tuple = ()
print(my_tuple)
# Tuple having integers
my_tuple = (1, 2, 3)
print(my_tuple)
# tuple with mixed datatypes
my_tuple = (1, "Hello", 3.4)
print(my_tuple)
# nested tuple
my_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
print(my_tuple) Saída
()
(1, 2, 3)
(1, 'Hello', 3.4)
('mouse', [8, 4, 6], (1, 2, 3)) Uma tupla também pode ser criada sem usar parênteses. Isso é conhecido como empacotamento de tuplas.
my_tuple = 3, 4.6, "dog"
print(my_tuple)
# tuple unpacking is also possible
a, b, c = my_tuple
print(a) # 3
print(b) # 4.6
print(c) # dog Saída
(3, 4.6, 'dog') 3 4.6 dog
Criar uma tupla com um elemento é um pouco complicado.
Ter um elemento entre parênteses não é suficiente. Precisaremos de uma vírgula à direita para indicar que é, de fato, uma tupla.
my_tuple = ("hello")
print(type(my_tuple)) # <class 'str'>
# Creating a tuple having one element
my_tuple = ("hello",)
print(type(my_tuple)) # <class 'tuple'>
# Parentheses is optional
my_tuple = "hello",
print(type(my_tuple)) # <class 'tuple'> Saída
<class 'str'> <class 'tuple'> <class 'tuple'>
Acessar elementos de tupla
Existem várias maneiras pelas quais podemos acessar os elementos de uma tupla.
1. Indexação
Podemos usar o operador de índice
[] para acessar um item em uma tupla, onde o índice começa em 0. Portanto, uma tupla com 6 elementos terá índices de 0 a 5. Tentar acessar um índice fora do intervalo de índice da tupla (6,7,... neste exemplo) gerará um
IndexError . O índice deve ser um inteiro, então não podemos usar float ou outros tipos. Isso resultará em
TypeError . Da mesma forma, tuplas aninhadas são acessadas usando indexação aninhada, conforme mostrado no exemplo abaixo.
# Accessing tuple elements using indexing
my_tuple = ('p','e','r','m','i','t')
print(my_tuple[0]) # 'p'
print(my_tuple[5]) # 't'
# IndexError: list index out of range
# print(my_tuple[6])
# Index must be an integer
# TypeError: list indices must be integers, not float
# my_tuple[2.0]
# nested tuple
n_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
# nested index
print(n_tuple[0][3]) # 's'
print(n_tuple[1][1]) # 4 Saída
p t s 4
2. Indexação negativa
Python permite indexação negativa para suas sequências.
O índice de -1 refere-se ao último item, -2 ao penúltimo item e assim por diante.
# Negative indexing for accessing tuple elements
my_tuple = ('p', 'e', 'r', 'm', 'i', 't')
# Output: 't'
print(my_tuple[-1])
# Output: 'p'
print(my_tuple[-6]) Saída
t p
3. Fatiando
Podemos acessar uma variedade de itens em uma tupla usando o operador de fatiamento dois pontos
: .
# Accessing tuple elements using slicing
my_tuple = ('p','r','o','g','r','a','m','i','z')
# elements 2nd to 4th
# Output: ('r', 'o', 'g')
print(my_tuple[1:4])
# elements beginning to 2nd
# Output: ('p', 'r')
print(my_tuple[:-7])
# elements 8th to end
# Output: ('i', 'z')
print(my_tuple[7:])
# elements beginning to end
# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
print(my_tuple[:]) Saída
('r', 'o', 'g')
('p', 'r')
('i', 'z')
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z') O fatiamento pode ser melhor visualizado considerando o índice entre os elementos, conforme mostrado abaixo. Então, se quisermos acessar um intervalo, precisamos do índice que cortará a parte da tupla.
Alterando uma Tupla
Ao contrário das listas, as tuplas são imutáveis.
Isso significa que os elementos de uma tupla não podem ser alterados depois de atribuídos. Mas, se o próprio elemento for um tipo de dados mutável como uma lista, seus itens aninhados poderão ser alterados.
Também podemos atribuir uma tupla a valores diferentes (reatribuição).
# Changing tuple values
my_tuple = (4, 2, 3, [6, 5])
# TypeError: 'tuple' object does not support item assignment
# my_tuple[1] = 9
# However, item of mutable element can be changed
my_tuple[3][0] = 9 # Output: (4, 2, 3, [9, 5])
print(my_tuple)
# Tuples can be reassigned
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
print(my_tuple) Saída
(4, 2, 3, [9, 5])
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z') Podemos usar
+ operador para combinar duas tuplas. Isso é chamado de concatenação . Também podemos repetir os elementos em uma tupla por um determinado número de vezes usando o
* operador. Ambos
+ e * operações resultam em uma nova tupla.
# Concatenation
# Output: (1, 2, 3, 4, 5, 6)
print((1, 2, 3) + (4, 5, 6))
# Repeat
# Output: ('Repeat', 'Repeat', 'Repeat')
print(("Repeat",) * 3) Saída
(1, 2, 3, 4, 5, 6)
('Repeat', 'Repeat', 'Repeat') Excluindo uma Tupla
Como discutido acima, não podemos alterar os elementos em uma tupla. Isso significa que não podemos excluir ou remover itens de uma tupla.
A exclusão completa de uma tupla, no entanto, é possível usando a palavra-chave del.
# Deleting tuples
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
# can't delete items
# TypeError: 'tuple' object doesn't support item deletion
# del my_tuple[3]
# Can delete an entire tuple
del my_tuple
# NameError: name 'my_tuple' is not defined
print(my_tuple) Saída
Traceback (most recent call last): File "<string>", line 12, in <module> NameError: name 'my_tuple' is not defined
Métodos de Tupla
Métodos que adicionam ou removem itens não estão disponíveis com tupla. Apenas os dois métodos a seguir estão disponíveis.
Alguns exemplos de métodos de tupla Python:
my_tuple = ('a', 'p', 'p', 'l', 'e',)
print(my_tuple.count('p')) # Output: 2
print(my_tuple.index('l')) # Output: 3 Saída
2 3
Outras operações de tupla
1. Teste de associação à tupla
Podemos testar se um item existe em uma tupla ou não, usando a palavra-chave
in .
# Membership test in tuple
my_tuple = ('a', 'p', 'p', 'l', 'e',)
# In operation
print('a' in my_tuple)
print('b' in my_tuple)
# Not in operation
print('g' not in my_tuple) Saída
True False True
2. Iterando por meio de uma tupla
Podemos usar um
for loop para percorrer cada item em uma tupla.
# Using a for loop to iterate through a tuple
for name in ('John', 'Kate'):
print("Hello", name) Saída
Hello John Hello Kate
Vantagens da Tupla sobre a Lista
Como as tuplas são bastante semelhantes às listas, ambas são usadas em situações semelhantes. No entanto, existem certas vantagens de implementar uma tupla sobre uma lista. Abaixo estão listadas algumas das principais vantagens:
- Geralmente usamos tuplas para tipos de dados heterogêneos (diferentes) e listas para tipos de dados homogêneos (semelhantes).
- Como as tuplas são imutáveis, iterar em uma tupla é mais rápido do que com uma lista. Portanto, há um pequeno aumento no desempenho.
- Tuplas que contêm elementos imutáveis podem ser usadas como chave para um dicionário. Com listas, isso não é possível.
- Se você tiver dados que não mudam, implementá-los como tupla garantirá que eles permaneçam protegidos contra gravação.
python