Numpy I

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:

1import 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.

1lst = [[1, 2, 3],

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

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:

1array_float_32 = arrayld.astype(np.float32)
2print(f'Array float32:\n{array_float_32}')
3print(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:

1array_2_dimesion = np.array([[1, 2, 3], [4, 5, 6]], dtype='int64')

print(f'array_2_dimesion=\n{array_2_dimesion}')
2print(f'array_2_dimesion.itemsize={array_2_dimesion.itemsize}')
3print(f'array_2_dimesion.size={array_2_dimesion.size}')
4print(f'array_2_dimesion.ndim={array_2_dimesion.ndim}')
5print(f'array_2_dimesion.shape={array_2_dimesion.shape}\n')
6

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:

1array_ahape = np.array([1, 2, 3]).shape

2print(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:

1 def generator():
2 for i in range(10):
3 if not (i % 2):
4 yield i
gen = generator()
5 array_generator = np.fromiter(gen, dtype=int)
6 print(f'array_generator={array_generator}')
7 generator_expression = (i for i in range(10) if i % 2)
8 array_generator_expression = np.fromiter(generator_expression,
9 dtype=int)
print(f'array_generator_expression={array_generator_expression}')
10

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:

1
2
# Inicializadores de arrays.
3 array_3_3_1 = np.ones((3, 3))
4 print(f'array_3_3_1=\n{array_3_3_1}\n')
5 array_3_3_0 = np.zeros((3, 3))
6 print(f'array_3_3_0=\n{array_3_3_0}\n')
7 array_eye_diagonal = np.eye(3)
print(f'array_eye_diagonal=\n{array_eye_diagonal}\n')
8 array_diagonal = np.diag((3, 3, 3))
9 print(f'array_diagonal=\n{array_diagonal}\n')
10array_arange_float = np.arange(4., 10.)
11print(f'array_arange_float=\n{array_arange_float}\n')
array_arange_int = np.arange(5)
12print(f'array_arange_int=\n{array_arange_int}\n')
13array_arange_interval = np.arange(1., 11., 2)
14print(f'array_arange_interval=\n{array_arange_interval}\n')
15array_insterval_space_1 = np.linspace(0., 1., num=5)
16print(f'array_insterval_space_1=\n{array_insterval_space_1}\n')
array_insterval_space_2 = np.linspace(0., 1., num=6)
17print(f'array_insterval_space_2=\n{array_insterval_space_2}\n')
18
19

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:

1
2 array = np.array([1, 2, 3])
3 print(f'array=\n{array}\n')
4 print(f'array[0]=\n{array[0]}')
print(f'array[1]=\n{array[1]}\n')
5 print(f'array[:2]=\n{array[:2]}\n')
6 print(f'array[1:]=\n{array[1:]}\n')
7 array_22 = np.array([[1, 2, 3], [4, 5, 6]])
8 print(f'array=\n{array_22}\n')
print(f'array_22[0,0]=\n{array_22[0, 0]}')
9 print(f'array_22[-1,-1]=\n{array_22[-1, -1]}\n')
10print(f'array_22[0]=\n{array_22[0]}\n')
11print(f'array_22[:, 0]=\n{array_22[:, 0]}\n')
12print(f'array_22[:, :2]=\n{array_22[:, :2]}\n')
13

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:

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

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:

1
2 ndarray = np.array(list)
3 print(f'np.add.reduce(ndarray)={np.add.reduce(ndarray)}')
print(f'np.sum(ndarray, axis=0)={np.sum(ndarray, axis=0)}')
4 print(f'np.sum(ndarray, axis=1)={np.sum(ndarray, axis=1)}')
5 print(f'ndarray.sum()={ndarray.sum()}')
6 print(f'ndarray.mean()={ndarray.mean()}')
7 print(f'ndarray.std()={ndarray.std()}')
8 print(f'ndarray.var()={ndarray.var()}')
print(f'ndarray.max()={ndarray.max()}')
9 print(f'ndarray.min()={ndarray.min()}')
10print(f'ndarray.argmax()={ndarray.argmax()}')
11print(f'ndarray.argmin()={ndarray.argmin()}')
12

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

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

1. Operaciones de arrays con sus dimensiones.

2. Indexación avanzada.
3. Operaciones de comparación.

1.- Operaciones de arrays con sus dimensiones.

Los arrays son estructuras n-dimensionales con los cuáles podemos realizar sumas a pesar
de tener diferente número de dimensión. A continuación, muestro una serie de ejemplos.

Sean dos arrays con la misma dimensión y número de elementos por dimensión, la
operación suma se realiza con el operador +. El snippet del código es el siguiente:

1array1 = np.array([1, 2, 3])

2array2 = np.array([4, 5, 6])
3print(f'array1 + array2={array1 + array2}')

La salida por consola es la siguiente:

array1 + array2=[5 7 9]

Sea un array de dos dimenciones con tres elementos por dimensión y un array de una
dimensión e igual número de elementos que el primero. El snippet del código es el
siguiente:

1array3 = np.array([[7, 8, 9], [3, 2, 1]])

2print(f'array3 + array1={array3 + array1}')

La salida por consola es la siguiente:

array3 + array1=[[ 8 10 12]

[ 4 4 4]]

Sea un array de dos dimensiones con tres elementos y un array de dos dimensiones de un
elemento por dimensión. El resultado es una array de dos dimensiones de tres elementos en
el que se ha incrementado el valor del segundo array. El snippet del código es el siguiente:

1array_21 = np.array([[1], [2]])

2print(f'array3 + array_21={array3 + array_21}')

La salida por consola es la siguiente:

array3 + array_21=[[ 8 9 10]

[ 5 4 3]]

2.- Indexación avanzada.

Para realizar operaciones con parte de los elmentos de un array, se deben de crear
referencias a la estructura con la que se desea operar. Si se desea incrementar en 100 la
segunda posición de las dimensiones que forman parte de un array, se crea una referencia a
las posiciones de todas las dimensiones y se incrementa en 100 con el operador +=, en
nuestro ejemplo, center_array; una vez operado, el array inicial contiene el resultado. Hay
que destacar que las operaciones no son inmutables y se trabaja con referencias. El
snippet del código es el siguiente:
1array = np.array([[1, 2, 3], [4, 5, 6]])
2center_array = array[:, 1]
3center_array += 100
4print(f'center_array=\n{center_array}')
print(f'array=\n{array}')
5

La salida por consola es la siguiente:

center_array=
[102 105]
array=
[[ 1 102 3]
[ 4 105 6]]

Si se desea realizar una copia de una dimensión se utiliza la función copy. En el siguiente
ejemplo, se realiza una copia de una dimensión de una array inicial. El snippet de ejemplo
es el siguiente:

1array2 = np.array([[1, 2, 3], [4, 5, 6]])

2second_row = array2[1].copy()
3second_row += 100
4print(f'second_row=\n{second_row}')
print(f'array2=\n{array2}')
5

La salida por consola es la siguiente:

second_row=
[104 105 106]
array2=
[[1 2 3]
[4 5 6]]

Para determinar si una referencia es una copia o forma parte de una estructura se emplea la
función may_share_memory. A continuación, se muestran dos ejemplos de ejemplos
previos. El snippet de código es el siguiente:

first_row = array2[:1]
1np.may_share_memory(first_row, array2)
2print(f'np.may_share_memory(first_row,
3array2)=\n{np.may_share_memory(first_row, array2)}')
4print(f'np.may_share_memory(second_row,
array2)=\n{np.may_share_memory(second_row, array2)}')

La salida por consola es la siguiente:

np.may_share_memory(first_row, array2)=
True
np.may_share_memory(second_row, array2)=
False
Para obtener arrays que sean subconjuntos de un array, podemos realizar seleccion de
posiciones de una determinada dimensión. En el siguiente ejemplo, se imprimen todos los
elementos de la primera dimensión y el primer y último elemento de la segundo; y, por
último, el caso contrario, último y primero. El snippet del código es el siguiente:

1array3 = np.array([[1, 2, 3], [4, 5, 6]])

2print(f'array3=\n{array3}')
3print(f'array3[:, [0,2]]=\n{array3[:, [0,2]]}')
4print(f'array3[:, [2,0]]=\n{array3[:, [2,0]]}')

La salida por consola es la siguiente:

array3=
[[1 2 3]
[4 5 6]]
array3[:, [0,2]]=
[[1 3]
[4 6]]
array3[:, [2,0]]=
[[3 1]
[6 4]]

Por último, se pueden realizar operaciones de comparación de los elementos y obtener array
lógicos con el resultado. En el siguiente ejemplo, se imprimen los elementos mayores a 3;
impresión de los elementos que son mayores a 3; y, por último, se compone un predicado
lógico. El snippet del código es el siiguiente:

1array3 = np.array([[1, 2, 3], [4, 5, 6]])

2print(f'array3 > 3=\n{array3 > 3}')
print(f'array3[array3 > 3]=\n{array3[array3 > 3]}')
3print(f'array3[(array3 > 2) & (array3 <5)]=\n{array3[(array3 > 2) &
4(array3 <5)]}')

La salida por consola es la siguiente:

array3 > 3=
[[False False False]
[ True True True]]
array3[array3 > 3]=
[4 5 6]
array3[(array3 > 2) & (array3 <5)]=
[3 4]

3.- Operaciones de comparación.

En el apartado anterior, se presentó la operación de comparación y, en el presente apartado,
profundizaremos en las operaciones de comparación. En este primer ejemplo, se muestra
una selección de elementos de un array mayores a 2. El snippet del código es el siguiente:

1array = np.array([1, 2, 3, 4])

2array_mayor_2 = array > 2
3print(f'array_mayor_2=\n{array_mayor_2}\n')

La salida por consola es la siguiente:

array_mayor_2=
[False False True True]

Con los resultados lógicos podemos realizar operaciones para poder operar con ellos. Para
ello, podemos emplear las siguientes funciones:

• Función sum.- función que cuantifica el número de elementos que cumplen la

función.
• Función nonzero.- función que retorna el índice de la posición en la dimensión.

En el siguiente snippet se muestran ejemplos a partir del array inicial:

1print(f'array[array_mayor_2]=\n{array[array_mayor_2]}\n')
2print(f'array_mayor_2.sum()=\n{array_mayor_2.sum()}\n')
3print(f'array_mayor_2.nonzero()=\n{array_mayor_2.nonzero()}\n')
4print(f'(array > 2).nonzero()=\n{(array > 2).nonzero()}\n')

La salida por consola es la siguiente:

array[array_mayor_2]=
[3 4]

array_mayor_2.sum()=
2

array_mayor_2.nonzero()=
(array([2, 3]),)

(array > 2).nonzero()=

(array([2, 3]),)

Para poder realizar un tratamiento más específico, podemos utilizar la función where en la
cuál podemos declarar qué valor asignar al resultado si cumple una condición, o bien,
cuando no la cumple. En el siguiente snippet se muestra un ejemplo de uso de la función
where:

1array_where = np.where(array > 2)

2print(f'np.where(array > 2)=\n{array_where}\n')
3array_where_2 = np.where(array > 2, 1, 0)
4print(f'np.where(array > 2, 1, 0)=\n{array_where_2}\n')

La salida por consola es la siguiente:

np.where(array > 2)=

 (array([2, 3]),)

np.where(array > 2, 1, 0)=

[0 0 1 1]

Otra forma de trabajar con predicados sin la función where es declarando un predicado con
una condición. Una vez creado el predicado, lo aplicamos en el array como una indexación
asignando el valor para el caso de éxito, o bien, utilizando el carácter ~ para el caso de no
cumplirse. En el siguiente snippet se muestra un ejemplo de uso de ejemplo:

1array2 = np.array([1, 2, 3, 4])

2array2_mayor_2 = array2 > 2
3array2[array2_mayor_2] = 1
4array2[~array2_mayor_2] = 0
5print(f'array2={array2}')

La salida por consola es la siguiente:

array2=[0 0 1 1]

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

1. Generación aleatoria de números.

2. Transformación de arrays de una dimensión a otra.
3. Álgebra linear.
4. Operaciones sobre conjuntos.
5. Serialización de arrays.

1.- Generación aleatoria de números.

Para la generación de números aleatorios emplearemos la función randn; para la definición
de la semilla de generación, emplearemos la función seed; y, para definir un objeto de
estado para la generación de números, emplearemos el objeto RandomState.

Para definir una distribución, empleados la función scatter del módulo matplotlib.pyplot; y,
para representar desde un punto de vista gráfico, se emplea la función show. El snippet de
código de ejemplo es el siguiente:

1 seed = np.random.seed(123)
randn = np.random.randn(3)
2 print(f'randn=\n{randn}\n')
3
4 rang1 = np.random.RandomState(seed=123)
5 array_rang1 = rang1.randn(3)
6 print(f'array_rang1=\n{array_rang1}\n')
7 rang2 = np.random.RandomState(seed=123)
8 array_rang2 = rang2.randn(100, 2) # Retorna una distribución normal
9 print(f'array_rang2=\n{array_rang2}\n')
10
11plt.scatter(array_rang2[:, 0], array_rang2[:, 1])
12
13rang3 = np.random.RandomState(seed=123)
normal_distribution = 2. * rang3.randn(100, 2) + 5.
14plt.scatter(normal_distribution[:, 0], normal_distribution[:, 1])
15plt.show()
16
17
18

La salida por consola son los siguientes:

randn=
[-1.0856306 0.99734545 0.2829785 ]

array_rang1=
[-1.0856306 0.99734545 0.2829785 ]

array_rang2=
[[-1.08563060e+00 9.97345447e-01]
...
[-3.41261716e-01 -2.17946262e-01]]

La gráfica generada en el ejemplo anterior es la que se muestra en el siguiente gráfico:

2.- Transformación de arrays de una dimensión a otra.
La creación de array n-dimensionales los podemos crear a partir de un array de una
dimensión. Para realizar el cambio de dimensión, se realiza con la función reshape; con
esta función, se puede especificar las dimensiones de forma explícita o implícito. Para
realizar el proceso inverso, empleamos la función flatten; y, por último, para concatenar
arrays, se emplea la función concatenate. En el siguiente snippet se muestra ejemplos de
uso:

array = np.array([1, 2, 3, 4, 5, 6])

1 print(f'array=\n{array}\n')
2 array_23 = array.reshape(2, 3)
3 print(f'array_23=\n{array_23}\n')
4 print(f'may_share_memory=\n{np.may_share_memory(array_23, array)}\n')
5
6 array_2_1 = array.reshape(2, -1)
print(f'array_2_1=\n{array_2_1}\n')
7
8 array_1_2 = array.reshape(-1, 2)
9 print(f'array_1_2=\n{array_1_2}\n')
10
11array2 = np.array([[1, 2, 3],
[4, 5, 6]])
12print(f'array2=\n{array2}\n')
13array2_1 = array2.reshape(-1)
14print(f'array2_1=\n{array2_1}\n')
15print(f'array2.ravel()=\n{array2.ravel()}\n') # ravel es flatten
16
17print(f'np.may_share_memory(array2.flatten(),
array2)={np.may_share_memory(array2.flatten(), array2)}') # False
18print(f'np.may_share_memory(array2.ravel(),
19array2) ={np.may_share_memory(array2.ravel(), array2)}') # True
20
21ary = np.array([1, 2, 3])
22ary_concatenate = np.concatenate((ary, ary))
23print(f'ary_concatenate=\n{ary_concatenate}\n')
24
25

La salida por consola es la siguiente:

array=
[1 2 3 4 5 6]

array_23=
[[1 2 3]
[4 5 6]]

may_share_memory=
True

array_2_1=
[[1 2 3]
[4 5 6]]

array_1_2=
[[1 2]
[3 4]
[5 6]]

array2=
[[1 2 3]
[4 5 6]]

array2_1=
[1 2 3 4 5 6]

array2.ravel()=
[1 2 3 4 5 6]

np.may_share_memory(array2.flatten(), array2)=False
np.may_share_memory(array2.ravel(), array2) =True
ary_concatenate=
[1 2 3 1 2 3]
3.- Algebra linear.
La multiplicación de matrices así como la operación con la matriz transpuesta es una
operación típica, en el presente apartado, presentamos dos funciones para realizar el
producto de dos matrices: función matmul, multiplica dos matrices pasadas por parámetro;
y, la función dot, realiza la misma funcionalidad pero más eficiente. Para calcular la
función transpuesta, empleamos la función T de un array. En el siguiente ejemplo, se
muestra un snippet de código con ejemplos de productos de matrices.

1 matrix = np.array([[1, 2, 3],

2 [4, 5, 6]])
3 column_vector = np.array([[1, 2, 3]]).reshape(-1, 1)
4 print(f'matrix=\n{matrix}\n')
5 print(f'column_vector=\n{column_vector}\n')
6 result = np.matmul(matrix, column_vector)
7 print(f'matrix X column_vector=\n{result}\n')
8
9 # Más eficiente con dot.
10print(f'np.dot(row_vector, row_vector)=\n{np.dot(row_vector,
11row_vector)}\n')
print(f'np.dot(matrix, row_vector)=\n{np.dot(matrix, row_vector)}\n')
12print(f'np.dot(matrix, column_vector)=\n{np.dot(matrix,
13column_vector)}\n')
14
15print(f'matrix.transpose()=\n{matrix.transpose()}\n')
16print(f'matrix.T=\n{matrix.T}\n')
17print(f'np.dot(matrix, matrix.T)=\n{np.dot(matrix, matrix.T)}\n')
print(f'np.matmul(matrix, matrix.T)=\n{np.matmul(matrix, matrix.T)}\n')
18

La salida por consola es la siguiente:

matrix=
[[1 2 3]
[4 5 6]]

column_vector=
[[1]
[2]
[3]]

matrix X column_vector=
[[14]
[32]]

np.dot(row_vector, row_vector)=
14

np.dot(matrix, row_vector)=
[14 32]

np.dot(matrix, column_vector)=
 [[14]
[32]]

matrix.transpose()=
[[1 4]
[2 5]
[3 6]]

matrix.T=
[[1 4]
[2 5]
[3 6]]

np.dot(matrix, matrix.T)=
[[14 32]
[32 77]]

np.matmul(matrix, matrix.T)=
[[14 32]
[32 77]]

4.- Operaciones sobre conjuntos.

Las operaciones de intersección, diferencia, unión o conjunto único sin repeticiones, se
realizan respectivamente con las siguientes funciones: intersect1d, setdiff1d, union1d y
unique. En el siguiente snippet de código se muestra ejemplos de uso:

array = np.array([1, 1, 2, 3, 1, 5])

1 array_set = np.unique(array)
2 print(f'array_set=\n{array_set}\n')
3
4 array1 = np.array([1, 2, 3])
5 array2 = np.array([3, 4, 5, 6])
print(f'array1=\n{array1}\n')
6 print(f'array2=\n{array2}\n')
7
8 array_intersec = np.intersect1d(array1, array2, assume_unique=True)
9 print(f'array_intersec=\n{array_intersec}\n')
10
11array_diff = np.setdiff1d(array1, array2, assume_unique=True) # aaray1
- array2
12print(f'array_diff=\n{array_diff}\n')
13
14array_union = np.union1d(array1, array2)La librería Numpy es aquella
15librería pensada y preparada para realizar operaciones matemáticas
16orientadas a distintos ámbitos de la ciencia la cual, en mi caso, me
17permita profundizar en casos prácticos de Machine Learning.
print(f'array_union=\n{array_union}\n')

La salida por consola es la siguiente:

array_set=
[1 2 3 5]
array1=
[1 2 3]

array2=
[3 4 5 6]

array_intersec=
[3]

array_diff=
[1 2]

array_union=
[1 2 3 4 5 6]

5.- Serialización de arrays.

Para almacenar los valores de un array en un fichero, empleamos la función save; para
almacenar un array con los índices, se emplea la función savez; y, para realizar la carga de
un fichero en memoria, se emplea la función load. Los ficheros con los que se operan
tienen extensión .npz.

En el siguiente snippet de código se muestra unos ejemplos de uso de estas funciones:

1
2 array = np.array([1, 2, 3])
3 np.save('ary-data.npy', array)
4
5 data_file = np.load('ary-data.npy')
6 print(f'data_file=\n{data_file}\n')
7
8 array2 = np.array([1, 2, 3, 4, 5, 6])
np.savez('ary2-data.npz', array, array2)
9
10ary2_data = np.load('ary2-data.npz')
11print(f'ary2_data=\n{ary2_data}\n')
12
13array2_key = ary2_data.keys()
14print(f'array2_key=\n{array2_key}\n')
15print(f'ary2_data["arr_0"]=\n{ary2_data["arr_0"]}\n')
print(f'ary2_data["arr_1"]=\n{ary2_data["arr_1"]}\n')
16
17kwarg = {'ary1': array, 'ary2': array2}
18np.savez('ary3-data.npz', **kwarg)
19
20ary3_data = np.load('ary3-data.npz')
21print(f'ary3_data=\n{ary3_data}\n')
print(f'ary3_data["ary1"]=\n{ary3_data["ary1"]}\n')
22print(f'ary3_data["ary2"]=\n{ary3_data["ary2"]}\n')
23
24
La salida por consola es la siguiente:

data_file=
[1 2 3]

ary2_data=
<numpy.lib.npyio.NpzFile object at 0x7f580fa5a128>

array2_key=
KeysView(<numpy.lib.npyio.NpzFile object at 0x7f580fa5a128>)

ary2_data["arr_0"]=
[1 2 3]

ary2_data["arr_1"]=
[1 2 3 4 5 6]

ary3_data=
<numpy.lib.npyio.NpzFile object at 0x7f57e8b7def0>

ary3_data["ary1"]=
[1 2 3]

ary3_data["ary2"]=
[1 2 3 4 5 6]

La librería Numpy es aquella librería pensada y preparada para realizar operaciones

matemáticas orientadas a distintos ámbitos de la ciencia la cual, en mi caso, me permita
profundizar en casos prácticos de Machine Learning.