====== NumPy ======

Se suele cargar en Python con el alias ''np'':

<code python>
import numpy as np
</code>

===== Arrays =====

Podemos convertir una lista de Python en un array/matriz de NumPy:

<code python>
mylist = [1, 2, 3]

myarray = np.array(mylist)

type(myarray)

# Devolverá: numpy.ndarray
</code>

==== Métodos ====

=== arange ===

Genera un array:

<code python>
np.arange(0, 3)

# array([0, 1, 2, 3])

# Genera un array del 0 al 10, pero con saltos de 2
np.arange(0, 10, 2)

# array([0, 2, 4, 6, 8])
</code>

=== zeros ===

Genera arrays de ceros. Permite indicar las dimensiones del array:

<code python>
np.zeros(shape=(3,5))

# resultado:
#array([[0., 0., 0., 0., 0.],
#       [0., 0., 0., 0., 0.],
#       [0., 0., 0., 0., 0.]])

</code>

<WRAP center round tip 60%>
No es necesario indicar el argumento ''shape'', podemos ahorrárnoslo y hacer ''np.zeros%%((3,5))%%''
</WRAP>


<WRAP center round info 60%>
Por defecto, el método **zeros()** crea números decimales (//float//).
</WRAP>

=== ones ===

Genera arrays de unos. Permite indicar las dimensiones del array:

<code python>
np.ones(shape=(3,5))

# resultado:
#array([[1., 1., 1., 1., 1.],
#       [1., 1., 1., 1., 1.],
#       [1., 1., 1., 1., 1.]])

</code>

<WRAP center round info 60%>
Por defecto, el método **ones()** crea números decimales (//float//).
</WRAP>

=== max ===

Devuelve el valor más alto de un array:

<code python>
# arr = array([ 4, 63, 40, 60, 92, 64,  5, 12, 93, 40])
arr.max() # 93
</code>

=== min ===

Devuelve el valor más pequeño de un array:

<code python>
# arr = array([ 4, 63, 40, 60, 92, 64,  5, 12, 93, 40])
arr.min() # 4
</code>

=== argmax ===

Devuelve la posición del elemento más grande del array

<code python>
# arr = array([ 4, 63, 40, 60, 92, 64,  5, 12, 93, 40])

arr.argmax # 8
</code>

=== argmin ===

Devuelve la posición del elemento más grande del array

<code python>
# arr = array([ 4, 63, 40, 60, 92, 64,  5, 12, 93, 40])

arr.argmin # 0
</code>

=== mean ===

Calcula el valor medio de un array

<code python>
# arr = array([ 4, 63, 40, 60, 92, 64,  5, 12, 93, 40])
arr.mean() # 47.3
</code>

=== reshape ===

Cambiar las dimensiones de un array

<code ptyhon>
arr = np.random.randint(0, 100, 10)

# array([95, 11, 81, 70, 63, 87, 75,  9, 77, 40])

arr.reshape((5, 2))

# array([[95, 11],
#       [81, 70],
#       [63, 87],
#       [75,  9],
#       [77, 40]])
</code>

<WRAP center round important 60%>
Las nuevas dimensiones tiene que ser lógicas. Si tenemos un array con 10 elementos, no podemos convertirlo en un array de 3 filas y 2 columnas, por ejemplo.
</WRAP>

Podemos combinar métodos:

<code python>
# Crear una matriz de 10 filas y 10 columnas con los 100 primeros números (del 0 al 99) 
mat = np.arange(0, 100).reshape(10,10)
</code>

=== copy ===

Realiza una copia de un array

<code python>
mat = np.arange(0, 100).reshape(10, 10)

matnew = mat.copy()
</code>
==== Selección ====

Para coger algún elemento del array, nos referimos a su posición.

<code python>
mat = np.arange(0, 100).reshape(10, 10)

# Elemento que ocupa la posición 0, 10 (fila, columna):
mat[0,10]
</code>

Para coger todos los elementos de una fila o columna utilizamos el //slicing// típico de Python:

<code python>
# Todos los valores de las filas, pero de la columna que ocupa la posición 1
mat[:,1]

# Todos los valores de las columnas para la fila 2:
mat[2, :]

# Porción:
mat[0:3,0,3]
</code>
===== Números aleatorios =====

<code python>
# Semilla para la aleatoriedad
np.random.seed(101)

# Creamos un array de 10 números entre el 0 y el 100
arr = np.random.randint(0, 100, 10)
</code>

===== Imágenes =====

Por sí mismo, NumPy no es capaz de manejar imágenes sino que se apoya en el módulo PIL (biblioteca pillow, //Python Imaging Library//)

<code python>
import numpy as np
from PIL import Image

# Para poder ver las imágenes en un Notebook de Jupyter
import matplotlib.pyplot as plt
%matplotlib inline

pic = Image.open('ruta/imagen.png')

# Si queremos ver la imagen en Jupyter
pic

type(pic)

# PIL.PngImagePlugin.PngImageFile
</code>

Convertimos la imagen a un array de NumPy:

<code python>
pic_arr = np.asarray(pic)

type(pic_array)

# numpy.ndarray

pic_arr.shape

# (1080,1920, 3)

# Mostrar el array como imagen:
plt.imshow(pic_arr)
</code>

Para acceder a los canales de color:

<code python>
pic_red = pic_arr.copy()

# R = 0, G = 1, B = 2

# Canal rojo. 0, sin rojo, negro. 255 puro rojo.
pic_red[:,:,0]

# Lo representamos como escala de grises, es decir,
# si la imagen se acerca al negro, es que no tendrá presencia de rojo. 
# Si se acerca al blanco, tendrá mucha presencia de rojo.
plt.imshow(pic_red[:,:,0],cmap='gray')

# Lo mismo para el verde
plt.imshow(pic_red[:,:,1],cmap='gray')

# Lo mismo para el azul
plt.imshow(pic_red[:,:,2],cmap='gray')
</code>