Tupla
Una tupla es una lista inmutable. Una tupla no se puede modificar de ninguna manera una vez creada. 
¿Por qué se necesitan tuplas?
 
- En el caso de proteger algún dato de cambios (intencionales o accidentales).
 
- Las tuplas ocupan menos espacio en la memoria y son más rápidas que las listas.
 
- Para devolver múltiples valores de una función.
 
- Las tuplas se pueden usar como claves de diccionario (más sobre eso más adelante).
 
 
 
 
Creando tuplas
1 manera: como una lista, pero con paréntesis
 
1
2
3 
 | 
a = (1,2,3,4,5)
imprimir(escribir(a))   # clase 'tupla'
imprimir(a)         # (1, 2, 3, 4, 5)
 | 
 
2 vías: usando la función  tuple()
1
2
3
 
 | 
b = tupla((1,2,3,4,5))
imprimir(escribir(b))   # <clase 'tupla'>
imprimir(b)         # (1, 2, 3, 4, 5)
 | 
 
 
 
¡Tienes que recordar!
- Las tuplas son una lista inmutable.
 
- Los elementos de una tupla pueden ser de diferentes tipos.
 
- Puedes crear una tupla usando la función 
tuple() o enumerando los elementos entre paréntesis. 
  
            
            
                  
            
             
                    
            
                 
      
                  
           | 
	
		
 
     
              
              
                  
                       
            
                
          
            Características de tupla
1) Puede asignar valores a una tupla sin usar paréntesis/ 
Por ejemplo, puede crear una tupla como esta:
 
1
2
3
 
 | 
a = 1,2,3,4,5    
print(a[3])    # 4   Se puede acceder a un elemento de una tupla de la misma forma que a un elemento de una lista, 
               # especificando el índice del elemento entre corchetes.
 | 
 
2) Para declarar una tupla que incluye un solo elemento, debe usar una coma final:
 
1
2
3
4 
 | 
a = 'a'   
b = 'b', 
print(tipo(b))   # <clase 'tupla'> 
imprimir(tipo(a))   # <clase 'str'>
 | 
 
3) Puede asignar los valores de los elementos de la tupla a variables individuales:
 
1
2
3 
 | 
mi_tupla = (1, 2, 3, 4, 5)
a, b, c, d, e = mi_tupla
imprimir(c)    #3
 | 
 
Los guiones bajos  _ se pueden usar como variables innecesarias
 
1
2
3 
 | 
mi_tupla = (1, 2, 3)
a, _, _ = mi_tupla
imprimir(a)    #1
 | 
 
El número de variables debe coincidir con el número de elementos de la tupla!
 
4) Una tupla puede contener varios elementos anidados. En este caso, al referirse a elementos  anidados, debe utilizar corchetes adicionales
 
1
2 
 | 
mi_tupla = (('a', 'b', 'c'), [1, 2], ((1, 'a' ), ('b', 'c')))
imprimir(mi_tupla[2][1]) # ('b', 'c')
 | 
 
 
            
            
                  
            
             
                    
            
                 
      
                  
           | 
	
		
 
     
              
              
                  
                       
            
                
          
            Refiriéndose a los elementos. Tuplas anidadas
Las tuplas pueden contener otras tuplas como elementos. Además, se pueden usar listas, cadenas, etc. como elementos de una tupla. 
Acceder a los elementos es similar a acceder a los elementos de una lista, especificando el índice del elemento entre corchetes. La indexación comienza desde cero. 
Al referirse a elementos anidados, se deben usar corchetes adicionales.
 
 
mi_tupla = (('a', 'b', 'c'), [1, 2], ((1, 'a' ), ('b', 'c')))
imprimir(mi_tupla[2][1])    # ('b', 'c') 
            
            
                  
            
             
                    
            
                 
      
                  
           | 
	
		
 
     
              
              
                  
                       
            
                
          
            Comparando tuplas
Al comparar tuplas:  
- los números se comparan por valor;  
- cadenas en orden lexicográfico;  
- en caso de igualdad de elementos en las mismas posiciones, se comparan los siguientes elementos;  
- la comparación de elementos ocurrirá hasta la primera desigualdad;  
- al comparar, los elementos deben tener el mismo tipo (no se puede comparar un número y una cadena). 
 
 Ejemplo
1
2
3
4
5
6
7
8
9
10
once
12
 
 | 
A=4
B=8
C = 'a',
D = 'z',
E = (14, 'máximo', 'mínimo')
F = (14, 'máximo', 'mín')
K = 999
imprimir (A < B)    # Verdadero
imprimir (C < D)    # Verdadero
imprimir(E > F)    # Verdadero
imprimir(K < F)    # Falso
imprimir (C < K)    # Error de tipo: '<' No soportado
                # entre instancias de 'str' y 'int'
 | 
 
 
            
            
                  
            
             
                    
            
                 
      
                  
           | 
	
		
 
     
              
              
                  
                       
            
                
          
            Rebanadas
El corte se puede realizar de manera similar a las listas. 
Debe recordarse que al tomar un elemento por índice o por segmento ( slice), no cambiamos la tupla de ninguna manera, simplemente copiamos parte de ella para su uso posterior (por ejemplo, para imprimir , algunos cálculos, etc. .p.).
 
 Sintaxis de división
my_tuple[start:stop:step]  # start, stop and step 
            
            
                  
            
             
                    
            
                 
      
                  
           | 
	
		
 
     
              
              
                  
                       
            
                
          
            Concatenación de tuplas
Es posible concatenar tuplas para crear un nuevo objeto (concatenación, similar a las cadenas).
 
1
2
3
4 
 | 
x = (1,2,3,4)
y = (5,6,7,8)
z = x + y 
imprimir(z)  # (1, 2, 3, 4, 5, 6, 7, 8)
 | 
 
Durante la operación de multiplicación, la tupla se repite varias veces (similar a la multiplicación de cadenas).
 
1
2
3 
 | 
x = (1,2,3,4)
z = x*2
imprimir(z)  # (1, 2, 3, 4, 1, 2, 3, 4)
 | 
 
 
 
Eliminando una tupla
Las operaciones y métodos de tupla son similares a las operaciones y métodos de lista. Excepto aquellas que modifican los elementos de una tupla. 
Un elemento contenido en una  tupla no puede agregarse ni eliminarse debido a la inmutabilidad. Sin embargo, la tupla en sí se puede eliminar usando el operador  del.
 
1
2 
 | 
estudiante = (2007, 'Ivan', 'Ivanov', '9-A', Falso)
del estudiante
 | 
 
 
            
            
                  
            
             
                    
            
                 
      
                  
           | 
	
		
 
     
              
              
                  
                       
            
                
          
            Métodos para trabajar con tuplas
Los métodos para trabajar con tuplas son similares a los métodos para trabajar con listas, excepto por los métodos que cambian la tupla. Dichos métodos no están disponibles debido a la inmutabilidad de la tupla. Se pueden aplicar creando una nueva tupla.
  
 
Ejemplo de clasificación por tupla
Puede ordenar fácilmente una tupla usando la función  sorted().
 
1
2
3
4 
 | 
a = (5, 3, 2, 1, 4)
imprimir(ordenado(a))    # [1, 2, 3, 4, 5] 
a = tupla(ordenada(a)) 
imprimir(a)    # (1, 2, 3, 4, 5) 
 | 
 
Tenga en cuenta que métodos como  append(),  extend(),  remove() NO funcionan con tuplas   y  pop().  
            
            
                  
            
             
                    
            
                 
      
                  
           |