Numpy es una librería Python open-source para computación científica que permite tener el poder de computación de lenguajes como C o Fortran en lenguaje Python. En la presente entrada, Numpy I, realizaré una breve presentación y realizaré unos ejemplos básicos.

Las características generales de Numpy son las siguientes:

1. Permite trabajar con matrices N dimensionales.
2. Proporciona herramientas de computación numérica ofreciendo un conjunto de funciones matemáticas complejas.
3. Es interoperable, con lo cual, permite trabajar con amplias plataformas, funciona con bibliotecas distribuidas y de GPU.
4. El núcleo de la librería es código C bien optimizado.
5. Fácil de usar.
6. Es una librería de código abierto.

Los ejemplos practicos que mostraré en los siguientes apartados están desarrollados con Python 3.6. Las dependencias de las librerías utilizadas son las siguientes: numpy y matplotlib; y, para la utilización de las funciones en cada módulo, es necesario importar la librería de la siguiente forma:

import numpy as np

Los ejemplos de utilización de la librería Numpy a presentar en esta entrada son los siguientes:

1. Creación de arrays n-dimensionales.
2. Generación e inicialización de arrys n-dimensionales.
3. Indexación de elementos en arrays n-dimensionales.
4. Funciones básicas en arrays n-dimensionales.

1.- Creación de arrays N dimensaionales.

La creación de un array la realizaremos empleando la función array y, para determinar el tipo de los elementos del array, emplearemos la función dtype. En el siguiente ejemplo se define una array de dos dimensiones a partir de una lista.

lst = [[1, 2, 3],
       [4, 5, 6]]
arrayld = np.array(lst)
print(f'Array integer:\n{arrayld}')
print(f'Type={arrayld.dtype}')

La salida por consola es la siguiente:

Array integer:
[[1 2 3]
[4 5 6]]
Type=int64

Para crear un array de elementos de tipos reales a partir del array anterior, utilizamos la función astype con el tipo float32 definidos en Numpy, el snippet ejemplo es el siguiente:

array_float_32 = arrayld.astype(np.float32)
print(f'Array float32:\n{array_float_32}')
print(f'Type={array_float_32.dtype}\n')

La salida por consola es la siguiente:

Array float32:
[[1. 2. 3.]
[4. 5. 6.]]
Type=float32

Para crear un array de dos dimensiones de elementos enteros a partir de una lista, se utiliza la función array y se especifica el tipos int64. Una vez creado el array, podemos conocer sus características con las siguientes funciones:

• itemsize.- para determinar el tamaño en bit que ocupan en el array.
• size.- para determinar el número de elementos del array.
• ndim.- para determinar el número de dimensiones.
• shap.- para determinar el número de elementos por dimensión.

El snippet ejemplo es el siguiente:

array_2_dimesion = np.array([[1, 2, 3], [4, 5, 6]], dtype='int64')
print(f'array_2_dimesion=\n{array_2_dimesion}')
print(f'array_2_dimesion.itemsize={array_2_dimesion.itemsize}') 
print(f'array_2_dimesion.size={array_2_dimesion.size}') 
print(f'array_2_dimesion.ndim={array_2_dimesion.ndim}') 
print(f'array_2_dimesion.shape={array_2_dimesion.shape}\n') 

La salida por consola es la siguiente:

array_2_dimesion=
[[1 2 3]
 [4 5 6]]
array_2_dimesion.itemsize=8
array_2_dimesion.size=6
array_2_dimesion.ndim=2
array_2_dimesion.shape=(2, 3)

En el caso de un array de una dimensión, el resultado de la función shape sería el siguiente:

array_ahape =  np.array([1, 2, 3]).shape
print(f'array_ahape={array_ahape}')  

La salida por consola es la siguiente:

array_ahape=(3,)

2.- Generación e inicialización de arrays n-dimensionales.

La creación de un array n-dimensional de forma dinámica con un generador se realiza con la función fromiter. El generador debe de ser pasado como parámetro ya sea una función explícita, o bien, mediante una sentencia que defina un generador. El snippet con un ejemplo es el siguiente:

 def generator():
     for i in range(10):
         if not (i % 2):
             yield i
 gen = generator()
 array_generator = np.fromiter(gen, dtype=int)
 print(f'array_generator={array_generator}')
 generator_expression = (i for i in range(10) if i % 2)
 array_generator_expression = np.fromiter(generator_expression, dtype=int)
 print(f'array_generator_expression={array_generator_expression}')

La salida por consola es la siguiente:

array_generator=[0 2 4 6 8]
array_generator_expression=[1 3 5 7 9]
array_3_3_1=
  [[1. 1. 1.]
   [1. 1. 1.]
   [1. 1. 1.]]

Otra forma de crear arrays con inicializaciones determinadas se pueden realizar con las siguientes funciones:

• ones.- Creación de un array n-dimensional de números reales con valor 1.
• zeros.- Creación de un array n-dimensional de números reales con valor 0.
• eye.- Creación de un array n-dimensional cuya diagonal tiene valor 1.
• diag.- Creación de un array n-dimensional cuya diagonal tiene un valor pasado por parámetro.
• arrange.- Creación de un array n-dimensional cuya diagonal tiene el rango de valores pasados por parámetro.
• linspace.- Creación de un array n-dimensional cuyos de x elementos pasados por paámetros y valores comprendidos entre un valor mínimo y máximo.

El snippet de código con ejemplos es el siguiente:

 # Inicializadores de arrays.
 array_3_3_1 = np.ones((3, 3))
 print(f'array_3_3_1=\n{array_3_3_1}\n')
 array_3_3_0 = np.zeros((3, 3))
 print(f'array_3_3_0=\n{array_3_3_0}\n')
 array_eye_diagonal = np.eye(3)
 print(f'array_eye_diagonal=\n{array_eye_diagonal}\n')
 array_diagonal = np.diag((3, 3, 3))
 print(f'array_diagonal=\n{array_diagonal}\n')
 array_arange_float = np.arange(4., 10.)  
 print(f'array_arange_float=\n{array_arange_float}\n')
 array_arange_int = np.arange(5)  
 print(f'array_arange_int=\n{array_arange_int}\n')
 array_arange_interval = np.arange(1., 11., 2)  
 print(f'array_arange_interval=\n{array_arange_interval}\n')
 array_insterval_space_1 = np.linspace(0., 1., num=5)  
 print(f'array_insterval_space_1=\n{array_insterval_space_1}\n')
 array_insterval_space_2 = np.linspace(0., 1., num=6)  
 print(f'array_insterval_space_2=\n{array_insterval_space_2}\n')

La salida por consola es la siguiente:

  array_3_3_0=
  [[0. 0. 0.]
   [0. 0. 0.]
   [0. 0. 0.]]
  array_eye_diagonal=
  [[1. 0. 0.]
   [0. 1. 0.]
   [0. 0. 1.]]
  array_diagonal=
  [[3 0 0]
   [0 3 0]
   [0 0 3]]
  array_arange_float=
  [4. 5. 6. 7. 8. 9.]
  array_arange_int=
  [0 1 2 3 4]
  array_arange_interval=
  [1. 3. 5. 7. 9.]
  array_insterval_space_1=
  [0.   0.25 0.5  0.75 1.  ]
  array_insterval_space_2=
  [0.  0.2 0.4 0.6 0.8 1. ]

3.- Indexación de elementos en arrays n-dimensionales.

El acceso a los elementos de los array se realiza indicando la posición entre corchetes. Unos ejemplos de acceso a elementos de un array de una y dos dimensiones son los que se muestran en el siguiente snippet de código:

array = np.array([1, 2, 3])
print(f'array=\n{array}\n')
print(f'array[0]=\n{array[0]}')
print(f'array[1]=\n{array[1]}\n')
print(f'array[:2]=\n{array[:2]}\n')
print(f'array[1:]=\n{array[1:]}\n')
array_22 = np.array([[1, 2, 3], [4, 5, 6]])
print(f'array=\n{array_22}\n')
print(f'array_22[0,0]=\n{array_22[0, 0]}')
print(f'array_22[-1,-1]=\n{array_22[-1, -1]}\n')
print(f'array_22[0]=\n{array_22[0]}\n') 
print(f'array_22[:, 0]=\n{array_22[:, 0]}\n')
print(f'array_22[:, :2]=\n{array_22[:, :2]}\n')

La salida por consola es la siguiente:

array=
[1 2 3]
array[0]=
1
array[1]=
2
array[:2]=
[1 2]
array[1:]=
[2 3]
array=
[[1 2 3]
 [4 5 6]]
array_22[0,0]=
1
array_22[-1,-1]=
6
array_22[0]=
[1 2 3]
array_22[:, 0]=
[1 4]
array_22[:, :2]=
[[1 2]
 [4 5]]

4.- Funciones básicas en arrays n-dimensionales.

La manipulación de los elementos de los array n-dimensionales se puede realizar accediendo de forma directo, o bien, utilizando operadores matemáticos. En el siguiente snippet, se muestra unos ejemplos de manipulación de elementos:

 # Forma1: Suma 1 a los elementos de la lista
 list = [[1, 2, 3], [4, 5, 6]]
 list_mas_1 = [[cell + 1 for cell in row] for row in list]  # Incrementamos en 1
 print(f'list_mas_1=\n{list_mas_1}\n')
 # Forma2: Suma 1
 array_nd_list_mas_1 = np.add(list, 1)
 print(f'array_nd_list_mas_1=\n{array_nd_list_mas_1}\n')
 # Forma3: Suma 1
 ndarray_3 = np.array(list)
 array_nd_list_mas_12 = ndarray_3 + 1
 print(f'array_nd_list_mas_12=\n{array_nd_list_mas_12}\n')
 ndarray_cuadrada = np.array(list)
 array_nd_list_cuadrado = ndarray_cuadrada**2
 print(f'array_nd_list_cuadrado=\n{array_nd_list_cuadrado}\n')

La salida por consola es la siguiente:

list_mas_1=
[[2, 3, 4], [5, 6, 7]]
array_nd_list_mas_1=
[[2 3 4]
 [5 6 7]]
array_nd_list_mas_12=
[[2 3 4]
 [5 6 7]]
array_nd_list_cuadrado=
[[ 1  4  9]
 [16 25 36]]

Otras funciones básicas pueden ser las siguientes:

• reduce.- función de suma de columnas de un array n-dimensional.
• sum.- función de suma de elemntos de una terminada dimensión.
• mean.- función de cálculo de la media.
• std.- función de cálculo de la desviación típica.
• var.- función de la varianza.
• max.- función de cálculo del valor máximo.
• min.- función de cálculo del vfalor mínimo

El snippet con ejemplos de utilización de uso de dichas funciones es el siguiente:

  ndarray = np.array(list)
  print(f'np.add.reduce(ndarray)={np.add.reduce(ndarray)}')  
  print(f'np.sum(ndarray, axis=0)={np.sum(ndarray, axis=0)}')  
  print(f'np.sum(ndarray, axis=1)={np.sum(ndarray, axis=1)}')  
  print(f'ndarray.sum()={ndarray.sum()}')  
  print(f'ndarray.mean()={ndarray.mean()}')
  print(f'ndarray.std()={ndarray.std()}')
  print(f'ndarray.var()={ndarray.var()}')
  print(f'ndarray.max()={ndarray.max()}')
  print(f'ndarray.min()={ndarray.min()}')
  print(f'ndarray.argmax()={ndarray.argmax()}')
  print(f'ndarray.argmin()={ndarray.argmin()}')

La salida por consola es la siguiente:

np.add.reduce(ndarray)=[5 7 9]
np.sum(ndarray, axis=0)=[5 7 9]
np.sum(ndarray, axis=1)=[ 6 15]
ndarray.sum()=21
ndarray.mean()=3.5
ndarray.std()=1.707825127659933
ndarray.var()=2.9166666666666665
ndarray.max()=6
ndarray.min()=1
ndarray.argmax()=5
ndarray.argmin()=0

En la siguiente entrada, Numpy II, continuaré describiendo operaciones con arrays en Numpy.