1. PYTHON
Universidad Nacional de
Ingenieria
Centro de Tecnologias de
Informacion y
Comunicaciones
Facultad de Ciencias
Abraham Zamudio Ch.
Abraham Zamudio 1

2. PYTHON
Clase 2
Abraham Zamudio Ch.
abraham.zamudio@gmail.com

3. Scipy
Abraham Zamudio 3

4. ¿ Que es Scipy ?
Abraham Zamudio 4

5. Scipy
Scipy es una librería de herramientas numéricas
para Python que se distribuye libremente. En este
sentido, podría considerarse un competidor de
MatLab, Octave o SciLab. Sin embargo, en su
filosofía no ha tratado de imitar a nadie, y tiene
detrás el respaldo de un auténtico lenguaje de
programación orientado a objetos e interpretado:
Python. Este hecho le confiere una gran potencia y
la capacidad de beneficiarse de mejoras en
lenguaje base.
Abraham Zamudio 5

6. Scipy
El desarrollo de Scipy comenzó en el año 2001. Sus
orígenes se remontan al paquete con extensiones
numéricas para Python denominado Numeric.
Posteriormente apareció Numarray, con la intención de
contruir un paquete más flexible y de limpiar el código,
aunque resultó ser más lento para cálculos matriciales en
pocas dimensiones. En el año 2005, el principal impulsor de
Scipy, Travis Oliphant, reunificó ambos en un único paquete
que integrase las ventajas de ambos, y que se denominó
Numpy, pudiéndose considerar como el núcleo de Scipy.
Scipy en sí mismo se concibe actualmente como una
extensión de las funcionalidades de Numpy
Abraham Zamudio 6

7. Scipy
Scipy posee módulos para optimización de
funciones, integración, funciones especiales,
resolución de ecuaciones diferenciales
ordinarias y otros muchos aspectos.
Puede ser usado con Linux, Windows y ha
sido también compilado para Sun y Mac.
Scipy es un proyecto de software libre que ha
sido patrocinado por la compañía Enthought
inc.
Abraham Zamudio 7

8. Scipy
Subpaquetes Disponibles
---------------------
ndimage --- n-dimensional image package [*]
stats --- Statistical Functions [*]
signal --- Signal Processing Tools [*]
lib --- Python wrappers to external libraries [*]
linalg --- Linear algebra routines [*]
linsolve.umfpack --- Interface to the UMFPACK library. [*]
odr --- Orthogonal Distance Regression [*]
misc --- Various utilities that don't have another home.
sparse --- Sparse matrix [*]
interpolate --- Interpolation Tools [*]
optimize --- Optimization Tools [*]
cluster --- Vector Quantization / Kmeans [*]
linsolve --- Linear Solvers [*]
fftpack --- Discrete Fourier Transform algorithms [*]
io --- Data input and output [*]
maxentropy --- Routines for fitting maximum entropy models [*]
integrate --- Integration routines [*]
lib.lapack --- Wrappers to LAPACK library [*]
special --- Airy Functions [*]
lib.blas --- Wrappers to BLAS library [*]
Abraham Zamudio 8

9. Scipy
>>> from scipy import *
Abraham Zamudio 9

10. Scipy
>>> Vector1 = array ([1,2,3,4,])
>>> Vector2 = zeros(4)
>>> Vector3 = ones(5)
>>> Matriz1 = array([1,2],[3,4])
>>> Matriz2 = zeros((4,3))
>>> Matriz3 = zeros((4,3), int)
>>> Matriz4 = zeros((4,3), complex)
Abraham Zamudio 10

11. Scipy
>>> Matriz2 = zeros((4,3))
Fila Columna
Abraham Zamudio 11

12. Scipy
Una de las muchas ventajas de los arrays es
que con un simple comando puedes hacer
operaciones matematica basicas:
>>>f = zeros((4,3))
>>> a = array([1,2,4.3]) En lenguajes como C o
>>> b = array([-0,9,3,4]) Java es necesario un
loop for para obtener
>>> a+b estas operaciones
>>> a-b
Abraham Zamudio 12

13. Scipy
a = array([[1,2,3],[4,5,6]])
b = array([i*i for i in range(100) if i%2==1])
c = b.tolist() # convierte un array en una lista
a = zeros(100)
b = zeros((2,8), int)
c = zeros((N,M,L), complex)
a = ones(10, int)
b = pi * scipy.ones((5,5))
Abraham Zamudio 13

14. Scipy
Podemos realizar comparaciones
>>> a = arange(5)
>>> a >= 3
array([False , False , False , True , True], dtype=bool)
>>> a % 2 == 0
array([ True , False , True , False , True], dtype=bool)
Abraham Zamudio 14

15. Scipy
Polinomios
>>> from scipy import poly1d
>>> p = poly1d ([2, 3, 4])
>>> print p
>>> print p*p
>>> print p.deriv()
>>> print p.integ(k=2)
>>> p(range(5))
Abraham Zamudio 15

16. Scipy
>>> from scipy import *
>>> help(fmin)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name 'fmin' is not defined
>>> help(optimize.fmin)
...
>>> from scipy.optimize import *
>>> help(fmin)
...
>>>
Abraham Zamudio 16

17. Scipy
Para obtener ayuda
El comando help
>>> help()
Nos llevará a una sesión interactiva en la que podemos
buscar en los módulos y palabras clave accesibles a Python
(no se trata de un comando específico de SciPy). Si
conocemos el nombre del objeto, podemos incluirlos
directamente como parámetro al llamar a help,
help(nombre_objecto). Una vez que entramos en la sesión
de ayuda, podemos teclar por ejemplo:
help> scipy
Da detalles acerca del paquete scipy
Abraham Zamudio 17

18. Scipy
Usando la notación de punto podemos
acceder a subpaquetes y funciones
help> scipy.integrate.quad
Nos da información sobre una de las
funciones para integrar que posee SciPy.
Para dejar la ayuda, basta con hacer quit.
help> quit
Abraham Zamudio 18

19. Scipy
Por convencion se usa la siguiente sintaxis :
>>> import scipy as sp
Con esto tenemos lo fundamental de scipy, pero la
mayor funcionalidad se encuentra en los subpaquetes
que (por orden) son importados por separado.
Por jemplo la funcion erf esta localizada en el
subpaquete special
Abraham Zamudio 19

20. Scipy
>>> from scipy import special
>>> special.erf(2.0)
0.99532226501895271
Abraham Zamudio 20

21. Scipy
El subpaquete special contiene funciones
que no estan incluidas en el paquete math.
Una de las funciones ampliamente utilizadas
es la Funcion Gamma
Abraham Zamudio 21

22. Scipy
>>> from scipy.special import gamma
>>> gamma(0.5)
1.7724538509055159
Abraham Zamudio 22

23. Scipy
Scipy tiene una docena de funciones relacionadas con la
funcion gamma.
* gamma -- Gamma function.
* gammaln -- Log of the absolute value of the gamma function.
* gammainc -- Incomplete gamma integral.
* gammaincinv -- Inverse of gammainc.
* gammaincc -- Complemented incomplete gamma integral.
* gammainccinv -- Inverse of gammaincc.
* beta -- Beta function.
* betaln -- Log of the absolute value of the beta function.
* betainc -- Incomplete beta integral.
* betaincinv -- Inverse of betainc.
* betaincinva -- Inverse (in first argument, a) of betainc
* betaincinvb -- Inverse (in first argument, b) of betainc
* psi(digamma) -- Logarithmic derivative of the gamma function.
* rgamma -- One divided by the gamma function.
* polygamma -- Nth derivative of psi function.
Abraham Zamudio 23

24. Scipy
El subpaquete constants tiene una variedad
de constantes fisicas :
>>> from scipy import constants
>>> constants.c # speed of light
299792458.0
>>> constants.h # Plank’s constant
6.6260693000000002e-034
>>> constants.N_A # Avogadro’s number
6.0221415000000003e+023
Abraham Zamudio 24

25. Scipy
El paquete base maneja array's de manera
sencilla : help(scipy) – help(scipy.zeros)
import scipy
def test():
a1 = scipy.arange(5, 10)
print a1
a2 = scipy.zeros((4,5), dtype='f')
print a2
test()
Abraham Zamudio 25

26. Scipy
Reshape – Transpose
>>> a1 = arange(12)
>>> a1
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> a2 = a1.reshape(3,4)
>>> a2
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> a3 = a2.transpose()
>>> a3
array([[ 0, 4, 8],
[ 1, 5, 9],
[ 2, 6, 10],
[ 3, 7, 11]])
Abraham Zamudio 26

27. Scipy
Integración de funciones
Para integrar numéricamente funciones podemos usar
el comando quad. La función debe devolver valores de
tipo flotante, por lo que redefinimos nuestro ejemplo
para hacerlo explícito.
>>> def sumcuad(a,b):
... return float(a**2+b**3)
>>> integrate.quad(sumcuad,0,4.0,args=(1))
(25.333333333333336, 2.8125649957170634e-13)
Abraham Zamudio 27

28. Scipy
El primer valor devuelto es el de la integral, el
segundo una estimación del error.
Los argumentos de quad son los siguientes:
●el nombre de una función
●los límites de integración, separados por comas
●si la función depende de más de una variable,
podemos pasar una lista de argumentos extra. La
integración se realiza en el primer argumento de la
función.
Abraham Zamudio 28

29. Scipy
Ecuaciones no lineales y optimización
Estos comandos usan funciones de valores flotantes,
por lo que conviene pasar todos los valores iniciales o
argumentos adicionales como tales; así por ejemplo si
quiero pasar un valor de 'uno', lo haré como 1.0.
Para resolver ecuaciones no lineales, utilizamos el
comando fsolve dentro del módulo optimize. Se le debe
pasar el nombre de una función, un argumento inicial, y
opcionalmente otros argumentos que pueda tener la
función. Para el control fino del método, se puede
acceder a la ayuda.
Abraham Zamudio 29

30. Scipy
>>> def f(x,k):
... return tanh(x)-k*x
...
>>> optimize.fsolve(f,5.6,0.5)
1.9150080481545375
>>> optimize.fsolve(f,5.6,2)
0.0
Abraham Zamudio 30

31. Scipy
Se pueden encontrar también mínimos de funciones. un
ejemplo sencillo se encuentra en el siguiente, donde
continuamos del anterior:
>>> del f
>>> def f(x):
... return (x[0]-1.5)**2+(x[1]-2.3)**2
...
>>> x0=[10.0,10.0]
>>> xopt=optimize.fmin(f,x0)
Optimization terminated successfully.
Current function value: 0.000000
Iterations: 43
Function evaluations: 84
Abraham Zamudio 31

32. Scipy
Integración numérica de ecuaciones
diferenciales ordinarias
Scipy tiene una función llamada odeint que
permite integrar ecuaciones de la forma:
donde y puede ser un vector.
Abraham Zamudio 32

33. Scipy
Consideremos por ejemplo la ecuación conocida:
cuya solución es de la forma
donde m1 y m2 son las soluciones de
Abraham Zamudio 33

34. Scipy
Esta ecuación se puede transformar en la
forma adecuada si escribimos:
Supondremos las condiciones iniciales:
Abraham Zamudio 34

35. >>> y1_0=0.0
>>> y_0=0.5
>>> y0=[y1_0, y_0]
>>> def f(y,t):
... return [5*y[0]-6*y[1], y[0]]
...
>>> t=arange(0,0.1,0.01)
>>> y=integrate.odeint(f,y0,t)
Abraham Zamudio 35

36. Scipy
Ajuste de mínimos cuadrados
Supongamos que tenemos una señal que
pensamos que se ajusta a la ecuación:
y que tenemos una serie de datos yi, xi, a partir de los
cuales queremos obtener los parámetros A y a por
mínimos cuadrados. En SciPy, la forma de hacerlo
sería:
Abraham Zamudio 36

37. >>> A=5.0
>>> a=1.1
>>> x=arange(0,1.0,0.1)
>>> y_true=A*exp(-a*x)
>>>y_meas=y_true+0.2*random.random(len(x))
>>> def error(p,y,x):
... A,a=p
... return y-A*exp(-a*x)
...
>>>plsq=optimize.leastsq(error,[1.0,1.0],args=(y_meas,x))
Abraham Zamudio 37

38. Abraham Zamudio 38

39. Matplotlib
Matplotlib es un ploteador o graficador de
funciones o datos muy sencillo de utilizar, es
muy eficiente
y su sintaxis es muy parecida matlab
>>>import matplotlib.pyplot as plt
>>>plt.plot([1, 3, 2, 4])
>>>plt.show()
Abraham Zamudio 39

40. Matplotlib
Abraham Zamudio 40

41. Matplotlib
Este pequeño codigo te
importa todas las librerias
del scipy , la funcion plot
lleva como parametros una
lista de datos y la funcion
show() te muestra los datos
ya representados en la
grafica
Abraham Zamudio 41

42. Matplotlib
La lista de datos que pase como argumentos dentro de la
funcion plot() te los grafica los 4 numeros en el eje de las 'y'
separados cada uno por default en 1 en el eje de las 'x'.
Para hacerlo mas representativo podemos pasar como
segundo argumento que te los grafique en forma de puntos,
de esta forma:
import matplotlib.pyplot as plt
plt.plot([1,2,3,4],'o')
plt.show()
Abraham Zamudio 42

43. Matplotlib
Abraham Zamudio 43

44. Matplotlib
import matplotlib.pyplot as plt
x = range(6)
plt.plot(x, [xi**2 for xi in x])
plt.show()
Abraham Zamudio 44

45. Matplotlib
Puedes conectar los puntos con una linea y
cambiar el color default que es el azul por
algun otro, por ejemplo el rojo:
import matplotlib.pyplot as plt
plt.plot([1,2,3,4],'o-',color='red')
plt.show()
Abraham Zamudio 45

46. Matplotlib
La funcion plot acepta los argumentos de esta forma
plot([ejex],[ejey]), por lo tanto, si deseas graficar mas de
1 punto seria plot([ejex1,ejex2,ejen...],
[ejex1,ejex2,ejen...]) (recuerda que si graficas de esta
forma, el tamaño de los puntos deben ser iguales en 'x'
y 'y')
Ejemplo:
import matplotlib.pyplot as plt
plt.plot([4,3,6,8,2,4,],[9,3,1,6,4,5],'o-',color='yellow')
plt.show()
Abraham Zamudio 46

47. Matplotlib
Abraham Zamudio 47

48. Matplotlib
En la grafica anterior el valor mas alto en el eje de las
'x' es 8 y en el eje de las 'y' es 9, nosotros podemos
darle un limite inferior y superior a las 'x' y 'y' con la
funcion
axis([ejexmenor,ejexmayor,ejeymenor,ejeymayor]) de
esta forma:
import matplotlib.pyplot as plt
plt.plot([4,3,6,8,2,4,],[9,3,1,6,4,5],'o-',color='yellow')
plt.axis([-1,10,-2,11])
plt.show()
Abraham Zamudio 48

49. Matplotlib
Abraham Zamudio 49

50. Matplotlib
import numpy as np
import matplotlib.pyplot as plt
t = np.arange(0.0, 1.0+0.01, 0.01)
s = np.cos(2*2*np.pi*t)
plt.plot(t, s)
plt.xlabel('Tiempo (s)')
plt.ylabel('voltaje (mV)')
plt.title('Pulso Senoidal')
plt.grid(True)
plt.savefig('simple_plot')
plt.show()
Abraham Zamudio 50

51. Matplotlib
Abraham Zamudio 51

52. Matplotlib
import matplotlib.pyplot as plt
import numpy
from numpy import sin, cos, exp, pi, arange
t = arange(0.0, 2.0, 0.01)
s1 = sin(2*pi*t)
s2 = exp(-t)
s3 = sin(2*pi*t)*numpy.exp(-t)
s4 = sin(2*pi*t)*numpy.cos(4*pi*t)
t = arange(0.0, 2.0, 0.01)
plt.plot(t, s1, t, s2+1, t, s3+2, t, s4+3, color='k')
plt.ylim(-1,4)
plt.yticks(arange(4), ['S1', 'S2', 'S3', 'S4'])
plt.show()
Abraham Zamudio 52

53. Matplotlib
Abraham Zamudio 53

54. Matplotlib
import matplotlib.pyplot as plt
x = range(1, 5)
plt.plot(x, [xi*1.5 for xi in x])
plt.plot(x, [xi*3.0 for xi in x])
plt.plot(x, [xi/3.0 for xi in x])
plt.show()
Abraham Zamudio 54

55. Matplotlib
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(0, 10, 0.1)
y = np.random.randn(len(x))
plt.plot(x, y)
plt.title('random numbers')
plt.show()
Abraham Zamudio 55

56. Matplotlib
import matplotlib.pyplot as plt
fig = plt.figure()
ax1 = fig.add_subplot(211)
ax1.plot([1, 2, 3], [1, 2, 3])
ax2 = fig.add_subplot(212)
ax2.plot([1, 2, 3], [3, 2, 1])
plt.show()
Abraham Zamudio 56

57. Matplotlib
import matplotlib.pyplot as plt
fig1 = plt.figure()
ax1 = fig1.add_subplot(111)
ax1.plot([1, 2, 3], [1, 2, 3]);
fig2 = plt.figure()
ax2 = fig2.add_subplot(111)
ax2.plot([1, 2, 3], [3, 2, 1]);
plt.show()
Abraham Zamudio 57

58. Matplotlib
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(1, 5)
plt.plot(x, x*1.5, label='Normal')
plt.plot(x, x*3.0, label='Rapido')
plt.plot(x, x/3.0, label='Lento')
plt.legend()
plt.show()
Abraham Zamudio 58

59. Matplotlib
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(1, 5)
plt.plot(x, x*1.5, label='Normal')
plt.plot(x, x*3.0, label='Fast')
plt.plot(x, x/3.0, label='Slow')
plt.grid(True)
plt.title('Sample Growth of a Measure')
plt.xlabel('Samples')
plt.ylabel('Values Measured')
plt.legend(loc='upper left')
plt.show()
Abraham Zamudio 59