Tupla
Uma tupla é uma lista imutável. Uma tupla não pode ser modificada de forma alguma depois de criada.
Por que as tuplas são necessárias?
- No caso de proteger quaisquer dados de alterações (intencionais ou acidentais).
- As tuplas ocupam menos espaço de memória e são mais rápidas que as listas.
- Para retornar vários valores de uma função.
- As tuplas podem ser usadas como chaves de dicionário (mais sobre isso depois).
Criando tuplas
1 maneira: como uma lista, mas com parênteses
1
2
3
|
a = (1,2,3,4,5)
print(tipo(a)) # classe 'tupla'
imprimir(a) # (1, 2, 3, 4, 5)
|
|
2 maneiras: usando a função
tuple()
1
2
3
|
b = tupla((1,2,3,4,5))
print(tipo(b)) # <class 'tuple'>
imprimir(b) # (1, 2, 3, 4, 5)
|
Você tem que se lembrar!
- Tuplas são uma lista imutável.
- Os elementos de uma tupla podem ser de tipos diferentes.
- Você pode criar uma tupla usando a função
tuple()
ou listando os elementos entre parênteses.
Recursos de tupla
1) Você pode atribuir valores a uma tupla sem usar parênteses/
Por exemplo, você pode criar uma tupla como esta:
1
2
3
|
a = 1,2,3,4,5
print(a[3]) # 4 Um elemento de uma tupla pode ser acessado da mesma forma que um elemento de uma lista,
# especificando o índice do elemento entre colchetes.
|
2) Para declarar uma tupla que inclui um único elemento, você precisa usar uma vírgula à direita:
1
2
3
4
|
a = 'a'
b = 'b',
print(type(b)) # <class 'tuple'>
print(tipo(a)) # <class 'str'>
|
3) Você pode atribuir os valores dos elementos da tupla a variáveis individuais:
1
2
3
|
minha_tupla = (1, 2, 3, 4, 5)
a, b, c, d, e = minha_tupla
imprimir(c) #3
|
Sublinhados _ podem ser usados como variáveis desnecessárias
1
2
3
|
minha_tupla = (1, 2, 3)
a, _, _ = minha_tupla
imprimir(a) #1
|
O número de variáveis deve corresponder ao número de elementos da tupla!
4) Uma tupla pode conter vários elementos aninhados. Nesse caso, ao se referir a elementos aninhados, você deve usar colchetes adicionais
1
2
|
minha_tupla = (('a', 'b', 'c'), [1, 2], ((1, 'a' ), ('b', 'c')))
print(my_tuple[2][1]) # ('b', 'c')
|
|
Referindo-se aos elementos. Tuplas aninhadas
Tuplas podem conter outras tuplas como elementos. Além disso, listas, strings, etc. podem ser usadas como elementos de uma tupla.
Acessar elementos é semelhante a acessar elementos de uma lista, especificando o índice do elemento entre colchetes. A indexação começa do zero.
Ao se referir a elementos aninhados, colchetes adicionais devem ser usados.
minha_tupla = (('a', 'b', 'c'), [1, 2], ((1, 'a' ), ('b', 'c')))
print(my_tuple[2][1]) # ('b', 'c')
|
Comparando tuplas
Ao comparar tuplas:
- os números são comparados por valor;
- strings em ordem lexicográfica;
- em caso de igualdade de elementos nas mesmas posições, comparam-se os seguintes elementos;
- a comparação dos elementos ocorrerá até a primeira desigualdade;
- ao comparar, os elementos devem ser convertidos para o mesmo tipo (você não pode comparar um número e uma string).
Exemplo
1
2
3
4
5
6
7
8
9
10
onze
12
|
A=4
B=8
C = 'a',
D = 'z',
E = (14, 'máximo', 'mínimo')
F = (14, 'máximo', 'min')
K=999
imprimir(A < B) # Verdadeiro
imprimir(C < D) # Verdadeiro
imprimir(E > F) # Verdadeiro
imprimir(K < F) # Falso
imprimir(C < K) # TypeError: '<' não suportado
# entre instâncias de 'str' e 'int'
|
|
Fatias
O fatiamento pode ser executado de forma semelhante às listas.
Deve-se lembrar que, ao pegar um elemento por índice ou por fatia ( slice ), não alteramos a tupla de forma alguma, apenas copiamos parte dela para uso posterior (por exemplo, para imprimir , alguns cálculos, etc. .p.).
Sintaxe da fatia
my_tuple[start:stop:step] # start, stop and step
|
Concatenação de tupla
É possível concatenar tuplas para criar um novo objeto (concatenação, semelhante a strings).
1
2
3
4
|
x = (1,2,3,4)
y = (5,6,7,8)
z = x + y
print(z) # (1, 2, 3, 4, 5, 6, 7, 8)
|
Durante a operação de multiplicação, a tupla é repetida várias vezes (semelhante à multiplicação de strings).
1
2
3
|
x = (1,2,3,4)
z = x*2
print(z) # (1, 2, 3, 4, 1, 2, 3, 4)
|
Removendo uma tupla
As operações e métodos de tupla são semelhantes aos métodos e operações de lista. Exceto aquelas que alteram os elementos de uma tupla.
Um elemento contido em uma tupla não pode ser adicionado ou removido devido à imutabilidade. No entanto, a própria tupla pode ser excluída usando o operador del .
1
2
|
aluno = (2007, 'Ivan', 'Ivanov', '9-A', Falso)
do aluno
|
|
Métodos para trabalhar com tuplas
Os métodos para trabalhar com tuplas são semelhantes aos métodos para trabalhar com listas, exceto os métodos que alteram a tupla. Tais métodos não estão disponíveis devido à imutabilidade da tupla. Eles podem ser aplicados criando uma nova tupla.
Exemplo de classificação de tupla
Você pode facilmente classificar uma tupla usando a função sorted() .
1
2
3
4
|
a = (5, 3, 2, 1, 4)
print(ordenado(a)) # [1, 2, 3, 4, 5]
a = tupla(ordenado(a))
imprimir(a) # (1, 2, 3, 4, 5)
|
Observe que métodos como append() , extend() , remove() NÃO funcionam com tuplas e pop() .
|