No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Tuplas

26/37
Recursos

Aportes 70

Preguntas 13

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 = (鈥滱鈥, 鈥淏鈥, 鈥淐鈥)

Tupla [0] Indice a consultar

鈥淎鈥 Nos retorna el resultado de la posici贸n 0 en la tupla

Encontrar un elemento

Tupla = (鈥滱鈥, 鈥淏鈥, 鈥淐鈥)

鈥淎鈥 in Tupla

True

鈥淶鈥 in Tupla

False

Metodos

Buscar el Indice de un elemento

Tupla = (鈥滱鈥, 鈥淏鈥, 鈥淐鈥)

Tupla.index(鈥滱鈥)

0 Nos devuelve el indice del elemento que buscamos

Numero de veces que un elemento aparece en la Tupla

Tupla = (鈥滱鈥, 鈥淏鈥, 鈥淐鈥)

Tupla.count(elemento)

Tupla.count(鈥滲鈥)

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 鈥楲鈥 de Listas, ya que se parece a un corchete a medias " [ "

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

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: Estructura de datos inmutables, solo para lectura

Numbers = (1, 2, 3, 4)
String = (鈥榥ico鈥, 鈥榡uan鈥, 鈥榮anti)

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

.index(鈥滱鈥): Buscar el Indice de un elemento
.count(鈥滲鈥): 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 鈥( )鈥?

tuplas son inmutables

platzi_founders = (鈥楩reddy Vega鈥,鈥楥hristian Van der Henst鈥)

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)

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.

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.

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

Tupla = (1, 2, 3, 4)

Los elementos estn 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)

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'>

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:

[鈥榮鈥, 鈥榯鈥, 鈥榬鈥, 鈥榠鈥, 鈥榥鈥, 鈥榞鈥, 鈥榮鈥橾

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

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,

Tuplas en Python

#se importa libreria para manejo de datos aleatorios
import random
#se agregan a variable tupla opciones para el pc
options=(鈥榩iedra鈥,鈥榩apel鈥,鈥榯ijera鈥)
#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(鈥楨mpate鈥)
elif user_option == 鈥榩iedra鈥:
if computer_option == 鈥榯ijera鈥:
print(鈥榩iedra gana a tijera鈥)
print(鈥榰ser gano!鈥)
else:
print(鈥楶apel gana a piedra鈥)
print(鈥榗omputer gano!鈥)
elif user_option == 鈥榩apel鈥 :
if computer_option == 鈥減iedra鈥:
print(鈥榩apel gana a piedra鈥)
print(鈥榰ser gano!鈥)
else:
print(鈥榯ijera gana a papel鈥)
print(鈥榗omputer gano!鈥)
else: # user tiene tijera
if computer_option == 鈥榩apel鈥:
print(鈥榯ijera gana a papel鈥)
print(鈥榰ser gano!鈥)
else:
print(鈥榩iedra gana a tijera鈥)
print(鈥榗omputer 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))

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)

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 鈥渟trings鈥 con el nombre 鈥渕y_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:

鈥減asamos de tupla hacia string鈥

Pero creo que quiso decir:

鈥減asamos de tupla hacia lista鈥

隆Saludos! 馃槃

#18_tuples
numbers=(1,2,3,4,5)
strings=(鈥榥ico鈥,鈥榥umeros鈥,鈥榯exto鈥)
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(鈥渢exto鈥))
#podemos ver cuantas veces esta nico
print(strings.count(鈥渢exto鈥))

#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

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

  • 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

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 鈥渘aranja鈥 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 鈥渕anzana鈥 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 鈥渄el鈥 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 鈥渆mpaquetar鈥 una tupla:

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

Pero, en Python, tambi茅n podemos volver a extraer los valores en variables. Esto se llama 鈥渄esempacar鈥:

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 鈥榯uple鈥 hereda de la clase 鈥榣ist鈥 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

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.

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 鈥渘ico鈥, 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 鈥淧iedra, 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 = (鈥淐amilo鈥 , 鈥淣icolas鈥 , 鈥淢ario鈥,鈥淐amilo鈥)
print(numeros)
print(numeros[0])
print(numeros[-1])
print(type(numeros))

print(strings)
print(type(strings))

CRUD

#numeros.append(10)
print(numeros)
#numeros[1]=鈥渃hange鈥

print(strings)
#Posicion del strings
print(strings.index(鈥淐amilo鈥))
#Cuenta cuantas veces esta repetida la palabra
print(strings.count(鈥淐amilo鈥))

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 = (鈥楯ulio鈥, 鈥楳arlene鈥,鈥榁ictor鈥, 鈥楯ulio鈥)
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]= 鈥榗hange鈥

print(strings)
print(strings.index(鈥楳arlene鈥))
print(strings.count(鈥楯ulio鈥))
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=[鈥楢鈥,鈥楤鈥,鈥楥鈥,鈥楧鈥,鈥楨鈥,鈥楩鈥橾
print(letters)
letters.append(鈥楪鈥)
print(letters)
letters.insert(0,鈥榸鈥)
print(letters)
letters.remove(鈥楥鈥)
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(鈥淟ISTA 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] 鈥渏hon鈥, y el segundo corchete es la posicion de las letras del nombre, por lo ue da coomo respuesta [-1] = 鈥渘鈥 . 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))