Tuplas

Tuplas

Estructura de datos inmutables que contiene una secuencia ordenada de elementos

Tupla = (1, 2, 3, 4)

• Los elementos están separados por espacios luego de las comas
• Puede contener cualquier tipo de datos
• Cada posición de la tupla tiene un índice
• Es inmutable y por lo tanto no puede ser modificada, lo que permite proteger mejor la data si no queremos que se modifique por error

Acceder a un elemento

Tupla = (”A”, “B”, “C”)

Tupla [0] Indice a consultar

“A” Nos retorna el resultado de la posición 0 en la tupla

Encontrar un elemento

Tupla = (”A”, “B”, “C”)

“A” in Tupla

True

“Z” in Tupla

False

Metodos

Buscar el Indice de un elemento

Tupla = (”A”, “B”, “C”)

Tupla.index(”A”)

0 Nos devuelve el indice del elemento que buscamos

Numero de veces que un elemento aparece en la Tupla

Tupla = (”A”, “B”, “C”)

Tupla.count(elemento)

Tupla.count(”B”)

1 Retorna el numero de veces del elemento en la Tupla

Para recordar entre listas y tuplas, cuales son inmutables y mutables personalmente uso una analogía:
Como las listas usan " [ ] “, lo veo como una caja donde se puede introducir mas elementos. En cambio como las tuplas emplean” ( ) ", lo veo como una esfera que no acepta introducir mas elementos.
Aparte de esto recuerdo cuales son listas y tuplas con la ‘L’ de Listas, ya que se parece a un corchete a medias " [ "

Lista = [ ] ,
Tuplas = ( ),
Diccionarios = { }

TUPLAS: Estructura de datos inmutables, solo para lectura

Numbers = (1, 2, 3, 4)
String = (‘nico’, ‘juan’, ‘santi)

My_list = list(string) : convertir una tupla en una lista
My_tuplea = tupla(my_list) : convert una lista en una tupla

.index(”A”): Buscar el Indice de un elemento
.count(”B”): Numero de veces que un elemento aparece en la Tupla

Queda por sentado que una lista se genera con los brackets “[ ]” mientras que una tupla se genera con parentesis “( )”?

Cuándo usar tuples sobre las listas de Python

Las tuplas son más eficientes en la memoria que las listas. Cuando se trata de la eficiencia del tiempo, las tuplas tienen una ligera ventaja sobre las listas, especialmente cuando consideramos el valor de búsqueda. Si tiene datos que no deberían cambiar, debe elegir el tipo de datos de Tuple sobre las listas.

tuplas son inmutables

platzi_founders = (‘Freddy Vega’,‘Christian Van der Henst’)

Recordemos que si queremos modificar tuplas podemos transfórmala en una lista y modificarla y luego convertirla en tupla de nuevo.
Las tuplas en Python son un tipo o estructura de datos que permite almacenar datos de una manera muy parecida a las listas, con la salvedad de que son inmutables.

numbers = (1, 2, 3, 5)
strings = ('nico', 'zule', 'santi','nico')
print(numbers)
#Primer elemento
print('0 =>', numbers[0])
#Último elemtno
print('-1 =>', numbers[-1])
print(type(numbers))

print(strings)
print(type(strings))

'''
Una tupla es inmutable, es decir, 
no se puede modificar
'''

print(strings.index('zule'))
print(strings.count('nico'))

my_list = list(strings)
print(my_list)
print(type(my_list))

my_list[1] = "juli"
print(my_list)

my_tuple = tuple(my_list)
print(my_tuple)

Tuplas
Estructura de datos inmutables que contiene una secuencia ordenada de elementos

Tupla = (1, 2, 3, 4)

Los elementos están separados por espacios luego de las comas
Puede contener cualquier tipo de datos
Cada posición de la tupla tiene un índice
Es inmutable y por lo tanto no puede ser modificada, lo que permite proteger mejor la data si no queremos que se modifique por error    
    
"""

#NO PUEDO CAMBIARLOS O ACTUALIZARLOS COMO EN UN STRING O CADENA
numeros=(1,2,3,4,5)
strings=("nico","pedro","santi","santi")

print(numeros)
print(type(numeros))

print(numeros[0])
print(numeros[-1])

#Busqueda
print(strings.index("nico"))
#Contar
print(strings.count("santi"))

#Podemos transformar una tupla a un string
mi_lista=list(strings)
print(mi_lista)
mi_lista[0]="andre"
print(mi_lista)

mi_tupla=tuple(mi_lista)
print(mi_tupla)

Por error escribí:

my_list = list('strings')

print(my_list)

ingresando strings como una cadena de texto y no haciendo referencia a la tupla creada en la clase.
El output fue:

[‘s’, ‘t’, ‘r’, ‘i’, ‘n’, ‘g’, ‘s’]

se los comparto, ya que puede ser funcional para algunos casos 😉

Algunas diferencias de las tuplas y listas:

• Las tuplas son inmutables, lo que significa que no podemos hacer cambios en ellas.

• Usamos paréntesis en lugar de corchetes para representarlas.

• Las tuplas son más eficientes en términos de memoria y rendimiento que las listas, lo que las hace ideales para situaciones que requieren una mayor velocidad.

Tuplas en Python

Otra sintaxis para generar una tupla, es simplemente sin los parentesis. Por ahora prefiero más la forma con parentesis, pero es bueno saberlo por si vemos esta forma en alguna documentación.

my_tuple = 1,2,3
print(my_tuple) # Output: (1, 2, 3)
print(type(my_tuple)) # Output: <class 'tuple'>

Espero les sirvan mis apuntes!

# TUPLES: Estructura de datos inmutables que contiene una secuencia ordenada de elementos, no puedo añadir ni modificar elementos. Visualmente podemos diferenciarlos por que las LIST usan corchetes [] y los TUPLES usan parentesis ()

numbers = (1, 2, 3, 5)
strings = ('nico', 'zule', 'santi', 'nico')
print(numbers)
print('0 =>', numbers[0]) 
# El entrecomillado es para que visualmente veamos la posición, podría simplificarse como "print(numbers[0])", en cualquier caso nos dice que valor ocupa el puesto '0'
print('-1 =>', numbers[-1]) 
# Usamos el mismo metodo que el anterior, pero preguntamos por el valor de la última posición
print(type(numbers))

print(strings)
print(type(strings))

# Al ser las TUPLES inmutables, si probaramos a por ejemplo añadir elementos , nos daría error "AttributeError: 'tuple' object has no attribute 'append'". Ejemplo de codigo:
#      · numbers.append(10)
#        print(numbers)
# Lo mismo pasaría si quiera modificar un valor
#      · numbers[1] = 'change'
#        print(numbers)

print(strings)
# Con TUPLES también tenemos distintos métodos, por ejemplo con '.index' podemos preguntar la posición de un valor
print(strings.index('zule')) 
# Con '.count', preguntamos cuantas veces aparece un valor, por ejemplo 'nico' para este ejemplo, aparece dos veces
print(strings.count('nico')) 

# IMPORTANTE: Si queremos añadir un valor a un TUPLE, no vamos a poder de forma natural, sin embargo podemos hacer transformaciones entre LIST y TUPLES. Para ello creamos una lista 'my_list' en este caso, y usamos el metodo 'list' delante del nombre del TUPLE que queremos convertir en LIST, si además imprimimos el TYPE de 'my_list'veremos que es -class 'list'-
my_list = list(strings) 
print(my_list)
print(type(my_list))

# Ahora haría modificaciones, por ejemplo cambiando el valor 1 por uno nuevo
my_list[1] = 'alex'
print(my_list)

# Y volveriamos a convertir la LIST en TUPLE, usando el metodo 'tuple' delante del LIST
my_tuple = tuple(my_list)
print(my_tuple)

Tuplas

• Las tuplas son listas de elementos, pero listas inmutables. Es decir, que una vez definida la tupla ya no puedes modificarla. La única opción que tienes para cambiar una tupla es volviendo a definirla. Al igual que sucede con las listas, las tuplas son conjuntos de elementos. Estos conjuntos de elementos puede contener todo tipo de datos, incluso, puedes tener en una misma tupla distintos tipos de datos.

• Para saber si un objeto es una tupla puedes utilizar la función type, que te debe devolver lo siguiente,

#se importa libreria para manejo de datos aleatorios
import random
#se agregan a variable tupla opciones para el pc
options=(‘piedra’,‘papel’,‘tijera’)
#captura la opcion del usuario
user_option = input('piedra, papel o tijera: ')
#pasa a minusculas opcion del usuario
user_option.lower()
#pc escoje una opcion aleatoria
computer_option = random.choice(options)

print('opcion usuario: ',user_option)
print('opcion pc: ',computer_option)

if user_option == computer_option:
print(‘Empate’)
elif user_option == ‘piedra’:
if computer_option == ‘tijera’:
print(‘piedra gana a tijera’)
print(‘user gano!’)
else:
print(‘Papel gana a piedra’)
print(‘computer gano!’)
elif user_option == ‘papel’ :
if computer_option == “piedra”:
print(‘papel gana a piedra’)
print(‘user gano!’)
else:
print(‘tijera gana a papel’)
print(‘computer gano!’)
else: # user tiene tijera
if computer_option == ‘papel’:
print(‘tijera gana a papel’)
print(‘user gano!’)
else:
print(‘piedra gana a tijera’)
print(‘computer gano!’)

""" Tuples """
numbers = (34, -12, 97.56, 45, -6.9)
print("numbers =", numbers)
print(type(numbers))
strings = ("haru", "ore", "star", "cpu")
print("strings =", strings)
print(type(strings))

# read
print("-" * 35)
numbers = (34, -12, 97.56, 45, -6.9)
print("numbers =", numbers)
print("numbers[2] =>", numbers[2])
print("numbers.index(45) =>", numbers.index(45))
print("numbers.count(52) =>", numbers.count(52))

# transformation
print("-" * 35)
numbers = (34, "ore", 97.56, "star", -6.9)
print("numbers =", numbers)
print(type(numbers))
print("numbers_1 = list(numbers)")
numbers_1 = list(numbers)
print("numbers_1 =", numbers_1)
print(type(numbers_1))
print("numbers_2 = tuple(numbers_1)")
numbers_2 = tuple(numbers)
print("numbers_2 =", numbers_2)
print(type(numbers_2))

Tuplas

• Una tupla es de solo lectura, no admite operaciones CRUD
• utiliza la función tuple()
• se puede crear una nueva tuplaa partir de una existente

Metodos:

• index(): da la posicion de un elemento
• count(): cantidad de elementos en la tupla
• len(): longitud de la tupla

Principales caracteristicas de las tuples:

1. Los elementos se encuentran encerrrados entre () y separados por comas (,)
2. Son estructuras ordenads, para ello se usan indices.
3. Son estructuras inmutables(no se puede agregar, eliminar, ordenar)
4. Pueden tener elementos duplicados.
5. Pueden tener los mismos o distinto tipos de elementos.

Hola les comparto mi codigo comentando

#tuplas
#las tuplas se ponen con parentesis, y las listas con parentesis cuadrados
#en las tuplas tambien puedo tener diferentes tipos de datos
#la diferencia de una tupla con una lista, es que no puedo meter mas valores en la tupla, no se puede hacer el "crud", en una lista si se puede
#las tuplas son immutables, no pueden seer modificadas

numbers = (1, 2, 3, 5)
strings = ('nico', 'zule', 'santi', 'nico')
print(numbers)
print('o => ', numbers[0]) #imprime el valor de la posicion 0
print('-1 => ', numbers[-1]) #imprime el ultimo valor de la tupla
print(type(numbers))

print(strings)
print(type(strings))

#CRUD
#no funciona el atributo como append, remove o insert

print(strings)
print(strings.index('zule')) #me dice la posicion de zule en la tupla
print(strings.count('nico')) #cuenta cuantas veces esta un valor en la tupla

my_list = list(strings) #esto convierte una tupla en una lista, las listas si se pueden modificar
print(my_list)
print(type(my_list))

my_list[1] = 'Juli'
print(my_list)

my_tuple = tuple(my_list)
print(type(my_tuple))
print(my_tuple)

puede que sea una aclaracion obvia pero cuando se esta aprendiendo cualquier aclaracion puede ser util:

No transformó la tupla en una lista, simplemente la copio y deposito sus datos en una lista, esto lo podemos ver si imbocamos type(strings) lo que nos va a devolver tupla mientras que al mismo tiempo vamos a tener my_list como una lista.
para dar la sensacion mas realista de que combertimos la tupla en una lista lo que debemos hacer es renombrar a la tupla “strings” con el nombre “my_list” tal que asi:

#creamos la tupla y la depositamos en la variable "cosas"
cosas = (1, 20, 3, "roberto estropajo")

'''
aca copiamos la tupla con list(cosas)
y la depositamos en una lista llamada my_list
'''
my_list = list(cosas) 



'''
por lo tanto ahora tenemos una tupla que podemos ver usando 
print(cosas)
 y una lista que podemos ver usando 
print(my_list)
'''



'''
Aca le asignamos a la variable cosas el valor de my_list
'''
cosas = my_list

'''
y ahora podemos decir que transformamos la tupla en una lista, aunque como vimos no es asi, solo reasignamos valores pero en todo momento la tupla sigue existiendo en una parte del codigo, solo que a este punto no tenemos como llamarla porque digamos que "quedó sin nombre", para evitar esto podemos hacer lo siguiente:
'''

cosas = (1, 20, 3, "roberto estropajo")
cosas = list(cosas)

#o tambien
cosas = list((1, 20, 3, "roberto estropajo"))

de esta forma evitamos consumir memoria de mas asignando solamente una variable a toda la operacion, aunque tambien hay que tener en cuenta que esto de asignar variables a todo puede ser una buena practica ya que estamos dejando el paso a paso de como procesamos todos nuestros datos, ya que es mas dificil leer esto:

print(type((1,30,20, "jajaxd", [pajarito, canino, (sorieketon, (cocos, 2))]).remove(1)))

que leer:

pajarito = "el topo"
canino = "pastel de platanos estamos salvados"
sorieketon = "para de fedear"
cocos = "ya no se puede compar un kilo de osobuco"
otra_tupla = (sorieketon, (cocos, 2))
listilla = [pajarito, canino, otra_tupla]

tupla = (1, 30, 20, "jajaxd", listilla)
tupla.remove(1)
print(type(tupla))

de ambas formas obtenemos el mismo resultado, pero es mas facil leer el error en una que en la otra lo que a su vez facilita al siguiente programador que vaya a tocar tu codigo que pueda resolver con mayor fluidez y evitar el codigo spagetti

pd: no lo ejecute pero deberia dar None o algun error.

NO ES OBLIGATORIO USAR PARENTESIS PARA DECLARAR UNA TUPLA

Puedes simplemente declarar la variable e igualarla a elementos separados por comas. Por ejemplo

my_tuple = 1, 2, 3

#OBS: Las tuplas son solo de lecturas
#Puedo tener una tupla que sea solo de numeros y/o String
numbers = (1, 2, 3, 5)
strings = ('ivan', 'zule', 'santi', 'ivan')
print(numbers)
#¿como accedo a un valor de la tupla?
print('0 =>', numbers[0])
print(type(numbers))
#¿como accedo a un valor al final de la tupla?
print('-1 =>', numbers[-1])
print(strings)
print(type(strings))

#¿En que posicion esta un elemento en la tupla?
print(strings)
print(strings.index('zule'))
#contar cuantas veces esta un elemento dentro de la tupla
print(strings.count('ivan')) 
#Para convertir una tupla en lista usamos la funcion list
my_list = list(strings)
print(my_list)
print(type(my_list))

#Ya teniendo la lista hacemos las modificaciones deseadas 
my_list[1] = 'juli'
print(my_list)

#Para convertir una lista en tupla usamos la funcion tuple
my_tuple = tuple(my_list)
print(my_tuple)

En el minuto 8:30 el profe tuvo un pequeño error, dijo:

“pasamos de tupla hacia string”

Pero creo que quiso decir:

“pasamos de tupla hacia lista”

¡Saludos! 😄

#18_tuples
numbers=(1,2,3,4,5)
strings=(‘nico’,‘numeros’,‘texto’)
print(numbers)
#saber la posicion de la tupla
print(‘0=>’,numbers[0])
print(‘0=>’,numbers[-1])
print(type(numbers))
#en la tupla no puedo hacer modificaciones como con las listas en crud, y son solo de lectura
print(strings)
print(type(strings))
print(strings.index(“texto”))
#podemos ver cuantas veces esta nico
print(strings.count(“texto”))

#si nos dan una tupla podemos convertirla a lista
my_list=list(strings)
print(my_list)
print(type(my_list))

my_list[1] = 'juli’
print(my_list)

my_tuple=list(my_list)
print(my_tuple)
print(type(my_tuple))

Hola

Les comparto el código de la clase.

# Tuplas
# https://www.w3schools.com/python/python_tuples.asp

'''
Las tuplas son inmutables, es decir que no podemos
realizar cambios sobre ellas.
En la tupla solo podemos realizar la declaración.
'''

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

print(numbers)
print(type(numbers))
print("0 =>", numbers[0])
print("-1 =>", numbers[-1])

strings = ('Sara', 'Nico', 'Freddy', 'Nico')
print(strings)
print(type(strings))

# Métodos
# Buscar elementos dentro de la tupla
print(strings.index("Sara"))

# Contar cuantas veces está un elemento dentro de la tupla
print(strings.count("Nico"))

# Pasar una tupla a lista
my_list = list(strings)
# Vemos que al imprimir se muestra entre [] correspondientes a listas
print(my_list)
print(type(my_list))

# Modificar lista
my_list[1] = "Juli"
print(my_list)

# Pasar una lista a una tupla
my_tuple = tuple(my_list)
print(my_tuple)
print(type(my_tuple))

Les comparto un artículo de freecodecamp que profundiza en las diferencias entre listas y tuplas

Tuplas

Son estructuras de datos inmutables, tiene elementos ordenados en ella
Algunas caracterísitcas son:

• Se separan con comas
• Se contienen en paréntesis
• Pueden contener cualquier tipo de dato
• La data está protegida de modificaciones involutarias

numbers = (1, 3, 4, 6, 6)
strings = ("Ana", "Vale", "Jorge")

print(numbers)
print(type(numbers))

print(strings)
print(type(strings))

Puedo imprimir su posición inicial indexándola

print("Posición 0: ", numbers[0])

Puedo imprimir su posición final indexándola

print("Posición final: ", numbers[-1]) 

En unta tupla podré solo declarar pero no modificar, porque son inmutables
Una vez declarada no se puede modificar

Imprime la posición dentro de la tupla

print(strings.index("Vale")) 

Cuenta cuántas veces está un elemento en una tupla

print(numbers.count(6)) 

Si necesariamente quiero modificar el contenido, debo transformar la tupla a lista

lista = list(strings)
print(lista)
print(type(lista))

lista[1] = "Pedro"
print(lista)

Una vez modificada la lista, puedo pasarla a tupla

tupla = tuple(lista)
print(lista)
print(type(tupla))

numbers = (1, 2, 3, 5)
strings = ('nico', 'zulo', 'santi', 'nico')
print(numbers)
print('0 => ',numbers[0])
print('-1 =>', numbers[-1])
print(type(numbers))

print(strings)
print(type(strings))

# CRUD
#numbers.append(10)
print(numbers)
#numbers[1] = 'change'

print(strings)
print(strings.index('zulo'))
print(strings.count('nico'))

my_list = list(strings)
print(my_list)
print(type(my_list))

my_list[1] = 'juli'
print(my_list)

my_tuple = tuple(my_list)
print(my_tuple)

Las inmutables

<numbers = (1, 2, 3, 5)
strings = ('nico', 'zule', 'santi', 'nico')
print(numbers)
print('0 =>', numbers[0])
print('-1 =>', numbers[-1])
print(type(numbers))

print(strings)
print(type(strings))

# CRUD no funciona en tuplas
# numbers.append(10)
print(numbers)
# numbers[1] = 'change'

# Métodos de las tuplas
print(strings)
print(strings.index('zule'))
print(strings.count('nico'))

#Transformar Tupla() a Lista[]
my_list = list(strings)
print(my_list)
print(type(my_list))

#Modificar Lista[] 
my_list[1] = 'juli'
print(my_list)

#Transformar Lista[] a Tupla()
my_tuple = tuple(my_list)
print(my_tuple)> 

básicamente las constantes de los arrays (listas)

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

print(numbers)
print('type of numbers: ',type(numbers))

# Primer elemento
print('Posición  0 =>', numbers[0])

# Último elemento
print('Posición -1 =>', numbers[-1]) # (4, 5)

Genial…!!

Me encanto esta estructura de datos. Jamas pense que me gustarian las tuplas. Espero seguir aprendiendo.

✅

Las tuplas en Python son una estructura de datos similar a las listas, pero con una diferencia clave: las tuplas son inmutables. Esto significa que una vez que creas una tupla, no puedes cambiar su contenido. Aquí hay una explicación más detallada sobre las tuplas:

1. Sintaxis de una tupla:
   En Python, las tuplas se crean utilizando paréntesis () o simplemente separando los elementos con comas ,. Por ejemplo:

   pythonCopy code
   mi_tupla = (1, 2, 3)
   otra_tupla = 4, 5, 6  # Sin paréntesis
   
   

   En estos ejemplos, mi_tupla y otra_tupla son tuplas que contienen valores enteros.

2. Inmutabilidad:
   La principal característica de las tuplas es su inmutabilidad. Esto significa que una vez que creas una tupla, no puedes modificar sus elementos, agregar nuevos elementos ni eliminar elementos existentes. Por ejemplo, esta operación generaría un error:

   pythonCopy code
   mi_tupla[0] = 10  # Esto generará un error, ya que las tuplas son inmutables.
   
   

3. Acceso a elementos:
   Puedes acceder a los elementos de una tupla utilizando índices, de la misma manera que lo haces con las listas. Por ejemplo:

   pythonCopy code
   primer_elemento = mi_tupla[0]  # Acceso al primer elemento (1)
   
   

4. Longitud de una tupla:
   Puedes obtener la longitud de una tupla utilizando la función len():

   pythonCopy code
   longitud = len(mi_tupla)  # Esto devolverá 3 en este caso
   
   

5. Desempaquetado de tuplas:
   Puedes desempaquetar los elementos de una tupla en variables individuales de la siguiente manera:

   pythonCopy code
   a, b, c = mi_tupla
   
   

   Esto asignará el valor 1 a a, el valor 2 a b y el valor 3 a c.

6. Uso de tuplas:
   Las tuplas se utilizan cuando necesitas una colección ordenada de elementos inmutable. Algunos ejemplos comunes de uso de tuplas incluyen:

   • Coordenadas (por ejemplo, (x, y)).
   • Representación de fechas y horas.
   • Claves para diccionarios (ya que las tuplas son inmutables y, por lo tanto, pueden ser usadas como claves).

Las tuplas son especialmente útiles cuando necesitas asegurarte de que los datos no cambien accidentalmente en tu programa y cuando deseas un rendimiento ligeramente mejor que el de las listas, ya que las tuplas son más eficientes en términos de memoria y velocidad debido a su inmutabilidad.

ejemplo de tuplas:

if __name__ == '__main__':
    print("**** ejemplo de tuplas y secuencias ****")
    print("Tuples are immutable, no se puede cambiar algun elemento\n\n")

    print("1. create tuples:")
    print("sintax: mi_tupla = (valor1, valor2, valor3)\n o mi_tupla = tuple(valor1, valor2, valor3)")

    puntos = ((1, 2), (3, 4), (5, 6))

    print(puntos)

    print("2. read any element with [posicion]. for example: mi_tupla[0]")
    print(puntos[0])

    print("3. Show elements with [:posicion]. for example: mi_tupla[:1]")
    print("[:posicion]->muestra los elementos de la tupla hasta la posicion, no incliuye la posicion")
    print("[posicion:]->muestra los elementos de la tupla desde la posicion, incluye la posicion")
    print(puntos[:0])
    print("puntos[:1]:-->",puntos[:1])
    print("puntos[1:]:-->",puntos[1:])
    print(puntos[:1])
    print(puntos[:2])
    print(puntos[:3])
    print(puntos[:4])
    print("4. puede crear una nueva tupla a partir de una existente, \nutilizando la sintaxis tupla = tupla[:indice] + (nuevo_valor,) + tupla[indice+1:]")
    nuevo_punto = (7, 8)
    puntos = puntos[:1] + (nuevo_punto,) + puntos[2:]
    print("puntos:", puntos)

    print("5. Tuples may be nested:")
    print("por ejemplo la tupla: (1, 2, 3, 4, 5) desea unirse con puntos. puntos + u")
    u = puntos, (1, 2, 3, 4, 5)
    print(u)

    print("6. pertenencia de elementos en los puntos")
    print("por ejemplo el punto (7,8)")
    print("puntos:", puntos)
    print("(7,8) pertenece a puntos -->", (7,8) in puntos)
    print("(0,1) pertenece a puntos -->", (0,1) in puntos)

    print("7. metodos en los puntos")
    print("7.1. index(elemento): Retorna el índice de la primera ocurrencia del elemento en la tupla.")
    #print(puntos.index((3, 4)))
    print(puntos.index((5, 6)))

    print("7.2. count(elemento): Cuenta cuántas veces un elemento está en una tupla.")
    print(puntos.count((5, 6)))

    print("7.3. len(tupla): Retorna la cantidad de elementos de la tupla")
    print(len(puntos))

TUPLAS - CHAT GPT

En Python, una tupla es una estructura de datos similar a una lista, pero con una diferencia clave: las tuplas son inmutables, lo que significa que una vez que se crean, no se pueden modificar, agregar ni eliminar elementos. Las tuplas son útiles cuando necesitas almacenar un conjunto de elementos que no cambiarán durante la ejecución de tu programa.

Características clave de las tuplas:

1. Creación de Tuplas:
   Puedes crear una tupla utilizando paréntesis () y separando los elementos con comas ,.

Ejemplo:

coordenadas = (10, 20)
colores = ("rojo", "verde", "azul")
mixta = (5, "hola", True)

1. Acceso a Elementos:
   Al igual que en las listas, puedes acceder a los elementos de una tupla utilizando la indexación (índices numéricos). Los índices comienzan desde 0 para el primer elemento.

Ejemplo:

colores = ("rojo", "verde", "azul")
primer_color = colores[0]  # "rojo"
segundo_color = colores[1]  # "verde"

1. Inmutabilidad:
   A diferencia de las listas, las tuplas son inmutables. Esto significa que no puedes cambiar, agregar ni eliminar elementos una vez que la tupla ha sido creada.

Ejemplo:

coordenadas = (10, 20)
coordenadas[0] = 15  # Esto generará un error, ya que las tuplas son inmutables

1. Usos Comunes de las Tuplas:
   Las tuplas son útiles cuando deseas almacenar datos que no deben cambiar, como coordenadas, nombres de días de la semana, información constante, entre otros. También son utilizadas para retornar múltiples valores desde una función.

Ejemplo de retorno de múltiples valores:

def obtener_coordenadas():
    x = 10
    y = 20
    return x, y

coordenada_x, coordenada_y = obtener_coordenadas()

1. Longitud de la Tupla:
   Puedes obtener la cantidad de elementos en una tupla utilizando la función len().

Ejemplo:

colores = ("rojo", "verde", "azul")
cantidad = len(colores)  # 3

1. Desempaquetado de Tuplas:
   Puedes asignar los valores de una tupla a variables individuales en una sola operación.

Ejemplo:

punto = (5, 10)
x, y = punto

Las tuplas son útiles cuando necesitas garantizar que un conjunto de datos permanezca constante a lo largo del programa. Su inmutabilidad puede ser beneficiosa en ciertos escenarios. Si sabes que no necesitarás modificar los elementos almacenados, las tuplas pueden ser una excelente opción para optimizar el rendimiento y prevenir cambios accidentales en tus datos.

TUPLAS A DETALLE

Las tuplas se utilizan para almacenar varios elementos en una sola variable. Una tupla es una colección ordenada e inmutable, lo que significa que no podemos cambiar, agregar o eliminar elementos después de que se haya creado la tupla. .Permite elementos duplicados, están ordenados (significa que los elementos tienen un orden definido y ese orden no cambiará.) y no se pueden modificar.

CREACIÓN DE UNA TUPLA:

Tupla de varios elementos:

mytuple = ("apple", "banana", "cherry")
print(mytuple)

Tupla de un elemento: Para crear una tupla con un solo elemento, debe agregar una coma después del elemento; de lo contrario, Python no lo reconocerá como una tupla.

thistuple = ("apple",)
print(type(thistuple))

#No es una tupla
thistuple = ("apple")
print(type(thistuple))

Permite duplicados:Dado que las tuplas están indexadas, pueden tener elementos con el mismo valor:

thistuple = ("apple", "banana", "cherry", "apple", "cherry")
print(thistuple)

El constructor tupla(): También es posible usar el constructor tuple() para hacer una tupla.

thistuple = ["apple", "banana", "cherry"]
print(type(thistuple))#<class 'list'>
thistuple = tuple(["apple", "banana", "cherry"])
print(type(thistuple))#<class 'tuple'>
print(thistuple)

LONGITUD DE LA TUPLA

thistuple = ("apple", "banana", "cherry")
print(len(thistuple))

TIPOS DE DATOS

Tipos de datos de cadena, int y booleanos:

tuple1 = ("apple", "banana", "cherry")
tuple2 = (1, 5, 7, 9, 3)
tuple3 = (True, False, False)

Una tupla puede contener diferentes tipos de datos:

tuple1 = ("abc", 34, True, 40, "male")
print(tuple1)

Cuál es el tipo de dato:

mytuple = ("apple", "banana", "cherry")
print(type(mytuple))

ACCEDER A LOS ELEMENTOS DELA TUPLA

thistuple = ("apple", "banana", "cherry")
print(thistuple[1])

Indexación negativa:La indexación negativa significa comenzar desde el final.-1 se refiere al último elemento, -2 se refiere al penúltimo elemento, e
tc.

thistuple = ("apple", "banana", "cherry")
print(thistuple[-1])

Gama de índices:La búsqueda comenzará en el índice 2 (incluido) y terminará en el índice 5 (no incluido).

thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
print(thistuple[2:5])

Al omitir el valor inicial, el rango comenzará en el primer elemento:

thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
print(thistuple[:4])

Al omitir el valor final, el rango pasará al final de la lista:

thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
print(thistuple[2:])

Rango de índices negativos:Este ejemplo devuelve los elementos del índice -4 (incluido) al índice -1 (excluido)

thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
print(thistuple[-4:-1])

Comprobar si el artículo existe:

thistuple = ("apple", "banana", "cherry")
print("apple" in thistuple)

ACTUALIZAR TUPLA

Cambiar valores de tupla: Una vez que se crea una tupla, no puede cambiar sus valores. Las tuplas son inmutables. Pero hay una solución. Puede convertir la tupla en una lista, cambiar la lista y volver a convertir la lista en una tupla.

x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)

print(x)

Agregar elementos:Convierta la tupla en una lista, agregue “naranja” y vuelva a convertirla en una tupla:

thistuple = ("apple", "banana", "cherry")
y = list(thistuple)
y.append("orange")
thistuple = tuple(y)
print(thistuple)

Agregue una tupla a una tupla . Puede agregar tuplas a tuplas, por lo que si desea agregar un elemento (o muchos), cree una nueva tupla con los elementos y agréguela a la tupla existente:

thistuple = ("apple", "banana", "cherry")
y = ("orange",)
thistuple += y

print(thistuple)

Eliminar elementos:Convierta la tupla en una lista, elimine “manzana” y vuelva a convertirla en una tupla:

thistuple = ("apple", "banana", "cherry")
y = list(thistuple)
y.remove("apple")
thistuple = tuple(y)
print(thistuple)

O puede eliminar la tupla por completo:La palabra clave “del” puede eliminar la tupla por completo:

thistuple = ("apple", "banana", "cherry")
del thistuple
print(thistuple) # esto generará un error porque la tupla ya no existe

DESEMPAQUETAR ELEMENTOS DE LA TUPLA

Cuando creamos una tupla, normalmente le asignamos valores. Esto se llama “empaquetar” una tupla:

fruits = ("apple", "banana", "cherry")

Pero, en Python, también podemos volver a extraer los valores en variables. Esto se llama “desempacar”:

fruits = ("apple", "banana", "cherry")

(green, yellow, red) = fruits

print(green)
print(yellow)
print(red)

Nota: El número de variables debe coincidir con el número de valores en la tupla, de lo contrario, debe usar un asterisco para recopilar los valores restantes como una lista.
Usando asterisco*:Si el número de variables es menor que el número de valores, puede agregar un *al nombre de la variable y los valores se asignarán a la variable como una lista:

fruits = ("apple", "banana", "cherry", "strawberry", "raspberry")

(green, yellow, *red) = fruits

print(green)
print(yellow)
print(red)

Si el asterisco se agrega a otro nombre de variable que no sea el último, Python asignará valores a la variable hasta que la cantidad de valores restantes coincida con la cantidad de variables restantes.

fruits = ("apple", "mango", "papaya", "pineapple", "cherry")

(green, *tropic, red) = fruits

print(green)
print(tropic)
print(red)

RECORRIDO DE TUPLAS CON BUCLE

Puede recorrer los elementos de la tupla mediante un forbucle.

thistuple = ("apple", "banana", "cherry")
for x in thistuple:
  print(x)

Bucle a través de los números de índice. También puede recorrer los elementos de la tupla haciendo referencia a su número de índice. Utilice las funciones range()y len()para crear un iterable adecuado.

for i in range(len(thistuple)):
  print(thistuple[i])

Usar un ciclo while:

thistuple = ("apple", "banana", "cherry")
i = 0
while i < len(thistuple):
  print(thistuple[i])
  i = i + 1

UNIR TUPLAS

Une dos tuplas. Para unir dos o más tuplas puedes usar el + operador:

tuple1 = ("a", "b" , "c")
tuple2 = (1, 2, 3)

tuple3 = tuple1 + tuple2
print(tuple3)

multiplicar tuplas. Si desea multiplicar el contenido de una tupla un número determinado de veces, puede utilizar el * operador:

fruits = ("apple", "banana", "cherry")
mytuple = fruits * 2

print(mytuple)

MÉTODOS DE TUPLA

El método count() devuelve el número de veces que aparece un valor especificado en la tupla.

thistuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)

x = thistuple.count(5)

print(x)

El método index() encuentra la primera aparición del valor especificado. El método index() genera una excepción si no se encuentra el valor.
Busque la primera aparición del valor 8 y devuelva su posición:

thistuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)

x = thistuple.index(8)

print(x)

Es una estructura similar a las listas en python pero con la diferencia de que es inmutable, algunas de sus características son:

1. Inmutabilidad: Una vez creada, una tupla no puede ser modificada, es decir, no puedes agregar, eliminar ni modificar elementos.
2. Indexación: Los elementos de una tupla se pueden acceder mediante su índice, al igual que en las listas.
3. Orden: Las tuplas mantienen el orden de los elementos, lo que significa que los elementos se mantienen en el mismo orden en el que fueron agregados.
4. Iteración: Puedes recorrer los elementos de una tupla utilizando un bucle for.
5. Soporte para diferentes tipos de datos: Los elementos de una tupla pueden ser de diferentes tipos de datos, por ejemplo, números enteros, cadenas, listas, etc.
6. Eficiencia: Las tuplas son más eficientes en términos de memoria y velocidad de acceso que las listas, debido a su inmutabilidad.
7. Operadores: Puedes utilizar operadores como + para concatenar tuplas y * para repetir sus elementos.
8. Métodos: Las tuplas tienen algunos métodos disponibles, como count() o index() para contar elementos y buscar índices, respectivamente.
9. Uso en diccionarios: Las tuplas se pueden utilizar como claves en un diccionario de Python debido a su inmutabilidad, mientras que las listas no se pueden utilizar como claves.
10. Uso en funciones: Las tuplas se pueden usar para devolver múltiples valores desde una función de Python.

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

# Contar la cantidad de veces que aparece el número 2 en la tupla
cantidad_de_dos = mi_tupla.count(2)
print("Cantidad de veces que aparece el número 2:", cantidad_de_dos)

# Obtener el índice de la primera aparición del número 4 en la tupla
indice_del_cuatro = mi_tupla.index(4)
print("Índice de la primera aparición del número 4:", indice_del_cuatro)

Generado con la ayuda de Chat GPT para concretar.

Usar una tupla en lugar de una lista puede ser beneficioso en ciertas situaciones debido a sus características específicas. Aquí te presento algunas razones por las que podrías optar por utilizar una tupla:

Inmutabilidad: Las tuplas son inmutables, lo que significa que una vez creadas, no se pueden modificar sus elementos. Esta característica asegura que los datos almacenados en una tupla no cambien accidentalmente, lo que puede ser útil en escenarios donde la integridad de los datos es crítica.

Hashable: Las tuplas son hashables, lo que significa que se pueden utilizar como claves en diccionarios de Python. Dado que las listas son mutables, no son hashables y no pueden usarse como claves en un diccionario.

Optimización: Las tuplas son más eficientes en términos de rendimiento y uso de memoria en comparación con las listas. Dado que las tuplas son inmutables, su tamaño y contenido se fijan en el momento de su creación, lo que permite que Python las optimice mejor en ciertas operaciones.

Estructuras de datos constantes: Si necesitas una colección de elementos que no cambie a lo largo del programa, una tupla puede ser una elección más adecuada. Por ejemplo, puedes usar tuplas para representar coordenadas (x, y) o constantes matemáticas.

Uso en funciones: Las tuplas son utilizadas para el empaquetado y desempaquetado de valores en funciones. Por ejemplo, una función puede devolver múltiples valores como una tupla, y al llamar la función, puedes desempaquetar los valores en variables individuales.

Definir claves de diccionario complejas: Puedes usar tuplas para definir claves de diccionario complejas que contengan múltiples valores. Por ejemplo, puedes usar una tupla como clave para representar coordenadas (x, y) en un diccionario.

Como pueden ver la clase ‘tuple’ hereda de la clase ‘list’ ya que las tuplas reutilizan métodos de las listas aunque no reflejan el mismo comportamiento.

o sea que las tuplas van encerradas con corchetes

Estructura de datos inmutables que contiene una secuencia ordenada de elementos

Tupla = (1, 2, 3, 4)

• Los elementos están separados por espacios luego de las comas
• Puede contener cualquier tipo de datos
• Cada posición de la tupla tiene un índice
• Es inmutable y por lo tanto no puede ser modificada, lo que
  permite proteger mejor la data si no queremos que se modifique por error

Métodos que se pueden usar en una tupla

• Acceder a un elemento de la strings[0]
• Verificar si un elemento está o no 'A' in strings
• Retorna la posición de un elemento strings. strings.index['A']
• contar elementos en una tupla strings.count('A')

from os import system
system('clear')
numbers = (1, 2, 3, 5)
strings = ('A', 'C', 'D', 'E', 'F', 'N')

#CONSULTANDO ELEMENTO DE UNA TUPLA
print(numbers)
print(strings)

print('TIPOS DE DATOS')
print(' :',type(numbers))
print(' :',type(strings))
print(' ')

#ACCEDER A AUN VALOR DE LA TUPLA
print('ACCDIENDO A UN VALOR DE LA TUPLAS')
print('numbers[0]  =', numbers[0])
print('numbers[-1] =', numbers[-1])
print(' ')

#BUSCAR LA POSICION DE UN ELEMENTO
print('index(elemento), ubicando la posicion A:') 
print(strings.index('A'))

#INDICAR SI UN ELEMETO EXISTE
print('ExistE el elemento Z')
print('Z' in strings)

#CONTAR LA CANTIDAD DE VECES QUE ESTA UN ELEMENTO EN UNA TUPLA
print('count(elemento), cuenta la cantidad de incidencias')
print(strings.count('F'))

#TRANSFORMANDO UN TUPLA EN LISTA
my_list = list(strings)
print ('Transformando una tupla ne lista')
print(my_list)
print(type(my_list))
my_list.append('E')
print(my_list)

#TRASNFORMANDO UNA LISTA EN TUPLA
print('Transformando un lista en tupla')
my_tuple = tuple(my_list)
print(my_tuple)

Una tupla es una estructura de datos similar a una lista, pero con una diferencia clave: es inmutable, lo que significa que no se pueden modificar una vez creadas.

Una tupla se define utilizando paréntesis ( ) y los elementos se separan por comas.

Las tuplas pueden contener elementos de diferentes tipos de datos, como números, cadenas, booleanos, listas u otras tuplas. Además, pueden tener cualquier cantidad de elementos, desde cero hasta un número ilimitado.

Y con ese bello error al colocar:

print(strings.index("nico"))

podemos ver que al usar index, solo devuelve la posición del primer elemento que encuentre (la posición 0 en este caso), ya que “nico”, está en la posición 0 y 3

Leyendo un artículo se comprueba que las tuplas consumen menos recursos entonces son más eficientes, lo ideal es usarlo cuando tengamos valores fijos, como en “Piedra, Papel, Tijera”

TUPLAS: Estructura de datos inmutables, solo para lectura

tupla una lista ordenada de solo lectura y finita de elementos

numeros =(1,2,3,5)
strings = (“Camilo” , “Nicolas” , “Mario”,“Camilo”)
print(numeros)
print(numeros[0])
print(numeros[-1])
print(type(numeros))

print(strings)
print(type(strings))

CRUD

#numeros.append(10)
print(numeros)
#numeros[1]=“change”

print(strings)
#Posicion del strings
print(strings.index(“Camilo”))
#Cuenta cuantas veces esta repetida la palabra
print(strings.count(“Camilo”))

convertir la tupla en lista

mi_lista = list(strings)
print(mi_lista)
print(type(mi_lista))

mi_lista[1] = "Julia"
print(mi_lista)

mi_tupla=tuple(mi_lista)
print(mi_tupla)

numbers = (1, 2, 3, 5) # Las tuplas se declaran con ()
strings = ('andru', 'flor', 'tata', 'andru') # Las tuplas son inmutables
print(numbers)
print('-1 => ', numbers[-1]) # Las tuplas solo son de lectura
print('0 => ', numbers[0]) # También se buscan los índices con []
print(type(numbers))

print(strings)
print(type(strings))

# CRUD
#numbers.append(10)
print(numbers)
#numbers[1] = 'change'
print(strings)
print(strings.index('andru'))
print(strings.count('andru')) #.count cuenta los valores en un elemento

my_list = list(strings)
print(my_list) #podemos pasar  tuplas a listas con list(tupla)
print(type(my_list))

my_list[1] = 'arlan'
print(my_list)

my_tuple = tuple(my_list) # también se puede pasar de listas a tuplas con tuple(lista)
print(my_tuple)

en la declaración en si solamente cambia el tipo de corchete!

numbers = (1,4,9,25)
strings = (‘Julio’, ‘Marlene’,‘Victor’, ‘Julio’)
print(numbers)
print(‘0 =>’, numbers [0])
print(’-1 =>’,numbers[-1])
print(type(numbers))
print(strings)
print(type(strings))

crud

numbers.appened(10)

print(numbers)

numbers[1]= ‘change’

print(strings)
print(strings.index(‘Marlene’))
print(strings.count(‘Julio’))
my_list = list(strings)
print(type(my_list))
my_list[1] = 'Peter’
print(my_list)
my_tuple=tuple(my_list)
print(my_tuple)

¿Se pueden eliminar elementos de una tupla?

letters=[‘A’,‘B’,‘C’,‘D’,‘E’,‘F’]
print(letters)
letters.append(‘G’)
print(letters)
letters.insert(0,‘z’)
print(letters)
letters.remove(‘C’)
print(letters)
letters.reverse()
print(letters)

#las listas se crean con [] las tuplas se crean con (), para acceder a una posición en las tuplas se hace igual que un arreglo [ ]

#La diferencia entre la lista y la tupla, la lista permite hacer CRUD y la tupla solo permite leer

#Index: Buscar posición de un elemento

#Count(): Contar elementos dentro de la Tupla

#List convierte una tupla en Lista y se pueden hacer transformaciones

#Se puede regresar de una lista a Tupla mediante la funcion Tuple(“LISTA o ARREGLO”)

Razones para usar una lista:

• Si necesita agregar o eliminar elementos de forma dinámica: Las listas son mutables, lo que significa que se pueden agregar o eliminar elementos en cualquier momento. Esto las hace útiles para manejar datos que cambian con frecuencia.

• Si necesita acceder a los elementos mediante un índice: Las listas en Python están indexadas, lo que significa que puede acceder a cualquier elemento en la lista usando su índice. Esto hace que las listas sean útiles para manejar grandes conjuntos de datos.

• Si necesita ordenar los elementos: Las listas en Python son ordenadas, lo que significa que puede ordenar los elementos en la lista en función de algún criterio específico. Esto las hace útiles para manejar datos que necesitan ser ordenados, como una lista de números.

Razones para usar una tupla:

• Si necesita garantizar que los elementos no cambien: A diferencia de las listas, las tuplas son inmutables, lo que significa que no se pueden modificar después de su creación. Esto hace que las tuplas sean útiles para manejar datos que no deben cambiarse, como los valores constantes en una fórmula matemática.

• Si necesita una estructura de datos más ligera: Las tuplas ocupan menos espacio en la memoria que las listas, lo que las hace más eficientes en términos de memoria. Esto las hace útiles para manejar grandes conjuntos de datos que deben ser procesados con rapidez.

• Si necesita devolver múltiples valores desde una función: Las tuplas pueden usarse para devolver múltiples valores desde una función. Esto hace que las tuplas sean útiles para manejar situaciones donde necesite devolver múltiples resultados desde una función.

No se si el profesor lo dijo en la anterior clase, pero descubri lo siguiente:

strings = ('jhon', 'jhony', 'Majo', 'mamor')
print(type(numbers))

print("es =>", strings[0][-1])

**Respuesta: "n"**
Por qué?

#aqui esta lo curioso, este doble [0] [-1], el primer elemento muestra el string clave, en este caso es [0] “jhon”, y el segundo corchete es la posicion de las letras del nombre, por lo ue da coomo respuesta [-1] = “n” . Pues no lo sabia, hice el ejercicio y me sorprendió 😃

Ejemplo

mi_tupla = (1, 2, 3)

<# Las tuplas se diferencian de las listas porque una vez se realiza la declaración no se pueden modificar dado que son inmutables.

numbers = (1,2,3,4,5)
Strings = ('nico', 'zule', 'santi')
print(numbers)
print(Strings)

print(type(Strings))
print(type(numbers))

print('0 =>', numbers[0])
print('-1 =>',Strings[-1] )

# Si se requiere realizar modificaciones podriamos hacer uso de las listas y convertir la tuple a tipo list, realizar la modificación y devolverla a su tipo inicial

myList = list(Strings)
print(myList)
myList[1] = 'juli'
Strings = tuple(myList)
print(Strings)> 

Difference and use case between Tuples and Lists

Reseumen las tuplas solo se puede colsultar
No se le puede agregar ningun dato despues de crearla, ni modificarla

#al igual que con las listas, podemos concatenar entre tuplas, tuplas enteras y tambien slices.

frutas = ("manzana", "pera", "melon", "piña", "fresa")
verduras = ("tomate", "cebolla", "platano", "cilantro", "papa")

fruver = frutas + verduras

print(fruver)
print(fruver[0:4])

print("="*40)
fruver = frutas + verduras[0:3]
print(fruver)

print("="*40)
fruver = frutas[0:3] + verduras[3:5]
print(fruver)

strings = ('Isabel', 'Francisco', 'Carlos', 'Rosita', 'Felix', 'Junada', 'Francisco')

print(my_list.index('Francisco'))
index = my_list.index('Francisco')
my_list[my_list.index('Francisco')]='Valentina'
print(my_list)

****En una lista tú puedes crear, leer, actualizar, y eliminar (CRUD), mientras que en una tupla solo podremos declararla ****

A diferencia de una lista o array. la tupla no puede ser modificada

Por lo general, se utilizan las tuplas para almacenar datos que no cambian a lo largo del tiempo (por ejemplo, las coordenadas geográficas de un lugar) y las listas para almacenar datos que cambian (por ejemplo, los resultados de un juego en tiempo real).

# Python tuples are immutable, once they are created cannot change
# the elements in it

# declaration of a tuple of integers
numbers = (1, 2, 3, 5)

# declaration of a tuple of strings
strings = ("nico", "zule", "santi")

print(numbers)

# we can access the elements by using indexing  
# [0] first element
print("0 =>", numbers[0])
# [-1] the last element of the tuple
print("0 =>", numbers[-1])
# method type() will always show the type of element 
print(type(numbers))

# Due to being immutable the we cannot make use of append() method
# numbers.append(10) 
# this will give us an error
# numbers[1] = "change" this also as we cannot re assign a value to an index

print(strings)
# index() method returns the index where the value "zule" is located
print(strings.index("zule"))

# count() method returns the times "nico" is in the tuple
print(strings.count("nico"))

# casting a tuple in to a list using the list() we make the 
# tuple strings in to a my_list of type list
my_list = list(strings)

print(my_list)
print(type(my_list))

# once a list is created we can modify by index or using other methods
my_list[1] = "juli"
print(my_list)

# once modified the list we can go back and create a new tuple
# with the content of the list 
my_tuple = tuple(my_list)
print(my_tuple)

Una consulta, según lo que veo, significaría que es como un ENUM, una lista de constantes cierto?

La diferencia entre listas y tuplas, es que las tuplas no pueden ser modificadas luego de ser declaras (Ni agregar, ni eliminar datos, son inmutables)

my_list[1] = 'juli’
print(my_list)

my_tuple = tuple(my_list)
print(my_tuple)

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

#Buscar la posicion de un dato
print(numbers.index(3))

#Contar el numero de veces que se repite un dato
print(numbers.count(2))

#Pasar de tupla inmutable a lista
numbers = list(numbers)
print(type(numbers))

#Pasar de lista a tupla inmutable

numbers = tuple(numbers)
print(type(numbers))