Listas de más dimensiones y Tuplas

Algo que me parecio muy interesante es que puedes incluir listas dentro de tuplas. Lo interesante de esto es que a pesar de que no puedes cambiar elementos de la tuplas si puedes cambiar los elementos que se encuentran dentro de la lista que se encuentra incluida en la tupla. Lo que de alguna manera implicaría que se estan cambiando elementos de una tupla. Que mundo tan maravilloso el que podemos descubrir. :) ```python 'We can include list inside tuples' numbers2 = (7,8,9,10,[11,12]) print(numbers2) print(numbers2[4]) print(type(numbers2[4])) # list # numbers2[4] = [20,40] -----> Gives error since they are inmutable numbers2[4][1] = 2 print(numbers2) '''No podemos cambiar la tupla pero si podemos modificar las variables que se encuentran dentro de la lista que a su vez esta incluida en la tupla''' ``` ```js ```

# Listas Multidimensionales y Tuplas ```js # Lista de dos dimensiones matriz = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ] print("Matriz:") for fila in matriz: for elemento in fila: print(elemento, end=' ') print() # Lista de tres dimensiones tensor = [ [ [1, 2, 3], [4, 5, 6] ], [ [7, 8, 9], [10, 11, 12] ] ] print("\nTensor:") for bloque in tensor: for fila in bloque: for elemento in fila: print(elemento, end=' ') print() print() # Tuplas tupla1 = (1, 2, 3) tupla2 = (4, 5, 6) print("Tupla1:", tupla1) print("Tupla2:", tupla2) tupla_concatenada = tupla1 + tupla2 print("Tupla concatenada:", tupla_concatenada) tupla_repetida = tupla1 * 2 print("Tupla repetida:", tupla_repetida) print("¿Está 3 en la tupla1?", 3 in tupla1) print("Longitud de tupla1:", len(tupla1)) print("Elementos de tupla1:") for elemento in tupla1: print(elemento) a, b, c = tupla1 print("Desempaquetado de tupla1:", a, b, c) ``` * **Listas de Dos Dimensiones**: Se crea una lista que representa una matriz, se accede a sus elementos y se iteran. * **Listas de Tres Dimensiones**: Se crea una lista que representa un tensor, se accede a sus elementos y se iteran. * **Tuplas**: Se crean tuplas, se accede a sus elementos, se muestran ejemplos de concatenación, repetición, verificación de pertenencia, longitud y desempaquetado.

Tanto las **listas** como las **tuplas** son tipos de secuencias que pueden almacenar múltiples elementos, pero tienen diferencias clave: 1. **Mutabilidad**: * **Lista**: Es **mutable**, lo que significa que puedes modificarla (agregar, eliminar o cambiar elementos) después de crearla. Ejemplo: `mi_lista = [1, 2, 3]` → Puedes hacer `mi_lista[0] = 10`. * **Tupla**: Es **inmutable**, lo que significa que no puedes modificarla una vez creada. Ejemplo: `mi_tupla = (1, 2, 3)` → No puedes hacer `mi_tupla[0] = 10`. 2. **Sintaxis**: * **Lista**: Se crea usando corchetes `[]`. Ejemplo: `mi_lista = [1, 2, 3]`. * **Tupla**: Se crea usando paréntesis `()`. Ejemplo: `mi_tupla = (1, 2, 3)`. 3. **Uso común**: * **Lista**: Se usa cuando necesitas una secuencia de elementos que puede cambiar a lo largo del programa. * **Tupla**: Se usa cuando tienes una secuencia de elementos que no debería cambiar, o para mejorar el rendimiento, ya que las tuplas son más rápidas y consumen menos memoria que las listas.

Spoiler alert! Las funciones, que son bloques de codigo que tienen un objetivo especifico pueden retornar un valor o varios, en caso de que sean varios, estos valores se devuelven `tuplas`!

🟢 **Qué son las referencias en memoria** La **referencia en memoria** se refiere a la manera en que Python gestiona y accede a los objetos almacenados en la memoria. En lugar de trabajar directamente con los valores, Python utiliza referencias, que son punteros que indican dónde se encuentra un objeto en la memoria (RAM). Por ejemplo, quiero tener los valores de una lista `a` en `b`. Entonces, si `b = a`, `b` no tendrá los valores de la lista `a`, sino su **referencia en memoria**. Visualmente, se vería de la siguiente manera:  Entonces si realizas un cambio en a, también lo harás en b. Puedes comprobar esto con el operador is, o como lo enseño la profesora de visualizar exactamente su posición en memoria. ```python a is b #True id(a) == id(b) #True ``` Para resolver esto puedes hacer una copia. Sin embargo, debes tener cuidado si utilizas el slicing `c = a[ : ]`. Este slicing hace una copia superficial. El problema de una copia superficial, es que si tienes estructuras no primitivas anidadas, como lista de más dimensiones, entonces estas seguirán teniendo la **misma referencia en memoria al momento de la copia**. ```python a = [1, [2]] c = a[:] a is c #False a[1] is c[1] #True ``` Para resolver esto, puedes hacer una **copia profunda** con el módulo `copy` de Python y su método `deepcopy`. ```python import copy a = [1, [2, [3]]] d = copy.deepcopy(a) a is d #False a[1] is d[1] #False a[1][1] is d[1][1] #False ``` Si no entiendes muy bien sobre módulos, no te preocupes, solo ten en cuenta que así debes de traer `copy` para utilizarlo en tu código. Espero haberte ayudado. ¡Nunca pares de aprender! 🚀🚀

### **Creando un Juego de Ajedrez en Python.**  ¡Hola a todos! 👋 Hoy quiero compartir **un juego de ajedrez en Python**. Aunque no es tan avanzado como los programas profesionales, es perfecto para aprender conceptos básicos de programación y entender cómo se pueden modelar juegos de lógica en código.  #### **¿Qué hace este proyecto?** * **Representa un tablero de ajedrez**: Usamos una lista de listas para simular el tablero 8x8, donde cada casilla contiene una pieza o está vacía. * **Valida movimientos**: Cada pieza tiene reglas específicas. Por ejemplo, los peones avanzan hacia adelante y las torres se mueven en línea recta. * **Alterna turnos**: Después de cada movimiento, el turno pasa al otro jugador. * **Lleva un registro del puntaje**: Basado en las piezas capturadas, el programa calcula el puntaje de cada jugador. #### **¿Por qué es útil para principiantes?** Este proyecto es ideal para practicar: * **Funciones**: Dividimos el código en partes reutilizables. * **Bucles**: El juego se ejecuta en un bucle infinito hasta que decides cerrarlo. * **Lógica condicional**: Validar movimientos requiere muchas condiciones y verificaciones. * **Estructuras de datos**: Usamos listas y diccionarios para organizar la información. #### **¿Qué sigue?** En el futuro, me gustaría añadir más reglas del ajedrez, como el enroque o el jaque mate, y quizás crear una interfaz gráfica para hacerlo más visual. ### **¿Te animas a probarlo?** Si quieres ver el código completo o tienes alguna pregunta, ¡no dudes en dejarme un comentario! Estoy aquí para ayudarte y compartir más detalles. ¡Vamos a programar juntos! 💻✨ <https://github.com/ruloCode/Learning-python/blob/main/ajedrez.py>

creo que en el ejemplo del minuto 2:40 falto abrír un corchete

Parece que ya discutimos sobre las listas de más dimensiones y las tuplas, pero puedo expandir o aclarar cualquier parte si lo deseas. Aquí tienes un resumen y algunos detalles adicionales sobre cada concepto: \### Listas de Más Dimensiones Las listas de más dimensiones en Python son simplemente listas que contienen otras listas como elementos. Esto te permite crear estructuras como matrices o tablas, donde los datos se organizan en filas y columnas. \#### Ejemplo de Lista Bidimensional: ```python \# Una matriz 3x3 matriz = \[ \[1, 2, 3], \[4, 5, 6], \[7, 8, 9] ] \# Acceder a un elemento: por ejemplo, el número 6 print(matriz\[1]\[2]) # Salida: 6 ``` En este ejemplo, `matriz` es una lista de listas, donde cada lista interna representa una fila de la matriz. \#### Ejemplo de Lista Tridimensional: ```python \# Un cubo 2x2x2 cubo = \[ \[ \[1, 2], \[3, 4] ], \[ \[5, 6], \[7, 8] ] ] \# Acceder a un elemento: por ejemplo, el número 7 print(cubo\[1]\[1]\[0]) # Salida: 7 ``` Aquí, `cubo` es una lista tridimensional, lo que significa que es una lista de listas de listas. Puedes pensar en esto como una estructura que contiene múltiples matrices. \### Tuplas Las tuplas en Python son estructuras de datos muy similares a las listas, pero con dos diferencias clave: 1\. \*\*Inmutabilidad:\*\* No se pueden modificar después de su creación. No puedes añadir, eliminar o cambiar elementos en una tupla. 2\. \*\*Sintaxis:\*\* Se definen utilizando paréntesis `()`. \#### Ejemplo de Tupla: ```python tupla = (1, 2, 3, 4, 5) \# Acceder a un elemento: por ejemplo, el número 3 print(tupla\[2]) # Salida: 3 \# Intentar modificar la tupla generará un error \# tupla\[2] = 10 # Esto provocará un TypeError ``` Las tuplas son útiles cuando necesitas asegurarte de que los datos no cambien durante la ejecución de un programa. \#### Tuplas Anidadas (Más Dimensiones): Al igual que las listas, las tuplas pueden anidarse para crear estructuras de datos más complejas: ```python tupla\_anidada = ( (1, 2, 3), (4, 5, 6), (7, 8, 9) ) \# Acceder a un elemento: por ejemplo, el número 8 print(tupla\_anidada\[2]\[1]) # Salida: 8 ``` En este caso, `tupla\_anidada` es una tupla de tuplas, lo que te permite trabajar con estructuras de datos que se asemejan a matrices. \### Comparación entre Listas y Tuplas \- \*\*Mutabilidad:\*\* Las listas son mutables (pueden cambiar), mientras que las tuplas son inmutables. \- \*\*Velocidad:\*\* Las tuplas son generalmente más rápidas que las listas, especialmente para operaciones de acceso. \- \*\*Uso:\*\* Las listas se utilizan cuando necesitas una estructura de datos que pueda cambiar. Las tuplas se utilizan cuando los datos deben permanecer constantes. Si tienes alguna pregunta específica sobre estos temas o necesitas ejemplos adicionales, estaré encantado de ayudarte.

### Características principales de las tuplas: 1. **Inmutables**: Una vez creada, no puedes cambiar, agregar ni eliminar elementos. 2. **Ordenadas**: Mantienen el orden en el que se definen. 3. **Permiten duplicados**: Pueden contener elementos repetidos. 4. **Más rápidas**: Operar con tuplas es más eficiente que con listas. 5. **Pueden contener diferentes tipos de datos**: Una misma tupla puede almacenar números, cadenas, listas, etc.

Hola, aquí algunos apuntes * Tuplas se definen con () y son inmutables. * Listas se definen con \[] y son mutables. * Diccionarios se definen con {} y son mutables.

Al principio no les encontraba utilidad a las tuplas, pero cuando tuve que trabajar con datos ingresados por usuarios cuya integridad era fundamental vine a entender lo útil que son.

una dimensión mas a la matrix por pares de datos \[1]\[0]\[1] para acceder al elemento 6   

### Listas Multidimensionales: Una lista multidimensional en Python es una lista que contiene otras listas como elementos. Esto permite organizar datos de manera estructurada y jerárquica. Por ejemplo, una matriz bidimensional se puede representar como una lista de listas, donde cada lista interna representa una fila de la matriz. **Ejemplo:** pythonCopiar código `# Crear una matriz 2x3` `matriz = [` ` [1, 2, 3],` ` [4, 5, 6]` `]` `# Acceder a elementos` `print(matriz[0][1]) # Imprime el segundo elemento de la primera fila, es decir, 2` En este ejemplo, `matriz` es una lista que contiene dos listas internas, cada una representando una fila de la matriz. ### Tuplas: Una tupla en Python es una colección ordenada e inmutable de elementos. A diferencia de las listas, las tuplas no pueden modificarse una vez creadas, es decir, no se pueden añadir, eliminar o modificar elementos después de la creación inicial. Se definen utilizando paréntesis `()`. **Ejemplo:** pythonCopiar código`# Crear una tupla` `mi_tupla = (1, 2, 3, 4`) `# Acceder a elementos` `print(mi_tupla[1]) # Imprime el segundo elemento, es decir, 2` `# Intentar modificar una tupla causará un error` `# mi_tupla[1] = 5 # Esto generará un TypeError` Las tuplas son útiles cuando se quiere asegurar que los datos no cambien accidentalmente. Se usan comúnmente para estructuras de datos donde la inmutabilidad es deseada, como claves en diccionarios o como estructuras de datos simples.

Las tuplas en Python son colecciones de datos ordenadas e inmutables, es decir, una vez creadas no se pueden modificar. Se definen usando paréntesis y pueden contener elementos de diferentes tipos. Son útiles para agrupar datos que no deben cambiar, como coordenadas o fechas, y se accede a sus elementos mediante indexación, similar a las listas. A diferencia de las listas, no se pueden añadir, eliminar ni modificar elementos dentro de una tupla. Su uso es común en programación para asegurar la integridad de los datos.


Para cambiar una tupla a una lista en Python, simplemente debes utilizar la función `list()`. Por ejemplo, si tienes una tupla `mi_tupla = (1, 2, 3)`, puedes convertirla en una lista con el siguiente código: ```python mi_lista = list(mi_tupla) ``` Ahora, `mi_lista` es una lista y puedes modificarla, a diferencia de la tupla, que es inmutable. Recuerda que en Python, las listas se definen con corchetes `[]`, mientras que las tuplas se definen con paréntesis `()`.

que no era la clase 10? porque dice la clase 9

Veo algo que no se explico en este video y me parece importante son los pasos. Tenemos: `lista = [1,2,3,4,5,6]` Tu puedes hacer lo siguiente para devolver los indices pares de la lista `print(lista[::2] #[1,3,5]` También puedes invertir la lista utilizando el paso. `print(lista[::-1] #[6, 5, 4, 3, 2, 1]`

```python matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] print() print(matrix) print(matrix[0]) print() matrix2 = [[1, 2], [3, 4], [5, 6], [7, 8]] print(matrix2) print(matrix2[2][1]) # Tupla, no sirven para cambiar los valores dentro de las tuplas se # representa (1, 2, 3, 4, 5) o 1, 2, 3, 4, 5 numbers = (1, 2, 3, 4, 5) print(numbers) print(type(numbers)) print(numbers[0]) # numbers[0] = "uno" no puedo cambiar los valores de una tupla # print() ```

**¿Qué quiere decir que las tuplas son inmutables?** Las tuplas en Python son inmutables, lo que significa que una vez que se crean, **no se pueden modificar**. Esto implica que no puedes agregar, eliminar o cambiar elementos dentro de una tupla después de su creación. Si necesitas modificar una tupla, debes crear una nueva tupla con los cambios deseados.

Hola, ¿alguien me podría decir porque en el primer caso no se genera error y en el segundo escenario sí se genera error? `matrix_1 = (1,2,3,4,[5,6])` `matrix_2 =(1,2,3,4,5,[a,b])` `print(type(matrix_1))` `print(type(matrix_2))`

```python ``` ```python matrix2 = [ [[1,2,3], [4,5,6]], [[7,8,9], [10,11,12]] ] print(f"Matrix2: {matrix2[1][1][0]}") ```matrix2 = \[ \[\[1,2,3], \[4,5,6]], \[\[7,8,9], \[10,11,12]] ]print(f"Matrix2: {matrix2\[1]\[1]\[0]}")

Por facilidad de la lectura del código, recomiendo siempre que usen los parentesis `()` . Al final, uno trabaja con personas y es mejor facilitar la lectura del código

Matrices son datos mutables Tuplas son inmutables numbers = 1,2,3,4,5 #tupla se puede hacer con ()

Como no tengo ni idea, para mi es más fácil entenderlo con casos de uso en el mundo rea, específicamente en ciberseguridad. Esto es lo que Chat CGPT me dijo al respecto: Desde el punto de vista de la **ciberseguridad**, las listas y las tuplas tienen ventajas y desventajas según su diseño y propósito en Python. Aquí tienes una comparación centrada en aspectos relevantes para la seguridad: ### **1. Mutabilidad** * **Lista**: Son mutables (puedes agregar, eliminar o modificar elementos después de crearlas). * **Ventaja**: Flexibles para datos dinámicos o configuraciones que pueden cambiar durante la ejecución. * **Desventaja**: La mutabilidad puede ser un problema si un atacante logra modificar datos sensibles en tiempo de ejecución (por ejemplo, claves API o configuraciones críticas). Esto aumenta el riesgo de manipulación. * **Tupla**: Son inmutables (una vez creadas, no se pueden modificar). * **Ventaja**: Más seguras para almacenar datos estáticos o sensibles (como credenciales o valores de configuración), ya que no pueden ser alteradas accidentalmente o de forma malintencionada. * **Desventaja**: Menos flexibles si se necesitan cambios dinámicos. ### **2. Performance y eficiencia** * **Lista**: * **Ventaja**: Más rápidas para operaciones que requieren modificación frecuente, como agregar o eliminar elementos. * **Desventaja**: Dado que son mutables, ocupan más espacio en memoria y pueden ser más susceptibles a ataques que exploten esta característica, como *buffer overflows*. * **Tupla**: * **Ventaja**: Más ligeras en términos de memoria y generalmente más rápidas para operaciones de lectura. Al ser inmutables, tienen una menor superficie de ataque. * **Desventaja**: No puedes modificar su contenido, lo que puede ser un problema si necesitas adaptabilidad. ### **3. Uso en sistemas sensibles** * **Lista**: * **Ventaja**: Adecuadas para manejar datos temporales o que no sean sensibles, como datos de usuarios que cambian frecuentemente. * **Desventaja**: Si una lista contiene datos sensibles y se comparte entre funciones o módulos, un atacante podría interceptar y modificar estos datos. * **Tupla**: * **Ventaja**: Son ideales para datos inmutables y sensibles, como configuraciones de seguridad o roles de usuario. La inmutabilidad reduce el riesgo de modificación maliciosa o accidental. * **Desventaja**: Menos prácticas si necesitas manejar datos dinámicos. ### **4. Protección contra ataques** * **Lista**: * **Desventaja**: Más vulnerable a ataques relacionados con la modificación de datos, como: * **Inyección maliciosa**: Un atacante podría manipular los datos si tiene acceso a la lista. * **Condiciones de carrera**: Si múltiples procesos acceden a una lista compartida, podrían sobrescribir datos críticos. * **Tupla**: * **Ventaja**: Más resistente a inyecciones maliciosas y condiciones de carrera debido a su inmutabilidad. * **Desventaja**: En aplicaciones dinámicas, los desarrolladores podrían intentar reemplazar la tupla completa (ya que no pueden modificarla), lo que introduce otro tipo de riesgos. ### **Conclusión y mejores prácticas** #### **¿Cuándo usar listas desde una perspectiva de ciberseguridad?** * Cuando manejas datos temporales o dinámicos que no son sensibles. * Si tienes mecanismos de seguridad para restringir el acceso o proteger los datos en tiempo de ejecución (por ejemplo, control de acceso). #### **¿Cuándo usar tuplas desde una perspectiva de ciberseguridad?** * Para almacenar datos sensibles, como: * Configuraciones de seguridad. * Claves criptográficas. * Roles o permisos. * Cuando necesitas garantizar que los datos no cambien después de ser definidos. #### **Recomendación general**: 1. Usa tuplas para datos inmutables y críticos. 2. Asegura las listas con validaciones estrictas si manejan datos importantes o sensibles. 3. Aplica controles de acceso y técnicas como inmutabilidad lógica (hacer que la lista no sea modificable en ciertos contextos).

*# Tipos de datos básicos en acción*edad = 30                   *# Entero*pi = 3.14                   *# Decimal*nombre = "Ana"              *# Cadena*es\_estudiante = False       *# Booleano*frutas = \["manzana", "pera"]  *# Lista*coordenadas = (10, 20)      *# Tupla*vocales = {"a", "e", "i"}   *# Conjunto*persona = {"nombre": "Ana", "edad": 30}  *# Diccionario*sin\_valor = None            *# Tipo None*

a continuacion trato de llevar a texto una explicacion que me parecio buena pero demaciado grafica. matiz es un nombre lindo pra una tabla, cada objeto de la tabla tiene una cordenada asignada que define su posicion en la misma, \[# fila,# columna] ahora imagina que fuera una tabla de tablas es decir una matriz de 3 dimensiones, ls corenadas seian \[#tabla,#fila, #columna] asi puedes aumentar la dimencion de la matriz (tablas de matricez de 3 dimensiones). ahora bien recuerden que las listas se encierran en \[] las tuplas en () y los diccionarios en {} si mal no recuerdo

Las tuplas son estructuras de datos inmutables (no se pueden modificar después de crearse) que pueden contener elementos de diferentes tipos. Características principales: * Se definen con paréntesis () * Son inmutables * Permiten elementos duplicados * Son ordenadas (mantienen el orden de inserción) * Son más eficientes en memoria que las listas * Son útiles para datos que no deben cambiar, como coordenadas o configuraciones

Me encantó la manera en que explicó el acceso a las listas anidadas. Siempre había sido un tema complicado para mí, en gran parte porque en cursos anteriores se enfocaban solo en el código, dejando de lado los elementos gráficos que ayudan a visualizar el concepto. Esta explicación fue mucho más clara y accesible, integrando la parte visual para hacerlo más comprensible.


Notas: -Las matrices en python son listas dentro de una lista -Las tuplas son un tipo de dato que no se puede modificar, no se pueden añadir o quitar elementos

las tuplas contienen elementos que son inmutables , es decir que no se pueden modificar, añadir o eliminar después de su creación La matriz es una herramienta para organizar las listas y los datos se ordenan en filas y columnas. Las tuplas se utilizan para almacenar datos que no deben cambiar.

Haciendo pruebas :) `matrix = [[1,2,3],          [4,5,6],          [7,9,9]]print("La longitud de la segunda lista de la tupla es", len(matrix[1]), "y su primer valor es", matrix[1][0])`

mi ejercicio en c\[odigo comentado ```js # >>>>>>>>>>>>>>>>> listas de listas > MATrIZ matrix = [[1,2,3], [4,5,6], [7,8,9]] #(columna, fila . . . seria : 2,2 es 9) print (matrix) print (matrix[2][1]) # mandaría el 8 print(type(matrix)) # Un amatix con más dimensión y pares de datos [1][0][1] para acceder al elemento 6 dimension = [[[1, 2],[3, 4]], #coma en medio y al final [[5, 6],[7, 8]] ] print (dimension) print(dimension[1][0][1]) print(type(dimension)) # ahora tuplas tupla_l = (1,2,3,4,5) print(tupla_l) print(type(tupla_l)) #print(tupla_l[0]) = "unos" #este no se pudo por que las tuplas no se pueden modificar ```

```js numbers[0] = 'unos' print(numbers) #las tuplas son inmutables por eso sale error ```

Muy buena clase!

Las buenas tuplas!

```js #En esta clases vamos a ver Matrices #Por lo visto a esto le dien lista de listas O.o matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] print(matriz) #Even we saw the matriz in one line, the system respect the order of columns and rows print(matriz[0]) #Whit this I can saw and use teh first list, in the positio 0 of the rows matrix = [[[1,2],[3,4]], [[5,6],[7,8]]] print(matrix) print("--------------------------------------------------------------------------------------------------") #Ahora veremos TUPLAS # es la misma clase numbers = (1,2,3,4,5) # para las tuplas puedo o NO poner parentesis, python solito se da cuenta aue es una TUPLA print(numbers) print(type(numbers)) print(numbers[0]) #numbers[0] = "uno" #comentamos esta parte por que marca error #print(numbers) #marca erro por que las TUPLAS son INMUTABLES ```#En esta clases vamos a ver Matrices#Por lo visto a esto le dien lista de listas O.omatriz = \[\[1, 2, 3],          \[4, 5, 6],          \[7, 8, 9]]print(matriz) #Even we saw the matriz in one line, the system respect the order of columns and rowsprint(matriz\[0]) #Whit this I can saw and use teh first list, in the positio 0 of the rowsmatrix = \[\[\[1,2],\[3,4]],          \[\[5,6],\[7,8]]]print(matrix) print("--------------------------------------------------------------------------------------------------")#Ahora veremos TUPLAS # es la misma clasenumbers = (1,2,3,4,5) # para las tuplas puedo o NO poner parentesis, python solito se da cuenta aue es una TUPLAprint(numbers)print(type(numbers))print(numbers\[0])#numbers\[0] = "uno" #comentamos esta parte por que marca error#print(numbers)     #marca erro por que las TUPLAS son INMUTABLES


Soy solo yo el que piensa que va habla y va muy rapido jajaa voy a tener que poner el video a 0.5 no me da tiempo de hacerlo en VSC