Cómo crear matrices en Python con NumPy

Introducción

En este breve apunte vamos a ver cómo crear matrices en Python usando la biblioteca NumPy. Para ello, vamos a hacer un repaso rápido de los métodos que ofrece NumPy para crear arrays y matrices.
Si buscas por Internet encontrarás varias recetas de cómo crear una matriz en Python utilizando listas, es decir, haciendo uso solamente de la biblioteca estándar. Sin embargo, aquí asumimos que vamos a emplear la matriz básicamente para hacer cálculos matemáticos con ella, y por otro lado en nuestro caso no supone un problema añadir NumPy como dependencia porque por unas razones o por otras lo íbamos a necesitar 😉
Esta entrada es básicamente una recopilación de los métodos listados en la documentación de NumPy. Otro día veremosEn este artículo en nuestro blog puedes leer cómo construir arrays a partir de ficheros externos.
Editado el 13 de junio de 2012: Añadidas funciones para crear arrays de NumPy a partir de listas y una nota sobre el peligro de la función empty.
En esta entrada se ha usado python 2.7.3 y numpy 1.6.1 y es compatible con python 3.2.3

Arrays vacíos, unos y ceros

Con estas funciones podemos crear una matriz en Python cuando conocemos el tamaño pero no conocemos los datos que va a contener, o cuando por cualquier motivo queremos matrices llenas de unos o de ceros. Para ello utilizaremos las funciones empty, zeros y ones, que aceptan como argumento una tupla con las dimensiones del array:
[sourcecode language=”python”]
In [1]: import numpy as np
In [2]: np.empty((2, 3)) # Matriz vacía, con valores residuales de la memoria
Out[2]:
array([[ 0.00000000e+000, 1.19528827e-316, 6.94132801e-310],
[ 1.41077362e-316, 6.94132772e-310, 6.94132772e-310]])
In [3]: np.zeros((3, 1)) # Matriz de ceros
Out[3]:
array([[ 0.],
[ 0.],
[ 0.]])
In [4]: np.ones((3, 2)) # Matriz de unos
Out[4]:
array([[ 1., 1.],
[ 1., 1.],
[ 1., 1.]])
[/sourcecode]
Leer más »Cómo crear matrices en Python con NumPy

Álgebra Lineal en Python con NumPy (I): Operaciones básicas

Introducción

En esta entrada vamos a ver una introducción al Álgebra Lineal en Python con NumPy. En la mayoría de los artículos que hemos escrito hasta ahora en Pybonacci hemos tocado sin mencionarlos conceptos relativos al Álgebra Lineal: sin ir más lejos, el propio manejo de matrices o la norma de vectores. El lenguaje matricial es el punto de partida para una enorme variedad de desarrollos físicos y matemáticos, y por eso le vamos a dedicar un apartado especial para repasar las posibilidades que ofrece el paquete NumPy.

  1. Operaciones básicas
  2. Sistemas, autovalores y descomposiciones

En esta entrada se ha usado python 2.7.3 y numpy 1.6.1 y es compatible con python 3.2.3

Arrays y matrices

Como ya comentamos hace tiempo en nuestra introducción a Python, el paquete NumPy introdujo los arrays N-dimensionales, que no son más que colecciones homogéneas de elementos indexados usando N elementos. Los hemos utilizado constantemente usando las funciones de creación de arrays:
[sourcecode lang=”python”]
In [1]: import numpy as np
In [2]: np.array([1, 2, 3]) # Array de una lista
Out[2]: array([1, 2, 3])
In [3]: np.arange(5) # Array de 5 enteros contando el 0
Out[3]: array([0, 1, 2, 3, 4])
In [4]: np.zeros((2, 3)) # Array de ceros de 2×3
Out[4]:
array([[ 0., 0., 0.],
[ 0., 0., 0.]])
In [5]: np.linspace(0.0, 1.0, 5) # Discretización de [0, 1] con 5 puntos
Out[5]: array([ 0. , 0.25, 0.5 , 0.75, 1. ])
[/sourcecode]
Además de los arrays, con NumPy también podemos manejar matrices. Aunque parecen lo mismo, se utilizan de manera distinta; si alguien quiere investigar las diferencias, puede consultar la página NumPy para usuarios de MATLAB (en inglés).
Leer más »Álgebra Lineal en Python con NumPy (I): Operaciones básicas

Manual de introducción a matplotlib.pyplot (IV): Tipos de gráfico (I)

Esto pretende ser un tutorial del módulo pyplot de la librería matplotlib. El tutorial lo dividiremos de la siguiente forma (que podrá ir cambiando a medida que vayamos avanzando).

  1. Primeros pasos
  2. Creando ventanas, manejando ventanas y configurando la sesión
  3. Configuración del gráfico
  4. Tipos de gráfico I
  5. Tipos de gráfico II
  6. Tipos de gráfico III
  7. Tipos de gráfico IV
  8. Texto y anotaciones (arrow, annotate, table, text…)
  9. Herramientas estadísticas (acorr, cohere, csd, psd, specgram, spy, xcorr, …)
  10. Eventos e interactividad (connect, disconnect, ginput, waitforbuttonpress…)
  11. Miscelánea

[Para este tutorial se ha usado python 2.7.1, ipython 0.11, numpy 1.6.1 y matplotlib 1.1.0]
[DISCLAIMER: Muchos de los gráficos que vamos a representar no tienen ningún sentido físico y los resultados solo pretenden mostrar el uso de la librería].
En todo momento supondremos que se ha iniciado la sesión y se ha hecho
[sourcecode language=”python”]
import matplotlib.pyplot as plt
import numpy as np
[/sourcecode]
Hasta ahora hemos visto como configurar las ventanas, manejo de las mismas, definir áreas de gráfico,… Ahora vamos a ir viendo los diferentes tipos de gráficos que existen.
Como habéis podido comprobar, en los ejemplos anteriores hemos estado viendo mucho plt.plot() que es lo que se suele usar para dibujar un gráfico simple de líneas representando los valores (x, f(x)). Ahora vamos a ver un ejemplo explicado para que veáis todas las posibilidades de plt.plot().
[sourcecode language=”python”]
plt.ion() # Nos ponemos en modo interactivo
x = np.arange(100) # Valores de x
y = np.random.rand(100) # Valores de y
plt.plot(x,y, color = ‘black’, label = ‘(x, f(x)’) # Dibujamos la evolución de f(x), frente a x
plt.plot(x[y > 0.9], y[y > 0.9], ‘bo’, label = ‘f(x) > 0.9′) # Destacamos los valores por encima de 0.9 colocándoles un marcador circular azul
plt.axhspan(0.9, 1, alpha = 0.1) # Colocamos una banda de color para los valores f(x) > 0.9
plt.ylim(0,1.2) # Limitamos el eje x
plt.legend() # Colocamos la leyenda
plt.title(u’Representación de (x, f(x))’) # Colocamos el título del gráfico
plt.xlabel(‘valores x’) # Colocamos la etiqueta en el eje x
plt.ylabel(‘valores f(x)’) # Colocamos la etiqueta en el eje y
[/sourcecode]

Este es el tipo de gráfico que suelo usar un 75% de las veces. Tipos de gráfico análogos a este son plt.plot_date(), que es similar a plt.plot() considerando uno o ambos ejes como fechas, y plt.plotfile(), que dibuja directamente desde los datos de un fichero.
Otro tipo de gráfico sería el que podemos obtener con plt.stem(). Dibuja líneas verticales desde una línea base. Imaginaros, por ejemplo, que tenéis una serie temporal, la normalizamos (restándole su Leer más »Manual de introducción a matplotlib.pyplot (IV): Tipos de gráfico (I)

Manual de introducción a matplotlib.pyplot (III): Configuración del gráfico

Esto pretende ser un tutorial del módulo pyplot de la librería matplotlib. El tutorial lo dividiremos de la siguiente forma (que podrá ir cambiando a medida que vayamos avanzando).

  1. Primeros pasos
  2. Creando ventanas, manejando ventanas y configurando la sesión
  3. Configuración del gráfico
  4. Tipos de gráfico I
  5. Tipos de gráfico II
  6. Tipos de gráfico III
  7. Tipos de gráfico IV
  8. Texto y anotaciones (arrow, annotate, table, text…)
  9. Herramientas estadísticas (acorr, cohere, csd, psd, specgram, spy, xcorr, …)
  10. Eventos e interactividad (connect, disconnect, ginput, waitforbuttonpress…)
  11. Miscelánea

[Para este tutorial se ha usado python 2.7.1, ipython 0.11, numpy 1.6.1 y matplotlib 1.1.0]
[DISCLAIMER: Muchos de los gráficos que vamos a representar no tienen ningún sentido físico y los resultados solo pretenden mostrar el uso de la librería].
En todo momento supondremos que se ha iniciado la sesión y se ha hecho
[sourcecode language=”python”]
import matplotlib.pyplot as plt
import numpy as np
[/sourcecode]
Hasta ahora hemos visto como podemos configurar la ventana y la sesión, en esta ocasión nos vamos a centrar en configurar el área del gráfico. Para ello vamos a empezar con plt.axes(), que sirve para ‘llamar’ y/o configurar a un área de gráfico. Podemos definir la posición, el tamaño, el color del área del fondo,…:
[sourcecode language=”python”]
plt.ion() # Ponemos la sesión como interactiva si no está como tal
plt.axes() # Coloca un área de gráfico con los valores por defecto
plt.plot(np.exp(np.linspace(0,10,100))) # Dibuja una exponencial de 0 a 10
plt.axes([0.2,0.55,0.3,0.3], axisbg = ‘gray’) # Dibuja una nueva área de gráfica colocada y con ancho y largo definido por [0.2,0.55,0.3,0.3] y con gris como color de fondo
plt.plot(np.sin(np.linspace(0,10,100)), ‘b-o’, linewidth = 2)
[/sourcecode]
El resultado es el siguiente:

Como podéis imaginar, podemos usar plt.axes() como sustituto de plt.subplot() si queremos dibujar gráficos que no tengan que tener una forma ‘regular’ dentro de la ventana. Si ahora queremos borrar el área del gráfico podemos usar plt.delaxes(), si queremos borrar el contenido que hay en el área del gráfico podemos usar plt.cla() y si queremos que no aparezca la ‘caja’ donde se dibuja el gráfico podemos usar plt.box() (si no hay ‘caja’ y queremos que aparezca podemos llamar a plt.box() y volverá a aparecer la ‘caja’).

El área del gráfico puede ser un área rectangular o un área para un gráfico polar (ver ejemplo).
Podemos colocar una rejilla que nos ayude a identificar mejor las áreas del gráfico mediante plt.grid() (en un gráfico polar deberemos usar plt.rgrid() y plt.thetagrids()).
Leer más »Manual de introducción a matplotlib.pyplot (III): Configuración del gráfico

Manual de introducción a matplotlib.pyplot (II): Creando y manejando ventanas y configurando la sesión

Esto pretende ser un tutorial del módulo pyplot de la librería matplotlib. El tutorial lo dividiremos de la siguiente forma (que podrá ir cambiando a medida que vayamos avanzando).

  1. Primeros pasos
  2. Creando ventanas, manejando ventanas y configurando la sesión
  3. Configuración del gráfico
  4. Tipos de gráfico I
  5. Tipos de gráfico II
  6. Tipos de gráfico III
  7. Tipos de gráfico IV
  8. Texto y anotaciones (arrow, annotate, table, text…)
  9. Herramientas estadísticas (acorr, cohere, csd, psd, specgram, spy, xcorr, …)
  10. Eventos e interactividad (connect, disconnect, ginput, waitforbuttonpress…)
  11. Miscelánea

[Para este tutorial se ha usado python 2.7.1, ipython 0.11, numpy 1.6.1 y matplotlib 1.1.0]
[DISCLAIMER: Muchos de los gráficos que vamos a representar no tienen ningún sentido físico y los resultados solo pretenden mostrar el uso de la librería].
En todo momento supondremos que se ha iniciado la sesión y se ha hecho
[sourcecode language=”python”]
import matplotlib.pyplot as plt
import numpy as np
[/sourcecode]
Como ya comentamos anteriormente, el módulo pyplot de matplotlib se suele usar para hacer pruebas rápidas desde la línea de comandos, programitas cortos o programas donde los gráficos serán, en general, sencillos.
Normalmente, cuando iniciamos la sesión, esta no está puesta en modo interactivo. En modo interactivo, cada vez que metemos código nuevo relacionado con el gráfico o la ventana (recordad, una instancia de matplotlib.axes.Axes o de matplotlib.figure.Figure, respectivamente), este se actualizará. Cuando no estamos en modo interactivo, el gráfico no se actualiza hasta que llamemos a show() (si no hay una ventana abierta) o draw() (normalmente no lo usaréis para nada) explícitamente. Veamos como es esto:
Si acabamos de iniciar sesión deberíamos estar en modo no interactivo. Para comprobarlo hacemos lo siguiente:
[sourcecode language=”python”]
plt.isinteractive()
False
[/sourcecode]
Si el resultado es False significa que estamos en modo no interactivo. Esto significa que si hacemos lo siguiente:
[sourcecode language=”python”]
plt.plot([1,2,3,4,5])
[/sourcecode]
No lanzará una ventana hasta que lo pidamos explícitamente mediante:
[sourcecode language=”python”]
plt.show()
[/sourcecode]
Podemos conmutar a modo interactivo o no usando plt.ion() y plt.ioff(), que lo que hacen es poner el modo interactivo en ‘on’ o en ‘off’, respectivamente. Como está en off (recordad que plt.isinteractive() nos ha dado False, lo que significa que está en ‘off’), si ahora  hacemos lo siguiente (cerrad antes cualquier ventana de gráficos que tengáis abierta):
[sourcecode language=”python”]
plt.ion()
plt.plot([1,2,3,4])
[/sourcecode]
Vemos que directamente se abre una ventana nueva sin necesidad de llamar a plt.show(). Yo suelo usar ipython así para ir probando cosas y cuando ya acierto con como quiero que me salgan los gráficos voy a spyder, donde tengo el programa que esté haciendo, y ya escribo el código que necesito con la interfaz orientada a objetos.
Jugad un poco con plt.isinteractive(), plt.ion(), plt.ioff(), plt.show() y plt.draw() para estar más familiarizados con el funcionamiento.
Leer más »Manual de introducción a matplotlib.pyplot (II): Creando y manejando ventanas y configurando la sesión

Manual de introducción a matplotlib.pyplot (I): Primeros pasos

Esto pretende ser un tutorial del módulo pyplot de la librería matplotlib. El tutorial lo dividiremos de la siguiente forma (que podrá ir cambiando a medida que vayamos avanzando).

  1. Primeros pasos
  2. Creando ventanas, manejando ventanas y configurando la sesión
  3. Configuración del gráfico
  4. Tipos de gráfico I
  5. Tipos de gráfico II
  6. Tipos de gráfico III
  7. Tipos de gráfico IV
  8. Texto y anotaciones (arrow, annotate, table, text…)
  9. Herramientas estadísticas (acorr, cohere, csd,  psd, specgram, spy, xcorr, …)
  10. Eventos e interactividad (connect, disconnect, ginput, waitforbuttonpress…)
  11. Miscelánea

[Para este tutorial se ha usado python 2.7.1, ipython 0.11, numpy 1.6.1 y matplotlib 1.1.0]
En todo momento supondremos que se ha iniciado la sesión y se ha hecho
[sourcecode language=”python”]
import matplotlib.pyplot as plt
import numpy as np
[/sourcecode]
Para empezar diremos que hay tres formas de usar la librería Matplotlib:

  • La podemos usar desde python usando el módulo pylab. El módulo pylab pretende mostrar un entorno de trabajo parecido al de matlab mezclando las librerías numpy y matplotlib. Es la forma menos pythónica de usar matplotlib y se obtiene usando

[sourcecode language=”python”]
from pylab import *
[/sourcecode]
Normalmente solo se recomienda para hacer pruebas rápidas desde la línea de comandos.

  • Una segunda forma, que es la que veremos en este tutorial, es usando el módulo pyplot.

[sourcecode language=”python”]
import matplotlib.pyplot as plt
[/sourcecode]

  • Por último, la forma más recomendable y pythónica, pero más compleja, sería usar matplotlib mediante la interfaz orientada a objetos. Cuando se programa con matplotlib, no mientras se trabaja interactivamente, esta es la forma que permite tener más control sobre el código. Quizá veamos esto en el futuro si alguno nos animamos/os animáis a escribir sobre ello.

Absolutamente todo lo que vamos a usar en este tutorial y que está relacionado con matplotlib.pyplot lo podréis encontrar documentado y detallado aquí. Como he comentado, todo lo que vamos a ver está en el anterior enlace, pero no todo lo que está en el anterior enlace lo vamos a ver. Por ejemplo, en el índice veréis que he tachado los puntos 9 y 10, las funciones estadísticas y las funciones que permiten meter algo de interactividad en los gráficos dentro de pyplot. Las funciones estadísticas incluidas son pocas, algunas son complejas y muy específicas y las veo poco coherentes como grupo dentro de pyplot, para ello ya tenemos scipy y estas funciones estarían mejor ahí para separar lo que es ‘gráficar’ (en español de Sudámerica existe la palabra) de lo que es analizar datos. Para interactividad con los gráficos tenemos el módulo matplotlib.widgets, muchísimo más completo.
Leer más »Manual de introducción a matplotlib.pyplot (I): Primeros pasos

Cómo crear una matriz tridiagonal en Python con NumPy y SciPy

Introducción

En este rápido apunte vamos a ver cómo construir una matriz tridiagonal en Python utilizando NumPy y SciPy. Una matriz tridiagonal es una matriz cuadrada que solamente tiene elementos distintos de cero en su diagonal principal y en las dos diagonales adyacentes a esta (la superdiagonal y la subdiagonal). Las matrices tridiagonales aparecen mucho en cálculo numérico, por ejemplo en la discretización de ecuaciones diferenciales, y tienen la característica de ser matrices dispersas (en lugar de densas) al ser la mayoría de sus elementos cero.
Sin que sirva de precedente, hoy vamos a escribir código que sea compatible tanto con Python 2 como con Python 3. Es un cambio nimio, pero merece la pena ir acostumbrándose a pensar que tarde o temprano habrá que abandonar Python 2 🙂
En esta entrada se ha usado python 2.7.3, numpy 1.6.1 y scipy 0.10.1 y es compatible con python 3.2.3.
Leer más »Cómo crear una matriz tridiagonal en Python con NumPy y SciPy

Sage: software matemático libre como alternativa

Seguro que muchos de vosotros ya conocéis Sage: un proyecto cuyo nada ambicioso objetivo es

Crear una alternativa de código abierto, libre y viable a Magma, Maple, Mathematica y MATLAB.

Desde luego hay que admitir que como declaración de intenciones no está mal. Hechas las presentaciones, ¿qué más podemos decir sobre Sage?

Sage comenzó en 2004 como un proyecto personal de William Stein, profesor de matemáticas en la Universidad de Washington, quien, como explica en su blog, estaba frustrado por no poder solucionar las limitaciones de Magma al no ser un programa libre. Stein se dio cuenta de que, aunque crear un sistema como Magma o Maple llevaría años con un equipo de desarrolladores voluntarios partiendo de cero, ya había numerosos paquetes de código abierto escritos en diferentes lenguajes enfocados a diversas áreas matemáticas. Así que decidió unir todos estos paquetes utilizando Python (en este momento son cerca de 100) para crear un enorme software matemático para crear Sage. En esto se diferencia de otros proyectos como SymPy, del que ya hemos hablado en este blog.
Leer más »Sage: software matemático libre como alternativa

Python es lento

La programación científica consiste, en su mayor parte, en cálculos numéricos intensos. CPU en estado puro. Un lenguaje interpretado es, por construcción, más lento que su homólogo compilado, por lo que puede parecer un contrasentido usar Python para aplicaciones «pesadas».  Estamos perdiendo el tiempo, ¿o no?
Muchos programas científicos se ejecutan sólo una vez, son un cálculo concreto que no hará falta repetir. La mayor parte del tiempo del cálculo no es la ejecución del programa, sino escribirlo, trabajo de un humano. Aquí es donde entran las bondades de Python: es sencillo, rápido de escribir, y potente como el que más. Y, por lo sencillo que eso, aunque sea de naturaleza lenta (o precisamente por eso), se han creado muchas herramientas para mejorar su eficiencia de formas elegantes y pythónicas.
Muchas críticas sobre la lentitud de Python adolecen de alguno de estos problemas:

  • Benchmarks irreales o incorrectos: ¿quién necesita un programa para imprimir el primer millón de números naturales?
  • Desconocimiento del lenguaje. A veces hay formas mejores de hacer las cosas, más sencillas y óptimas.
  • Se limitan a la biblioteca estándar, que se queda coja para el cálculo numérico (como veremos más adelante).
  • No tienen en cuenta el tiempo necesario para escribirlo y depurarlo. Cuanto más largo sea el programa, más difícil será encontrar los problemas o añadirle nuevas funcionalidades (tiempo del programador).
  • Por lo tanto, usar un lenguaje de más alto nivel permite, a igualdad de inteligencia, tiempo y habilidad, crear un programa potencialmente más complejo y eficiente.
  • No son guays (pero nosotros sí).Leer más »Python es lento