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`!

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.

🟢 **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! 🚀🚀

### 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.

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

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

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.

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