Numpy

Librería para operar con vectores y matrices.

Hace posible operar con cualquier dato numérico o array.
Incorpora operaciones básicas como la suma o la multiplicación u otras más complejas como la transformada de Fourier o el álgebra lineal.
Además incorpora herramientas que nos permiten incorporar código fuente de otros lenguajes de programación como C/C++ o Fortran lo que incrementa notablemente su compatibilidad e implementación.

Arrays de Vacíos, Unos, Ceros:

Cuando se conoce la dimensión pero no se saben los datos que contendrán, o cuando se requieren matrices de Unos o Ceros.
Existen las funciones: empty, zeros y ones



In [1]:

    
import numpy as np  # Importo numpy con el alias np.
np.empty((2, 3))    # Matriz vacía de 2 x 3.









    Out[1]:





array([[ -3.10503618e+231,   3.11108985e+231,   2.19054232e-314],
       [  2.19201692e-314,   2.20986187e-314,   4.17203558e-309]])

Atención: empty asigna valores residuales. No necesariamente van a ser ceros.



In [2]:

    
np.zeros((3, 1))   # Matriz de 3 x 1 con ceros









    Out[2]:





array([[ 0.],
       [ 0.],
       [ 0.]])



In [3]:

    
np.ones((3, 2))    # Matriz de 3 x 2 con unos









    Out[3]:





array([[ 1.,  1.],
       [ 1.,  1.],
       [ 1.,  1.]])

Estas funciones tienen una contrapartida con el sufijo _like, con la que podemos crear matrices con la misma dimensión que una dada.
empty_like, zeros_like y ones_like



In [4]:

    
a = np.ones((3, 2))   # Matriz de 3 x 2 con unos
b = np.zeros_like(a)  # Matriz con ceros con la forma de a
b









    Out[4]:





array([[ 0.,  0.],
       [ 0.,  0.],
       [ 0.,  0.]])

Arrays a partir de listas

Cuando conocemos los valores del array, podemos crealos utilizando la función array y pasarle como argumento una lista, tupla o, en general, una secuencia.
Es útil para arrays pequeños.



In [5]:

    
np.array([1, 2, 3])   # Lista









    Out[5]:





array([1, 2, 3])



In [6]:

    
np.array([[1, -1],    # Lista de listas
          [2, 0]])









    Out[6]:





array([[ 1, -1],
       [ 2,  0]])



In [7]:

    
np.array((0, 1, -1))  # Tupla









    Out[7]:





array([ 0,  1, -1])



In [8]:

    
np.array(range(5))    # Rango









    Out[8]:





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

Rangos numéricos

NumPy ofrece funciones para crear rangos numéricos.
La función arange se utiliza para crear rangos de números enteros, de manera similar a la función range estándar de Python.



In [9]:

    
np.arange(5)









    Out[9]:





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



In [10]:

    
np.arange(2, 5)       # Rango donde se indica intervalo (Desde, Hasta)









    Out[10]:





array([2, 3, 4])



In [11]:

    
np.arange(2, 14, 2)    # Rango donde se indica el paso









    Out[11]:





array([ 2,  4,  6,  8, 10, 12])

Para rangos en el que el paso no sea un número entero se utilizan las funciones linspace y logspace.
Estas funciones aceptan como argumento el número de elementos en lugar del paso:



In [12]:

    
np.linspace(0, 1, 11)  # 11 puntos entre 0 y 1









    Out[12]:





array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9,  1. ])



In [13]:

    
np.logspace(2, 5, 4, base=10)  # 4 puntos según una escala logarítmica entre 10^2 y 10^5









    Out[13]:





array([    100.,    1000.,   10000.,  100000.])

Clase ndarray

Los principales atributos son:



In [14]:

    
a = np.array([[1, -1],    # Lista de listas
              [2, 0]])
type(a)          # Verifico que es un ndarray









    Out[14]:





numpy.ndarray



In [15]:

    
a.ndim           # Consulto nro. de dimensiones









    Out[15]:





2



In [16]:

    
a.size           # Consulto nro. de elementos









    Out[16]:





4



In [17]:

    
a.dtype          # Consulto tipo de elementos









    Out[17]:





dtype('int64')



In [18]:

    
a.itemsize       # Consulto tamaño en bytes









    Out[18]:





8



In [19]:

    
a.data           # Consulto el buffer de memoria.









    Out[19]:





<memory at 0x10a948ea0>



In [20]:

    
a.shape          # Consulto las dimensiones









    Out[20]:





(2, 2)

Matrices

Arreglo bidimensional. Se crean con la función: matrix



In [21]:

    
from numpy import matrix       # Importar matrix del módulo numpy.

a = matrix([[1,2,-4],[6,4,2],[-5,3,0]])   # Matriz de 3 x 3 
a









    Out[21]:





matrix([[ 1,  2, -4],
        [ 6,  4,  2],
        [-5,  3,  0]])



In [22]:

    
b = matrix([[3],[5],[7]])                # Matriz de 1 x 3 
b









    Out[22]:





matrix([[3],
        [5],
        [7]])



In [23]:

    
a*b          # Multiplicación de matrices:









    Out[23]:





matrix([[-15],
        [ 52],
        [  0]])



In [24]:

    
a.T          # Transpuesta de a









    Out[24]:





matrix([[ 1,  6, -5],
        [ 2,  4,  3],
        [-4,  2,  0]])



In [25]:

    
a.H         # Hermítica de a (transpuesta y conjugada)









    Out[25]:





matrix([[ 1,  6, -5],
        [ 2,  4,  3],
        [-4,  2,  0]])



In [26]:

    
c = a.I     # Inversa de a
c









    Out[26]:





matrix([[ 0.03370787,  0.06741573, -0.11235955],
        [ 0.05617978,  0.11235955,  0.14606742],
        [-0.21348315,  0.07303371,  0.04494382]])



In [27]:

    
c









    Out[27]:





matrix([[ 0.03370787,  0.06741573, -0.11235955],
        [ 0.05617978,  0.11235955,  0.14606742],
        [-0.21348315,  0.07303371,  0.04494382]])

Matriz identidad

Para crear una matriz cuadrada con Unos en la diagonal se utiliza la función: identity



In [28]:

    
np.identity(3)     # Matriz identidad de tamaño 3









    Out[28]:





array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.]])

Para un caso más general, sin que sean matrices cuadradas podemos utilizar la función : eye



In [29]:

    
np.eye(4, 3)       # Matriz de 4x3 con unos en una diagonal y ceros en el resto de elementos









    Out[29]:





array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.],
       [ 0.,  0.,  0.]])



In [30]:

    
np.eye(4, 3, k=-1)  # Con el parámetro k podemos controlar qué diagonal está llena de unos









    Out[30]:





array([[ 0.,  0.,  0.],
       [ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.]])