Manejo b

asico de la libreria NumPy

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

NumPy

En este notebook encontrar

an algunos ejemplos basicos sobre el uso de la libreria NumPy de python.
Para crear arrays en NumPy hay tres formas de hacerlo:
1.
2.
3.
4.

A partir de secuencias (Listas o tuplas) de python

Usando funciones de NumPy
Lectura de datos desde ficheros
Copiando desde otro array

1.0.1

Manejo o manipulaci
on basica de arrays

Los arrays tiene un manejo de sus elementos muy similares a las listas o tuplas,puesto que su
contenido tambien est
a indexado. Para acceder a un elemento de array, se hace de la misma forma
que en una lista: se indica la posici
on del elemento mediante un indice entero entre corchetes [ ]
Las formas b
asicas de selecci
on de los elementos de un array de numpy son:
Tipo de Seleccion
Un solo elemento
Varios elementos
Una rebanada de elementos
Elementos en cualquier orden

Sintaxis
x[i]
x[i : j]
x[start : end : step]
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,
18, 19, 20])

5,

6,

7,

8,

9, 10, 11, 12, 13, 14, 15, 16, 17,

#Se muestra el elemento con indice i:3

a[3]

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,

1.0.2

3,

5,

7,

9, 11])

Arrays N-Dimensionales

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

1
2
3
4
5

Haciendo uso de listas de listas o tuplas de tuplas

Usando funciones de NumPy
Leyendo desde ficheros
Copiando o extrayendo de otro array
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]])

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

0.
0.
1.
1.

0.]
0.]]
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 se
obtiene para una lista:
# Obteniendo el elemento en la fila 1 y columna 2
b[1,2]

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 en
algunos 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])

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,
17, 18, 19])

4,

5,

6,

7,

8,

9, 10, 11, 12, 13, 14, 15, 16,

# 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], dtype=bool)

True,
True,

#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 menor
que una cota superior (x < xmax), se multiplica el resultado de las dos condiciones evaluadas por
separado.
mask1 = a>7
mask1
array([False, False, False, False, False, False, False, False,
True, True, True, True, True, True, True, True,
True, True], dtype=bool)

True,
True,

mask2 = a<14
mask2
array([ True, True, True, True,
True, True, True, True,
False, False], dtype=bool)

True, True, True, True, True,

True, False, False, False, False,

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])

ALGEBRA LINEAL CON NUMPY

2.0.3

Operaciones entre escalares y arrays

v1 = np.arange(5)
v1
array([0, 1, 2, 3, 4])

v1*2
array([0, 2, 4, 6, 8])
v1 + 2
array([2, 3, 4, 5, 6])
A*2
array([[ 0,
[10,
[20,
[30,
[40,

2,
12,
22,
32,
42,

4,
14,
24,
34,
44,

6,
16,
26,
36,
46,

8],
18],
28],
38],
48]])

array([[ 2, 3, 4, 5,
[ 7, 8, 9, 10,
[12, 13, 14, 15,
[17, 18, 19, 20,
[22, 23, 24, 25,

6],
11],
16],
21],
26]])

A+2

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([[
[
[
[
[

2.0.4

0, 1, 4, 9,
0, 6, 14, 24,
0, 11, 24, 39,
0, 16, 34, 54,
0, 21, 44, 69,

16],
36],
56],
76],
96]])

Algebra de matrices

Para multiplicar matrices, se puede hacer de dos formas: 1. Se utiliza la funcion dot de numpy
que 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,
[10,
[20,
[30,
[40,

2,
12,
22,
32,
42,

4,
14,
24,
34,
44,

6,
16,
26,
36,
46,

8],
18],
28],
38],
48]])

M.T
matrix([[ 0,
[ 1,
[ 2,

5, 10, 15, 20],

6, 11, 16, 21],
7, 12, 17, 22],

[ 3,
[ 4,

8, 13, 18, 23],

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.,
[ 3.,

2.],
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.58051713,
0.84858787,
0.51741227,

0.13147996,
0.85565047,
0.21242671,
0.11330968,

0.59162834,
0.33222481,
0.78883623,
0.95400589,

# suma de todos los elementos

np.sum(x)
8.9915409391687717
# Promedio
np.sum(x)/len(x)
0.44957704695843859

0.01609892,
0.49542213,
0.80013435,
0.05716937,

0.1596889 ,
0.22280343,
0.88774711,
0.19833854])

# suma cumulativa del array

np.cumsum(x)
array([ 0.22805884,
1.70747209,
4.46216079,
7.66871746,

0.3595388 ,
2.56312256,
4.6745875 ,
7.78202714,

0.95116714,
2.89534737,
5.46342373,
8.73603303,

0.96726607,
3.3907695 ,
6.26355808,
8.7932024 ,

1.12695496,
3.61357292,
7.1513052 ,
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.
10.
18.
36.
54.
86.

,
,
,
,
,
,

4.0026],
20.183 ],
39.948 ],
83.8
],
131.3
],
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

10

131.3

222.

])

# 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 datos
queden guardados en 2 columnas. DAT es una matriz de 2 filas por 6 columnas, mientras que
DAT.T en una matriz de 6 filas por 2 columnas. Observen:
DAT
array([[
[

4.
,
2.0013,

20.
,
10.0915,

36.
,
19.974 ,

72.
41.9

DAT.T
array([[
4.
[ 20.
[ 36.
[ 72.
[ 108.
[ 172.

,
,
,
,
,
,

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

11

,
,

108.
65.65

,
,

172.
111.

],
]])