Manejo basico de la libreria NumPy

<img src="http://www.numpy.org/_static/numpy_logo.png">

1 NumPy

En este notebook encontraran algunos ejemplos basicos sobre el uso de la libreria NumPy de python.Para crear arrays en NumPy hay tres formas de hacerlo:

1. A partir de secuencias (Listas o tuplas) de python

2. Usando funciones de NumPy

3. Lectura de datos desde ficheros

4. Copiando desde otro array

1.0.1 Manejo o manipulacion basica de arrays

Los arrays tiene un manejo de sus elementos muy similares a las listas o tuplas,puesto que sucontenido tambien esta indexado. Para acceder a un elemento de array, se hace de la misma formaque en una lista: se indica la posicion del elemento mediante un indice entero entre corchetes [ ]Las formas basicas de seleccion de los elementos de un array de numpy son:

Tipo de Seleccion Sintaxis

Un solo elemento x[i]

Varios elementos x[i : j]

Una rebanada de elementos x[start : end : step]

Elementos en cualquier orden x[[p1, p2, ..., pk]]

# Se importa la libreria numpy

import numpy as np

# Se crea un array utilizando funciones de NumPy

a = np.arange(1,21)

#Se muestra toda la lista

a

array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,

18, 19, 20])

#Se muestra el elemento con indice i:3

a[3]

1

4

#Se muestran los elementos desde el indice i=2 hasta el indice i=6

a[2:7]

array([3, 4, 5, 6, 7])

# Se le pasa una lista con las posiciones deseadas (no necesariamente consecutivas).

# Esto es algo nuevo, en ocomparacin con las listas o tuplas en python

a[[2,5,7,10,15,19]]

array([ 3, 6, 8, 11, 16, 20])

Notese que el extraer varios elementos de un array, genera otro array.Los indices del array tambien pueden tomar valores negativos.

# Muestra el elemento i:1 y el ultimo elemento

a[1],a[-1]

(2, 20)

# muestra el elemento i:3, el elemento i:16 y una array con i desde 3 hasta 16

a[3],a[-4],a[3:-4]

(4, 17, array([ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]))

#Muestra los tres ultimos elementos

a[-3:]

array([18, 19, 20])

# Muestra los elementos del array de 2 en 2

a[0:11:2]

array([ 1, 3, 5, 7, 9, 11])

1.0.2 Arrays N-Dimensionales

Se pueden crear de la misma forma que un array simple:

1 Haciendo uso de listas de listas o tuplas de tuplas

2 Usando funciones de NumPy

3 Leyendo desde ficheros

4 Copiando o extrayendo de otro array

5 Haciendo uso de la propiedad shape o del metodo reshape

# Usando la forma 1:

a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])

2

print a

print "SHAPE: ", a.shape

[[ 1 2 3 4]

[ 5 6 7 8]

[ 9 10 11 12]]

SHAPE: (3, 4)

#Usando la forma 2:

a1 = np.ones((2,3))

a0 = np.zeros((2,3))

print a0

print a1

[[ 0. 0. 0.]

[ 0. 0. 0.]]

[[ 1. 1. 1.]

[ 1. 1. 1.]]

# Usando shape:

a = np.arange(10)

print " a: ",a

a.shape = [2,5]

a

a: [0 1 2 3 4 5 6 7 8 9]

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

[5, 6, 7, 8, 9]])

# Usando reshape

a = np.arange(10)

print "a: ", a,"\n"

b = a.reshape((2,5))

print "b: ",b

a: [0 1 2 3 4 5 6 7 8 9]

b: [[0 1 2 3 4]

[5 6 7 8 9]]

La sintaxis para obtener un elemento de la matriz con arrays, difiere de la forma en que seobtiene para una lista:

# Obteniendo el elemento en la fila 1 y columna 2

b[1,2]

3

7

#Se crea un array de 5x5

A = np.arange(25)

A.shape = (5,5)

A

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

[ 5, 6, 7, 8, 9],

[10, 11, 12, 13, 14],

[15, 16, 17, 18, 19],

[20, 21, 22, 23, 24]])

Tambien se puede rebanar de forma indexada una matriz

A[1:3,2:4]

array([[ 7, 8],

[12, 13]])

B = A[::2,::2]

B

array([[ 0, 2, 4],

[10, 12, 14],

[20, 22, 24]])

Se pueden utilizar etiquetas para los indices del array. Esta es una forma elegante y util enalgunos casos.

i,j=0,2

A[i,j]

2

Se pueden utilizar listas como indices de la misma forma:

filas = [0,2,4]

columnas = [1,2,3]

A[filas]

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

[10, 11, 12, 13, 14],

[20, 21, 22, 23, 24]])

A[filas,columnas]

array([ 1, 12, 23])

4

Los indices pueden ser datos booleanos, es decir TRUE o FALSE

mask_1 = np.array([True,True,True,True,True])

mask_2 = np.array([True,False,True,False,True])

A[mask_1]

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

[ 5, 6, 7, 8, 9],

[10, 11, 12, 13, 14],

[15, 16, 17, 18, 19],

[20, 21, 22, 23, 24]])

A[np.array([False,True])]

array([[5, 6, 7, 8, 9]])

A[mask_2]

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

[10, 11, 12, 13, 14],

[20, 21, 22, 23, 24]])

x = np.arange(5)

print x

mask=np.array([True,True,False,True,False],dtype=bool)

x[mask]

[0 1 2 3 4]

array([0, 1, 3])

Esto es util cuando se quieren evaluar condiciones en el array. Por ejemplo: filtrar entradas

a = np.arange(0,20)

a

array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,

17, 18, 19])

# Se verifican que numeros son mayores a 7. El resultado es un array con datos booleanos

mask = a>7

mask

array([False, False, False, False, False, False, False, False, True,

True, True, True, True, True, True, True, True, True,

True, True], dtype=bool)

5

#Se evalua el array con la mascara obtenida,

a[mask] # se muestran solo los elementos que cumplieron la condicion

array([ 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])

Si se quieren obtener los numero que sean mayor que una cota inferior (x > xmin) y menorque una cota superior (x < xmax), se multiplica el resultado de las dos condiciones evaluadas porseparado.

mask1 = a>7

mask1

array([False, False, False, False, False, False, False, False, True,

True, True, True, True, True, True, True, True, True,

True, True], dtype=bool)

mask2 = a<14

mask2

array([ True, True, True, True, True, True, True, True, True,

True, True, True, True, True, False, False, False, False,

False, False], dtype=bool)

mask = (a>7)*(a<14)

mask

array([False, False, False, False, False, False, False, False, True,

True, True, True, True, True, False, False, False, False,

False, False], dtype=bool)

a[mask]

array([ 8, 9, 10, 11, 12, 13])

2 ALGEBRA LINEAL CON NUMPY

2.0.3 Operaciones entre escalares y arrays

v1 = np.arange(5)

v1

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

6

v1*2

array([0, 2, 4, 6, 8])

v1 + 2

array([2, 3, 4, 5, 6])

A*2

array([[ 0, 2, 4, 6, 8],

[10, 12, 14, 16, 18],

[20, 22, 24, 26, 28],

[30, 32, 34, 36, 38],

[40, 42, 44, 46, 48]])

A+2

array([[ 2, 3, 4, 5, 6],

[ 7, 8, 9, 10, 11],

[12, 13, 14, 15, 16],

[17, 18, 19, 20, 21],

[22, 23, 24, 25, 26]])

v1*v1

array([ 0, 1, 4, 9, 16])

A*A # Se multiplica elemento a elemento (no es una multiplicacion de matrices)

array([[ 0, 1, 4, 9, 16],

[ 25, 36, 49, 64, 81],

[100, 121, 144, 169, 196],

[225, 256, 289, 324, 361],

[400, 441, 484, 529, 576]])

A*v1

array([[ 0, 1, 4, 9, 16],

[ 0, 6, 14, 24, 36],

[ 0, 11, 24, 39, 56],

[ 0, 16, 34, 54, 76],

[ 0, 21, 44, 69, 96]])

2.0.4 Algebra de matrices

Para multiplicar matrices, se puede hacer de dos formas: 1. Se utiliza la funcion dot de numpyque puede ser aplicada a la multiplicacion matriz-matriz, matriz-vector o vector-vector(producto

7

interno) 2. Haciendo un casting a matrix para que los operadores *, -, + queden sobrecargados

np.dot(A,A)

array([[ 150, 160, 170, 180, 190],

[ 400, 435, 470, 505, 540],

[ 650, 710, 770, 830, 890],

[ 900, 985, 1070, 1155, 1240],

[1150, 1260, 1370, 1480, 1590]])

np.dot(A,v1)

array([ 30, 80, 130, 180, 230])

np.dot(v1,v1)

30

# Haciendo el casting

M = np.matrix(A)

M

matrix([[ 0, 1, 2, 3, 4],

[ 5, 6, 7, 8, 9],

[10, 11, 12, 13, 14],

[15, 16, 17, 18, 19],

[20, 21, 22, 23, 24]])

M*M

matrix([[ 150, 160, 170, 180, 190],

[ 400, 435, 470, 505, 540],

[ 650, 710, 770, 830, 890],

[ 900, 985, 1070, 1155, 1240],

[1150, 1260, 1370, 1480, 1590]])

M + M

matrix([[ 0, 2, 4, 6, 8],

[10, 12, 14, 16, 18],

[20, 22, 24, 26, 28],

[30, 32, 34, 36, 38],

[40, 42, 44, 46, 48]])

M.T

matrix([[ 0, 5, 10, 15, 20],

[ 1, 6, 11, 16, 21],

[ 2, 7, 12, 17, 22],

8

[ 3, 8, 13, 18, 23],

[ 4, 9, 14, 19, 24]])

#A = np.array([[1.,2.,3.,5.],[0,-1.,2.,3.],[4.,0,0,2.],[1.,3.,0,1.]])

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

M = np.matrix(A)

M

matrix([[ 3., 2.],

[ 3., 4.]])

M.I

matrix([[ 0.66666667, -0.33333333],

[-0.5 , 0.5 ]])

print (M*M.I)

[[ 1. 0.]

[ 0. 1.]]

np.linalg.det(M)

6.0

2.1 Procesamiento de datos

x = np.random.rand(20) # Crea un array con 20 numeros aleatorios entre [0,1)

x

array([ 0.22805884, 0.13147996, 0.59162834, 0.01609892, 0.1596889 ,

0.58051713, 0.85565047, 0.33222481, 0.49542213, 0.22280343,

0.84858787, 0.21242671, 0.78883623, 0.80013435, 0.88774711,

0.51741227, 0.11330968, 0.95400589, 0.05716937, 0.19833854])

# suma de todos los elementos

np.sum(x)

8.9915409391687717

# Promedio

np.sum(x)/len(x)

0.44957704695843859

9

# suma cumulativa del array

np.cumsum(x)

array([ 0.22805884, 0.3595388 , 0.95116714, 0.96726607, 1.12695496,

1.70747209, 2.56312256, 2.89534737, 3.3907695 , 3.61357292,

4.46216079, 4.6745875 , 5.46342373, 6.26355808, 7.1513052 ,

7.66871746, 7.78202714, 8.73603303, 8.7932024 , 8.99154094])

# media o promedio

np.mean(x)

0.44957704695843859

# valor maximo y minimo del array

np.min(x),np.max(x)

(0.016098923490379446, 0.95400589155259152)

# el producto de todos los elementos del array

np.prod(x)

5.3215484228038969e-11

2.2 Lectura de archivo de datos

# Se va a leer el archivo noble.dat

# la variable aguardar los archivos de la tabla

tabla = np.loadtxt(’nobles.dat’)

#Se muestra el contenido de tabla

# que es una matriz

tabla

array([[ 2. , 4.0026],

[ 10. , 20.183 ],

[ 18. , 39.948 ],

[ 36. , 83.8 ],

[ 54. , 131.3 ],

[ 86. , 222. ]])

tabla[:,0] # muestra la columna 0 con todas las filas

array([ 2., 10., 18., 36., 54., 86.])

tabla[:,1] # muestra la columna 1 con todas las filas

array([ 4.0026, 20.183 , 39.948 , 83.8 , 131.3 , 222. ])

10

# Cada columna puede ser guardada en una variable distinta

Z = tabla[:,0] #numero atomico

P = tabla[:,1] #peso

# Se pueden guardar los datos en variables distinta desde la lectura del archivo

Zatomico,Patomico = np.loadtxt(’nobles.dat’,unpack=True)

Zatomico

array([ 2., 10., 18., 36., 54., 86.])

Patomico

array([ 4.0026, 20.183 , 39.948 , 83.8 , 131.3 , 222. ])

# se puede guardar un array de numpy en un archivo de datos

Zatomico = Zatomico*2.

Patomico = Patomico/2.0

DAT = np.array([Zatomico,Patomico])

np.savetxt(’nobles_nuevo.dat’,DAT.T,fmt=’%.3f’)

DAT.T da como resultado la transpuesta de la matriz. Esto se hace con el fin de que los datosqueden guardados en 2 columnas. DAT es una matriz de 2 filas por 6 columnas, mientras queDAT.T en una matriz de 6 filas por 2 columnas. Observen:

DAT

array([[ 4. , 20. , 36. , 72. , 108. , 172. ],

[ 2.0013, 10.0915, 19.974 , 41.9 , 65.65 , 111. ]])

DAT.T

array([[ 4. , 2.0013],

[ 20. , 10.0915],

[ 36. , 19.974 ],

[ 72. , 41.9 ],

[ 108. , 65.65 ],

[ 172. , 111. ]])

11