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(). 
            
            
                  
            
             
                    
            
                 
      
                  
           |