7/11/2018 4.1.

Numpy — Computación científica con Python para módulos de evaluación continua en asignaturas de ciencias aplicadas

4.1. Numpy
Autores:José María Herrera Fernández, Luis Miguel Sánchez Brea
Contenidos de este capítulo:

Carga de un archivo de datos

Arrays
Matrices
Operaciones y funciones

Uno de los módulos más importantes de Python es Numpy. El origen de Numpy se debe principalmente al diseñador de software Jim
Hugunin quien diseñó el módulo Numeric para dotar a Python de capacidades de cálculo similares a las de otros softwares como
MATLAB. Posteriormente, mejoró Numeric incorporando nuevas funcionalidades naciendo lo que hoy conocemos como Numpy.
Numpy es el encargado de añadir toda la capacidad matemática y vectorial a Python haciendo posible operar con cualquier dato numérico
o array (posteriormente veremos qué es un array). Incorpora operaciones tan básicas como la suma o la multiplicación u otras mucho 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.
Para poder utilizar este módulo sino hemos instalado python(x,y) lo primero que debemos de hacer es descargarnos la última versión desde
el sitio oficial http://www.scipy.org/Download. En caso de que nuestro sistema operativo sea Linux probablemente venga instalado dentro
de Python. De no ser así debemos instalarlo por el método habitual. Para más información y otros sistemas operativos consultar las notas
oficiales de instalación. Para cargar el módulo en Python y poder llamarlo de formar más cómoda es de uso extendido la utilización del
alias np,

import numpy as np

4.1.1. Carga de un archivo de datos

En el ámbito científico es frecuente almacenar y trasladar paquetes de datos en archivos escritos en, por ejemplo, código ASCII. Python
incorpora varias funciones que nos permiten la lectura y escritura en estos archivos facilitando su manejo. Un ejemplo de ello es el comando
“loadtxt” que nos permite cargar los datos contenidos en un archivo de texto o dat.

Ejemplo 4.1

>>> import numpy as np # Importamos numpy como el alias np

# Cargamos los datos de archivo.txt en datos. En este caso el delimitador es la coma.
>>> datos = numpy.loadtxt('C:\ruta\a\tu\archivo.txt', delimiter = ',')

Ejemplo 4.2

>>> import numpy as np # Importamos numpy como el alias np.

>>> archivoDatos = np.loadtxt('codigo\archivoDatos.dat')
>>> print (archivoDatos) # Presentamos en pantalla los datos cargados.

Ejemplo 4.3

>>> from StringIO import StringIO # StringIO se comporta como un archivo objeto.
>>> c = StringIO("0 1\n2 3")
>>> np.loadtxt(c)
array([[ 0., 1.],
[ 2., 3.]])

4.1.2. Arrays
http://webs.ucm.es/info/aocg/python/modulos_cientificos/numpy/index.html 1/5
7/11/2018 4.1. Numpy — Computación científica con Python para módulos de evaluación continua en asignaturas de ciencias aplicadas

Con toda probabilidad, el lector que haya realizado un acercamiento a cualquier lenguaje de programación habrá oído hablar de arrays. Un
array es el termino que traslada el concepto matemático de vector o matriz a la programación añadiéndole la noción de almacenamiento en
memoria. Los arrays disponen en su interior de una serie de elementos dispuestos en filas y/o columnas dependiendo de la dimensión.
El desarrollo y la principal finalidad del módulo Numpy es la creación y modificación de arrays multidimensionales. Para este fin utilizaremos
las clase ndarray del ingles N-dimensional array o usando su alias simplemente array (no confundir con la clase array.array que ofrece
menos funcionalidad). En Python cada clase puede tener atributos que se pueden llamar con el método visto anteriormente o simplemente
escribiendo a continuación de la clase un punto y el atributo. En la mayoría de los IDEs al cargar la clase y escribir el punto aparecen todos
los atributos disponibles en orden alfabético por lo que en caso de dudar siempre podemos utilizar este método para escribir el comando.
En el caso de ndarray los principales atributos son los siguientes:

ndarray.ndim –> Proporciona el número de dimensiones de nuestro array. El array identidad es un array cuadrado con una diagonal
principal unitaria.
ndarray.shape –> Devuelve la dimensión del array, es decir, una tupla de enteros indicando el tamaño del array en cada dimensión.
Para una matriz de n filas y m columnas obtendremos (n,m).
ndarray.size –> Es el número total de elementos del array.
ndarray.dtype –> Es un objeto que describe el tipo de elementos del array.
ndarray.itemsize –> devuelve el tamaño del array en bytes.
ndarray.data –> El buffer contiene los elementos actuales del array.

Veamos un ejemplo de su uso con un array sencillo de diez elementos,

Ejemplo 4.4

>>> import numpy as np # Importamos numpy como el alias np

>>> miArray = np.arange(10) # Creamos un array de 0 a 9 separados de uno en uno
>>> miArray # Presentamos en pantalla el array creado
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> type(miArray) #Comprobamos que es un ndarray
<type 'numpy.ndarray'>
>>> miArray.ndim # Consultamos el número de dimensiones
1
>>> miArray.shape # Consultamos la dimensión
(10,)
>>> miArray.size # Consultamos la dimensión
10
>>> miArray.dtype # Consultamos el tipo de elementos del array
dtype('int64')
>>> miArray.itemsize # tamaño en bytes
8
>>> miArray.data # Consultamos el buffer de memoria.
<read-write buffer for 0x2fb57a0, size 80, offset 0 at 0x2f664b0>

Como hemos mencionando anteriormente, los arrays son unos de los elementos más utilizados por los programadores bajo cualquier
lenguaje. Este gran uso hace que dispongamos de una gran variedad de comandos para la creación de arrays: arrays unidimensionales,
multidimensionales, nulos, unitarios, secuenciales, de números aleatorios, etc. Dependiendo de las necesidades de nuestro problema
escogeremos la opción más adecuada.

identity(n,dtype). Devuelve la matriz identidad, es decir, uma matriz cuadrada nula excepto en su diagonal principal que es
unitaria. n es el número de filas (y columnas) que tendrá la matriz y dtype es el tipo de dato. Este argumento es opcional. Si no se
establece, se toma por defecto como flotante.
ones(shape,dtype). Crea un array de unos compuesto de shape elementos.
zeros(shape, dtype). Crea un array de ceros compuesto de “shape” elementos”.
empty(shape, dtype). Crea un array de ceros compuesto de “shape” elementos” sin entradas.
eye(N, M, k, dtype). Crea un array bidimensional con unos en la diagonal k y ceros en el resto. Es similar a identity. Todos los
argumentos son opcionales. N es el número de filas, M el de columnas y k es el índice de la diagonal. Cuando k=0 nos referimos a
la diagonal principal y por tanto eye es similar a identity.
arange([start,]stop[,step,],dtype=None). Crea un array con valores distanciados step entre el valor inicial star y el valor
final stop. Si no se establece step python establecerá uno por defecto.
http://webs.ucm.es/info/aocg/python/modulos_cientificos/numpy/index.html 2/5
7/11/2018 4.1. Numpy — Computación científica con Python para módulos de evaluación continua en asignaturas de ciencias aplicadas
linspace(start,stop,num,endpoint=True,retstep=False). Crea un array con valor inicial start, valor final stop y numelementos.
meshgrid(x,y). Genera una matriz de coordenadas a partir de dos los arrays x, y.

En el siguiente ejemplo podemos ver su utilización,

Ejemplo 4.5

>>> from numpy import * # Importamos todo el módulo numpy.

>>> zeros( (3,4) ) # Creamos un array nulo de 3 filas y 4 columnas.
array([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]])
>>> ones(9) # Creamos un array unitario de 1 fila y 9 columnas,
array([ 1., 1., 1., 1., 1., 1., 1., 1., 1.])
>>> empty( (2,3) ) # Creamos un array sin entradas de 2x3.
array([[ 3.73603959e-262, 6.02658058e-154, 6.55490914e-260],
[ 5.30498948e-313, 3.14673309e-307, 1.00000000e+000]])
>>> arange( 10, 30, 5 ) # Creamos un array con inicio en 10 final en 30 y paso de 5.
array([10, 15, 20, 25])
>>> linspace( 0, 2, 9 ) # Array de 9 elementos de 0 a 2
array([ 0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ])
>>> x = linspace( 0, 2*pi, 100 ) # Para gráficas conviene tener muchos puntos, en este caso 100 puntos entre 0 y 2*pi.
>>> X, Y = np.meshgrid([1,2,3], [4,5,6,7]) # Generamos una matriz de coordenadas.
>>> X
array([[1, 2, 3],
[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])
>>> Y
array([[4, 4, 4],
[5, 5, 5],
[6, 6, 6],
[7, 7, 7]])

4.1.3. Matrices

Un subtipo especial de array bidimensional de NumPy es la matriz. Una matriz es como una array, excepto que la multiplicación de matrices
(y exponenciación) reemplaza la multiplicación elemento a elemento. Las matrices se crean mediante la función matrix.

Ejemplo 4.6

>>> from numpy import matrix # Importamos matrix del módulo numpy.
>>> a = matrix([[1,3,-5],[3,4,2],[-5,2,0]])
matrix([[ 1, 3, -5],
[ 3, 4, 2],
[-5, 2, 0]])
>>> b = matrix([[1],[5],[3]])
>>> b
matrix([[1],
[5],
[3]])
>>> a*b
matrix([[ 1],
[29],
[ 5]])

Definidas las matrices, podemos hacer uso de todas las funciones relacionadas con el álgebra lineal como la transposición, la diagonalización
etc.

Ejemplo 4.7

>>> b.T # Calculamos la transpuesta de *b*.

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

http://webs.ucm.es/info/aocg/python/modulos_cientificos/numpy/index.html 3/5
7/11/2018 4.1. Numpy — Computación científica con Python para módulos de evaluación continua en asignaturas de ciencias aplicadas
>>> b.H # Calculamos la hermítica (transpuesta y conjugada) de *b*.
matrix([[1, 5, 3]])
>>> c = a.I # Calculamos la inversa de *b*.
>>> c
matrix([[ 0.02439024, 0.06097561, -0.15853659],
[ 0.06097561, 0.15243902, 0.10365854],
[-0.15853659, 0.10365854, 0.0304878 ]])
>>> a*c # Multiplicamos las matrices *a* y *c*.
matrix([[ 1.00000000e+00, -5.55111512e-17, -6.93889390e-18],
[ 0.00000000e+00, 1.00000000e+00, 4.16333634e-17],
[ 0.00000000e+00, 0.00000000e+00, 1.00000000e+00]])

Con el paquete linalg podemos calcular el determinante (det), resolver ecuaciones lineales (solve) y calcular autovalores y autovectores.

Ejemplo 4.8

>>> linalg.det(a) # Cálculo del determinante.

-164.0
>>> d = linalg.solve(a,b) # Resolución de ecuaciones lineales.
>>> d
matrix([[-0.14634146],
[ 1.13414634],
[ 0.45121951]])
>>> a*d
matrix([[ 1.],
[ 5.],
[ 3.]])
>>> e = linalg.eig(a) # Cálculo de autovalores y autovectores.
>>> e[0]
array([-5.78304165, 6.23396835, 4.5490733 ])
>>> e[1]
matrix([[ 0.65072855, -0.7001856 , -0.29375583],
[-0.33849942, -0.61380708, 0.71320335],
[ 0.67968412, 0.3646656 , 0.6364342 ]])
>>> u = e[1]
>>> u.T*a*u
matrix([[ -5.78304165e+00, -1.22688318e-15, -7.92985469e-16],
[ -1.62554432e-15, 6.23396835e+00, 1.43223107e-15],
[ -7.68916181e-16, 1.83533744e-15, 4.54907330e+00]])

La función eig devuelve una tupla donde el primer elemento es un array de autovalores y el segundo es una matriz que contiene a los
autovectores.

4.1.4. Operaciones y funciones

El módulo numpy contiene todas las operaciones usuales entre arrays como las matemáticas (suma, resta, multiplicación, etc), las lógicas
(and, or, xor, etc), binarias, ... Lo más fácil y sencillo es en caso de duda consultar la documentación oficial. De particular interés en óptica
es la transformada de Fourier,

Ejemplo 4.9

>>> import numpy as np # Importamos numpy como el alias np.

>>> x=np.linspace(0,1,16)
>>> y=np.sin(x)
>>> print np.fft.fft(y)
array([ 6.82834723+0.j , -0.72886897+1.98380961j,
-0.46469805+0.9337634j , -0.42166285+0.57663662j,
-0.40711196+0.38478538j, -0.40066563+0.25695308j,
-0.39747563+0.15924205j, -0.39594637+0.07645992j,
-0.39548834+0.j , -0.39594637-0.07645992j,
-0.39747563-0.15924205j, -0.40066563-0.25695308j,
-0.40711196-0.38478538j, -0.42166285-0.57663662j,
-0.46469805-0.9337634j , -0.72886897-1.98380961j])

http://webs.ucm.es/info/aocg/python/modulos_cientificos/numpy/index.html 4/5
7/11/2018 4.1. Numpy — Computación científica con Python para módulos de evaluación continua en asignaturas de ciencias aplicadas
obsérvese como se ha formado en número complejo 2j. En python los números complejos se forman (parte real signo jparte imaginaria), es
decir, separando parte real e imaginaria y sin ningún signo multiplicativo entre el coeficiente y el numero imaginario j.

Ejemplo 4.10

>>> numero_complejo = (1 + 1j) # Defino el número complejo.

>>> print(numero_complejo) # Lo presento en pantalla.
(1+1j)
>>> type(numero_complejo) # Compruebo el tipo.
complex

http://webs.ucm.es/info/aocg/python/modulos_cientificos/numpy/index.html 5/5