Técnicas Fundamentales de Creación de Arrays en NumPy

Introducción

Prerrequisitos

Antes de comenzar este curso, deberías tener habilidades básicas de programación en Python. Si aún no has aprendido Python, puedes empezar con nuestra Ruta de Aprendizaje de Python.

Bienvenido al laboratorio sobre técnicas fundamentales de creación de arrays en NumPy. Antes de empezar a codificar, comprendamos qué es NumPy y por qué es esencial para la computación científica.

¿Qué es NumPy?

NumPy (abreviatura de Numerical Python) es la biblioteca fundamental para la computación científica en Python. Proporciona potentes estructuras de datos y funciones para trabajar con grandes arrays y matrices de datos numéricos.

¿Por qué NumPy en lugar de listas de Python?

Si bien las listas integradas de Python son flexibles y fáciles de usar, tienen limitaciones al trabajar con datos numéricos:

• Rendimiento: Los arrays de NumPy son mucho más rápidos para operaciones matemáticas.
• Eficiencia de memoria: NumPy utiliza menos memoria para almacenar la misma cantidad de datos.
• Conveniencia: NumPy proporciona cientos de funciones matemáticas integradas.
• Funcionalidad: NumPy soporta operaciones avanzadas como multiplicación de matrices, transformadas de Fourier, etc.

En este laboratorio, aprenderás los métodos más comunes para crear arrays de NumPy. Escribirás y ejecutarás scripts de Python para practicar la conversión de secuencias de Python, el uso de funciones integradas de NumPy, la manipulación de arrays existentes y la carga de datos desde archivos. Toda la codificación se realizará dentro del WebIDE.

Creación de Arrays a partir de Secuencias de Python

La forma más básica de crear un array de NumPy es convirtiendo una secuencia de Python, como una lista o una tupla. La función numpy.array() toma una secuencia como argumento y devuelve un nuevo array de NumPy.

Entendiendo los Arrays de NumPy

Antes de crear arrays, comprendamos qué hace que los arrays de NumPy sean especiales:

Dimensiones de los Arrays

• Array 1D (Vector): Una lista simple de números, como [1, 2, 3, 4]
• Array 2D (Matriz): Una tabla de números con filas y columnas, como una hoja de cálculo
• Array 3D (Tensor): Un cubo de números, útil para imágenes o datos 3D

Diferencias Clave con las Listas de Python

• Homogéneos: Todos los elementos deben ser del mismo tipo de dato (generalmente números)
• Tamaño fijo: Una vez creados, el tamaño no se puede cambiar
• Eficientes: Mucho más rápidos para operaciones matemáticas
• Funcionalidad rica: Soporta operaciones vectorizadas (operaciones sobre arrays completos a la vez)

Importando NumPy

En Python, importamos NumPy usando el alias estándar np:

import numpy as np

Este alias np es una convención ampliamente adoptada en la comunidad científica de Python.

Ahora creemos algunos arrays. Abra el archivo array_from_sequence.py desde el explorador de archivos de la izquierda. Agregue el siguiente código. Este código importará la biblioteca NumPy y creará arrays unidimensionales (1D), bidimensionales (2D) y tridimensionales (3D) a partir de listas de Python.

import numpy as np

## Crear un array 1D a partir de una lista
a1D = np.array([1, 2, 3, 4])
print("Array 1D:")
print(a1D)

## Crear un array 2D a partir de una lista de listas
a2D = np.array([[1, 2], [3, 4]])
print("\nArray 2D:")
print(a2D)

## Crear un array 3D a partir de listas anidadas
a3D = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print("\nArray 3D:")
print(a3D)

Sugerencia: Puede copiar el código anterior en su editor de código, luego leer cuidadosamente cada línea de código para comprender su función. Si necesita una explicación adicional, puede hacer clic en el botón "Explicar Código" 👆. Puede interactuar con Labby para obtener ayuda personalizada.

Después de agregar el código, guarde el archivo. Ahora, ejecute el script desde la terminal para ver la salida.

python array_from_sequence.py

Debería ver la siguiente salida, que muestra los arrays que creó:

1D Array:
[1 2 3 4]

2D Array:
[[1 2]
 [3 4]]

3D Array:
[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]

Entendiendo los Tipos de Datos (dtype)

Los arrays de NumPy tienen un tipo de dato fijo para todos los elementos, que se especifica mediante el parámetro dtype. Esto es diferente de las listas de Python, donde cada elemento puede tener un tipo diferente.

Por qué Importan los Tipos de Datos

• Eficiencia de memoria: Los diferentes tipos usan diferentes cantidades de memoria
• Rendimiento: Las operaciones están optimizadas para tipos de datos específicos
• Precisión: Controla cómo se almacenan y calculan los números

Tipos de Datos Comunes

• int32 / int64: Números enteros (32 o 64 bits)
• float32 / float64: Números decimales (32 o 64 bits)
• complex: Números complejos
• bool: Valores Verdadero/Falso

Puede especificar el tipo de dato al crear un array usando el parámetro dtype, como np.array([1, 2], dtype=complex). Si no especifica un dtype, NumPy elegirá uno apropiado automáticamente basándose en los datos de entrada.

Uso de Funciones Intrínsecas de Creación de Arrays

NumPy proporciona varias funciones integradas para crear arrays desde cero sin necesidad de una secuencia de Python. Estas funciones están optimizadas para casos de uso específicos y son mucho más rápidas que la creación manual de arrays a partir de listas.

¿Por qué usar estas funciones?

En lugar de escribir np.array([0, 0, 0, 0, 0]), puede simplemente usar np.zeros(5). Estas funciones son:

• Más rápidas: Código C optimizado internamente.
• Más legibles: La intención es clara por el nombre de la función.
• Eficientes en memoria: Asignación directa de memoria.
• Convenientes: No es necesario especificar manualmente cada elemento.

Abra el archivo intrinsic_creation.py y añada el siguiente código. Este script demuestra varias funciones de creación comunes.

import numpy as np

## Create an array with a range of elements
## np.arange(start, stop, step) - similar to Python's range()
## Use case: Creating sequences for loops, generating indices
arr_range = np.arange(0, 10, 2)  ## [0, 2, 4, 6, 8]
print("Array from arange:")
print(arr_range)

## Create an array with a specific number of elements between two points
## np.linspace(start, stop, num_elements) - evenly spaced points
## Use case: Creating points for plotting, sampling data
arr_linspace = np.linspace(0, 10, 5)  ## 5 points from 0 to 10
print("\nArray from linspace:")
print(arr_linspace)

## Create an array filled with zeros
## np.zeros((rows, columns)) - initialize arrays for calculations
## Use case: Pre-allocating arrays before filling with computed values
arr_zeros = np.zeros((2, 3))  ## 2x3 array of zeros
print("\nArray of zeros:")
print(arr_zeros)

## Create an array filled with ones
## np.ones((rows, columns)) - initialize with ones
## Use case: Creating masks, scaling factors, or starting points for algorithms
arr_ones = np.ones((3, 2))  ## 3x2 array of ones
print("\nArray of ones:")
print(arr_ones)

## Create an identity matrix
## np.eye(size) - square matrix with 1s on diagonal, 0s elsewhere
## Use case: Linear algebra, resetting transformations, matrix multiplication
identity_matrix = np.eye(3)  ## 3x3 identity matrix
print("\nIdentity matrix:")
print(identity_matrix)

Guarde el archivo y ejecútelo desde la terminal.

python intrinsic_creation.py

La salida mostrará los diferentes arrays creados por estas funciones:

Array from arange:
[0 2 4 6 8]

Array from linspace:
[ 0.   2.5  5.   7.5 10. ]

Array of zeros:
[[0. 0. 0.]
 [0. 0. 0.]]

Array of ones:
[[1. 1.]
 [1. 1.]
 [1. 1.]]

Identity matrix:
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

Manipulación de Arrays Existentes

También puedes crear nuevos arrays modificando, combinando o dividiendo los existentes. Esta sección cubre dos conceptos importantes: vistas vs. copias y concatenación de arrays.

Vistas vs. Copias: Comprensión del Compartir Memoria

Este es uno de los conceptos más importantes en NumPy que a menudo confunde a los principiantes.

¿Qué es una Vista?

Una vista es una forma diferente de ver los mismos datos en memoria. Cuando creas una vista (como a través del slicing), no estás creando un nuevo array, solo estás creando una nueva referencia a los datos existentes.

¿Qué es una Copia?

Una copia crea un array completamente nuevo en memoria con sus propios datos. Los cambios en una copia no afectan al array original, y viceversa.

Por qué esto es importante

• Las vistas son eficientes en memoria: No duplican datos.
• Las vistas son rápidas: Sin sobrecarga de copiado.
• Pero las vistas pueden causar efectos secundarios inesperados: Modificar una vista cambia los datos originales.
• Las copias son más seguras: Los cambios están aislados pero usan más memoria.

Exploremos también cómo unir múltiples arrays en un array más grande.

Abra el archivo array_manipulation.py y añada el siguiente código:

import numpy as np

## --- Part 1: Views vs. Copies ---
a = np.arange(1, 5)
print("Original array 'a':", a)

## Create a view of the first two elements
b = a[:2]
b[0] = 99 ## Modify the view
print("Modified view 'b':", b)
print("Array 'a' after modifying the view:", a) ## 'a' is also changed

## Create a copy
c = a[:2].copy()
c[0] = 0 ## Modify the copy
print("\nModified copy 'c':", c)
print("Array 'a' after modifying the copy:", a) ## 'a' is unchanged

## --- Part 2: Joining Arrays ---
A = np.ones((2, 2))
B = np.eye(2) * 2
C = np.zeros((2, 2))
D = np.diag((-3, -4))

## Join arrays into a block matrix
block_matrix = np.block([
    [A, B],
    [C, D]
])
print("\nBlock matrix:")
print(block_matrix)

Guarde el archivo y ejecútelo desde la terminal.

python array_manipulation.py

La salida demuestra cómo la modificación de una vista afecta al array original, mientras que la modificación de una copia no lo hace. También muestra el resultado de combinar cuatro arrays más pequeños en una única matriz de bloques.

Original array 'a': [1 2 3 4]
Modified view 'b': [99  2]
Array 'a' after modifying the view: [99  2  3  4]

Modified copy 'c': [0 2]
Array 'a' after modifying the copy: [99  2  3  4]

Block matrix:
[[ 1.  1.  2.  0.]
 [ 1.  1.  0.  2.]
 [ 0.  0. -3.  0.]
 [ 0.  0.  0. -4.]]

Lectura de Arrays desde un Archivo

Una tarea común en el análisis de datos es cargar datos de un archivo en un array de NumPy. NumPy destaca en esto porque puede leer eficientemente grandes conjuntos de datos y convertirlos automáticamente a los formatos numéricos apropiados.

¿Por qué NumPy para I/O de Archivos?

• Velocidad: Mucho más rápido que leer línea por línea con Python
• Inferencia de tipos: Detecta automáticamente los tipos de datos apropiados
• Eficiencia de memoria: Carga los datos directamente en arrays optimizados
• Conveniencia: Una sola llamada a la función en lugar de un análisis complejo

Formatos de Archivo Comunes

• Archivos CSV: Valores separados por comas (el más común)
• Archivos TSV: Valores separados por tabulaciones
• Archivos de texto: Separados por espacios o delimitadores personalizados
• Archivos binarios: Para conjuntos de datos muy grandes (avanzado)

Para archivos de texto simples como CSV (Valores Separados por Comas), NumPy proporciona la función np.loadtxt().

El script de configuración para este laboratorio ya ha creado un archivo llamado data.csv en tu directorio de proyecto. Su contenido es:

col1,col2,col3
1.0,2.5,3.2
4.5,5.0,6.8
7.3,8.1,9.9

Ahora, abre el archivo read_from_file.py y añade el siguiente código para leer estos datos.

Comprensión de los Parámetros de np.loadtxt

La función np.loadtxt() tiene varios parámetros importantes:

• delimiter=',': Especifica cómo se separan las columnas (coma para CSV)
• skiprows=1: Omite la primera fila (generalmente encabezados)
• dtype: Opcional - especifica el tipo de dato (detectado automáticamente si no se proporciona)
• usecols: Opcional - especifica qué columnas leer
• comments: Opcional - especifica el carácter de comentario para ignorar líneas

Usamos delimiter=',' para especificar que las columnas están separadas por comas y skiprows=1 para ignorar la fila de encabezado.

import numpy as np

## Load data from the CSV file
try:
    ## Relative paths will cause validation to fail, please use absolute paths in the lab
    data = np.loadtxt('/home/labex/project/data.csv', delimiter=',', skiprows=1)
    print("Data loaded from data.csv:")
    print(data)
except IOError:
    print("Error: data.csv not found.")

Guarda el archivo y ejecútalo desde la terminal.

python read_from_file.py

El script leerá los datos numéricos de data.csv y los imprimirá como un array de NumPy.

Data loaded from data.csv:
[[1.  2.5 3.2]
 [4.5 5.  6.8]
 [7.3 8.1 9.9]]

Este método es muy eficiente para cargar datos numéricos estructurados en arrays para su posterior procesamiento.

Resumen

En este laboratorio, ha aprendido las técnicas fundamentales para crear arrays de NumPy. Ha practicado la creación de arrays a partir de listas de Python, el uso de funciones intrínsecas como np.arange y np.zeros, la manipulación de arrays existentes a través de vistas, copias y uniones, y la carga de datos desde un archivo de texto utilizando np.loadtxt.

Estas habilidades son los pilares para casi todas las tareas de computación numérica y científica que realizará con Python. Con una sólida comprensión de la creación de arrays, ahora está listo para explorar la manipulación de arrays y las operaciones matemáticas más avanzadas en NumPy.