Tutorial Numpy: Modificación de arrays en Numpy

¿En qué consiste la modificación de Arrays en Numpy?

Numpy proporciona un conjunto robusto de herramientas para la modificación de arrays, permitiendo realizar transformaciones eficientes y flexibles. Estas modificaciones pueden ser de varios tipos, que se detallan a continuación.

Modificación directa de elementos

Se pueden modificar elementos individuales o subconjuntos de un array a través del indexado y el slicing:

import numpy as np

# Crear un array 1D
array = np.array([1, 2, 3, 4, 5])

# Modificar un elemento
array[0] = 10
# array ahora es [10, 2, 3, 4, 5]

# Modificar un subarray usando slicing
array[1:3] = [20, 30]
# array ahora es [10, 20, 30, 4, 5]

Modificación condicional

Numpy permite modificar elementos basados en una condición lógica:

# Usar una condición para modificar elementos
array[array < 20] = 0
# array ahora es [0, 20, 30, 0, 0]

Inserción y eliminación

Numpy ofrece funciones como np.insert() y np.delete() para insertar o eliminar elementos a lo largo de un eje específico de un array:

# Crear un array 2D
array2d = np.array([[1, 2], [3, 4]])

# Insertar un valor en una posición específica
array2d = np.insert(array2d, 1, [9, 9], axis=0)
# array2d ahora es [[1, 2], [9, 9], [3, 4]]

# Eliminar un valor en un índice específico
array2d = np.delete(array2d, 1, axis=0)
# array2d ahora es [[1, 2], [3, 4]]

Modificación mediante operaciones matemáticas

Las operaciones matemáticas se pueden aplicar directamente sobre los arrays:

# Operaciones con escalares
array = np.array([1, 2, 3, 4, 5])
array = array * 2
# array ahora es [2, 4, 6, 8, 10]

# Operaciones vectoriales
array2 = np.array([1, 1, 1, 1, 1])
array = array + array2
# array ahora es [3, 5, 7, 9, 11]

Modificación usando funciones universales (ufuncs)

Las ufuncs proporcionan una interfaz más eficiente para realizar operaciones element-wise en arrays:

# Aplicación de una ufunc
array = np.array([1, 4, 9, 16])
sqrt_array = np.sqrt(array)
# sqrt_array es [1.0, 2.0, 3.0, 4.0]

Transformación de tipo de dato

Es posible cambiar el tipo de datos de un array utilizando el método astype():

# Cambiar el tipo de datos del array
array = np.array([1.5, 2.5, 3.5])
array_int = array.astype(int)
# array_int ahora es [1, 2, 3]

Estas herramientas permiten un manejo versátil y eficiente de los datos, ofreciendo a los ingenieros de software una gran flexibilidad a la hora de trabajar con arrays en Numpy.

Copia y vista de Arrays y aspectos a tener en cuenta

En Numpy, es crucial entender la diferencia entre copias y vistas de arrays, ya que tienen implicaciones notables en el rendimiento y en la manipulación de datos.

Una vista significa que dos arrays comparten los mismos datos pero pueden tener diferente forma o tamaño. Modificar la vista afectará al array original y viceversa. Para crear una vista, se pueden usar diversas operaciones como el slicing.

import numpy as np

# Crear un array 1D
array = np.array([1, 2, 3, 4, 5])

# Crear una vista del array original
vista = array[1:4]
# Modificar la vista también modifica el array original
vista[0] = 20
# array ahora es [1, 20, 3, 4, 5]

Una copia de un array cuenta con su propio conjunto de datos. Modificaciones en la copia no afectarán al array original. La función copy() se utiliza para crear copias explícitas.

# Crear una copia del array original
copia = array.copy()
# Modificar la copia no afecta al array original
copia[0] = 10
# array sigue siendo [1, 20, 3, 4, 5]
# copia es [10, 20, 3, 4, 5]

Aspectos a tener en cuenta:

• Memoria: Las vistas consumen menos memoria, ya que no se crean nuevos datos sino que se utilizan los del array original. Las copias ocupan más memoria al duplicar los datos.
• Rendimiento: Las vistas pueden ser más rápidas en operaciones subsecuentes, ya que no requieren duplicar los datos. Las copias pueden ser más lentas si se trabaja con grandes volúmenes de datos debido a la duplicación.

Reshape y manipulación de dimensiones de Arrays

Numpy permite cambiar la forma de un array sin modificar sus datos mediante la función reshape(). Esta función es útil en múltiples escenarios como la transformación de datos en matrices 2D, 3D u otras estructuras de mayor dimensión.

# Crear un array 1D
array = np.arange(1, 7)

# Convertir el array 1D en un array 2D de 2x3
array_2d = array.reshape(2, 3)
# array_2d es 
# [[1, 2, 3],
#  [4, 5, 6]]

Además, se pueden aplanar arrays multidimensionales de nuevo a una dimensión utilizando el método ravel() o flatten(). ravel() devuelve una vista cuando es posible (es decir, no cambia la estructura de datos subyacente), mientras que flatten() siempre devuelve una copia.

# Aplanar array_2d usando ravel
flatten_ravel = array_2d.ravel()
# flatten_ravel es [1, 2, 3, 4, 5, 6]

# Aplanar array_2d usando flatten
flatten_flatten = array_2d.flatten()
# flatten_flatten es [1, 2, 3, 4, 5, 6]

Otro método útil es transpose() que permite cambiar los ejes de un array.

# Transponer array_2d
array_transposed = array_2d.transpose()
# array_transposed es 
# [[1, 4],
#  [2, 5],
#  [3, 6]]

La función resize() no solo cambia la forma del array sino que también puede modificar su tamaño. Si el tamaño nuevo es mayor, el array se rellena con copias del array original.

# Redimensionar array_2d
array_resized = np.resize(array_2d, (3, 4))
# array_resized es 
# [[1, 2, 3, 4],
#  [5, 6, 1, 2],
#  [3, 4, 5, 6]]

Estos métodos ofrecen un control preciso y eficiente sobre la forma y las dimensiones de los arrays, siendo fundamentales en el procesamiento y la manipulación avanzada de datos con Numpy.

Combinación y división de Arrays

En Numpy, la combinación y división de arrays son operaciones esenciales que permiten construir y manipular arrays complejos de manera eficiente.

Para combinar arrays, Numpy proporciona varias funciones:

• np.concatenate()
• np.vstack()
• np.hstack()
• np.dstack()
• np.column_stack()
• np.row_stack()

Mientras que para dividir arrays, las funciones disponibles incluyen:

• np.split()
• np.hsplit()
• np.vsplit()
• np.dsplit()

Combinación de arrays

• np.concatenate()

Esta función conecta arrays a lo largo de un eje especificado (eje-0 por defecto).

import numpy as np

# Crear dos arrays 1D
array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])

# Concatenar a lo largo del eje-0
result = np.concatenate((array1, array2))
# result es [1, 2, 3, 4, 5, 6]

• np.vstack()

Apila arrays en una secuencia verticalmente (fila a fila).

# Crear dos arrays 2D
array1 = np.array([[1, 2], [3, 4]])
array2 = np.array([[5, 6]])

# Apilar verticalmente
result = np.vstack((array1, array2))
# result es 
# [[1, 2],
#  [3, 4],
#  [5, 6]]

• np.hstack()

Apila arrays en una secuencia horizontalmente (columna a columna).

# Crear dos arrays 2D
array1 = np.array([[1, 2], [3, 4]])
array2 = np.array([[5, 6], [7, 8]])

# Apilar horizontalmente
result = np.hstack((array1, array2))
# result es 
# [[1, 2, 5, 6],
#  [3, 4, 7, 8]]

• np.dstack()

Apila arrays en la profundidad (tercer eje).

# Crear dos arrays 2D
array1 = np.array([[1, 2], [3, 4]])
array2 = np.array([[5, 6], [7, 8]])

# Apilar en profundidad
result = np.dstack((array1, array2))
# result es 
# [[[1, 5],
#   [2, 6]],
#  [[3, 7],
#   [4, 8]]]

• np.column_stack() y np.row_stack()

np.column_stack() apila arrays 1D como columnas en una matriz 2D:

# Crear dos arrays 1D
array1 = np.array([1, 2])
array2 = np.array([3, 4])

# Apilar como columnas
result = np.column_stack((array1, array2))
# result es 
# [[1, 3],
#  [2, 4]]

División de arrays

• np.split()

Divide un array en sub-arrays como se especifica por las posiciones de división.

# Crear un array 1D
array = np.array([1, 2, 3, 4, 5, 6])

# Dividir en tres partes
result = np.split(array, 3)
# result es [array([1, 2]), array([3, 4]), array([5, 6])]

• np.hsplit()

Divide un array en sub-arrays horizontalmente (columna-wise).

# Crear un array 2D
array = np.array([[1, 2, 3], [4, 5, 6]])

# Dividir en tres partes horizontales
result = np.hsplit(array, 3)
# result es [array([[1],
#                   [4]]),
#            array([[2],
#                   [5]]),
#            array([[3],
#                   [6]])]

• np.vsplit()

Divide un array en sub-arrays verticalmente (fila-wise).

# Crear un array 2D
array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Dividir en tres partes verticales
result = np.vsplit(array, 3)
# result es [array([[1, 2, 3]]),
#            array([[4, 5, 6]]),
#            array([[7, 8, 9]])]

• np.dsplit()

Divide un array en sub-arrays a lo largo del eje-3 (profundidad).

# Crear un array 3D
array = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

# Dividir en dos partes a lo largo de la profundidad
result = np.dsplit(array, 2)
# result es [array([[[1],
#                    [3]],
#                   [[5],
#                    [7]]]),
#            array([[[2],
#                    [4]],
#                   [[6],
#                    [8]]])]

Estas funciones permiten una manipulación avanzada de arrays en Numpy, facilitando la creación y transformación de estructuras de datos complejas.

Operaciones de forma y tipo

Las operaciones de forma y tipo en Numpy permiten transformar y manipular arrays de manera sofisticada y eficiente. 

Estas operaciones incluyen ajustes en la forma del array, cambios en el tipo de datos, y transformaciones relacionadas con la memoria y la estructura subyacente.

Cambio de forma con .reshape()

El método reshape() permite ajustar la estructura de un array sin alterar sus datos. Es especialmente útil para preparar datos para operaciones matriciales o algoritmos de aprendizaje automático:

import numpy as np

# Crear un array 1D y cambiar su forma a 2D
array = np.arange(1, 10)
array_2d = array.reshape(3, 3)
# array_2d es:
# [[1, 2, 3],
#  [4, 5, 6],
#  [7, 8, 9]]

Aplanar arrays

Para convertir un array multidimensional en un array 1D, puedes usar flatten() o ravel(). La diferencia es que ravel() intenta devolver una vista siempre que sea posible, mientras que flatten() siempre devuelve una copia:

# Aplanar usando ravel
flattened_ravel = array_2d.ravel()
# flattened_ravel es [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Aplanar usando flatten
flattened_flatten = array_2d.flatten()
# flattened_flatten es [1, 2, 3, 4, 5, 6, 7, 8, 9]

Transposición de arrays

La transposición de matrices se logra con transpose(), invirtiendo los ejes del array:

# Transponer el array 2D
transposed = array_2d.transpose()
# transposed es:
# [[1, 4, 7],
#  [2, 5, 8],
#  [3, 6, 9]]

Modificación del tamaño del array

El método resize() no solo cambia la forma del array sino que también puede modificar su tamaño. Si el nuevo tamaño es mayor, el array se rellena con copias de los datos originales:

# Redimensionar array_2d
resized = np.resize(array_2d, (4, 4))
# resized es:
# [[1, 2, 3, 4],
#  [5, 6, 7, 8],
#  [9, 1, 2, 3], 
#  [4, 5, 6, 7]]

Cambio de tipo de datos

Puedes cambiar el tipo de datos de un array usando astype(), lo cual es útil cuando se necesita optimizar el uso de memoria o realizar operaciones específicas:

# Pasar de float a int
float_array = np.array([1.2, 2.5, 3.8])
int_array = float_array.astype(int)
# int_array es [1, 2, 3]

Casteo explícito de tipos

Para conversiones más avanzadas, puedes hacer uso de np.asarray() seguido del tipo de datos deseado:

# Casting explícito a float32
array = np.array([1, 2, 3])
float32_array = np.asarray(array, dtype='float32')
print(float32_array)
# float32_array es [1.0, 2.0, 3.0]

Cambios en la orientación con .swapaxes() y .moveaxis()

• swapaxes() permite intercambiar dos ejes de un array:

array_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
swapped = array_3d.swapaxes(0, 2)
# swapped es:
# [[[1, 5],
#   [3, 7]],
#  [[2, 6],
#   [4, 8]]]

• moveaxis() reordena los ejes de acuerdo a las especificaciones dadas:

moved = np.moveaxis(array_3d, 0, -1)
# moved es:
# [[[1, 5],
#   [2, 6]],
#  [[3, 7],
#   [4, 8]]]

Estas operaciones de forma y tipo son herramientas esenciales para la manipulación avanzada de datos en Numpy, ofreciendo flexibilidad y eficiencia en el procesamiento y análisis de datos.