Python Hispano

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

Sat, 19 May 2012 19:31:43 GMT

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

Primeros pasos
Creando ventanas, manejando ventanas y configurando la sesión.
Configuración del gráfico.
Tipos de gráfico I
Tipos de gráfico II
Tipos de gráfico III
…
Texto y anotaciones (arrow, annotate, table, text…)
~~Herramientas estadísticas (acorr, cohere, csd, psd, specgram, spy, xcorr, …)~~
~~Eventos e interactividad (connect, disconnect, ginput, waitforbuttonpress…)~~
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


import matplotlib.pyplot as plt

import numpy as np

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:

plt.isinteractive()
False

Si el resultado es False significa que estamos en modo no interactivo. Esto significa que si hacemos lo siguiente:

plt.plot([1,2,3,4,5])

No lanzará una ventana hasta que lo pidamos explícitamente mediante:

plt.show()

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

plt.ion()
plt.plot([1,2,3,4])

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.

Lo siguiente que veremos es plt.hold() y plt.ishold(). plt.hold es un conmutador para decir si queremos que los gráficos se sobreescriban, que en el mismo gráfico tengamos diferentes gráficas representadas, o para que el gráfico se limpie y se dibuje la nueva gráfica cada vez. Si usamos plt.ishold() nos ‘responderá’ True o False. Si acabáis de iniciar sesión, normalmente estará en True.

plt.ishold()
True

Como está en True, si hacemos lo siguiente:

plt.plot(np.random.rand(10))
plt.plot(np.random.rand(10))
plt.show()

Obtendremos lo siguiente:

Si el modo ‘hold’ estuviera en False, solo se habría conservado el último plot y solo veríamos una línea de las dos (probadlo usando plt.hold() y plt.ishold()).

Si estamos en modo interactivo (plt.ion()) y queremos borrar todos los gráficos (matplotlib.axes.Axes), títulos, …, de la ventana (matplotlib.figure.Figure) podemos usar plt.clf() y nos volverá a dejar el ‘lienzo’ limpio.

Si seguimos en modo interactivo (plt.ion()) y queremos cerrar la ventana podemos usar plt.close().

Imaginaos que ahora queréis trabajar con varias ventanas de gráficos simultáneamente donde en una dibujáis unos datos y en la otra otro tipo de datos y los queréis ver simultáneamente. Podemos hacer esto dándole nombre (o número) a las ventanas con las que vamos a trabajar. Veamos un ejemplo:

plt.figure('scatter') # Crea una ventana titulada 'scatter'
plt.figure('plot')    # Crea una ventana titulada 'plot'
a = np.random.rand(100) # Generamos un vector de valores aleatorios
b = np.random.rand(100) # Generamos otro vector de valores aleatorios
plt.figure('scatter') # Le decimos que la ventana activa en la que vamos a dibujar es la ventana 'scatter'
plt.scatter(a,b)  # Dibujamos un scatterplot en la ventana 'scatter'
plt.figure('plot') # Ahora cambiamos a la ventana 'plot'
plt.plot(a,b)

Y os quedaría algo como lo siguiente:

Es decir, podemos ir dibujando en varias ventanas a la vez. Podéis probar a cerrar una de las dos ventanas, limpiar la otra, crear una nueva,… Haciendo una llamada a plt.figure() también podemos definir la resolución del gráfico, el tamaño de la figura,…

Pero yo no quiero dibujar los gráficos en dos ventanas, yo quiero tener varios gráficos en la misma. Perfecto, también podemos hacer eso sin problemas con la ayuda de plt.subplot(). Con plt.subplot() podemos indicar el número de filas y columnas que corresponderán a como dividimos la ventana. En el siguiente ejemplo se puede ver dos áreas de gráfico en la misma ventana:

plt.ion()  # Nos ponemos en modo interactivo
plt.subplot(1,2,1)  # Dividimos la ventana en una fila y dos columnas y dibujamos el primer gráfico
plt.plot((1,2,3,4,5))
plt.subplot(1,2,2)  # Dividimos la ventana en una fila y dos columnas y dibujamos el segundo gráfico
plt.plot((5,4,3,2,1))

Obteniendo el siguiente gráfico:

Os dejo como ejercicio ver como podéis conseguir la siguiente gráfica (si no sabéis como dejad un comentario) y con ello creo que habréis entendido perfectamente el uso de plt.subplot():

Por último, vamos a ver como configurar la sesión para ahorrarnos escribir código de más. Por ejemplo, imaginaos que queréis que todas las líneas sean más gruesas por defecto porque os gustan más así, que queréis usar otro tipo de fuente sin escribirlo explícitamente cada vez que hacéis un gráfico, que los gráficos se guarden siempre con una resolución superior a la que viene por defecto,… Para ello podéis usar plt.rc(), plt.rcParams, plt.rcdefaults(). En este caso vamos a usar plt.rc(), podréis encontrar más información sobre como configurar matplotlib en este enlace. Veamos un ejemplo para ver como funciona todo esto:

plt.ion()  # Nos ponemos en modo interactivo
plt.figure('valores por defecto')  # Creamos una ventana donde dibujamos el gráfico con la configuración por defecto
plt.suptitle('Titulo valores por defecto')  # Esto sirve para poner título dentro de la ventana
plt.plot((1,2,3,4,5), label = 'por defecto')  # Hacemos el plot
plt.legend(loc = 2)  # Colocamos la leyenda en la esquina superior izquierda

plt.rc('lines', linewidth = 2)  # A partir de aquí todas las líneas que dibujemos irán con ancho doble
plt.rc('font', size = 18)  # A partir de aquí las fuentes que aparezcan en cualquier gráfico en la misma sesión tendrán mayor tamaño
plt.figure('valores modificados')  # Creamos una ventana donde dibujamos el gráfico con la configuración por defecto
plt.suptitle('Titulo valores modificados')  # Esto sirve para poner título dentro de la ventana
plt.plot((1,2,3,4,5), label = u'linea más ancha y letra más grande')  # Hacemos el plot
plt.legend(loc = 2)  # Colocamos la leyenda en la esquina superior izquierda

Después de usar plt.rc() para modificar un parámetro esa modificación será para toda la sesión a no ser que lo volvamos a modificar explícitamente o a no ser que usemos plt.rcdefaults(), que devolverá todos los parámetros a los valores por defecto.

Si quieres puedes pasar a la siguiente parte.

Filed under: Básico, Tutoriales

python majibu: Permitir links en los fields en el admin con Django

Fri, 18 May 2012 15:24:12 GMT

Si bien se puede hacer en el admin que el list_display contenga texto formateado a html, ajustando el valor de la propiedad allow_tags a True.

¿Cómo podría hacer lo mismo con un atributo del modelo(fields)? que he ajustado como de solo lectura mediante la tupla readonly_fields.

Yo intenté hacerlo del mismo modo que para un list_display pero no me funcionó.

python majibu: Deployment con django: gunicorn o uwsgi?

Thu, 17 May 2012 08:51:01 GMT

Estoy realizando un deployment de un proyecto de django con un par de instancias manejadas por supervisord, y estaba preguntándome qué podría ser más efectivo en cuanto a tiempo de respuesta y gasto de recursos, si gunicorn o uwsgi.

Ahora mismo estoy con uwsgi, pero el servidor llega a comer hasta 1GB de RAM, auque responde de forma muy rápida a las peticiones (ver: http://188.40.90.250, el deployment está incompleto, si intentais registraros dará error).

Que me recomendaríais vosotros para el deployment? El combo que estoy usando es supervisord + nginx + uwsgi + django 1.4

Actaulización: Tras ejecutar un cat en cada proceso de uwsgi y mirar mediante top y ps los consumos, tengo dos procesos de uwsgi (workers 2, threads 40) que consumen 400MB de ram cada uno, es normal?

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

Mon, 14 May 2012 19:31:00 GMT

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

Primeros pasos
Creando ventanas, manejando ventanas y configurando la sesión.
Configuración del gráfico.
Tipos de gráfico I
Tipos de gráfico II
Tipos de gráfico III
…
Texto y anotaciones (arrow, annotate, table, text…)
~~Herramientas estadísticas (acorr, cohere, csd, psd, specgram, spy, xcorr, …)~~
~~Eventos e interactividad (connect, disconnect, ginput, waitforbuttonpress…)~~
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


import matplotlib.pyplot as plt

import numpy as np

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


from pylab import *

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.


import matplotlib.pyplot as plt

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.

Para que quede claro desde un principio, las dos zonas principales donde se dibujaran cosas o sobre las que se interactuará serán:

figure, que es una instancia de matplotlib.figure.Figure. Y es la ventana donde irá el o los gráficos en sí:

axes, que es una instancia de matplotlib.axes.Axes, que es el gráfico en sí donde se dibujará todo lo que le digamos y está localizada dentro de una figure.

Para lo primero (figure) usaremos la palabra ‘ventana’ mientras que para lo segundo (axes) usaremos la palabra ‘gráfico’.

Si quieres puedes pasar a la siguiente sección (próximamente…).

Filed under: Básico, Tutoriales

JavAguirre.net: Raequel, scraping en la web de la rae con app engine

Mon, 14 May 2012 13:50:48 GMT

La semana pasada me enteré de que DuckDuckGo te permitía implementar plugins que luego ellos testean e introducen en la plataforma (DuckDuckHack), me pareció que podía ser muy divertido. :-)

Tras pensar varias cosas y ver cómo se podía implementar el plugin, estuve investigando por ahí y me pareció buena idea hacer un plugin que buscase en la RAE la palabra buscada y devolviese las acepciones de ésta.

En Github encontré a una persona que había hecho scraping sobre la web de la RAE y con el SDK de Python para Google App Engine había creado una API, este fue mi punto de partida. :-)

Leyendo el código y probándolo me di cuenta de que necesitaba por el momento un par de cosas por implementar, una era que la API debía ser JSONP, y otra que las peticiones debían responder más rápido.

La primera solución fue muy sencilla, simplemente añadir un par de cabeceras:

self.response.headers['Access-Control-Allow-Origin'] = '*'
self.response.headers['Access-Control-Allow-Methods'] = 'GET'

La segunda también resultó muy sencilla, ya que el SDK de Google App Engine dispone de una biblioteca para memcache, bastó añadir esa funcionalidad a la petición JSON/JSONP y listo.

Ahora toca la parte de DuckDuckGo, hará falta tiempo para ello, el proyecto está en Github.

May 10, 2012 -- Using Aspen (0)
April 19, 2012 -- M2Crypto from pip in old GNU/Linux OS (0)
April 1, 2012 -- Ducksboard Python module (0)

python majibu: Django: Pyjamas vs pythonwebkit?

Sun, 13 May 2012 03:30:56 GMT

Hola! :D

otra duda que me surge sin haber escrito ni una sola linea de código :). Sucede que en el desarrollo web, usar javascript es la regla, si deseas que tu sitio sea "dinámico" (¿usas flash para esta labor? disculpe ¿De que planeta viene usted?).

En una búsqueda, encontré dos posibilidades para usar Javascript sin usar Javascript, una es Pyjamas y la otra es pythonwebkit.

Pyjamas parece ser algo así como Django... creo. Y embeber Pyjamas en Django es una suerte de usar un middleware escrito en Python para hacerlo funcionar. ¿Pero Pytonwebkit?

Por eso recurro a ustedes que tienen más experiencia en desarrollo web, quiero escuchar sus opiniones sobre Pyjamas vs PythonWebKit (para usar dentro y fuera de Django) como reemplazos a Javascript para la web.

Monobot: [python] manejo de directorios y ficheros

Sat, 12 May 2012 18:00:14 GMT

Esta es la tipica pagina de referencia cuando quiero mirar referencias al manejo de directorios y ficheros … la tengo como favoritos y la miro cada varios dias … la quería compartir con ustedes.

python majibu: Subir ficheros en django

Sat, 12 May 2012 11:58:15 GMT

problema con subir archivos en django:

en MODELS

class Usuario_curriculo(models.Model):
    nombreusuario = models.CharField(max_length=25)

    nombre = models.CharField(max_length=25)
    apellidos = models.CharField(max_length=100)
    dni = models.CharField(max_length=9, blank=True)
    foto_carnet = models.FileField(upload_to=settings.MEDIA_ROOT)

    def __unicode__(self):
        return ('USUARIO:%s | NOMBRE:%s %s | EMAIL:%s') % (
                    self.nombreusuario, self.nombre, self.apellidos,
                    self.email
                    )
    __unicode__.allow_tags = True

en FORMS:

class FormularioPersonal(ModelForm):

    foto_carnet = forms.FileField(required=False)

    nombreusuario = forms.CharField(label='Nombre de usuario',
                widget=forms.HiddenInput
                )
    nombre = forms.CharField(label='Nombre*')
    apellidos = forms.CharField(label='Apellidos*')
    dni = ESIdentityCardNumberField(required=False)

en VISTAS

def c_datos(request):
    '''donde definimos los datos personales y de contacto'''
    _nombreusuario = request.user.username
    try:
        _persona = get_object_or_404(
                    models.Usuario_curriculo,
                    nombreusuario=_nombreusuario
                    )
    except Http404:
        _persona = None
    if request.method == 'POST':
        form = forms.FormularioPersonal(request.POST,
                    request.FILES,
                    instance=_persona)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect(reverse('formacion'))
    else:
        form = forms.FormularioPersonal(instance=_persona)
    return render_to_response(
                'vista_formulario.html', {'titulo': 'DATOS PERSONALES',
                'form': form}, context_instance=RequestContext(request)
                )

el problema es que request.FILES esta vacio ... es un diccionario sin ninguna entrada y por tanto no se graba ni hace nada .. de hecho si el formulario no pongo required=False aunque si que se haya seleccionado me canta el error.

JavAguirre.net: Using Aspen

Thu, 10 May 2012 21:48:22 GMT

Aspen is a python web framework based in the filesystem, mixing controller and view in the same archive, it’s called a Simplate.

We had some static html files in production, but months later we needed to add some server logic to this ones, without changing any url and having it integrated fast in our actual environment. These conditions make us think in this framework, it is perfect for this kind of situation, we hadn’t to change our actual filesystem for our html files and we could have easily integrated this new logic inside them. :-)

Our main problem using aspen is the lack of documentation, in my opinion is really poor and it could explain more and better basic things, such as requests handling. Anyway, I like to explore the code but sometimes you don’t want to spend some time in it when you have to get things done.

I have been using Django and Flask and I could say I found basics less intuitive in aspen than the others. I will try to explain what I meant in a later post when I get deeper in it.

April 1, 2012 -- Mejoras en Openboe (0)
January 10, 2012 -- Añadido el BOE diario y el Borme a Openboe (0)
January 8, 2012 -- Avance en Openboe, estilos y búsqueda por fecha (0)

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

Thu, 10 May 2012 09:41:37 GMT

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.

Problema matemático

Como ejemplo, vamos a construir la matriz del sistema de ecuaciones diferenciales ordinarias que resulta de discretizar la ecuación del calor unidimensional

en el dominio . Aproximando el operador mediante diferencias centradas de orden 2 en los puntos de colocación , se obtiene para los puntos interiores

que, expresado matricialmente, queda

con

Esta matriz es la que vamos a construir.

Matriz tridiagonal

Para crear la matriz tridiagonal, vamos a utilizar la función spdiags del módulo sparse de SciPy, que contiene diversas funciones para trabajar con matrices dispersas. Los argumentos de esta función son una lista de las diagonales de la matriz y una lista de posiciones donde colocar cada una de esas diagonales. En este caso nos interesan las posiciones k = 0 (diagonal principal), k = 1 (superdiagonal) y k = -1 (subdiagonal).

Para escribir código compatible con Python 3, al principio del programa escribiremos la línea

from __future__ import print_function

que sustituye la sentencia print de Python 2 por la nueva función print de Python 3. El módulo __future__ de Python 2 contiene varias sentencias que importan características de versiones de Python posteriores, de tal manera que podemos aprovechar nuevas posibilidades o simplemente hacer nuestro código más portable. Para lo que vamos a hacer hoy no necesitamos más.

En primer lugar construimos las tres diagonales, haciendo uso de la función ones de NumPy que nos da un array lleno de unos, y utilizando la función vstack de Numpy las apilamos (de ahí el nombre) por filas:

# Número de puntos de colocación
N = 100

dl = np.ones(N - 1)
du = np.ones(N - 1)
d0 = -2 * np.ones(N - 1)
d = np.vstack((dl, d0, du))

Ahora simplemente tenemos que llamar a la función spdiags para construir la matriz:

A = sparse.spdiags(d, (-1, 0, 1), N - 1, N - 1)

El código quedará finalmente de esta manera:

# coding: utf-8
#
# Crea una matriz tridiagonal
# Juan Luis Cano Rodríguez <juanlu001@gmail.com>

from __future__ import print_function

import numpy as np
from scipy import sparse

# Número de puntos de colocación
N = 100

dl = du = np.ones(N - 1)
d0 = -2 * np.ones(N - 1)
d = np.vstack((dl, d0, du))

A = sparse.spdiags(d, (-1, 0, 1), N - 1, N - 1)
print(A.todense())

Si lo ejecutamos desde IPython:

In [1]: %run tridiag.py
[[-2.  1.  0. ...,  0.  0.  0.]
 [ 1. -2.  1. ...,  0.  0.  0.]
 [ 0.  1. -2. ...,  0.  0.  0.]
 ..., 
 [ 0.  0.  0. ..., -2.  1.  0.]
 [ 0.  0.  0. ...,  1. -2.  1.]
 [ 0.  0.  0. ...,  0.  1. -2.]]

In [2]: A
Out[2]: 
<99x99 sparse matrix of type '<class 'numpy.float64'>'
	with 295 stored elements (3 diagonals) in DIAgonal format>

In [3]: type(A)
Out[3]: scipy.sparse.dia.dia_matrix

In [4]: sparse.dia?
Type:       module
Base Class: <class 'module'>
String Form:<module 'scipy.sparse.dia' from '/usr/lib/python3.2/site-packages/scipy/sparse/dia.py'>
Namespace:  Interactive
File:       /usr/lib/python3.2/site-packages/scipy/sparse/dia.py
Docstring:  Sparse DIAgonal format

¡Y ya está! Espero que te haya resultado útil, no dudes mandarnos tus dudas y sugerencias así como de difundir el artículo.

¡Un saludo!

Filed under: Básico Tagged: ecuaciones diferenciales, EDOs, EDPs, matrices, numpy, python, scipy, scipy.sparse

Genbeta:dev: Cazadores de Mitos: Las propiedades privadas en Python

Thu, 10 May 2012 04:00:00 GMT

El otro día discutía con un buen amigo en Twitter sobre lo que el llamaba “falta de private protected y public keywords“ en Python y recordé la tremenda confusión y desinformación que hay en la red en relación a las propiedades y/o métodos “privadas/os“ en el lenguaje creado por Guido Van Rossum.

En esta entrada voy a intentar explicar por qué no existen propiedades ni métodos privados en Python y por qué no son necesarios, por qué existe esta confusión sobre los métodos y propiedades (o atributos) que utilizan el underscore (_ y __) y cual es la auténtica naturaleza de los mismos.

El origen del Mito

Muy posiblemente el origen del mito comenzó con el fantástico libro de Mark Pilgrim Dive into Python que ha sido el primer contacto y libro de referencia por antonomasia para los novicios en Python desde prácticamente su lanzamiento el treinta de octubre del 2000. Yo mismo aprendí con él.

El capítulo 5.9. del citado libro, lamentablemente, se titula “Private Functions“ y en él se dice lo siguiente:

Como en muchos otros lenguajes, Python tiene el concepto de elementos privados:
Funciones privadas, que no pueden ser invocadas desde fuera de su módulo
Métodos de clase privados, que no pueden ser invocados desde fuera de su clase
Atributos privados, que no pueden ser accedidos desde fuera de su clase

Pero a diferencia de la mayoría de lenguajes, lo que hace a una función, método o atributo de Python privado viene determinado enteramente por su nombre.

Si el nombre de una función, el método de una clase o uno de sus atributos comienza con (pero no termina con) dos guiones bajos (underscores), es privado; todo lo demás es público.

Para reforzar esta afirmación recurre a un sencillo ejemplo que demuestra que no se puede invocar un método llamado “__parse“ desde fuera de una clase. Yo voy a escribir otro sencillo ejemplo en el REPL e iré explicando sobre la marcha por qué Mark Pilgrim estaba, sencillamente, equivocado con respecto a este particular en específico.

>> class Gato(object):
>>>    """Clase Gato"""
>>>    def __init__(self):
>>>        super(Gato, self).__init__()
>>>    def __privado(self):
>>>        """Metodo supuestamente privado"""
>>>        print "Soy privado como los intereses del Estado…"
>>>    def un_metodo(self):
>>>        """Metodo supuestamente publico desde el que se accede a __privado"""
>>>        self.__privado()
>>>
>>> g1 = Gato()
>>> g1.__privado()
>>> Traceback (most recent call last): 
>>>   File "<interactive input>", line 1, in ?
>>> AttributeError: 'Gato' object has no attribute '__privado'
>>> 
>>> g1.un_metodo()
Soy privado como los intereses del Estado…
>>>

Vemos como efectivamente no hemos sido capaces de invocar al método __privado de nuestra clase Gato pero sin embargo al invocar al método un_metodo que llama internamente al método “__privado“ si se ha imprimido el mensaje y por lo tanto “demuestra” la teoría explicada por Pilgrim en Dive Into Python.

Pero esto no es más que una desagradable coincidencia. Que el método no sea accesible desde fuera de la clase no tiene nada que ver con la visibilidad o restricción del método sino que es el efecto de un mecanismo de Python conocido como name mangling (presente en otros lenguajes como C++ o Java) y no sirve para lo que por error se cree de manera popular. Vamos a explicarlo con otro ejemplo en la REPL:

>>> class Gatico(Gato):
>>>    """La clase Gatico hereda de la clase Gato"""
>>>    def __init__(self):
>>>        super(Gatico, self).__init__()
>>>    def __privado(self):
>>>        """Estoy sobreescribiendo el metodo privado?"""
>>>        print "Es necesario abrir los datos al publico y dejar de ser privado…"
>>>    def otro_metodo(self):
>>>        """Soy otro metodo y me llamo asi a posta para nos sobreescribir a un_metodo de la clase base"""
>>>        self.__privado()
>>>
>>> g2 = Gatico()
>>> g2.__privado()
>>> Traceback (most recent call last): 
>>>   File "<interactive input>", line 1, in ?
>>> AttributeError: 'Gatico' object has no attribute '__privado'
>>> 
>>> g2.otro_metodo()
Es necesario abrir los datos al publico y dejar de ser privado…
>>>
>>> g2.un_metodo()
Soy privado como los intereses del Estado…
>>>

¿Qué es lo que ha pasado aquí?. Los programadores de Java y de C++ que están leyendo este artículo (porque lo estáis leyendo verdad, os interesa un montón…) se habrán percatado rápidamente de que algo raro está pasando.

En Java no está permitido sobreescribir métodos privados, si el programador nombra a un método privado en una clase heredada exactamente igual que un método privado de su clase base, sencillamente estará creando un método completamente nuevo en la subclase y este ocultará al método de la superclase.

En C++ se puede sobreescribir cualquier método que sea virtual, de hecho, es una práctica aceptada y recomendable sobreescribir solo funciones virtuales privadas y nunca públicas pero si sobreescribimos un método privado de una clase base en una subclase y lo invocamos desde la subclase, debería de llamarse al método adecuado, es decir, al nuevo método que sobreescribe al de la clase base aunque sea invocado por un método de la clase base desde la subclase. Este es uno de los principios del polimorfismo en C++.

Por lo tanto es extraño que en Python hayamos sobreescrito el método “__privado“ pero sin embargo el método “un_metodo“ siga pudiendo invocar a la implementación del método “__privado“ de su propia clase. De hecho, esto ocurre por que en ningún momento hemos sobreescrito el método “__privado“ de la clase Gato ni es un método privado, ni nunca ha sido intención del lenguaje poder crear métodos privados ni por éste ni por ningún otro medio.

Ahora si que estoy perdido, ¿me lo explica?

Python es un lenguaje potente que permite al programador hacer prácticamente lo que quiera, como por ejemplo, definir algo como True = False y liarla parda o bien sobreescribir una función builtin. Esto es así por la particular visión de como debe ser el lenguaje por parte de los Pythonistas y del BDFL (Benevolent Dictator For Life).

Uno de los principales valores de Python es que trata al programador como mayor de edad y en lugar de imponer restricciones confía en el buen juicio de nosotros, los programadores, para no hacer barbaridades así que la Comunidad define una serie de convenciones sobre el lenguaje.

Entre estas convenciones se encuentra la de nombrar a toda aquella función, todo aquel método o atributo que no sea parte de la API pública (que no métodos ni propiedades) de nuestra clase, librería, framework o módulo y sea perceptible a cambios, la desaparición o el estado obsoleto y olvidado sin previo aviso, con un underscore delante del nombre para informar a los consumidores de dicha API de que se trata de un método interno que puede cambiar sin previo aviso y no está diseñado (ni es útil) para el uso normal de la API.

Si además el nombre de nuestra variable coincide con una clase, método, variable o builtin pero es el único que tiene lógica, por ejemplo, list, sum, rand por convención se añade un underscore al nombre antes de hacer algo “tan guarro“ (para el Zen de Python) como nombrarlo “lst“, “sm“, “rnd“ que no aporta valor semántico.

Por otro lado, para posibilitar que las clases que heredan de clases bases puedan sobreescribir métodos sin romper las llamadas internas de sus clases base a dichos métodos, cualquier método (o función o atributo) que comience con al menos dos underscores (y no acabe en dos underscores, uno si está permitido) es renombrado por el intérprete en la definición de la clase siguiendo la siguiente norma “_classname__methodname“ así que para nuestro ejemplo el método quedaría así “_Gato__privado“ y de hecho podría seguir siendo invocado desde fuera de la clase si así lo queremos:

&gt;&gt;&gt; g1._Gato__privado()
Soy privado como los intereses del Estado...

Y puede ser invocado ya que nunca fue la intención del lenguaje que existieran los métodos privados, ya que en Python, por su propia condición de lenguaje dinámico y sus características, no es necesario. Asimismo, los métodos, funciones o variables que empiezan con un underscore no son importados al usar from bleh import * que por otro lado es una sintaxis considerada “deprectaed“ y mala práctica de programación por el PEP-8.

Conclusión

Ya se que ha sido un artículo ladrillazo pero considero que en vista a la falta total de literatura al respecto era necesario realizar esta aclaración para ayudar así a comprender mejor este maravilloso lenguaje.

En breve escribiré otro artículo explicando porque no es necesario el uso de métodos o propiedades privados. Hasta entonces, happy hacking.

Más Desinformación | Capítulo 5.9. de Dive Into Python

Pybonacci: Sage: software matemático libre como alternativa

Sun, 06 May 2012 18:15:42 GMT

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.

En este momento Sage ha visto más de 300 versiones y cuenta con más de 200 colaboradores por todo el mundo. Además, desde febrero de 2006 se han celebrado numerosos eventos, conocidos como «Sage Days», en los que los desarrolladores se han reunido para solucionar errores, implementar nuevas características, escribir documentación o hablar sobre el uso de Sage en educación.

Hablando de eventos, en España desde hace dos años se celebran cada verano las Jornadas Sage/Python, en las que se muestran las experiencias docentes que ya se están llevando a cabo con este programa en algunas universidades españolas y se explican ejemplos de aplicación. Este año se celebrarán las III Jornadas Sage/Python en la Universidad de Vigo los días 21 y 22 de junio de 2012 y estáis todos invitados

Sage dispone de una documentación enorme compuesta de tutoriales, guías y el manual de referencia. Solo por el tamaño de este último nos damos cuenta de la sorprendente amplitud de posibilidades que tiene este programa. Actualmente Sage le lleva la delantera a todos sus competidores no libres en cuanto a temas de matemática teórica, como pueden ser curvas elípticas o espacios de matrices, y por supuesto es capaz de dibujar gráficos en 2D y en 3D y de crear componentes interactivos al estilo de Mathematica, con la diferencia que para compartirlos no necesitas el Mathematica Player: solamente un navegador. En la Wikipedia podemos leer una extensa lista de características:

Algunos de las muchas características de Sage incluyen:

Una interfaz gráfica (notebook) para la revisión y reutilización de entradas y salidas anteriores, incluyendo gráficas y notas de texto disponibles en la mayoría de los navegadores web incluyendo Firefox, Opera, Konqueror, y Safari.

Una línea de comandos basada en texto usando iPython

El lenguaje de programación Python, que soporta expresiones en programación orientada a objetos y funcional.

Procesamiento paralelo usando tanto procesadores de núcleo múltiple como multiprocesadores simétricos.

Cálculo usando Maxima y SymPy

Álgebra lineal numérica usando GSL, SciPy y NumPy

Control interactivo de los cálculos

Librerías de funciones elementales y especiales

Gráficas en 2D y 3D tanto de funciones como de datos.

Herramientas de manipulación de datos y matrices.

Librerías de estadística multivariable

Una caja de herramientas para añadir interfaces de usuario a cálculos y aplicaciones

Herramientas para procesamiento de imágenes usando pylab así como Python

Herramientas para visualizar y analizar gráficas

Librerías para funciones de teoría de números

Filtros para importar y exportar datos, imágenes, vídeo, sonido, CAD, y GIS

Soporte para números complejos, aritmética de precisión arbitraria, y computación simbólica de funciones donde esto sea apropiado.

Embeber Sage en documentos LaTeX.

Interfaces a otro software como Mathematica, Magma y Maple, que le permite a los usuarios combinar software y comparar resultados y desempeño.

¿Alguien habló de interfaz gráfica? ¡Sí! Sage tiene una interfaz a imitación de los «notebooks» de Mathematica que funciona a través del navegador, y que además permite la edición colaborativa de documentos. Puedes utilizarla con el programa, montar tu propio servidor o crear una cuenta en el servidor público de Sage para empezar a experimentar.

Ejemplo de cómo se ve un «notebook» en la interfaz de Sage (vista pública en http://sagenb.org/home/pub/3319/)

Es complicado hacer una introducción a este programa porque es bastante inabarcable, pero espero que te haya resultado interesante. Si te apetece saber más cosas sobre Sage, puedes consultar este «notebook» público que explica algunas de sus posibilidades (e incluso editarlo tú mismo). O puedes estar atento a futuras publicaciones en Pybonacci

¡Un saludo!

Filed under: Recursos Tagged: cálculo simbólico, notebook, python, sage

python majibu: Enlaces temporales con Django?

Wed, 02 May 2012 19:33:51 GMT

Hola! :D no sé nada de django, quiero estudiarlo en está semana. Aún así tengo una pregunta que me mata de la curiosidad: ¿es posible crear enlaces temporables para contenido descargable? La idea es básicamente crear un enlace y que luego de un determinado número de descargas del archivo, dicho enlace sea inservible. No busco un ejemplo completo, con ver como crear e invalidar el enlace satisfacería mi curiosidad.

Saludos!

Genbeta:dev: Otro que cae en las garras de Github, Django

Tue, 01 May 2012 15:08:49 GMT

Y con Django no nos referimos, claro está, ni al afamado cantante español ni al popular personaje del spaguetti-western interpretado por Franco Nero. No, nada de eso, Django es el poderoso y cada día más conocido framework de desarrollo web en Python (por ejemplo, el chico de moda Pinterest lo lleva en sus entrañas) y que en los últimos días ha abandonado definitivamente Subversión, sistema de control de versiones que utiliza desde sus albores, allá por 2005, para pasarse a Git y compartir su código en Github.

De hecho la gente del Django Project ya tenía un repositorio en Github pero lo que compartían eran versiones siempre muy antiguas y desfasadas de su código. Ahora eso ha cambiado y han decidido unirse al gran hype que hay alrededor de este popular repositorio de código por lo que todos los pythonistas pueden encontrar a partir de ahora versiones muy actualizadas y calentitas con las que jugar.

Y lo cierto es que, después de echarle un vistazo a este repositorio en Github de Django, esta gente tiene un código de mucha calidad. Realmente da gusto, si te gusta leer código (oye, cada uno tiene sus vicios), pasearte por su árbol de ficheros e ir abriendo cada uno e indagando en él (aunque, como es mi caso, ni siquiera tengas gran idea de Python). Un gran trabajo al que ahora todos podemos acceder y contribuir.

Vía | Nettus+
Descarga | Github
En Genbeta Dev | Otro proyecto más que migra a GitHub: ahora Spring Framework

Pybonacci: Python es lento

Tue, 01 May 2012 01:11:32 GMT

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í).

En este artículo pretendo hacer un repaso no exhaustivo y no muy riguroso de las principales formas de acelerar código Python para un científico. La mayoría requieren la instalación de bibliotecas específicas, y algunas de ellas, una configuración cuidadosa, por lo que no todas son adecuadas para distribuir un producto al público general. Vamos allá:

Optimiza, que algo queda.

Antes de empezar a pensar en optimizar debemos saber qué optimizar. Si tenemos una rutina simple, es obvio, pero si el programa es complejo, no es trivial ver por dónde atacarlo. Podemos tirarnos horas tratando de mejorar el tiempo de una función que, de varias horas de simulación, sólo se lleva cinco minutos, mientras que cambiando una línea, podemos obtener una mejora del 33% (historia real).

Por lo tanto, antes de meter la zarpa de optimización debemos saber dónde se está empleando nuestro tiempo. Eso se hace con sistemas de profiling (véanse algunos ejemplos). Otro día trataremos este tema.

Conociendo el lenguaje: list comprehension

Como decía al principio, conocer el lenguaje es importante a la hora de escribir código eficiente, y Python guarda algunas sorpresas. Por ejemplo, sacar cosas por pantalla es lento, no imprimas todo lo que va haciendo, será más rápido (y más útil) imprimir sólo una docena de marcas clave, para saber por dónde va.

Otro de los pozos de tiempo son los bucles. La mayoría de las veces son inevitables, pero a veces hay opciones más rápidas. Imagina que queremos construir una lista resultado de aplicar una función a todos los elementos de una lista. Una forma obvia de hacerlo es:

lis2=[]
for element in lis:
   lis2.append(f(element))

Pero la opción idiomática, usando list comprehensions, es:

# Una list comprehension básica:
lis2=[f(element) for element in lis]

O incluso, restringiendo el dominio:

# Sólo a los elementos positivos.
lis2=[f(element) for element in lis if element>0]

Que es substancialmente más rápido.

# Sugerencia avanzada: los comandos map y filter.

Optimización automágica: Psyco

Psyco es un compilador JIT (just in time, «en tiempo real»), que optimiza en tiempo de ejecución el código.

Cuando el compilador JIT detecta un bucle [función] en el código [...] se le hace un seguimiento. Cuando esa función sea ejecutada, el intérprete la inspecciona y registra todas las instrucciones ejecutadas.

Cuando ha finalizado, el seguimiento se detiene y el registro es mandado a un optimizador, y de ahí a un ensamblador que genera código máquina optimizado. La próxima vez que se ejecute esa pieza de código, se usará esta versión mejorada.

(El código) depende de varias suposiciones sobre el código que van incluidas en la versión optimizada. Si alguna de esas suposiciones falla, la ejecución pasa de nuevo a la versión original.

(Extraído del blog de Huy Nguyen citando a su vez el blog de PyPy)

El uso no podría ser más sencillo. Símplemente añade al principio de tu programa:

import psyco
psyco.full()

Y obtiene una aceleración de un factor 2-3, que puede llegar hasta un factor 10 para el cálculo numérico puro. La gran ventaja de Psyco es que no requiere hacer modificaciones específicas en el código: añádelo y funciona. En casi todas partes. Y ya.

Pero no es siempre útil. Por ejemplo, cuando hacemos uso intensivo de NumPy, el código ya está optimizado, así que Psyco poco puede rascar, y su único efecto es ralentizar el programa (en cantidades inapreciables, eso sí). Además, tras años en los que sólo ha recibido mantenimiento básico (nadie llegó a portarlo a Python 2.7 ni a las versiones de 64 bits), desde el 12 de marzo está definitivamente muerto. Hubo en algún momento una distribución de la Psyco 2, prometiendo una página web y nuevas características, pero nunca más se supo, y hace que otras bibliotecas como Matplotlib dejen de funcionar. Es mejor quedarse con la vieja versión 1.7.

Espera, ¿he dicho NumPy? ¿qué es NumPy?

NumPy y SciPy

La Biblia cuando hablamos de cálculo numérico en Python. Su mayor contribución es una nueva estructura de datos: el array. Una lista (multidimensional) homogénea, en la que todos sus elementos han de ser del mismo tipo: entero, decimal en precisión arbitraria, complejo… y sobre la que se puede aplicar una gran cantidad de funciones. Veamos un ejemplo: ¿cuál es la suma de las raíces cuadradas de los diez primeros números y los senos de esos mismos números?

# Implementación estándar
import psyco
psyco.full()

import math
numbers=range(10)

result=[math.sqrt(num)+math.sin(num) for num in numbers]

# Implementación con NumPy
import numpy as np
numbers=np.range(10)

result=np.sqrt(numbers)+np.sin(numbers)

Como vemos, ya no hace falta ir elemento a elemento, sino que le podemos dar la lista completa, y él solo hace la iteración. Esto no es sólo una cuestión de conveniencia, sino que también permite incrementar la velocidad de ejecución. En algunas operaciones, como las matriciales, esto es incluso más interesante, ya que de forma completamente transparente y automática, ejecuta el código en paralelo, mandando cada número a un núcleo del procesador, ahorrando mucho tiempo.

Y, por supuesto, NumPy y SciPy tienen muchísimas funciones muy potentes, como rutinas para integrar, interpolaciones, regresiones, funciones de Bessel, convoluciones, transformadas diversas… Prácticamente toda la matemática genérica que uno puede necesitar.

¿Cómo funciona? Np y Sc son una gran interfaz para bibliotecas matemáticas en C, por lo que, tu código Python no hace más que llamar la ejecución de código C compilado.

Paralelizando: Numexpr

La paralelización es una buena forma de acelerar la ejecución de un programa, siempre que sea suficientemente separable. El caso extremo son los problemas vergonzosamente paralelizables, en los que podemos dividir el espacio de parámetros a estudiar en suficientes compartimentos estancos. En este caso, la paralelización es tan fácil como lanzar tantos programas como núcleos tengamos, cada uno estudiando una parte. Ejemplo: colisiones de un acelerador de partículas, cada evento es completamente independiente de los demás.

Otras veces no tenemos tanta suerte y sólo podemos paralelizar algunas partes de nuestro programa. Python ofrece los módulos threading y multiprocessing, pero su uso es más sutil y complicado de lo que quiero tratar en este artículo.

No obstante, no está todo perdido. Si queremos aplicar funciones básicas sobre grandes conjuntos de números y NumPy se nos queda corto, podemos usar Numexpr. Nuestro viejo código quedaría:

# Implementación con NumPy y Numexpr
import numpy as np
import numexpr as ne
numbers=np.range(10)

result=ne.evaluate('sqrt(numbers)+sin(numbers)') # Nótese que va como texto

Numexpr tiene varias estrategias para acelerar el código. En primer lugar, cuando NumPy ejecuta el código, primero calcula las raíces y las guarda en memoria, después los senos y los guarda en memoria, y por último, los suma ambos y guarda el resultado final en memoria. Esto supone triplicar la memoria necesaria, y por tanto, el tráfico de datos entre la CPU y la RAM.

Podemos ahorrar memoria haciendo la cuenta elemento a elemento, calculando la raíz y el seno del primero y sumarlos, etc. Esto fuerza a Python a comprobar qué tipo de dato es en cada momento para saber cómo hacer la cuenta, y esto ha de hacerse cada vez. Numexpr, en cambio, divide la operación en trozos manejables, que no castiguen mucho la memoria, y que eviten comprobaciones redundantes.

Además, incluye su propio compilador JIT, que genera código muy eficiente, y además intenta usar varios núcleos allí donde NumPy no sabe. Para tamaños suficientemente grandes de datos, podemos llegar a alcanzar la velocidad límite que da la memoria del ordenador, ¡y sin haber escrito una sola línea fuera de Python!

Magia arcana: blitz

Llegamos a un problema en el que nada de lo anterior ha sido suficiente, sigue siendo demasiado lento. En realidad, sabemos que la causa son sólo unas pocas líneas de código… es la hora de la magia misteriosa.

weave es un módulo dentro de NumPy para comunicar Python y C. Una de sus funciones es blitz, que toma una línea de Python, la traduce de forma transparente a C, y cada vez que la llames se ejecutará esta versión optimizada. En hacer esta primera conversión necesita entorno a un segundo, pero consigue velocidades generalmente superiores a todas las opciones anteriores. Ya no es bytecode como Numexpr o Psyco, o una interfaz a C como NumPy, sino tu propia función escrita directamente en C y completamente compilada y optimizada.

Nota: aunque en Linux y Mac funciona según se instala, en Windows no he sido capaz de hacerlo funcionar nunca.

Rindiéndonos al compilador

Está bien, vamos a compilar algo de código.Una opción previa es Cython, una versión del lenguaje Python con declaración de variables opcional (pero recomendada) que puede ser compilada a código C y luego llamado desde Python. La gran ventaja es que este código es plenamente funcional dentro de Python, incluso antes del compilado. Además, soporta arrays de NumPy. Sin embargo, está limitado a tipos estáticos y el proceso de generar el código es un tanto complejo/pesado.

Otro proyecto interesante es Shedskin. En este caso, toma código Python puro (con algunas restricciones, como el tipado estático) y genera código C++ (ilegible, pero funcional) optimizado. El proyecto parece ser llevado por una sola persona, y va lento, pero el resultado promete interesante y más sencillo que Cython. Como principal desventaja es que no soporta estructuras de NumPy o similares.

Podemos seguir aprovechando weave a través de su función inline. Ésta toma como argumento código C dentro del programa Python. Al igual que blitz, la primera ejecución es la más lenta, pues tiene que compilarlo, pero las siguientes son mucho más rápidas. Su principal inconveniente es que requiere escribir código en otro lenguaje… a menos que uses lo que te ha dado Shedskin, por ejemplo. También puede ser usado como método de inserción de piezas sencillas de código de un colaborador.

Por último, los de la vieja escuela quizá gusten de F2py para llamar a código Fortran desde Python.

El futuro: PyPy.

PyPy es un intérprete de Python… escrito en Python. Usando un lenguaje de mucho más alto nivel son capaces de optimizar ese mismo lenguaje. Es un gran proyecto aún en desarrollo, en el que se está invirtiendo mucho esfuerzo, pero que ha obtenido algunos resultados impresionantes. ¡En un benchmark se llega a una aceleración del 98%!

No es una opción todavía porque todavía le faltan muchas cosas, como soporte para bibliotecas externas como NumPy, aunque estamos cerca. Ignoro si hay algún problema más allá de las bibliotecas.

Filed under: Básico, Intermedio, Optimización

Pybonacci: Cómo calcular límites, derivadas, series e integrales en Python con SymPy

Mon, 30 Apr 2012 15:19:27 GMT

Introducción

Como buen paquete de cálculo simbólico que es, Sympy ofrece numerosas posibilidades para realizar tareas comunes del cálculo infinitesimal, como son calcular límites, derivadas, series e integrales simbólicas. Por ejemplo, mientras que con SciPy podemos calcular, utilizando diferencias centradas, la derivada de una función en un punto utilizando la función scipy.misc.derivative, con SymPy podemos calcular la derivada simbólica de la función.

Si no conoces SymPy, puedes leer nuestra Introducción al Cálculo Simbólico en Python con SymPy para hacerte una idea del manejo del paquete. Este artículo está basado en la sección de Cálculo Infinitesimal del tutorial de SymPy, y en él utilizaremos el intérprete interactivo de SymPy (isympy) que viene incluido con el paquete; para que el código funcione en un programa Python normal, sólo habría que incluir las correspondientes sentencias import.

En esta entrada se ha usado python2 2.7.3 y sympy 0.7.1.

Límites

Para calcular límites simbólicos con SymPy se utiliza la función limit. Podemos calcular el límite de casi cualquier expresión [1], con una o varias variables y por las dos direcciones:

In [1]: limit?
Type:       function
Base Class: <type 'function'>
String Form:
Namespace:  Interactive
File:       /usr/lib/python2.7/site-packages/sympy/series/limits.py
Definition: limit(e, z, z0, dir='+')
Docstring:
Compute the limit of e(z) at the point z0.
[...]

In [2]: limit(1 / x, x, oo)
Out[2]: 0

In [3]: limit(sin(x) / x, x, 0)
Out[3]: 1

In [4]: limit(1 / sin(x), x, 0)
Out[4]: ∞

In [5]: limit(1 / (x ** 2 + y ** 2), x, 0)
Out[5]:
1
──
 2
y

In [6]: limit(tan(x), x, pi / 2)
Out[6]: -∞

In [7]: limit(tan(x), x, pi / 2, dir='+')
Out[7]: -∞

In [8]: limit(tan(x), x, pi / 2, dir='-')
Out[8]: ∞

Como indican en la documentación de la función, hay bastantes ejemplos de límites no triviales en el archivo https://github.com/sympy/sympy/blob/master/sympy/series/tests/test_demidovich.py.

Derivadas

Para calcular la derivada simbólica en SymPy (esto es: la función derivada) se usa la función diff o el método .diff de una expresión. Esta admite varias sintaxis para indicar las variables y el orden de las derivadas:

In [1]: cos(x) * (1 + x)
Out[1]: (x + 1)⋅cos(x)

In [2]: diff(_1, x)  # Derivada primera con respecto a x
Out[2]: -(x + 1)⋅sin(x) + cos(x)

In [3]: diff(_, x)  # Derivada primera con respecto a x de lo anterior
Out[3]: -(x + 1)⋅cos(x) - 2⋅sin(x)

In [4]: diff(_1, x, 2)  # Derivada segunda con respecto a x
Out[4]: -(x + 1)⋅cos(x) - 2⋅sin(x)

In [5]: diff(_1, x, x)  # Otra forma de escribir lo mismo
Out[5]: -(x + 1)⋅cos(x) - 2⋅sin(x)

In [6]: diff(log(x * y), y)  # Derivada parcial con respecto a y
Out[6]: 
1
─
y

In [7]: diff(x * y * log(x * y), x, y)  # Derivada parcial con respecto a x e y
Out[7]: log(x⋅y) + 2

También se pueden derivar funciones simbólicas, y se respeta la regla de la cadena:

In [8]: diff(f(x) * sin(x), x)
Out[8]: 
                     d       
f(x)⋅cos(x) + sin(x)⋅──(f(x))
                     dx   

In [9]: diff(f(g(x)), x)
Out[9]: 
d        ⎛ d        ⎞│       
──(g(x))⋅⎜───(f(ξ₁))⎟│       
dx       ⎝dξ₁       ⎠│ξ₁=g(x)   

In [10]: diff(f(x * y), y)
Out[10]: 
  ⎛ d        ⎞│      
x⋅⎜───(f(ξ₁))⎟│      
  ⎝dξ₁       ⎠│ξ₁=x⋅y

In [11]: diff(exp(f(x)), x, 2)
Out[11]: 
              2           2      
 f(x) d            f(x)  d       
ℯ    ⋅──(f(x))  + ℯ    ⋅───(f(x))
      dx                  2      
                        dx       

In [12]: diff(f(x), x, 3)
Out[12]: 
  3      
 d       
───(f(x))
  3      
dx

También, utilizando sustitución como ya vimos en nuestra introducción, podemos calcular la derivada en un punto o dejar la derivada sin efectuar utilizando el argumento evaluate:


In [13]: diff(sin(x) ** 2, x)
Out[13]: 2⋅sin(x)⋅cos(x)

In [14]: diff(sin(x) ** 2, x).subs(x, pi / 4)
Out[14]: 1

In [15]: diff(tan(x), x)
Out[15]: 
   2       
tan (x) + 1

In [16]: _.subs(x, pi / 6)
Out[16]: 4/3

In [17]: diff(cos(x), x, evaluate=False)
Out[17]: 
d         
──(cos(x))
dx

Series

Para calcular desarrollos en series de potencias en SymPy utilizamos la función series o el método .series de una expresión [2].

In [1]: Expr.series?
Type:       instancemethod
Base Class: <type 'instancemethod'>
String Form:<unbound method Expr.series>
Namespace:  Interactive
File:       /usr/lib/python2.7/site-packages/sympy/core/expr.py
Definition: Expr.series(self, x=None, x0=0, n=6, dir='+')
Docstring:
Series expansion of "self" around ``x = x0`` yielding either terms of
the series one by one (the lazy series given when n=None), else
all the terms at once when n != None.
[...]

In [2]: cos(x).series(x)  # Por defecto, desarrollo en torno al 0 con n = 6 términos
Out[2]: 
     2    4          
    x    x           
1 - ── + ── + O(x**6)
    2    24          

In [3]: log(1 + x).series(x, 0, n=5)
Out[3]: 
     2    3    4          
    x    x    x           
x - ── + ── - ── + O(x**5)
    2    3    4           

In [4]: log(z).series(z, 1, n=5)  # Desarrollo en torno a z = 1 (nótese que en la salida z es (z - 1))
Out[4]: 
     2    3    4          
    z    z    z           
z - ── + ── - ── + O(z**5)
    2    3    4  

In [5]: abs(x).series(x, 0, dir='+')  # Desarrollo por la derecha
Out[5]: x

In [6]: abs(x).series(x, 0, dir='-')  # Y por la izquierda
Out[6]: -x

SymPy ofrece otros dos métodos relacionados con el cálculo de series interesantes:

El método .nseries. Calcula el desarrollo de una expresión de una manera distinta. Mientras que .series nos da el número de términos que hemos indicado con el argumento n, .nseries calcula los desarrollos de los diferentes factores con ese número de términos y luego opera con ellos, de tal forma que el resultado final puede no llegar al orden que pretendíamos conseguir. En cambio, es un método más rápido porque no requiere saber a priori el número de términos necesarios:
```
In [7]: (sin(x) / x).series(x, n=3)
Out[7]: 
     2          
    x           
1 - ── + O(x**3)
    6           

In [8]: (sin(x) / x).nseries(x, n=3)  # El resultado sigue siendo correcto
Out[8]: 1 + O(x**2)
```

El método .lseries proporciona un iterador con los términos del desarrollo (es equivalente a llamar a .series con n=None:

In [9]: s = cos(x).lseries(x)

In [10]: for term in s:
   ....:     pprint(term)
   ....:     
1
  2
-x 
───
 2 
 4
x 
──
24
  6
-x 
───
720
^C---------------------------------------------------------------------------
KeyboardInterrupt                         Traceback (most recent call last)
[...]

In [11]: s = cos(x).series(x, n=None)  # Equivalente a lo anterior

In [12]: type(s)
Out[12]: generator

In [13]: s.next()
Out[13]: 1

In [14]: s.next()
Out[14]: 
  2
-x 
───
 2 

In [15]: s.next()
Out[15]: 
 4
x 
──
24

Integrales

Para calcular integrales definidas e indefinidas con SymPy emplearemos la función integrate. Esta utiliza el algoritmo de Risch-Norman extendido más algunas reglas heurísticas y búsqueda de patrones:

In [1]: integrate(6 * x ** 5, x)
Out[1]: 
 6
x 

In [2]: integrate(x * log(x), x)
Out[2]: 
 2           2
x ⋅log(x)   x 
───────── - ──
    2       4 

In [3]: integrate(exp(-x ** 2), x)
Out[3]: 
  ⎽⎽⎽       
╲╱ π ⋅erf(x)
────────────
     2      

In [4]: integrate(x * y, y)
Out[4]: 
   2
x⋅y 
────
 2  

In [5]: integrate(cos(x), y)
Out[5]: y⋅cos(x)

In [6]: integrate(x * y, x, y)
Out[6]: 
 2  2
x ⋅y 
─────
  4  

In [7]: integrate(x, x, x, y)
Out[7]: 
 3  
x ⋅y
────
 6

También podemos efectuar integrales definidas, tanto propias como impropias:

In [8]: integrate(log(x), (x, 0, 1))
Out[8]: -1

In [9]: integrate(sin(x) ** 2, (x, 0, pi))
Out[9]: 
π
─
2

In [10]: integrate(sin(x), (x, 0, oo))
Out[10]: 1 - cos(∞)

In [11]: integrate(exp(-x ** 2), (x, 0, oo))
Out[11]: 
  ⎽⎽⎽
╲╱ π 
─────
  2

Y hasta aquí el artículo de hoy. Si te ha resultado útil o interesante (que espero que sí), recuerda comentar y difundir.

¡Un saludo!

Notas

[^] SymPy utiliza el algoritmo de Gruntz para calcular límites y requiere evaluar la serie de las funciones, por lo que los límites no pueden involucrar funciones definidas por el usuario (véase [2]).
[^] Las series para funciones definidas por el usuario no están soportadas todavía en la versión 0.7.1.

Filed under: Básico Tagged: cálculo simbólico, derivadas, integrales, límites, python, series, sympy

python majibu: Streaming de audio en tiempo real

Sun, 29 Apr 2012 07:10:03 GMT

Alguien sabe como realizar streaming de audio en tiempo real con python ya sea usando las librerias de gstreamer o pygame ?

de antemano muchas gracias

python majibu: Descargar ficheros en Django

Sat, 28 Apr 2012 14:24:06 GMT

Como descargar ficheros en Django.

He escrito la siguiente vista:

def descarga2(request):
    # Create the HttpResponse object with the appropriate PDF headers.
    response = HttpResponse(mimetype='application/pdf')
    response['Content-Disposition'] = 'attachment; filename=ARONA.pdf'

    # Create the PDF object, using the response object as its "file."
    fichero = open('.\\media\\images\\ARONA.pdf', 'rb')

    response.write(fichero)

    return response

Pero aunque aparentemente funciona el objeto que te descargas está vacío, no hay nada.

Como alternativas he visto las siguientes:

Esta:

El problema que tiene es que no envías el pdf existente en el sistema, sino que envía un objeto que creas sobre la marcha, puede que sea la solución para lo que necesito, pero aun no lo tengo claro del todo.

y esta:

En este caso pasa algo parecido, envia ficheros sobre la marcha y he intentado modificarlo para que me funcione y no me rula ...

El tema es que no se porque la vista que les he puesto arriba no me funciona, ya que no tira ningún error pero el objeto que envia está vacío.

Gracias y saludos.!!

python majibu: ¿Es correcto agregar atributos a una clase de modelo en tiempo de ejecución?

Fri, 27 Apr 2012 20:56:01 GMT

Hola comunidad!!!

Tengo un blog en Blogger, de Pensamientos, el cual lo estoy pasando a una pagina personal creada en Django (estoy usando Django 1.4). Para almacenar la información, en varios idiomas, he creado 4 modelos, dos para los pensamientos y dos para las etiquetas. Les pongo una versión reducida del models.py (le saque atributos para traducción de texto, algunos unique=True y valores por defecto)

class Etiquetas(models.Model):
    numero = models.AutoField(primary_key=True)

class TEtiquetas(models.Model):
    texto = models.CharField(max_length=80)
    explicacion = models.TextField()
    idioma = models.CharField(max_length=5, choices=settings.LANGUAGES)
    eid = models.ForeignKey(Etiquetas, related_name='traducciones')

class Pensamientos(models.Model):
    numero = models.AutoField(primary_key=True)
    fecha = models.DateTimeField()
    mostrar_pensamiento = models.BooleanField()
    etiquetas = models.ManyToManyField(Etiquetas, related_name='pensamientos')

class TPensamientos(models.Model):
    texto = models.TextField()
    explicacion = models.TextField()
    idioma = models.CharField(max_length=5, choices=settings.LANGUAGES)
    mostrar_pensamiento = models.BooleanField()
    mostrar_comentarios = models.BooleanField()
    habilitar_comentarios = models.BooleanField()
    pid = models.ForeignKey(Pensamientos, related_name='traducciones')

La idea es así: para un pensamiento determinado, se crea un objeto Pensamientos, y luego se crean objetos TPensamientos con los contenidos en los distintos idioma. Lo mismo para las etiquetas. En el views.py, tengo lo siguiente:

class PensamientosListView(ListView):
    context_object_name = 'PENSAMIENTOS'
    template_name = 'lista.html'
    paginate_by = conf['pensamientos_por_pagina']

    def get_queryset(self):
        filtros = {
            'idioma__istartswith': REGEX_SEPARADOR.split(get_language())[0],
            'mostrar_pensamiento': True,
            'pid__mostrar_pensamiento': True,
        }
        if 'etiqueta' in self.kwargs:
            e = self.kwargs['etiqueta']
            filtros.update({
                'pid__etiquetas__traducciones__texto__iexact': e,
            })
        return get_list_or_404(TPensamientos, **filtros)

    def get_context_data(self, **kwargs):
        context = super(PensamientosListView, self).get_context_data(**kwargs)
        for pensamiento in context['PENSAMIENTOS']:
            etiquetas = TEtiquetas.objects.filter(
                eid__pensamientos__traducciones=pensamiento,
                idioma__istartswith=pensamiento.idioma,
            )
            pensamiento.etiquetas = (etiqueta.texto for etiqueta in etiquetas)
        return context

Así funciona sin problemas aparentemente o al menos no los detecte todavía. Esa ultima parte de la vista es para tener disponible las etiquetas en la plantilla para mostrarlas. Ya que la relación es un ManyToMany debo filtrarlo antes de ir a la plantilla. Se me acaba de ocurrir que ese trabajo lo podría delegar a un filtro en la plantilla (igual me queda esta duda).

La pregunta es: esta bien agregar el atributo etiquetas al objeto pensamiento de la clase TPensamientos (en el método get_context_data de PensamientosListView). Había leído en alguna parte de la documentación oficial una advertencia relacionado a esto (según recuerdo) pero no la encuentro. Entiende que las clases se instáncian una ves al arrancar el servidor por cuestiones de eficiencia, y mi duda es si eso no es un problema una ves que este en producción y múltiples usuarios acedan a la pagina.

Les agradeceré cualquier comentario o referencia para aclarar esta duda, desde ya muchas gracias!

EDITO: Corregí un error en el método get_context_data

EDITO 2: Corregí el titulo, la clase modificada en tiempo de ejecución es de modelo y no de vista.

codeplasticlesthack: FLISOL Celaya 2012: Plática “Python + WebKit”

Fri, 27 Apr 2012 14:39:04 GMT

Es el 4to año consecutivo que este evento se lleva a cabo en Celaya, única sede del estado de Guanajuato por desgracia. Evento que es realizado dentro del Instituto Tecnológico de Celaya y en el que estuve involucrado en organización y coordinación durante 2 años (2009, 2010).

Este año (como el pasado) estuve de invitado para impartir una plática, y en este caso, con la temática de algunos experimentos que durante mis ratos libres (ya realmente son pocos) he estado probando con python y webkit.

Webkit ya es considerada como una plataforma para aplicaciones, podemos embeberla sencillamente con python para transportar una aplicación web a una aplicación de escritorio, y aprovechar toda la tecnología que Apple, Google y la comunidad ha venido desarrollando.

Los a credos a Python como yo, sabemos que este lenguaje es hermoso, pero mas allá de la estética en sintaxis, encontramos una infinidad de librearías para casi todo, y es por ello que juega un papel importante.

Dejo la presentación para aquellos que quisieran darle una simple vista, y en breve subiré los pocos códigos de ejemplo que presenté.

Pybonacci: Regiones de estabilidad de métodos numéricos en Python

Fri, 27 Apr 2012 08:36:19 GMT

Introducción

Hoy veremos cómo computar con Python la región de estabilidad absoluta de un método numérico para resolver problemas de valores iniciales en ecuaciones diferenciales ordinarias, una herramienta muy importante a la hora de escoger un método numérico adecuado para integrar nuestro problema concreto. Se trata simplemente de otro ejemplo aplicado de lo que publicamos hace unos días sobre cómo pintar curvas de nivel con matplotlib; si quieres ver otro más, puedes leer nuestro ejemplo de uso de Basemap y NetCDF4, donde vimos cómo representar datos climatológicos.

En esta entrada se ha usado python 2.7.3, numpy 1.6.1 y matplotlib 1.1.0.

Región de estabilidad absoluta

A la hora de integrar numéricamente un problema diferencial del tipo

nos interesa que la solución numérica tenga el mismo carácter de estabilidad que la solución analítica y saber para qué valores del paso de integración podemos conseguir esto [Hernández]. Mediante los autovalores de la matriz del sistema o los de la matriz jacobiana que resulta de linealizar el sistema [LeVeque], podemos definir la

Región de estabilidad absoluta: región del plano complejo tal que el método es estable .

Si la solución de la ecuación en diferencias resultante de discretizar el problema diferencial es de la forma

entonces los deben ser raíces del polinomio característico de estabilidad del método numérico:

que no depende del problema que estamos integrando. Si se cumple que el mayor de los valores absolutos de las raíces es menor o igual que 1 entonces la solución numérica será estable (asintóticamente estable en el caso estrictamente menor), e inestable si hay alguna raíz mayor que 1 en valor absoluto. Con esta información, vamos a computar la región de estabilidad absoluta siguiendo el algoritmo que propone [Hernández]:

Algoritmo

Discretizar una región del plano complejo .

Sea una matriz. Para cada ,

Obtener las raíces de .

Representar las curvas de nivel de . La será la frontera de la región de estabilidad absoluta y las serán el interior de la misma.

Código y representación

Vamos a incluir el código en un módulo para poder acceder a esta funcionalidad más fácilmente. El código completo, añadiendo documentación y ejemplos con el estándar de documentación de NumPy/SciPy, quedaría así:

# -*- coding: utf-8 -*-
#
# Región de estabilidad absoluta
# Juan Luis Cano Rodríguez

import numpy as np

def region_estabilidad(p, X, Y):
    """Región de estabilidad absoluta

    Computa la región de estabilidad absoluta de un método numérico, dados
    los coeficientes de su polinomio característico de estabilidad.

    Argumentos
    ----------
    p : function
        Acepta un argumento w y devuelve una lista de coeficientes
    X, Y : numpy.ndarray
        Rejilla en la que evaluar el polinomio de estabilidad generada por
        numpy.meshgrid

    Devuelve
    --------
    Z : numpy.ndarray
        Para cada punto de la malla, máximo de los valores absolutos de las
        raíces del polinomio de estabilidad

    Ejemplos
    --------
    >>> import numpy as np
    >>> x = np.linspace(-3.0, 1.5)
    >>> y = np.linspace(-3.0, 3.0)
    >>> X, Y = np.meshgrid(x, y)
    >>> Z = region_estabilidad(lambda w: [1,
    ... -1 - w - w ** 2 / 2 - w ** 3 / 6 - w ** 4 / 24], X, Y)  # RK4
    >>> import matplotlib.pyplot as plt
    >>> cs = plt.contour(X, Y, Z, np.linspace(0.05, 1.0, 9))
    >>> plt.clabel(cs, inline=1, fontsize=10)  # Para etiquetar los contornos
    >>> plt.show()

    """

    Z = np.zeros_like(X)
    w = X + Y * 1j
    
    for j in range(len(X)):
        for i in range(len(Y)):
            r = np.roots(p(w[i, j]))
            Z[i, j] = np.max(abs(r if np.any(r) else 0))

    return Z

Como sucede casi siempre en Python, el código es casi una traducción literal del algoritmo. Vamos a explicar un poco el código:

Obtenemos los coeficientes del polinomio para w[i, j].
Calculamos las raíces de dicho polinomio con np.roots, que acepta un array de rango 1 o equivalente (por esto no se puede vectorizar el bucle) y devuelve un array con las raíces del polinomio.
La expresión r if np.any(r) else 0 es un condicional ternario, y tiene la misión de devolver un 0 si el polinomio no tiene raíces (porque todos los coeficientes se han hecho nulos, por ejemplo) para que la función np.max no reciba un array vacío. Es equivalente a
```
if np.any(r):
    return r
else:
    return 0
```
Calculamos el valor absoluto de estas raíces.
Con la función np.max calculamos el mayor de estos valores.
Lo asignamos a Z[i, j].

Resultados

Una vez tenemos esto en un archivo region_estabilidad.py, si abrimos un intérprete de IPython en el mismo directorio será tan sencillo como

In [1]: import numpy as np

In [2]: x = np.linspace(-3.0, 1.5)

In [3]: y = np.linspace(-3.0, 3.0)

In [4]: X, Y = np.meshgrid(x, y)

In [5]: def p(w):
   ...:     """Polinomio de estabilidad del método RK4."""
   ...:     return [1, -1 - w - w ** 2 / 2 - w ** 3 / 6 - w ** 4 / 24]
   ...:

In [6]: from region_estabilidad import region_estabilidad

In [7]: Z = region_estabilidad(p, X, Y)

In [8]: import matplotlib.pyplot as plt

In [9]: plt.contour(X, Y, Z, np.linspace(0.0, 1.0, 9))
Out[9]:

In [10]: plt.show()

El segundo argumento de plt.contour es para especificar los niveles que queremos pintar (normalmente sólo nos interesará hasta el 1.0). Podemos obtener resultados similares a estos:

Región de estabilidad absoluta de un método Adams-Bashforth 3

Región de estabilidad absoluta de un método Runge-Kutta 4

Y hasta aquí llega el artículo de hoy. Espero que os haya resultado interesante y útil, no olvidéis difundir y comentar

¡Un saludo!

Referencias

HERNÁNDEZ, Juan A. Cálculo Numérico en Ecuaciones Diferenciales Ordinarias. ADI, 2001.
LEVEQUE, Randall J. Finite Difference Methods for Ordinary and Partial Differential Equations. Society for Industrial and Applied Mathematics, 2007.

Filed under: Básico Tagged: ecuaciones diferenciales, matplotlib, métodos numéricos, numpy, python

joe di castro: Sincronizar Bitbucket y GitHub

Thu, 26 Apr 2012 19:15:00 GMT

Para mis proyectos empleo generalmente mercurial (hg) como sistema de control de versiones, porque está hecho en Python y me parece más elegante y agradable de usar que git, aunque empleo git para algunas tareas, como gestionar los plugins de Vim. Del mismo modo, el emplear hg como DCVS me llevaba de forma natural a emplear Bitbucket como alojamiento para mis repositorios públicos.

Siempre me ha gustado Bitbucket, su estilo sencillo, pero muy potente y creo que tiene algunas características que son superiores a las de sus rivales (el diff side-by-side, por ejemplo¹). Pero también tengo claro que si hay algún alojamiento de código en la red que destaca sobre todos los demás es GitHub, "todo" el mundo está allí y de algún modo, estás "obligado" a estar. GitHub tiene algunas características muy potentes y en ciertos aspectos es muy superior a Bitbucket, aunque me sigue gustando más el feeling de este último.

Hg != Git

Me planteé entonces hace unos días que lo mejor era mantener una replica de mis repositorios alojados en Bitbucket en GitHub, como dice el refrán, Nunca tengas todos tus huevos en una misma cesta. El problema es que aunque Bitbucket soporta repositorios tanto en mercurial como en git (para competir con GitHub), GitHub solo soporta repositorios en Git. Y dado el éxito que tienen, dudo mucho que tengan intención alguna de soportar otro sistema de versiones distinto a Git.

Técnicamente es posible mantener un repositorio con los dos dcvs a la vez, pero maldita la gracia que me hacía, ademas de que no es nada aconsejable por el incremento de tamaño en disco que esto supondría. Entonces, ¿como hacer para poder alojar un repositorio mantenido con mercurial en un alojamiento que solo soporta Git? La solución, hg-git.

hg-git

hg-git es un plugin para mercurial que permite sincronizar el repositorio local en hg con un repositorio en git, admitiendo tanto push como pull y sin perdidas de información. Gracias a este plugin, podemos alojar el repositorio en los dos sitios a la vez, empleando solo mercurial para gestionarlo.

Instalarlo es muy fácil (desde easy_install o pip) y emplearlo también. Primero necesitas habilitarlo en el fichero ~/.hgrc, así como la extensión bookmarks que necesita para trabajar.

[extensions]
hgext.bookmarks =
hggit =

A continuación tienes que ir a tu repositorio y asignarle un bookmark a la rama que tengas por defecto (suele ser default) o a tip con el nombre de master (el nombre de las ramas por defecto en git), es decir:

$ hg bookmark -r default master -f

Y luego emplearlo es tan sencillo como si fuera un repositorio de mercurial, por ejemplo un push:

$ hg push git+ssh://git@github.com/joedicastro/joedicastro.com.git

Sincronizar el repositorio con Bitbucket y GitHub

Ahora, lo que tampoco me apetecía era tener que andar haciendo un push cada vez para cada alojamiento, lo ideal es que cada vez que hiciera un push a un sitio se sincronizara también el otro de forma automática. La solución pasa por emplear los paths para definir alias para los repositorios remotos y un hook para automatizar la sincronización.

Definir los alias con paths es realmente sencillo, nos vamos al fichero .hg/hgrc del repositorio local y añadimos esto (e.g. el repo de este blog):

[paths]
github = git+ssh://git@github.com:joedicastro/joedicastro.com.git
bitbucket = ssh://hg@bitbucket.org/joedicastro/joedicastro.com

De este modo, realizar un push es tan sencillo como:

$ hg push bitbucket

Ahora necesitamos crear el hook que nos sincronice los dos alojamientos. Hay en la red varias soluciones para esto, por ejemplo esta y esta, pero ninguna de las dos acababa de convencerme, la una por emplear un script bash que entraba muy fácilmente en un bucle infinito y la otra por necesitar otro modulo externo, que en mi caso no acababa de funcionar. Así que basándome en la idea del script bash del primero, decidí crearme uno en Python que funcionara correctamente y me solucionara el problema.

El código del hook es el siguiente:

#!/usr/bin/env python
# encoding: utf-8

"""
    bb_gh_sync.py: Mercurial hook to keep synced a repo to Bitbucket & GitHub.
"""

#==============================================================================
# This script maintain synced a repository to booth github and bitbucket sites,
# using only a local mercurial repository. To do this, makes use of hg-git, the
# paths defined in my local hg repo and the environment variable given by hg, to
# push to the site non described in the command line argument. This way, it's
# irrelevant which site I decided to push every time, booth are done by this
# hook.
##==============================================================================

#==============================================================================
#    Copyright 2012 joe di castro <joe@joedicastro.com>
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#==============================================================================

__author__ = "joe di castro <joe@joedicastro.com>"
__license__ = "GNU General Public License version 3"
__date__ = "23/04/2012"
__version__ = "0.1"

import os
from tempfile import gettempdir
from subprocess import call

def main():
    """Main section"""

    tmp_dir = gettempdir()
    lock_file = os.path.join(tmp_dir, "bb_gh.lock")

    # make sure that only runs once for each repository
    if not os.path.exists(lock_file):
        open(lock_file, "w").close()
        # if pushed to bitbucket, push to github too
        if os.environ['HG_ARGS'] == "push bitbucket":
            call(["/usr/bin/env", "hg", "push", "github"])
        # et viceversa...
        if os.environ['HG_ARGS'] == "push github":
            call(["/usr/bin/env", "hg", "push", "bitbucket"])
    else:
        os.remove(lock_file)

if __name__ == "__main__":
    main()

Ahora solo tenemos que editar nuestro fichero ~/.hgrc para habilitarlo y ya estaría listo para funcionar. Editamos el fichero y le añadimos estas lineas:

[hooks]
post-push = $HOME/dotfiles/hg/bb_gh_sync.py

Ahora, si hacemos un push a Bitbucket, el hace automáticamente un push también a GitHub al acabar el primero, y viceversa. De este modo, hacer un push a ambos alojamientos es tan sencillo como:

$ hg push bitbucket
pushing to ssh://hg@bitbucket.org/joedicastro/joedicastro.com
running ssh hg@bitbucket.org 'hg -R joedicastro/joedicastro.com serve --stdio'
searching for changes
no changes found
running hook post-push: $HOME/dotfiles/hg/bb_gh.py
pushing to git+ssh://git@github.com:joedicastro/joedicastro.com.git
creating and sending data
["git-receive-pack 'joedicastro/joedicastro.com.git'"]
    github::refs/heads/master => GIT:198e8cc9
running hook post-push: $HOME/dotfiles/hg/bb_gh.py
$

De este modo puedo mantener copias de los repositorios locales en ambos sitios de manera automática y sincronizada, sin preocuparme, ni hacer un trabajo extra. Eso si, conviene prescindir de los wikis y documentarlo todo a través de ficheros README.md en formato Markdown para facilitar la integración de los dos sitios. Lo que por otro lado también ayuda a mantenerlos actualizados de manera más sencilla.

Bueno, algunos rivales como Gitorius, también soportan esta característica ↩

python majibu: Campos no obligatorios en django admin

Tue, 24 Apr 2012 21:26:48 GMT

Tengo un formulario en django administration, el problema es que es un formulario con muchos campos, quiero que todos los campos se muestren pero no quiero que todos sean obligatorios solo uno o dos. Esto lo puedo definir bien en los formularios normales de django.forms pero en el django admin usando el admin.ModelAdmin no se como se hace. Tampoco encuentro nada en link text Tengo de momento definido el admin.py de esta forma. Pero como digo todos los campos me salen como obligatorios.

class CurriculoAdmin(admin.ModelAdmin):
list_display = ('__unicode__',
                'nombre', 'apellidos', 'profesion', 'poblacion',
                'provincia'
                )
list_filter = ('profesion', 'provincia')

def save_model(self, request, obj, form, change):
    obj.autor = request.user
    obj.save()

Pybonacci: Estadística en Python con SciPy (I)

Sat, 21 Apr 2012 16:46:31 GMT

Introducción

Hoy vamos a ver cómo trabajar con variable aleatoria con el módulo stats de la biblioteca Scipy. Scipy viene con numerosas distribuciones de probabilidad, tanto discretas como continuas, y además pone a nuestra disposición herramientas para crear nuestras propias distribuciones y multitud de herramientas para hacer cálculos estadísticos. En esta primera parte nos centraremos en cómo manejar esas distribuciones y sus funciones de distribución, cómo representarlas con matplotlib y cómo definir nuevas distribuciones.

En esta entrada se ha usado python 2.7.3, numpy 1.6.1, matplotlib 1.1.0 y scipy 0.10.1.

Nota: En mi opinión la documentación de este módulo deja un poco que desear. No resulta demasiado didáctica, hay algunas imprecisiones y cosas que directamente no tienen sentido o están mal. En cuanto sepas manejarlo un poco puedes usar de referencia en primer enlace de la entrada.

Distribuciones de variable continua

Entre las muchas distribuciones continuas que tiene SciPy vamos a ver un ejemplo de cómo manejar la distribución normal o gaussiana. Primero vamos a importar un par de módulos

In [1]: import numpy as np

In [2]: import scipy.stats as st

Todas las distribuciones continuas están definidas en función de dos parámetros: loc y scale, que juegan distinto papel en función de la distribución que manejemos. Por ejemplo, para la normal, loc es la media y por tanto el centro de la distribución y scale es la desviación típica y puede verse como un factor de escala (de ahí los nombres de los parámetros). Por otro lado, para la distribución uniforme, loc y scale son los extremos del intervalo en el que toma valores la variable.

Tenemos dos formas de manejar las distribuciones: una de ellas es crear un objeto que represente a la distribución con los parámetros fijados, y acceder después a todos sus métodos («frozen distribution»), de esta manera:

In [3]: rv1 = st.norm()  # Normal estándar

In [4]: rv1.cdf(0.5)  # Evaluamos la función de distribución en 0.5
Out[4]: 0.69146246127401312

In [5]: x = np.linspace(0.0, 1.0)

In [6]: rv1.pdf(x)  # Densidad de probabilidad en el intervalo [0.0, 1.0]
Out[6]:
array([ 0.39894228,  0.39885921,  0.39861011,  0.39819528,  0.39761524,
        0.39687072,  0.39596264,  0.39489214,  0.39366054,  0.39226937,
        0.39072035,  0.38901539,  0.38715659,  0.38514623,  0.38298676,
        0.38068082,  0.37823119,  0.37564085,  0.37291289,  0.37005059,
        0.36705736,  0.36393672,  0.36069236,  0.35732807,  0.35384775,
        0.35025541,  0.34655518,  0.34275126,  0.33884794,  0.33484957,
        0.3307606 ,  0.3265855 ,  0.32232884,  0.31799518,  0.31358916,
        0.30911541,  0.30457861,  0.29998342,  0.29533453,  0.29063661,
        0.28589432,  0.28111231,  0.27629519,  0.27144753,  0.26657387,
        0.26167871,  0.25676648,  0.25184154,  0.24690821,  0.24197072])

In [7]: rv2 = st.norm(2.0, 0.0)  # Normal (2.0, 0.0)

In [8]: rv3 = st.norm(loc=-1.0, scale=np.sqrt(0.5))  # Media -1.0 y varianza 0.5

La otra manera sería llamar en cada momento a la función que queramos evaluar, pasando los parámetros correspondientes, de manera que no se crea una distribución concreta:

In [9]: st.norm.cdf(0.5)  # Función de distribución de una normal estándar en 0.5
Out[9]: 0.69146246127401312

In [10]: st.norm.pdf(x, -1.0, np.sqrt(0.5))  # Densidad de una normal (-1.0, 0.5) en [0.0, 1.0]
Out[10]:
array([ 0.20755375,  0.19916976,  0.1909653 ,  0.18294635,  0.17511819,
        0.16748543,  0.16005198,  0.15282109,  0.14579538,  0.13897686,
        0.13236692,  0.12596638,  0.11977553,  0.11379411,  0.10802137,
        0.10245611,  0.09709665,  0.09194093,  0.08698648,  0.08223049,
        0.0776698 ,  0.07330098,  0.0691203 ,  0.06512379,  0.06130727,
        0.05766636,  0.05419651,  0.05089303,  0.04775112,  0.04476588,
        0.04193231,  0.0392454 ,  0.03670008,  0.03429126,  0.03201387,
        0.02986284,  0.02783314,  0.0259198 ,  0.02411789,  0.02242256,
        0.02082904,  0.01933266,  0.01792884,  0.01661312,  0.01538113,
        0.01422864,  0.01315155,  0.01214588,  0.01120776,  0.01033349])

Esto será útil cuando queramos hacer ajustes o estimaciones sobre los parámetros de la distribución, como veremos en la próxima entrega.

Para quien no conozca los nombres en inglés, los métodos más importantes son

Salida pseudoaleatoria («random variates» rvs)
Función densidad de probabilidad («probability density function» pdf)
Función de distribución («cumulative distribution function» cdf)

y todos ellos, y alguno más, están vectorizados, lo que significa que les podemos pasar un array de NumPy y obtendremos un array de valores.

Representación gráfica

Como los métodos básicos están vectorizados, es muy sencillo representarlos gráficamente en la manera a la que estamos acostumbrados, utilizando arrays de NumPy. Simplemente tenemos que escribir

In [11]: import matplotlib.pyplot as plt

In [12]: x = np.linspace(0.0, 1.0)

In [13]: plt.plot(x, st.norm.pdf(x, -1.0, np.sqrt(0.5)))
Out[13]: []

In [14]: plt.show()

Y podemos obtener bonitas figuras como esta.

Función de densidad de probabilidad de varias distribuciones normales (inspiración: http://commons.wikimedia.org/wiki/File:Normal_Distribution_PDF.svg)

Definir distribuciones

La manera de crear nuestras propias distribuciones continuas con SciPy es extender la clase rv_continuous y definir o bien su función de densidad o su función de distribución. Las clases y la herencia son conceptos de la Programación Orientada a Objetos, pero no es nuestra intención meternos a fondo en estos temas. De igual manera que hemos hecho rv = st.norm() para crear un objeto distribución al que manipular, queremos un mecanismo parecido para hacer rv = nueva_dist(), y para eso hemos de definir nueva_dist primero.

Por ejemplo, supongamos que queremos definir una distribución uniforme cuya función de densidad es

el código sería el siguiente

In [15]: from scipy.stats import rv_continuous

In [16]: class variable_gen(rv_continuous):
   ....:     """Variable aleatoria continua de distribución logarítmica."""
   ....:     def _pdf(self, x):
   ....:         return -log(x)
   ....:

In [17]: variable_gen?
Type:       type
Base Class: <type 'type'>
String Form:<class '__main__.variable_gen'>
Namespace:  Interactive
Definition: variable_gen(self, *args, **kwds)
Docstring:  Variable aleatoria continua de distribución logarítmica.
Constructor information:
 Definition:variable_gen(self, momtype=1, a=None, b=None, xa=-10.0, xb=10.0, xtol=1e-14, badvalue=None, name=None, longname=None, shapes=None, extradoc=None)

In [18]: variable = variable_gen(a=0.0, b=1.0, name="variable")

In [19]: variable.pdf(0.0)
/usr/bin/ipython2:4: RuntimeWarning: divide by zero encountered in log

Out[19]: inf

In [20]: from scipy.integrate import quad

In [21]: from numpy import inf

In [22]: quad(variable.pdf, -inf, inf)
Out[22]: (0.9999999999999962, 6.149525333398742e-12)

Lo que hemos hecho ha sido

Definir la clase variable_gen, que hereda las propiedades de rv_continuous.
Escribir la cadena de documentación de la clase.
Definir su función de densidad de probabilidad.
Crear una nueva variable, variable, en la que guardamos un objeto distribución cuya variable recorre el intervalo (nótese que es cerrado).
Comprobar qué pasa en 0. Nada que no supiéramos.
Comprobar que la función densidad está normalizada integrándola sobre la recta real (el primer número es el valor de la integral y el segundo una estimación del error, como podemos ver en la documentación de la función quad).

A partir de ahora podemos hacer lo mismo que hemos hecho antes: o bien crear una distribución fija o acceder a los métodos de la misma directamente. Aunque sólo hemos dado la función de densidad, comprobamos que también podemos llamar al resto:

In [23]: rv = variable()  # Nótense los paréntesis

In [24]: rv.cdf(0.5)
Out[24]: 0.84657359027997248

In [25]: x = np.linspace(0.0, 1.0)

In [25]: rv.cdf(x)
Out[25]:
array([ 0.        ,  0.09983307,  0.17137441,  0.23223723,  0.28616538,
        0.33493698,  0.37959929,  0.42084431,  0.45916388,  0.49492574,
        0.52841535,  0.55986072,  0.58944824,  0.61733311,  0.64364656,
        0.66850105,  0.69199398,  0.71421058,  0.73522599,  0.75510704,
        0.77391348,  0.79169908,  0.8085125 ,  0.82439796,  0.83939582,
        0.8535431 ,  0.86687383,  0.87941944,  0.89120902,  0.90226958,
        0.91262628,  0.92230257,  0.93132042,  0.93970041,  0.94746188,
        0.95462303,  0.961201  ,  0.96721201,  0.97267137,  0.97759362,
        0.98199253,  0.98588117,  0.98927201,  0.99217689,  0.99460713,
        0.9965735 ,  0.99808632,  0.99915544,  0.99979032,  1.        ])

In [26]: rv.rvs()
Out[26]: 0.11391190950607678

In [27]: rv.rvs()
Out[27]: 0.41700479602973284

In [28]: rv.rvs()
Out[28]: 0.00019824204606004107

Distribuciones de variable discreta

Scipy también trae unas cuantas distribuciones discretas para que no las tengamos que definir nosotros, y se usan de manera similar a las continuas. Por ejemplo, la distribución binomial:

In [29]: rv = st.binom(5, 0.5)  # Experimento de Bernoulli 5 veces con probabilidad 0.5

In [30]: k = np.arange(6)

In [31]: pk = rv.pmf(k)

In [32]: pk
Out[32]: array([ 0.03125,  0.15625,  0.3125 ,  0.3125 ,  0.15625,  0.03125])

Para el caso de distribuciones discretas, la función de densidad se distribuye por la función de probabilidad («probability mass function» pmf).

Representación gráfica

Ahora representar gráficamente una distribución discreta tiene un poco más de enjundia que en el caso de distribuciones continuas. Para la función de probabilidad hay al menos dos opciones, en función de los gustos de cada cual: hacer un diagrama de barras con bar o uno de líneas verticales con vlines, como vemos en este fragmento de código:

In [33]: plt.vlines(k, 0, pk)  # El segundo argumento da el extremo inferior de las líneas
Out[33]:

In [34]: plt.plot(k, pk, 'o')  # Añadimos puntos en los extremos
Out[34]: []

In [35]: plt.show()

In [36]: plt.bar(k - 0.5, _81, width=1.0)  # Se resta 0.5 para que las barras estén centradas
Out[36]:

In [37]: plt.show()

Se obtienen resultados similares a estos:

Función de probabilidad de una distribución binomial (5, 1/2) con líneas verticales

Función de probabilidad de una distribución binomial (5, 1/2) con barras

Para la función de distribución, sabemos que en el caso discreto esta tiene discontinuidades de salto. Para no obtener una gráfica horrible con puntos unidos que no deberían estarlo, o bien hacemos otro diagrama de barras o utilizamos arrays enmascarados («masked arrays» suena menos chistoso). Los masked arrays con arrays de NumPy en los que, bien manualmente o bien siguiendo alguna regla o patrón, hemos marcado algunas entradas como inválidas. Son de utilidad cuando, por ejemplo, estamos recogiendo datos y queremos descartar los que sean erróneos o se alejen demasiado de la media.

Si representamos gráficamente arrays enmascarados, matplotlib no unirá los puntos correspondientes a entradas inválidas, que es exactamente lo que queremos (como podemos leer en esta respuesta de StackOverflow). Los elementos que queremos marcar como inválidos son aquellos en los que la función da un salto, por lo que comprobaremos la diferencia entre un elemento y el siguiente del array. Para ello usaremos la función roll de NumPy:

In [38]: rv = st.binom(5, 0.5)

In [39]: x = np.linspace(-0.5, 5.5)

In [40]: cdf = rv.cdf(x)

In [41]: deltas = cdf - np.roll(cdf, 1)  # Array de diferencias

In [42]: deltas
Out[42]:
array([-1.     ,  0.     ,  0.     ,  0.     ,  0.     ,  0.03125,
        0.     ,  0.     ,  0.     ,  0.     ,  0.     ,  0.     ,
        0.     ,  0.15625,  0.     ,  0.     ,  0.     ,  0.     ,
        0.     ,  0.     ,  0.     ,  0.3125 ,  0.     ,  0.     ,
        0.     ,  0.     ,  0.     ,  0.     ,  0.     ,  0.3125 ,
        0.     ,  0.     ,  0.     ,  0.     ,  0.     ,  0.     ,
        0.     ,  0.15625,  0.     ,  0.     ,  0.     ,  0.     ,
        0.     ,  0.     ,  0.     ,  0.03125,  0.     ,  0.     ,
        0.     ,  0.     ])

In [43]: cdf = np.ma.masked_where(abs(deltas) > tol, cdf)

In [44]: cdf
Out[44]:
masked_array(data = [-- 0.0 0.0 0.0 0.0 -- 0.03125 0.03125 0.03125 0.03125 0.03125 0.03125
 0.03125 -- 0.1875 0.1875 0.1875 0.1875 0.1875 0.1875 0.1875 -- 0.5 0.5 0.5
 0.5 0.5 0.5 0.5 -- 0.8125 0.8125 0.8125 0.8125 0.8125 0.8125 0.8125 --
 0.96875 0.96875 0.96875 0.96875 0.96875 0.96875 0.96875 -- 1.0 1.0 1.0 1.0],
             mask = [ True False False False False  True False False False False False False
 False  True False False False False False False False  True False False
 False False False False False  True False False False False False False
 False  True False False False False False False False  True False False
 False False],
       fill_value = 1e+20)

Y se obtiene un diagrama similar a este:

Función de distribución de una distribución binomial (5, 1/2)

Definir distribuciones

Definir nuevas distribuciones discretas es aún más sencillo que en el caso continuo. Igual que antes, podemos crear una clase que extienda de, en este caso, rv_discrete, pero ahora demás podemos construir la distribución directamente pasando los al constructor. Por ejemplo, si queremos construir una distribución discreta con los siguientes datos:

	1	2	3	4
	0.1	0.4	0.2	0.3

el código será el siguiente:

In [45]: xk = [1, 2, 3, 4]

In [46]: pk = [0.1, 0.4, 0.2, 0.3]

In [47]: rv = st.rv_discrete(xk[0], xk[-1], values=(xk, pk))

y ya podemos acceder a todos los métodos que hemos visto anteriormente con normalidad.

Aquí se termina la primera parte de esta introducción al cálculo estadístico con SciPy. Espero que te haya resultado útil; no olvides difundirlo en las redes sociales y comentar lo que te apetezca.

¡Un saludo!

Filed under: Tutoriales Tagged: estadística, matplotlib, numpy, python, scipy

JavAguirre.net: M2Crypto from pip in old GNU/Linux OS

Thu, 19 Apr 2012 19:47:13 GMT

We had a problem today with M2Crypto package from pip repository in a CentOS server.

... Error: Unable to find 'opensslconf-x86_64.h'

The actual version in pip repositories is 0.21.1, but the setup.py file doesn’t search for the correct headers in this version of CentOS 5.5 (It’s old, I know :-) ).

There’s an easy workaround to get it working, I found it in a Zenoss community thread, you can just add a new path to search for files to self.swig_opts list.

First, we can download it from pip, and modify the setup.py file.

pip install -d . M2Crypto==0.21.1
untar M2Crypto-0.21.1.tar.gz

BEFORE

#LINE 58
self.swig_opts = ['-I%s' % i for i in self.include_dirs + \                                                                                  
                 [opensslIncludeDir]]
self.swig_opts.append('-includeall')

AFTER

self.swig_opts = ['-I%s' % i for i in self.include_dirs + \                                                                                  
                 [opensslIncludeDir]]
self.swig_opts.append('-includeall')
self.swig_opts.append('-I/usr/include/openssl')

Then running python setup.py install might do the trick.

December 31, 2011 -- Generar claves ssh desde python sin meter contraseña (0)
October 25, 2011 -- Python virtualenv (0)
May 14, 2012 -- Raequel, scraping en la web de la rae con app engine (0)

python majibu: Agregar fields adicionales a autocompletar

Thu, 19 Apr 2012 15:24:50 GMT

Hola tengo un formulario con un campo de búsqueda con autocompletado, me devuelve la identificación de un vendedor, pero necesito que me devuelva la identificación del vendedor, el nombre y apellido.

Mis modelos:

class Usuario(models.Model):
    user = models.OneToOneField(User)
    rut=models.CharField(max_length=15, unique=True) 
    nombre=models.CharField(max_length=30)
    apellido_paterno=models.CharField(max_length=30)
    apellido_materno=models.CharField(max_length=30)

    def __unicode__ (self):
        return '%s %s %s' % (self.nombre, self.apellido_paterno, self.apellido_materno)

class Vendedor(Usuario):
    local=models.ForeignKey(Local)

    class Meta:
        ordering = ['rut', 'apellido_paterno', 'apellido_materno']

Mi Vista:

@login_required
def buscar_vendedor(request):
    term = request.GET.get('term', '')
    resultado = list(Vendedor.objects.filter(rut__icontains=term, user__is_active=True).values_list('rut', flat=False))
    return HttpResponse(simplejson.dumps(resultado), mimetype='application/json')

La vista anterior me funciona bien pero no se como agregar las fields adicionales que necesito.

Intente usando otro metodo:

@login_required
def buscar_vendedor(request):
    term = request.GET.get('term', '')
    resultado = serializers.serialize('json', Vendedor.objects.all(), fields=('rut','nombre'))
    return HttpResponse(resultado, mimetype='application/json')

Pero no me devuelve el contenido de las fields, pero me devuelve esto:

[
    {
        "pk": 3, 
        "model": "Vendedores.vendedor", 
        "fields": {}
    }, 
    {
        "pk": 4, 
        "model": "Vendedores.vendedor", 
        "fields": {}
    }
]

Espero me puedan ayudar con este problema, saludos.

Pybonacci: Ecuaciones no lineales: método de bisección y método de Newton en Python

Wed, 18 Apr 2012 18:53:50 GMT

En este artículo vamos a ver cómo implementar en Python el método de bisección y el método de Newton, dos métodos iterativos clásicos para hallar raíces de ecuaciones no lineales de la forma , con y . Estos métodos y muchos otros más refinados están ya implementados en multitud de bibliotecas muy utilizadas, sin ir más lejos en el módulo optimize del paquete Scipy (referencia).

Crearemos un módulo ceros.py en el que incluiremos los dos métodos que vamos a desarrollar aquí, y así veremos un ejemplo de código limpio y fácilmente reutilizable.

Módulo `ceros.py`

Vamos a ver la anatomía de un módulo en Python. Este es el código del archivo:

# -*- coding: utf-8 -*-

"""Búsqueda de raíces

Este módulo contiene métodos para la búsqueda de raíces de ecuaciones de la
forma f(x) = 0, con f función real de variable real, continua y de derivada
continua.

"""

def biseccion():
    """Método de bisección"""
    pass

def newton():
    """Método de Newton"""
    pass

Analicemos el código:

La primera línea es fundamental en Python 2 si vamos a usar caracteres que se salen de ASCII. En ella especificamos que la codificación sea UTF-8, como viene recogido en la PEP 263.
La línea entre triples comillas dobles es lo que se llama docstring o cadena de documentación del módulo, y siempre es una cadena que se pone al principio del archivo, como viene especificado en la PEP 257. Lo de usar triples comillas nos aseguramos de que podemos incluir saltos de línea.
Definimos dos funciones, también con su docstring. La palabra clave pass se utiliza para que cuadre el sangrado del código: no hace nada.
Las convenciones en cuanto a espacios, longitud de las líneas, etc. están definidas en la PEP 8, que viene a ser como el manual de estilo oficial para programas en Python. Puedes comprobar si tu código se adhiere a esta convención con la herramienta pep8 disponible en el Índice de Paquetes de Python (PyPI).

Para utilizar este módulo, simplemente lenzaríamos un intérprete Python en la carpeta donde esté el archivo ceros.py y escribiríamos:

>>> import ceros
>>> dir(ceros)
['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'biseccion', 'newton']
>>> print ceros.__doc__
Búsqueda de raíces

Este módulo contiene métodos para la búsqueda de raíces de ecuaciones de la
forma f(x) = 0, con f función real de variable real, continua y de derivada
continua.
>>> print ceros.biseccion
<function biseccion at 0x7fc17efb5668>

Ahora no hay más que implementar estos métodos.

Método de la bisección

Descripción y algoritmo

El método de bisección es un método geométricamente muy intuitivo: partiendo de un intervalo tal que (es decir: la función cambia de signo en el intervalo), se va dividiendo en dos generando una sucesión de intervalos encajados hasta que se converge con la precisión deseada a la raíz de la ecuación que, como asegura el teorema de Bolzano, tiene que existir; es decir, el tal que .

El algoritmo del método de bisección sería el siguiente:

Sean ,  y .

Sea .

Si , terminar.

Si , entonces  y volver al paso 1.

Si no, entonces  y volver al paso 1.

Este método, aunque es lento, tiene convergencia garantizada.

Método de bisección en Python

A la vista del algoritmo anterior, ya podemos implementar el método de bisección en Python. Nos vamos a saltar la parte de escribir el pseudocódigo.

Nota: Cambiado por sugerencia de David para evitar errores de precisión.

import numpy as np

def biseccion(f, a, b, tol=1.0e-6):
    """Método de bisección

    Halla una raíz de la función f en el intervalo [a, b] mediante el método
    de bisección.

    Argumentos
    ----------
    f - Función, debe ser tal que f(a) f(b) < 0
    a - Extremo inferior del intervalo
    b - Extremo superior del intervalo
    tol (opcional) - Cota para el error absoluto de la x

    Devuelve
    --------
    x - Raíz de f en [a, b]

    Excepciones
    -----------
    ValueError - Intervalo mal definido, la función no cambia de signo en el
                 intervalo o cota no positiva

    Ejemplos
    --------
    >>> def f(x): return x ** 2 - 1
    ...
    >>> biseccion(f, 0, 2)
    1.0
    >>> biseccion(f, 0, 5)
    1.000000238418579
    >>> biseccion(f, -2, 2)
    Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        File "ceros.py", line 35, in biseccion
        raise ValueError("La función debe cambiar de signo en el intervalo")
    ValueError: La función debe cambiar de signo en el intervalo
    >>> biseccion(f, -3, 0, tol=1.0e-12)
    -1.0000000000004547

    """
    if a > b:
        raise ValueError("Intervalo mal definido")
    if f(a) * f(b) >= 0.0:
        raise ValueError("La función debe cambiar de signo en el intervalo")
    if tol <= 0:
        raise ValueError("La cota de error debe ser un número positivo")
    x = (a + b) / 2.0
    while True:
        if b - a < tol:
            return x
        # Utilizamos la función signo para evitar errores de precisión
        elif np.sign(f(a)) * np.sign(f(x)) < 0:
            b = x
        else:
            a = x
        x = (a + b) / 2.0

Vamos a señalar algunas cosas:

Como se puede observar, el código se parece bastante al algoritmo.
Podemos pasar una función como argumento sin ningún esfuerzo.
Hemos incluido en la documentación información sobre los argumentos que recibe la función, de manera que si escribimos en el intérpretehelp(ceros.biseccion) podremos consultarla.
No he incluido un número máximo de iteraciones: fijada una precisión, el método convergerá siempre.

Por último, nótese que el programa produce un error si el límite inferior de intervalo es mayor que el límite superior, si la función no cambia de signo o si la cota de error es un número negativo. Python hace muy sencillas este tipo de construcciones: se denomina manejo de excepciones.

Podíamos haber tomado la decisión de no incluir este manejo de errores, y dejar que el programa falle inesperadamente si el usuario hace «cosas raras». Esto que lo decida cada uno.

Para gestionar los errores que se pueden producir, utilizamos el bloque try...except:

try:
    biseccion(f, a, b)
except ValueError:
    pass  # Este bloque se ejecuta si se produce un error

Gracias a esta característica de Python podemos evitar cosas como que una división por cero mate al programa, por ejemplo.

Método de Newton

Descripción y algoritmo

El método de Newton o método de Newton-Raphson linealiza la función a cada paso utilizando su derivada, que se debe proporcionar como argumento, para hallar la raíz de la ecuación en las proximidades de un punto inicial . Este método puede no converger, pero si el punto inicial está lo suficientemente próximo a la raíz, la convergencia será muy rápida.

El algoritmo del método de Newton es este:

Sean , y .

Sea .

Sea .

Si , terminar.

Si no, volver al paso 2.

Método de Newton en Python

Aquí, debido a que el método no tiene garantizada la convergencia, habrá que considerar un número máximo de iteraciones y cotas de error tanto para la raíz como para el valor de la función.

El código sería este:

def newton(f, df, x_0, maxiter=50, xtol=1.0e-6, ftol=1.0e-6):
    """Método de Newton

    Halla la raíz de la función f en el entorno de x_0 mediante el método de
    Newton.

    Argumentos
    ----------
    f - Función
    df - Función, debe ser la función derivada de f
    x_0 - Punto de partida del método
    maxiter (opcional) - Número máximo de iteraciones
    xtol (opcional) - Cota para el error relativo para la raíz
    ftol (opcional) - Cota para el valor de la función

    Devuelve
    --------
    x - Raíz de la ecuación en el entorno de x_0

    Excepciones
    -----------
    RuntimeError - No hubo convergencia superado el número máximo de
                   iteraciones
    ZeroDivisionError - La derivada se anuló en algún punto
    Exception - El valor de x se sale del dominio de definición de f

    Ejemplos
    --------
    >>> def f(x): return x ** 2 - 1
    ...
    >>> def df(x): return 2 * x
    ...
    >>> newton(f, df, 2)
    1.000000000000001
    >>> newton(f, df, 5)
    1.0
    >>> newton(f, df, 0)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "ceros.py", line 102, in newton
        dx = -f(x) / df(x)  # ¡Aquí se puede producir una división por cero!
    ZeroDivisionError: float division by zero

    """
    x = float(x_0)  # Se convierte a número de coma flotante
    for i in xrange(maxiter):
        dx = -f(x) / df(x)  # ¡Aquí se puede producir una división por cero!
                            # También x puede haber quedado fuera del dominio
        x = x + dx
        if abs(dx / x) < xtol and abs(f(x)) < ftol:
            return x
    raise RuntimeError("No hubo convergencia después de {} \
                        iteraciones".format(maxiter))

Se deja como ejercicio (qué placentero es decir esto) programar el método de la secante que se utilice como alternativa si no se dispone de la derivada de la función.

¡Y con eso terminamos el artículo de hoy! Espero que te haya resultado provechoso, no olvides comentar, retwittear y demás zarandajas

Referencias

RIVAS, Damián y VÁZQUEZ, Carlos. Elementos de Cálculo Numérico. ADI, 2010.

Filed under: Básico Tagged: biseccion, ecuaciones no lineales, newton, python

python majibu: Problema Feed Rss Django

Wed, 18 Apr 2012 00:11:54 GMT

Estoy creando un feed rss y me estoy basando en [1]. He realizado todo pero me manda este error :

1 2	ImproperlyConfigured at /feeds/blog/ Give your Videos class a get_absolute_url() method, or define an item_link() method in your Feed class.

He encontrado algo parecido a mi error en [2], al parecer me hacía falta los archivos :

blog_title.html 
{{ obj.title }}

blog_description.html
{{ obj.body }}

Me basé en esta página [3], pero sigo teniendo el mismo error. Dejo mis archivos:

feeds.py

from django.contrib.syndication.feeds import Feed
from kukulkan.control.models import Videos

class EntradaFeed(Feed):
    title='Mi Blog'
    link='http://www.mi_proyecto.com/blog/'
    description='Descripcion de la tematica del blog.'

    def items(self):
        # elementos del feed
        return Videos.objects.all().order_by("-fecha")[:10]

    def item_pubdate(self,item):
        return item.fecha

    def item_author_name(self, item):
        # nombre del autor de cada elemento del feed
        return '%s ' % (item.titulo)

urls.py

from kukulkan.control.feeds import EntradaFeed
feeds = {
    'blog': EntradaFeed,
}
urlpatterns = patterns('', 
    (r'^feeds/(?P<url>.*)/$', 'django.contrib.syndication.views.feed', {'feed_dict': feeds}),
)

No se que me falta hacer para que no me arroje este error

Pybonacci: Ejemplo de uso de Basemap y NetCDF4

Sat, 14 Apr 2012 11:14:50 GMT

Continuando lo que enseñó Juanlu en la anterior entrada vamos a mostrar líneas de nivel y temperatura del aire en la superficie, en este caso la presión al nivel del mar del día 01 de enero de 2012 a las 00.00 UTC según los datos extraídos del reanálisis NCEP/NCAR, sobre un mapa con la ayuda de la librería Basemap.

Como los datos del reanálisis NCEP/NCAR vienen en formato netCDF usaremos la librería netcdf4-python. El formato netCDF es un estándar abierto y es ampliamente usado en temas de ciencias de la tierra, atmósfera, climatología, meteorología,… No es estrictamente necesario usar netcdf4-python para acceder a ficheros netCDF puesto que desde scipy tenéis esta funcionalidad. Pero bueno, yo uso esta por una serie de ventajas que veremos otro día.

En la presente entrada se ha usado python 2.7.2, numpy 1.6.1, matplotlib 1.1.0, netCDF4 0.9.7 y Basemap 1.0.2.

Primero de todo vamos a importar todo lo que necesitamos:

## Importamos las librerías que nos hacen falta
import numpy as np
import netCDF4 as nc
import matplotlib.pyplot as plt
from mpl_toolkits import basemap as bm

Los ficheros netCDF de presión al nivel del mar y de Temperatura del aire de la superficie los podéis descargar de aquí y aquí, respectivamente. Veréis un enlace que pone ‘FTP a copy of the file’, lo pincháis y guardáis en el mismo sitio donde tengáis el script que estamos haciendo en la presente entrada.

Una vez que tenemos los ficheros los podemos abrir usando la librería netCDF4-python:

## Abrimos los ficheros de datos,
## el nombre de los ficheros lo tendréis que cambiar
## con el nombre de los ficheros que os habéis descargado
slp = nc.Dataset('X83.34.8.250.104.4.18.19.nc') #slp por 'sea level pressure'
tsfc = nc.Dataset('X83.34.8.250.104.4.15.31.nc') #tsfc 'por temperature at surface'

Para saber las variables que tenemos en cada fichero netCDF podemos escribir lo siguiente:

## Qué variables hay dentro de cada netCDF
print slp.variables
print tsfc.variables

El output que veremos para slp será:

OrderedDict([(u'lat', <netCDF4.Variable object at 0x05F72FA8>), (u'lon', <netCDF4.Variable object at 0x0603C198>), (u'time', <netCDF4.Variable object at 0x0603C150>), (u'slp', <netCDF4.Variable object at 0x060A1FA8>)])

De la misma forma, para tsfc tendremos:

OrderedDict([(u'lat', <netCDF4.Variable object at 0x060AE108>), (u'lon', <netCDF4.Variable object at 0x060AE030>), (u'time', <netCDF4.Variable object at 0x060AE078>), (u'air', <netCDF4.Variable object at 0x060AE150>)])

Nos interesa acceder a las variables ‘slp’, ‘air’, ‘lat’ y ‘lon’. Las dos últimas variables son las mismas tanto en slp como en tsfc ya que nos hemos descargado el campo de presión y temperatura para la misma fecha y para la misma área. Por tanto, para acceder a los datos y poder dibujarlos hacemos lo siguiente:

slpdata = slp.variables['slp'][:] #Obtenemos los datos en Pa
tsfcdata = tsfc.variables['air'][:] #Obtenemos los datos en ºK
lat = slp.variables['lat'][:] #Obtenemos los datos en º
lon = slp.variables['lon'][:] #Obtenemos los datos en º

Los datos se han guardado en las variables slpdata, tsfcdata, lat y lon como numpy arrays. Para que la presión esté en hPa o mb (hectopascales o milibares), la temperatura en ºC y las longitudes vayan en una escala de -180º a 180º hacemos lo siguiente:

slpdata = slpdata * 0.01
tsfcdata = tsfcdata - 273.15
lon[lon > 180] = lon - 360.

Ahora creamos una instancia a Basemap:

m = bm.Basemap(llcrnrlon = -20,
               llcrnrlat = 25,
               urcrnrlon = 60,
               urcrnrlat = 80,
               projection = 'mill')

En el anterior código hemos puesto lo siguiente:

|      llcrnrlon        longitud de la esquina inferior izquierda del dominio del mapa seleccionado.
|      llcrnrlat        latitud de la esquina inferior izquierda del dominio del mapa seleccionado.
|      urcrnrlon        longitud de la esquina superior derecha del dominio del mapa seleccionado.
|      urcrnrlat        latitud de la esquina superior derecha del dominio del mapa seleccionado.

Para projection hemos usado mill que será para una proyección Miller cylindrical. Si queréis ver todas las proyecciones disponibles podéis escribir:

print bm.supported_projections

Y veréis el siguiente output:

aeqd             Azimuthal Equidistant
poly             Polyconic
gnom             Gnomonic
moll             Mollweide
tmerc            Transverse Mercator
nplaea           North-Polar Lambert Azimuthal
gall             Gall Stereographic Cylindrical
mill             Miller Cylindrical
merc             Mercator
stere            Stereographic
npstere          North-Polar Stereographic
hammer           Hammer
geos             Geostationary
nsper            Near-Sided Perspective
vandg            van der Grinten
laea             Lambert Azimuthal Equal Area
mbtfpq           McBryde-Thomas Flat-Polar Quartic
sinu             Sinusoidal
spstere          South-Polar Stereographic
lcc              Lambert Conformal
npaeqd           North-Polar Azimuthal Equidistant
eqdc             Equidistant Conic
cyl              Cylindrical Equidistant
omerc            Oblique Mercator
aea              Albers Equal Area
spaeqd           South-Polar Azimuthal Equidistant
ortho            Orthographic
cass             Cassini-Soldner
splaea           South-Polar Lambert Azimuthal
robin            Robinson

Buscamos los valores x e y que representarán a las latitudes y longitudes de la proyección del mapa seleccionada:

## Encontramos los valores x,y para el grid de la proyección del mapa.
lon, lat = np.meshgrid(lon, lat)
x, y = m(lon, lat)

Vamos a representar el campo de presiones en el mapa:

fig=plt.figure(figsize=(8,6))
ax = fig.add_axes([0.05,0.05,0.9,0.85])
cs = m.contour(x,y,slpdata[0,:,:],np.arange(900,1100.,5.),colors='y',linewidths=1.25)
m.drawparallels(np.arange(0,360,10),labels=[1,1,0,0])
m.drawmeridians(np.arange(-180,180,10),labels=[0,0,0,1])
m.bluemarble()
plt.show()

Este último código mostrará la siguiente figura:

En el anterior mapa hemos mostrado las líneas de nivel de la presión, hemos dibujado meridianos y paralelos y lo hemos representado con una proyección cilíndrica de Miller usando como fondo los datos Blue Marble de la NASA.

Ahora vamos a introducir también los datos de temperatura usando contourf (la f viene de fill, relleno y son contornos rellenados). Metemos lo siguiente en nuestro script:

# create figure.
fig=plt.figure(figsize=(8,6))
ax = fig.add_axes([0.05,0.05,0.9,0.85])
cs = m.contour(x,y,slpdata[0,:,:],np.arange(900,1100.,5.),colors='k',linewidths=1.)
csf = m.contourf(x,y,tsfcdata[0,:,:],np.arange(-50,50.,2.))
m.drawcoastlines(linewidth=1.25, color='grey')
m.drawparallels(np.arange(0,360,10),labels=[1,1,0,0])
m.drawmeridians(np.arange(-180,180,10),labels=[0,0,0,1])
plt.show()

Y obtenemos el siguiente resultado:

Donde hemos representado la presión al nivel del mar (isolíneas en color negro), las temperaturas en superficie (contornos de color rellenos), las líneas de costa (líneas continuas grises), paralelos y meridianos.

El script final quedaría algo así:

## Importamos las librerías que vamos a usar
import numpy as np
import netCDF4 as nc
import matplotlib.pyplot as plt
from mpl_toolkits import basemap as bm

## Abrimos los ficheros de datos
slp = nc.Dataset('X83.34.8.250.104.4.18.19.nc') #slp por 'sea level pressure'
tsfc = nc.Dataset('X83.34.8.250.104.4.15.31.nc') #tsfc 'por temperature at surface'slp.variables
print slp.variables
print tsfc.variables

slpdata = slp.variables['slp'][:] #Obtenemos los datos en Pa
tsfcdata = tsfc.variables['air'][:] #Obtenemos los datos en ºK
lat = slp.variables['lat'][:] #Obtenemos los datos en º
lon = slp.variables['lon'][:] #Obtenemos los datos en º
slpdata = slpdata * 0.01
tsfcdata = tsfcdata - 273.15
lon[lon > 180] = lon - 360.

## Creamos una instancia a Basemap
m = bm.Basemap(llcrnrlon = -20,
               llcrnrlat = 25,
               urcrnrlon = 60,
               urcrnrlat = 80,
               projection = 'mill')
print bm.supported_projections

## Encontramos los valores x,y para el grid de la proyección del mapa.
lon, lat = np.meshgrid(lon, lat)
x, y = m(lon, lat)

# Creamos la figura con P sobre fondo Blue Marble.
fig=plt.figure(figsize=(8,6))
ax = fig.add_axes([0.05,0.05,0.9,0.85])
cs = m.contour(x,y,slpdata[0,:,:],np.arange(900,1100.,5.),colors='y',linewidths=1.25)
m.drawparallels(np.arange(0,360,10),labels=[1,1,0,0])
m.drawmeridians(np.arange(-180,180,10),labels=[0,0,0,1])
m.bluemarble()
plt.show()

# Creamos la figura con P y T.
fig=plt.figure(figsize=(8,6))
ax = fig.add_axes([0.05,0.05,0.9,0.85])
cs = m.contour(x,y,slpdata[0,:,:],np.arange(900,1100.,5.),colors='k',linewidths=1.)
csf = m.contourf(x,y,tsfcdata[0,:,:],np.arange(-50,50.,2.))
m.drawcoastlines(linewidth=1.25, color='grey')
m.drawparallels(np.arange(0,360,10),labels=[1,1,0,0])
m.drawmeridians(np.arange(-180,180,10),labels=[0,0,0,1])
plt.show()

Y eso es todo por hoy. En algún momento, siempre que el tiempo lo permita, veremos más en profundidad Basemap y Netcdf4-python.

Saludos.

P.D.: Lo de siempre, si encontráis errores, queréis criticar (constructivamente) mis bajas dotes como programador o queréis aportar alguna cosa usad los comentarios.

Filed under: Básico, Tutoriales Tagged: basemap, mapas, matplotlib, meteorología, netcdf, netcdf4-python, numpy, python

Pybonacci: Dibujando líneas de nivel en Python con matplotlib

Fri, 13 Apr 2012 11:08:04 GMT

Introducción

En este artículo vamos a ver cómo representar en Python un mapa de curvas de nivel o de isolíneas, esto es, curvas que conectan los puntos en los que una función tiene un mismo valor constante, utilizando NumPy y matplotlib. Los mapas de curvas de nivel («contour lines» en inglés) son muy útiles, porque ayudan a ver la información de una manera mucho más cómoda que las representaciones de superficies en tres dimensiones, por muy espectaculares que estas últimas puedan quedar. Un ejemplo muy cotidiano es el mapa de isobaras que nos dan en la predicción del tiempo como el que se ve en la imagen: los puntos que están sobre la misma línea están todos a la misma presión.

Mapa HIRLAM-AEMET 0.16° de Superficie (Presión). Válido para el viernes, 13 abril 2012 a las 08:00. © Agencia Estatal de Meteorología.

En este artículo nos ceñiremos a funciones

es decir, funciones que están definidas en un conjunto del plano y que a cada punto del mismo le asignan un número real. En el caso del ejemplo que hemos puesto, la función estaría definida (aceptando por un segundo que la Tierra es plana) en un conjunto del mapa que comprende la zona de la imagen y a cada punto le asigna el valor de presión atmosférica en dicho punto.

Para la siguiente entrada se ha usado python 2.7.2, numpy 1.6.1, scipy 0.9.0 y matplotlib 1.1.0.

Creación del mallado

Vamos a representar el mapa de curvas de nivel de la función

en el dominio . Me la acabo de inventar, y quedan las líneas curiosas.

Para empezar tenemos que discretizar este dominio: generaremos una malla o rejilla de puntos y evaluaremos la función en cada uno de ellos. Para ello, utilizaremos la función meshgrid() de NumPy:

$ ipython2
Python 2.7.2 (default, Jan 31 2012, 13:19:49)
Type "copyright", "credits" or "license" for more information.

IPython 0.12 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.

In [1]: import numpy as np

In [2]: xx = np.linspace(-1.5, 1.5)

In [3]: yy = xx.copy()

In [4]: X, Y = np.meshgrid(xx, yy)

In [5]: X
Out[5]:
array([[-1.5       , -1.43877551, -1.37755102, ...,  1.37755102,
         1.43877551,  1.5       ],
       [-1.5       , -1.43877551, -1.37755102, ...,  1.37755102,
         1.43877551,  1.5       ],
       [-1.5       , -1.43877551, -1.37755102, ...,  1.37755102,
         1.43877551,  1.5       ],
       ...,
       [-1.5       , -1.43877551, -1.37755102, ...,  1.37755102,
         1.43877551,  1.5       ],
       [-1.5       , -1.43877551, -1.37755102, ...,  1.37755102,
         1.43877551,  1.5       ],
       [-1.5       , -1.43877551, -1.37755102, ...,  1.37755102,
         1.43877551,  1.5       ]])

In [6]: Y
Out[6]:
array([[-1.5       , -1.5       , -1.5       , ..., -1.5       ,
        -1.5       , -1.5       ],
       [-1.43877551, -1.43877551, -1.43877551, ..., -1.43877551,
        -1.43877551, -1.43877551],
       [-1.37755102, -1.37755102, -1.37755102, ..., -1.37755102,
        -1.37755102, -1.37755102],
       ...,
       [ 1.37755102,  1.37755102,  1.37755102, ...,  1.37755102,
         1.37755102,  1.37755102],
       [ 1.43877551,  1.43877551,  1.43877551, ...,  1.43877551,
         1.43877551,  1.43877551],
       [ 1.5       ,  1.5       ,  1.5       , ...,  1.5       ,
         1.5       ,  1.5       ]])

En primer lugar hemos creado dos vectores xx e yy donde hemos almacenado los dos intervalos, y después hemos llamado a la función meshgrid(xx, yy) y nos ha devuelto dos arrays de dimensión 2: el primero de ellos varía sólo a lo largo de las columnas, y el segundo sólo a lo largo de las filas. A los que vengan de MATLAB esto les parecerá obvio, pero el resto tal vez se estén preguntando ¿por qué? y ¿para qué?

Para entender por qué esto es útil, es fundamental recordar que en NumPy las operaciones están vectorizadas. Observa que si para cada fila i y columna j creamos el par , ya tenemos la rejilla de puntos creada y almacenada en una matriz que tiene la misma dimensión que X e Y. Si ahora hiciésemos

Z = np.cos(X ** 2 + Y ** 2)

en realidad sería como escribir

for i in range(len(X)):
    for j in range(len(Y)):
        Z[i, j] = np.cos(X[i, j] ** 2 + Y[i, j] ** 2)

y en el array bidimensional Z tendríamos los valores de la función coseno para cada punto de la malla. Esta forma abreviada de escribir el código es la que se denomina vectorizada y funciona porque X, Y y Z tienen la misma dimensión y el mismo tamaño. Es muy importante porque, además de escribir menos código, las operaciones se ejecutan órdenes de magnitud más deprisa.

Dicho esto, justamente lo que queremos es la matriz Z donde almacenar el valor de nuestra función para cada uno de los puntos de la malla:

In [7]: from numpy import cos, sinh, log

In [8]: Z = cos(-10 * X * Y) + sinh(X + Y) - log((3 + X ** 2) / (1 + Y ** 2))

In [9]: Z
Out[9]:
array([[-11.37075265, -10.78189814,  -9.50784471, ...,  -0.77338623,
         -1.42327703,  -1.35287772],
       [-10.87372363,  -9.63560489,  -8.22976433, ...,   0.03672752,
         -0.77839121,  -1.39257702],
       [ -9.69207397,  -8.3221681 ,  -7.36241976, ...,   0.46710156,
          0.06684924,  -0.71210509],
       ...,
       [ -0.95761549,  -0.05567626,   0.46710156, ...,   8.29662289,
          8.33334108,   8.02235339],
       [ -1.51510252,  -0.77839121,   0.15925301, ...,   8.42574485,
          8.07882247,   7.96604409],
       [ -1.35287772,  -1.30075153,  -0.52787582, ...,   8.20658265,
          8.05786958,   8.66499721]])

Ya tenemos la parte de cálculo lista, y ahora sólo queda representar.

Representación de las líneas de nivel

La biblioteca matplotlib ofrece dos funciones para representar curvas de nivel: contour() y contourf(). La única diferencia entre las dos es que en la primera se representan sólo las líneas, y en la segunda se rellena el espacio entre ellas.

Para obtener ayuda sobre estas funciones sin acudir a la documentación, recuerda que en IPython podemos escribir

In [10]: import matplotlib.pyplot as plt

In [11]: plt.contour?
...

Para crear la figura bastan dos líneas:

In [12]: plt.contour(X, Y, Z)
Out[12]:

In [13]: plt.show()

E voilà! Sencillo como siempre Incluso podemos rizar más el rizo:

In [14]: cs1 = plt.contourf(X, Y, Z, 25)  # Pintamos 25 niveles con relleno

In [15]: cs2 = plt.contour(X, Y, Z, cs1.levels, colors='k')  # Añadimos bordes negros

In [16]: plt.show()

La biblioteca matplotlib es enorme y da docenas de opciones para configurar la apariencia: colores, ejes… es cuestión de bucear en la documentación y experimentar.

Espero que el artículo os haya resultado útil, no olvidéis recomendar el artículo y hacernos vuestras aportaciones en los comentarios. ¡Nos vemos pronto!

Filed under: Básico Tagged: gráficos, matplotlib, numpy, python, vectorización

Python Hispano

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

python majibu: Permitir links en los fields en el admin con Django

python majibu: Deployment con django: gunicorn o uwsgi?

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

JavAguirre.net: Raequel, scraping en la web de la rae con app engine

Related Posts

python majibu: Django: Pyjamas vs pythonwebkit?

Monobot: [python] manejo de directorios y ficheros

python majibu: Subir ficheros en django

JavAguirre.net: Using Aspen

Related Posts

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

Introducción

Problema matemático

Matriz tridiagonal

Genbeta:dev: Cazadores de Mitos: Las propiedades privadas en Python

El origen del Mito

Ahora si que estoy perdido, ¿me lo explica?

Conclusión

Pybonacci: Sage: software matemático libre como alternativa

python majibu: Enlaces temporales con Django?

Genbeta:dev: Otro que cae en las garras de Github, Django

Pybonacci: Python es lento

Optimiza, que algo queda.

Conociendo el lenguaje: list comprehension

Optimización automágica: Psyco

NumPy y SciPy

Paralelizando: Numexpr

Magia arcana: blitz

Rindiéndonos al compilador

El futuro: PyPy.

Pybonacci: Cómo calcular límites, derivadas, series e integrales en Python con SymPy

Introducción

Límites

Derivadas

Series

Integrales

Notas

python majibu: Streaming de audio en tiempo real

python majibu: Descargar ficheros en Django

python majibu: ¿Es correcto agregar atributos a una clase de modelo en tiempo de ejecución?

codeplasticlesthack: FLISOL Celaya 2012: Plática “Python + WebKit”

Pybonacci: Regiones de estabilidad de métodos numéricos en Python

Introducción

Región de estabilidad absoluta

Algoritmo

Código y representación

Resultados

Referencias

joe di castro: Sincronizar Bitbucket y GitHub

Hg != Git

hg-git

Sincronizar el repositorio con Bitbucket y GitHub

python majibu: Campos no obligatorios en django admin

Pybonacci: Estadística en Python con SciPy (I)

Introducción

Distribuciones de variable continua

Representación gráfica

Definir distribuciones

Distribuciones de variable discreta

Representación gráfica

Definir distribuciones

JavAguirre.net: M2Crypto from pip in old GNU/Linux OS

Related Posts

python majibu: Agregar fields adicionales a autocompletar

Pybonacci: Ecuaciones no lineales: método de bisección y método de Newton en Python

Módulo ceros.py

Método de la bisección

Descripción y algoritmo

Método de bisección en Python

Método de Newton

Descripción y algoritmo

Método de Newton en Python

Referencias

python majibu: Problema Feed Rss Django

Pybonacci: Ejemplo de uso de Basemap y NetCDF4

Pybonacci: Dibujando líneas de nivel en Python con matplotlib

Introducción

Creación del mallado

Módulo `ceros.py`