Las tuplas son una estructura de datos fundamental en Python que permite almacenar una colección ordenada de elementos. A diferencia de las listas, las tuplas son inmutables, lo que significa que una vez creadas, no pueden ser modificadas. Esta característica las hace útiles para almacenar datos que no deben cambiar a lo largo del tiempo.

Contenido

  1. ¿Qué es una tupla?
  2. Creación de tuplas
  3. Acceso a elementos de una tupla
  4. Operaciones con tuplas
  5. Métodos de tuplas
  6. Desempaquetado de tuplas
  7. Ejemplos prácticos
  8. Ejercicios

  1. ¿Qué es una tupla?

Una tupla es una colección ordenada e inmutable de elementos. Se pueden almacenar diferentes tipos de datos en una tupla, incluyendo números, cadenas, listas e incluso otras tuplas.

  1. Creación de tuplas

Las tuplas se crean utilizando paréntesis () y separando los elementos con comas ,.

# Creación de una tupla vacía
tupla_vacia = ()

# Creación de una tupla con un solo elemento (nota la coma al final)
tupla_un_elemento = (1,)

# Creación de una tupla con múltiples elementos
tupla_varios_elementos = (1, 2, 3, 'a', 'b', 'c')

# Creación de una tupla sin paréntesis (packing)
tupla_sin_parentesis = 1, 2, 3, 'a', 'b', 'c'

  1. Acceso a elementos de una tupla

Puedes acceder a los elementos de una tupla utilizando índices, de manera similar a las listas. Los índices comienzan en 0.

mi_tupla = (10, 20, 30, 40, 50)

# Acceso al primer elemento
print(mi_tupla[0])  # Salida: 10

# Acceso al último elemento
print(mi_tupla[-1])  # Salida: 50

# Acceso a un rango de elementos (slicing)
print(mi_tupla[1:4])  # Salida: (20, 30, 40)

  1. Operaciones con tuplas

Las tuplas soportan varias operaciones comunes como concatenación, repetición y verificación de pertenencia.

tupla1 = (1, 2, 3)
tupla2 = (4, 5, 6)

# Concatenación
tupla_concatenada = tupla1 + tupla2
print(tupla_concatenada)  # Salida: (1, 2, 3, 4, 5, 6)

# Repetición
tupla_repetida = tupla1 * 3
print(tupla_repetida)  # Salida: (1, 2, 3, 1, 2, 3, 1, 2, 3)

# Verificación de pertenencia
print(2 in tupla1)  # Salida: True
print(4 in tupla1)  # Salida: False

  1. Métodos de tuplas

Las tuplas tienen dos métodos incorporados: count() y index().

mi_tupla = (1, 2, 3, 2, 4, 2, 5)

# count() - Cuenta el número de veces que aparece un elemento
print(mi_tupla.count(2))  # Salida: 3

# index() - Devuelve el índice de la primera aparición de un elemento
print(mi_tupla.index(4))  # Salida: 4

  1. Desempaquetado de tuplas

El desempaquetado de tuplas permite asignar los elementos de una tupla a variables individuales.

mi_tupla = (10, 20, 30)

# Desempaquetado
a, b, c = mi_tupla
print(a)  # Salida: 10
print(b)  # Salida: 20
print(c)  # Salida: 30

# Desempaquetado parcial con el operador *
mi_tupla = (1, 2, 3, 4, 5)
a, *b, c = mi_tupla
print(a)  # Salida: 1
print(b)  # Salida: [2, 3, 4]
print(c)  # Salida: 5

  1. Ejemplos prácticos

Ejemplo 1: Uso de tuplas para devolver múltiples valores desde una función

def coordenadas():
    return (10, 20)

x, y = coordenadas()
print(f"Coordenadas: x={x}, y={y}")  # Salida: Coordenadas: x=10, y=20

Ejemplo 2: Uso de tuplas como claves en un diccionario

# Las tuplas pueden ser usadas como claves en un diccionario porque son inmutables
puntos = {(0, 0): "origen", (1, 2): "punto A", (3, 4): "punto B"}

print(puntos[(1, 2)])  # Salida: punto A

  1. Ejercicios

Ejercicio 1: Crear y acceder a una tupla

Crea una tupla con los números del 1 al 5 y accede al tercer elemento.

# Solución
mi_tupla = (1, 2, 3, 4, 5)
print(mi_tupla[2])  # Salida: 3

Ejercicio 2: Concatenar y repetir tuplas

Crea dos tuplas, tupla1 con los elementos ('a', 'b', 'c') y tupla2 con los elementos (1, 2, 3). Luego, concaténalas y repite la tupla resultante dos veces.

# Solución
tupla1 = ('a', 'b', 'c')
tupla2 = (1, 2, 3)
tupla_concatenada = tupla1 + tupla2
tupla_repetida = tupla_concatenada * 2
print(tupla_repetida)  # Salida: ('a', 'b', 'c', 1, 2, 3, 'a', 'b', 'c', 1, 2, 3)

Ejercicio 3: Desempaquetado de tuplas

Dada la tupla (10, 20, 30, 40, 50), desempaquétala en las variables a, b, c, d, e.

# Solución
mi_tupla = (10, 20, 30, 40, 50)
a, b, c, d, e = mi_tupla
print(a, b, c, d, e)  # Salida: 10 20 30 40 50

Conclusión

En esta sección, hemos aprendido qué son las tuplas, cómo crearlas, acceder a sus elementos, realizar operaciones comunes y utilizar sus métodos. También hemos explorado el desempaquetado de tuplas y visto ejemplos prácticos de su uso. Las tuplas son una herramienta poderosa y eficiente para manejar colecciones de datos inmutables en Python. En la próxima sección, exploraremos las estructuras de datos avanzadas, lo que nos permitirá manejar datos de manera aún más efectiva.

Curso de Programación en Python

Módulo 1: Introducción a Python

Módulo 2: Estructuras de Control

Módulo 3: Funciones y Módulos

Módulo 4: Estructuras de Datos

Módulo 5: Programación Orientada a Objetos

Módulo 6: Manejo de Archivos

Módulo 7: Manejo de Errores y Excepciones

Módulo 8: Temas Avanzados

Módulo 9: Pruebas y Depuración

Módulo 10: Desarrollo Web con Python

Módulo 11: Ciencia de Datos con Python

Módulo 12: Proyecto Final

© Copyright 2024. Todos los derechos reservados