Dimensiones en NumPy y Pandas: De Escalares a Tensors

Me saqué las ganas de experimentar y probé cosas que no estaban en la clase. Siempre hay que estimular la curiosidad intelectual. 

### **Vector:** * **Qué es:** Es como una flecha que tiene una longitud (magnitud) y una dirección. * **Ejemplo:** Piensa en un vector como las instrucciones en un mapa que te dicen "ve 3 cuadras al norte y 4 cuadras al este". * **Dimensiones:** Tiene una dimensión, como una lista de números (por ejemplo, \[3, 4]). ### **Tensor:** * **Qué es:** Es una extensión de un vector que puede tener muchas dimensiones. * **Ejemplo:** Si un vector es una línea, un tensor puede ser una tabla (2D), un cubo (3D), o más complejo. * **Dimensiones:** Puede tener múltiples dimensiones. Por ejemplo: * Un escalar (rango 0) es solo un número. * Un vector (rango 1) es una lista de números. * Una matriz (rango 2) es una tabla de números. * Un tensor de rango 3 sería como un cubo de datos, y así sucesivamente. ### **Diferencias Clave:** 1. **Número de Dimensiones:** * Un vector tiene solo una dimensión (es una lista). * Un tensor puede tener múltiples dimensiones (puede ser una lista, tabla, cubo, etc.). 2. **Complejidad:** * Un vector es más simple, solo te dice dirección y magnitud en un espacio. * Un tensor puede describir relaciones más complejas, como las fuerzas que actúan en todas direcciones dentro de un material. ### **Analogía:** * **Vector:** Imagina que estás caminando por la ciudad y usas un vector para describir tu camino: "3 cuadras al norte, 4 al este". * **Tensor:** Ahora imagina que estás describiendo no solo tu camino, sino también cómo cambia la altura del terreno en cada punto, la temperatura, y la humedad. Necesitas más información en cada punto, así que usas un tensor para describir todo eso. En resumen, un vector es una lista de números que describe una dirección y una magnitud, mientras que un tensor es una extensión que puede tener muchas dimensiones y describir relaciones más complejas.

 ya se me juntaron todos los cursos que mas me interesan

Las matrices de Vandermonde se utilizan en criptografía para crear sistemas de cifrado más seguros. Ayudan a generar claves que son difíciles de descifrar sin la información correcta. `vander(x, n)` define un array de Vandermonde como una matriz 2D NumPy. Cada columna del array Vandermonde es una potencia decreciente del array 1D de entrada o lista o tupla, x donde el orden polinómico más alto es n-1. Esta rutina de creación de matrices es útil para generar modelos lineales de mínimos cuadrados, como tal: ![]()

# **NumPy Array** Existen 6 mecanismos generales para crear Arrays: 1. Conversión desde otras estructuras de Python (por ejemplo, listas y tuplas) 2. Funciones intrínsecas de NumPy para la creación de arrays (por ejemplo, arange, ones, zeros, etc.) 3. Replicación, unión o mutación de matrices existentes 4. Lectura de matrices desde disco, ya sea desde formatos estándar o personalizados 5. Creación de matrices a partir de bytes sin procesar mediante cadenas o buffers. 6. Utilización de funciones especiales de biblioteca (por ejemplo, random) Puede utilizar estos métodos para crear ndarrays o arrays estructurados.

Profe Carli 👩‍💻🇧🇴 comparto contigo el RETO **Un array de valores aleatorios** `random_int_array = np.random.randint(1, 100, size=(4, 4))` `print(random_int_array)`

Una forma visual para entender la dimensionalidad en numpy 

Es posible crear un array que tenga en cada entrada el mismo número, con el método `np.full`. Un ejemplo: 

```python import numpy as np a = np.array([1, 2, 3]) b = np.array([4, 5, 6]) Aritméticas suma = a + b resta = a - b multiplicacion = a * b division = a / b Matemáticas Avanzadas raiz_cuadrada = np.sqrt(a) exponente = np.exp(a) logaritmo = np.log(a) Estadísticas mean = np.mean(a) median = np.median(a) varianza = np.var(a) desviacion_estandar = np.std(a) ```

### **Importancia de las Dimensiones en Numpy** Imagina que tienes datos provenientes de múltiples sensores que miden diversas variables en tiempo real. Para analizar y organizar esta gran cantidad de información de forma efectiva, necesitas estructurar los datos correctamente. **Numpy** facilita esta tarea al permitir: * Realizar cálculos complejos. * Extraer información valiosa rápidamente. * Trabajar con estructuras que van desde escalares simples hasta tensores multidimensionales. ## **Ejemplos Prácticos por Dimensión** ### **1. Escalares (Dimensión 0)** Un escalar representa un único valor, como la temperatura de una ciudad. **Código de ejemplo:** import numpy as np escalar = np.array(42) print(escalar)  # Resultado: 42 print(type(escalar))  # Clase: numpy.ndarray ### **2. Vectores (Dimensión 1)** Para almacenar datos como las temperaturas de una semana, usamos un vector: **Código de ejemplo:** vector = np.array(\[30, 29, 35, 31, 33, 36, 42]) print(vector)  # Resultado: \[30 29 35 31 33 36 42] ### **3. Matrices (Dimensión 2)** Las matrices son ideales para representar datos tabulares o imágenes. **Código de ejemplo:** matrix = np.array(\[\[1, 2, 3], \[4, 5, 6], \[7, 8, 9]]) print(matrix) **Salida:** \[\[1 2 3]  \[4 5 6]  \[7 8 9]] ### **4. Tensores (Dimensión 3 o Más)** Los tensores representan datos más complejos, como imágenes RGB en varias capas. **Código de ejemplo:** tensor = np.array(\[\[\[1, 2], \[3, 4]], \[\[5, 6], \[7, 8]]]) print(tensor) ## **Métodos para Crear Arrays en Numpy** **Conversión desde listas o tuplas:**array = np.array(\[1, 2, 3]) **Generación de arrays con funciones:** **Rango de números:** array\_arange = np.arange(10) print(array\_arange)  # Resultado: \[0 1 2 3 4 5 6 7 8 9] **Matriz identidad:** eye\_matrix = np.eye(3) print(eye\_matrix) **Matriz diagonal:** diag = np.diag(\[1, 2, 3]) print(diag) **Creación de arrays aleatorios:**random = np.random.random((2, 3)) print(random) **Otras funciones avanzadas:** Más adelante, en clases de pandas o Numpy avanzado, aprenderás a usar métodos adicionales como lectura desde archivos o creación de arrays personalizados. **Aplicaciones y Sugerencias** * **Álgebra lineal:** Conceptos como matrices identidad y diagonales son fundamentales. Si necesitas reforzar este tema, revisa un curso de álgebra lineal. * **Exploración:** Investiga otros métodos de Numpy para crear arrays y comparte tus hallazgos.

Existen seis métodos generales para crear tensores (arrays) en NumPy: 1. **Conversión desde otras estructuras de Python**: como listas o tuplas. 2. **Funciones de creación de arrays**: como `np.zeros()` para crear matrices de ceros. 3. **Replicación, unión o mutación** de arrays existentes. 4. **Lectura de arrays desde disco**: formatos estándar o personalizados. 5. **Creación desde bytes crudos**: mediante cadenas o buffers. 6. **Funciones especiales de bibliotecas**: como `np.random` para generar números aleatorios. Estos métodos son esenciales para trabajar con datos en múltiples dimensiones en ciencia de datos.

Un tensor es una estructura matemática que generaliza scalars (dimensión 0), vectores (dimensión 1) y matrices (dimensión 2) a dimensiones superiores. En el contexto de NumPy y ciencia de datos, los tensores permiten almacenar datos en múltiples dimensiones, crucial para operaciones complejas y procesamiento de grandes volúmenes de información, como imágenes y series temporales. En NumPy, los tensores se representan como arrays con tres o más dimensiones, facilitando cálculos eficientes y la organización de datos.


```python Creación de matriz de ceros ``` ```python matrix_zeros = np.zeros((4,3)) print(matrix_zeros) ```

Un ejemplo sencillo de manipulación de datos con las funciones que nos proporciona numpy: Temperaturas = np.array(\[\[40,43,42],\[30,35,37]]) # 2023: 40,43,42# a. Calcular el promedio de temperatura para un año (2023): Temperatura\_promedio\_2023 = np.mean(Temperaturas\[0])print(f'Temperatura promedio de 2023 entre el 15 al 18 de Junio: {Temperatura\_promedio\_2023}') \# b. Calcular la diferencia de temperatura día a día entre los años: diferencia\_temperatura = Temperaturas\[0] - Temperaturas\[1]print(f'Diferencia de temperaturas del 15 al 18 de Junio del 2023 - 2022: {diferencia\_temperatura}')

Hay dos maneras de crear una matriz identidad en numpy 1. La primera es creando la diagonal de 1s como la diagonal mas larga. Para este caso usamos np.identity e indicamos su dimensión matriz\_identidad = np.identity(3) print(matriz\_identidad) \# Resultado: \[ \[1. 0. 0.] \[0. 1. 0.] \[0. 0. 1.] ] En este caso se creó una matriz identidad de 3x3 2. La segunda es usando np.eye que se puede usar de dos formas: \* Para crear una matriz igual a la del caso anterior así: matriz\_identidad\_2 = np.eye(3) print(matriz\_identidad\_2) \# Resultado: \[ \[1. 0. 0.] \[0. 1. 0.] \[0. 0. 1.] ] \* o para crear una matriz, pero desplazando la diagonal de 1s, k posiciones matriz\_desplazada = np.eye(4, k=1) print(matriz\_desplazada) \#Resultado: \[ \[0. 1. 0. 0.] \[0. 0. 1. 0.] \[0. 0. 0. 1.] \[0. 0. 0. 0.] ] En este caso se cr una matriz identidad de 4x4 y la diagonal de 1s se deplazó una columna hacia la derecha.

Podemos decir que un tensor representa una matriz de 3 dimensiones ?

El usuario Dany Escudero planteó una interesante pregunta: ¿Cómo construir una matriz 3x3 que ponga en cada entrada un elemento al azar de la lista L=\["a","b","c"]? Intenté utilizar la instrucción fromfunction, la cual permite ejecutar en cada entrada una función cuando se construye un arreglo. Sin embargo no logro hacer que se ejecute cada vez. Aquí el código por si desean intentarlo: 

El reto# Crear un arreglo aleatorio de enteros entre 1 y 10 (incluyendo 1 pero excluyendo 10) con un tamaño de 2x3random1 = np.random.randint(1, 10, size=(2, 3))print(random1)  # Imprime el arreglo de enteros aleatorios \# Crear un arreglo aleatorio de números decimales entre 0 y 1 con un tamaño de 2x3random2 = np.random.rand(2, 3)print(random2)  # Imprime el arreglo de números decimales aleatorios \# Crear un arreglo aleatorio de números con una distribución normal (media = 0, desviación estándar = 1) de tamaño 2x3random3 = np.random.randn(2, 3)print(random3)  # Imprime el arreglo de números aleatorios con distribución normal \# Seleccionar aleatoriamente un elemento de la lista \[1, 2, 3, 4, 5]random4 = np.random.choice(\[1, 2, 3, 4, 5])print(random4)  # Imprime el número seleccionado aleatoriamente \# Seleccionar aleatoriamente elementos de la lista \[1, 2, 3, 4, 5] para formar un arreglo de tamaño 2x3random5 = np.random.choice(\[1, 2, 3, 4, 5], size=(2, 3))print(random5)  # Imprime el arreglo de números seleccionados aleatoriamente ```js # Crear un arreglo aleatorio de enteros entre 1 y 10 (incluyendo 1 pero excluyendo 10) con un tamaño de 2x3 random1 = np.random.randint(1, 10, size=(2, 3)) print(random1) # Imprime el arreglo de enteros aleatorios # Crear un arreglo aleatorio de números decimales entre 0 y 1 con un tamaño de 2x3 random2 = np.random.rand(2, 3) print(random2) # Imprime el arreglo de números decimales aleatorios # Crear un arreglo aleatorio de números con una distribución normal (media = 0, desviación estándar = 1) de tamaño 2x3 random3 = np.random.randn(2, 3) print(random3) # Imprime el arreglo de números aleatorios con distribución normal # Seleccionar aleatoriamente un elemento de la lista [1, 2, 3, 4, 5] random4 = np.random.choice([1, 2, 3, 4, 5]) print(random4) # Imprime el número seleccionado aleatoriamente # Seleccionar aleatoriamente elementos de la lista [1, 2, 3, 4, 5] para formar un arreglo de tamaño 2x3 random5 = np.random.choice([1, 2, 3, 4, 5], size=(2, 3)) print(random5) # Imprime el arreglo de números seleccionados aleatoriamente ```

**Importancia de NumPy y Pandas** Ambas bibliotecas usan dimensiones para estructurar los datos de formas que permiten realizar operaciones complejas de manera eficiente y efectiva.

### EN RESUMEN: * **NumPy** se centra en la capacidad de manejar arrays multidimensionales de manera eficiente, lo que es crucial para el cálculo numérico y la manipulación de datos a gran escala. * **Pandas** se enfoca en proporcionar estructuras de datos que sean intuitivas para el análisis y la manipulación de datos tabulares, con un fuerte enfoque en la flexibilidad y las etiquetas.

Excelente curso, me anime a volverlo a ver en esta actualización una vez vi la conferencia de la profe Carli en platzi Conf😅 Empezó muy bien!

![]()Aprovechando los excelentes cursos de Platzi.

Comparto algunas opciones adicionales para crear diferentes tipos de matrices: `ceros = np.zeros((3,3)) # Crea una matriz de 3x3 de ceros` `print(ceros)` `unos = np.ones((3,3)) # Crea una matriz de 3x3 de unos` `print(unos)` `valor = np.full((3,3),8) # Crea una matriz de 3x3 de ochos` `print(valor)`

Está increíble este curso. Había hecho un boot camp de Data Science pero no me explicaron lo que eran los tensores, vectores, matrices ni escalares. Pensaba que estas estructuras de datos eran listas. Hay todo un mundo de estructuras de datos antes de siquiera pensar en hacer análisis de estos. ¡Gracias por ello!

Empezó muy brutal el curso! Ya quería tomarlo! Justo había tomado las de algebra lineal hace un mes.


¡Hola! 🌟 Comparto el código contigo 👋🏻 `import numpy as np` `escalar = np.array(42)` `print(type(escalar))` `print(escalar)` `vector = np.array([30,29,35,31,33,36,42])` `print(vector)` `matrix = np.array([[1,2,3],[4,5,6],[7,8,9]])` `print(matrix)` `tensor = np.array([[1,2],[3,4],[5,6],[7,8]])` `print(tensor)` `array_arange = np.arange(10)` `print(array_arange)` `eye_matrix = np.eye(6)` `print(eye_matrix)` `diag = np.diag([1,2,3,4,5,6,7])` `print(diag)` `random = np.random.random((2,3))` `print(random)` A su vez quiero compartir con ustedes cómo manejar datos de diferentes dimensiones en NumPy y Pandas que vimos en esta Clase 2: <https://github.com/julianacastilloaraujo/NumPy-Pandas>