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!
  1. Tuplas são uma lista imutável.
  2. Os elementos de uma tupla podem ser de tipos diferentes.
  3. 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().