14-Tuplas en python

Acordeón de los Índices

Índice de los temas

• Tupla
• Tupla de acceso
• Actualizar tupla
• Desempaquetar tupla
• Bucles con tupla o tupla bucles
• Unirse a tuplas
• Metodos de tuplas

---

Lección: 14 - Tuplas en Python

Tupla

🧱 Tupla: Colecciones Inmutables y Ordenadas

Una tupla en Python es una colección de elementos que está ordenada y es inmutable (no se puede cambiar, agregar ni eliminar elementos una vez creada). Las tuplas se escriben con paréntesis `()`.

Características Principales de las Tuplas:

• Ordenadas: Los elementos en una tupla tienen un orden específico, y ese orden no cambiará.
• Inmutables: Una vez que se crea una tupla, no se pueden modificar sus elementos (no se pueden agregar, eliminar ni cambiar elementos).
• Permiten duplicados: Las tuplas pueden contener elementos con el mismo valor.
• Indexadas: Se puede acceder a los elementos de una tupla utilizando índices, comenzando desde 0.

Creación de Tuplas:

Para crear una tupla, coloca los elementos entre paréntesis, separados por comas.

# Tupla con diferentes tipos de datos
    mi_tupla = ("manzana", 3.14, True)
    print(mi_tupla) # Output: ('manzana', 3.14, True)

    # Tupla con elementos duplicados
    tupla_duplicados = (1, 5, 2, 5, 3)
    print(tupla_duplicados) # Output: (1, 5, 2, 5, 3)

    # Tupla vacía
    tupla_vacia = ()
    print(tupla_vacia) # Output: ()

    # Tupla con un solo elemento (¡ojo con la coma!)
    tupla_un_elemento = ("pera",)
    print(type(tupla_un_elemento)) # Output: <class 'tuple'>

    # ¡Sin la coma, Python lo interpreta como una cadena!
    no_es_tupla = ("uva")
    print(type(no_es_tupla)) # Output: <class 'str'>
    

¿Por qué usar Tuplas?

• Integridad de los datos: La inmutabilidad garantiza que los datos permanezcan protegidos contra modificaciones accidentales.
• Rendimiento: Las tuplas suelen ser ligeramente más rápidas de iterar que las listas.
• Uso como claves en diccionarios: Las tuplas pueden usarse como claves en diccionarios (a diferencia de las listas, que son mutables).
• Representación de datos fijos: Son útiles para representar colecciones de elementos que no deben cambiar, como coordenadas, registros, etc.

Las tuplas son una estructura de datos fundamental en Python, especialmente útil cuando la inmutabilidad es una propiedad deseada.

Tupla de acceso

🗝️ Acceder a Elementos de una Tupla

Al igual que con las listas, se puede acceder a los elementos de una tupla haciendo referencia a su índice. Los índices en Python comienzan desde 0.

Acceso por Índice Positivo:

Para acceder a un elemento específico, utiliza el índice entre corchetes `[]` después del nombre de la tupla.

frutas_tupla = ("manzana", "plátano", "cereza")

    primer_elemento = frutas_tupla[0]
    print(f"El primer elemento es: {primer_elemento}") # Output: manzana

    segundo_elemento = frutas_tupla[1]
    print(f"El segundo elemento es: {segundo_elemento}") # Output: plátano

    tercer_elemento = frutas_tupla[2]
    print(f"El tercer elemento es: {tercer_elemento}") # Output: cereza
    

Indexación Negativa:

También puedes utilizar la indexación negativa para acceder a los elementos desde el final de la tupla. El índice `-1` se refiere al último elemento, `-2` al penúltimo, y así sucesivamente.

colores_tupla = ("rojo", "verde", "azul", "amarillo")

    ultimo_color = colores_tupla[-1]
    print(f"El último color es: {ultimo_color}") # Output: amarillo

    penultimo_color = colores_tupla[-2]
    print(f"El penúltimo color es: {penultimo_color}") # Output: azul
    

Rango de Índices (Slicing):

Puedes especificar un rango de índices para acceder a una sub-tupla. Recuerda que el índice de inicio es inclusivo y el índice de fin es exclusivo.

numeros_tupla = (10, 20, 30, 40, 50, 60)

    sub_tupla1 = numeros_tupla[2:5]
    print(f"Sub-tupla del índice 2 al 4: {sub_tupla1}") # Output: (30, 40, 50)

    sub_tupla2 = numeros_tupla[:4]
    print(f"Sub-tupla hasta el índice 3: {sub_tupla2}") # Output: (10, 20, 30, 40)

    sub_tupla3 = numeros_tupla[3:]
    print(f"Sub-tupla desde el índice 3: {sub_tupla3}") # Output: (40, 50, 60)

    sub_tupla_negativo = numeros_tupla[-4:-1]
    print(f"Sub-tupla con índices negativos: {sub_tupla_negativo}") # Output: (30, 40, 50)
    

Consideraciones:

• Intentar acceder a un índice fuera del rango de la tupla resultará en un `IndexError`.
• La inmutabilidad de las tuplas significa que no puedes modificar los elementos accedidos; solo puedes leerlos.

Acceder a los elementos de una tupla utilizando índices es fundamental para trabajar con esta estructura de datos en Python.

Actualizar tupla

🔄 Actualizar Tuplas: Superando la Inmutabilidad

Las tuplas son inmutables, lo que significa que una vez creadas, sus elementos no pueden ser modificados directamente (no se pueden cambiar, agregar ni eliminar elementos).

El "Truco" para Actualizar Tuplas: Convertir a Lista

Sin embargo, existe una forma indirecta de "actualizar" una tupla: puedes convertirla a una lista, realizar las modificaciones deseadas en la lista y luego volver a convertir la lista a una tupla.

Pasos para "Actualizar" una Tupla:

1. Convertir la tupla a una lista: Utiliza la función `list()` para crear una versión mutable de la tupla.
2. Modificar la lista: Realiza las operaciones de modificación que necesites (cambiar elementos, agregar, eliminar).
3. Convertir la lista de nuevo a una tupla: Utiliza la función `tuple()` para crear una nueva tupla con los cambios realizados.

Ejemplos de "Actualización" de Tuplas:

mi_tupla = ("manzana", "banana", "cereza")
    print(f"Tupla original: {mi_tupla}") # Output: ('manzana', 'banana', 'cereza')

    # Convertir a lista
    mi_lista = list(mi_tupla)
    print(f"Lista convertida: {mi_lista}") # Output: ['manzana', 'banana', 'cereza']

    # Modificar la lista (cambiar un elemento)
    mi_lista[1] = "kiwi"
    print(f"Lista modificada: {mi_lista}") # Output: ['manzana', 'kiwi', 'cereza']

    # Convertir de nuevo a tupla
    mi_tupla = tuple(mi_lista)
    print(f"Tupla 'actualizada': {mi_tupla}") # Output: ('manzana', 'kiwi', 'cereza')

    # Ejemplo de agregar un elemento (se crea una nueva tupla)
    otra_tupla = ("perro", "gato")
    otra_lista = list(otra_tupla)
    otra_lista.append("pájaro")
    nueva_tupla = tuple(otra_lista)
    print(f"Nueva tupla con elemento agregado: {nueva_tupla}") # Output: ('perro', 'gato', 'pájaro')
    

Consideraciones:

• Este proceso de "actualización" no modifica la tupla original; en realidad, se crea una nueva tupla con los cambios.
• Si la inmutabilidad es un requisito estricto, es importante ser consciente de que esta es una forma de sortear esa restricción.

Aunque las tuplas no se pueden modificar directamente, la conversión a lista proporciona una manera de realizar cambios y luego volver a tener una tupla con los elementos actualizados.

Desempaquetar tupla

📦 Desempaquetar Tuplas: Asignación Directa de Elementos

En Python, puedes extraer los valores de una tupla y asignarlos a variables individuales. Esto se conoce como desempaquetado de tuplas. Es una forma concisa y legible de trabajar con los elementos de una tupla cuando conoces su estructura (el número y el orden de los elementos).

Desempaquetado Básico:

Para desempaquetar una tupla, simplemente asigna la tupla a un número igual de variables, separadas por comas. Python automáticamente asignará cada elemento de la tupla a la variable correspondiente según su posición.

coordenadas = (10, 20)
    x, y = coordenadas
    print(f"El valor de x es: {x}") # Output: 10
    print(f"El valor de y es: {y}") # Output: 20

    persona = ("Ana", 30, "Madrid")
    nombre, edad, ciudad = persona
    print(f"Nombre: {nombre}, Edad: {edad}, Ciudad: {ciudad}") # Output: Nombre: Ana, Edad: 30, Ciudad: Madrid
    

Número Incorrecto de Variables:

Es importante que el número de variables en el lado izquierdo de la asignación coincida exactamente con el número de elementos en la tupla. Si no coinciden, Python generará un error `ValueError`.

# Esto causará un ValueError: demasiadas variables para desempaquetar
    # punto = (5, 5)
    # a, b, c = punto

    # Esto también causará un ValueError: no suficientes variables para desempaquetar
    # info = ("Carlos", 25)
    # nombre_completo = info
    

Usando el Asterisco `*` para Elementos Restantes:

Si tienes una tupla con más elementos de los que quieres asignar a variables individuales, puedes usar un asterisco `*` delante del nombre de una variable para recoger el resto de los elementos en una lista.

numeros = (1, 2, 3, 4, 5)
    primero, segundo, *resto = numeros
    print(f"Primero: {primero}") # Output: 1
    print(f"Segundo: {segundo}") # Output: 2
    print(f"Resto: {resto}") # Output: [3, 4, 5]

    colores = ("rojo", "verde", "azul", "amarillo", "morado")
    principal, *intermedios, ultimo = colores
    print(f"Principal: {principal}") # Output: rojo
    print(f"Intermedios: {intermedios}") # Output: ['verde', 'azul', 'amarillo']
    print(f"Último: {ultimo}") # Output: morado
    

Aplicaciones del Desempaquetado:

• Asignación clara y concisa de valores.
• Iteración sobre secuencias de pares (por ejemplo, al usar `enumerate()` o `zip()`).
• Devolución de múltiples valores desde una función.

El desempaquetado de tuplas es una característica poderosa de Python que puede hacer que tu código sea más legible y eficiente al trabajar con colecciones de elementos.

Bucles con tupla o tupla bucles

🔄 Bucles en Tuplas: Iterando a Través de los Elementos

Puedes recorrer los elementos de una tupla utilizando un bucle `for` de manera similar a como lo harías con una lista.

Bucle `for` Simple:

La forma más común de iterar sobre una tupla es utilizando un bucle `for` que recorre cada elemento de la tupla.

frutas_tuple_bucle = ("manzana", "plátano", "cereza")

    for fruta in frutas_tuple_bucle:
        print(fruta)
    # Output:
    # manzana
    # plátano
    # cereza
    

Bucle `for` con Índices:

Si también necesitas acceder al índice de cada elemento durante la iteración, puedes utilizar las funciones `range()` y `len()` o la función `enumerate()`.

colores_tuple_bucle = ("rojo", "verde", "azul")

    # Usando range() y len()
    for i in range(len(colores_tuple_bucle)):
        print(f"Índice {i}: {colores_tuple_bucle[i]}")
    # Output:
    # Índice 0: rojo
    # Índice 1: verde
    # Índice 2: azul

    # Usando enumerate()
    for indice, color in enumerate(colores_tuple_bucle):
        print(f"Índice {indice}: {color}")
    # Output:
    # Índice 0: rojo
    # Índice 1: verde
    # Índice 2: azul
    

Bucle `while`:

Aunque menos común para iterar sobre colecciones, también puedes usar un bucle `while` para recorrer una tupla utilizando índices.

numeros_tuple_bucle = (10, 20, 30)
    i = 0
    while i < len(numeros_tuple_bucle):
        print(numeros_tuple_bucle[i])
        i += 1
    # Output:
    # 10
    # 20
    # 30
    

Consideraciones:

• La inmutabilidad de la tupla significa que no puedes modificar los elementos dentro del bucle.
• La elección del tipo de bucle depende de si solo necesitas los elementos o también sus índices. `for` simple y `enumerate()` suelen ser las opciones más legibles para la mayoría de los casos.

Iterar a través de los elementos de una tupla es una operación fundamental para procesar los datos que contiene.

Métodos de tuplas

⚙️ Métodos de Tuplas en Python

Las tuplas en Python tienen pocos métodos en comparación con las listas, debido a su naturaleza inmutable. Los dos métodos principales disponibles para las tuplas son:

• `count()`: Devuelve el número de veces que un valor especificado aparece en la tupla.
• `index()`: Devuelve el índice de la primera aparición de un valor especificado en la tupla.

El Método `count()`:

Este método toma un valor como argumento y devuelve la frecuencia de ese valor dentro de la tupla.

mi_tupla_count = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5, 7)
    conteo_sietes = mi_tupla_count.count(7)
    print(f"El número 7 aparece {conteo_sietes} veces.") # Output: El número 7 aparece 3 veces.

    conteo_cincos = mi_tupla_count.count(5)
    print(f"El número 5 aparece {conteo_cincos} veces.") # Output: El número 5 aparece 2 veces.

    conteo_nueves = mi_tupla_count.count(9)
    print(f"El número 9 aparece {conteo_nueves} veces.") # Output: El número 9 aparece 0 veces.
    

El Método `index()`:

Este método toma un valor como argumento y devuelve el índice de la primera ocurrencia de ese valor en la tupla. Si el valor no se encuentra en la tupla, se genera un error `ValueError`.

mi_tupla_index = ("manzana", "banana", "cereza", "dátil", "banana")
    indice_banana = mi_tupla_index.index("banana")
    print(f"La primera aparición de 'banana' está en el índice: {indice_banana}") # Output: La primera aparición de 'banana' está en el índice: 1

    indice_cereza = mi_tupla_index.index("cereza")
    print(f"La primera aparición de 'cereza' está en el índice: {indice_cereza}") # Output: La primera aparición de 'cereza' está en el índice: 2

    # Intentar encontrar un valor que no existe causará un ValueError
    # indice_uva = mi_tupla_index.index("uva")
    # print(indice_uva)
    

Limitaciones debido a la Inmutabilidad:

Debido a que las tuplas son inmutables, no existen métodos que permitan modificar la tupla después de su creación (como `append()`, `insert()`, `remove()`, `pop()`, `sort()`, etc., que sí están disponibles para las listas).

Aunque las tuplas tienen pocos métodos, `count()` e `index()` son útiles para obtener información sobre los elementos que contienen.

Métodos de tuplas

⚙️ Métodos de Tuplas en Python

Las tuplas en Python tienen pocos métodos en comparación con las listas, debido a su naturaleza inmutable. Los dos métodos principales disponibles para las tuplas son:

• `count()`: Devuelve el número de veces que un valor especificado aparece en la tupla.
• `index()`: Devuelve el índice de la primera aparición de un valor especificado en la tupla.

El Método `count()`:

Este método toma un valor como argumento y devuelve la frecuencia de ese valor dentro de la tupla.

mi_tupla_count = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5, 7)
    conteo_sietes = mi_tupla_count.count(7)
    print(f"El número 7 aparece {conteo_sietes} veces.") # Output: 3

    conteo_cincos = mi_tupla_count.count(5)
    print(f"El número 5 aparece {conteo_cincos} veces.") # Output: 2

    conteo_nueves = mi_tupla_count.count(9)
    print(f"El número 9 aparece {conteo_nueves} veces.") # Output: 0
    

El Método `index()`:

Este método toma un valor como argumento y devuelve el índice de la primera ocurrencia de ese valor en la tupla. Si el valor no se encuentra en la tupla, se genera un error `ValueError`.

mi_tupla_index = ("manzana", "banana", "cereza", "dátil", "banana")
    indice_banana = mi_tupla_index.index("banana")
    print(f"La primera aparición de 'banana' está en el índice: {indice_banana}") # Output: 1

    indice_cereza = mi_tupla_index.index("cereza")
    print(f"La primera aparición de 'cereza' está en el índice: {indice_cereza}") # Output: 2

    # Intentar encontrar un valor que no existe causará un ValueError
    # indice_uva = mi_tupla_index.index("uva")
    # print(indice_uva)
    

Limitaciones debido a la Inmutabilidad:

Debido a que las tuplas son inmutables, no existen métodos que permitan modificar la tupla después de su creación (como `append()`, `insert()`, `remove()`, `pop()`, `sort()`, etc., que sí están disponibles para las listas).

Aunque las tuplas tienen pocos métodos, `count()` e `index()` son útiles para obtener información sobre los elementos que contienen.

---

Ir al indice