El viaje del navegante

Método de estimación Probe

2012-01-13T11:53:00.000+01:00

Metodología Ágil

2011-12-28T19:24:00.000+01:00

Gestión de configuraciones de software

2011-12-28T19:22:00.000+01:00

Calidad del software

2011-12-28T19:19:00.000+01:00

vipera 1.0.0

2011-12-03T17:31:00.001+01:00

Hola. Acabo de subir vipera 1.0.0 en: http://code.google.com/p/vipera/.

vipera está bajo licencia GPL 3, por lo que se puede modificar, distribuir y hacer lo que se considere siempre bajo los términos de la General Public License, versión 3.

No he creado instaladores, puesto que no me ha dado tiempo, y como estoy en fase de pruebas y depuración de cosas, pues no me ha parecido conveniente.

Para hacer funcionar vipera únicamente hay que hacer:

python vipera.py

Si diera algún problema de fichero de configuración.... (perdón):

python vipera.py -r

Si encontráis alguna cosa rara, algún mal funcionamiento os agradecería eternamente que me lo comentaseis.

vipera es un proyecto, que ahora que está terminado, veo que puede mejorarse en muchas cosas, pero la idea era lo primero, así que a partir de dicha idea se puede ir a otros puertos, con otras tecnologías, como OpenGL en vez de OGL.

NOTA: Hay un vídeo demostrativo de su funcionamiento en:

https://www.facebook.com/photo.php?v=2040359947038

Un saludo.

wxPython: cómo controlar los PyDeadObject

2011-11-18T14:33:00.002+01:00

Hola. En este artículo vamos a ver una manera muy fácil de poder controlar los errores producidos en wxPython cuando se intenta acceder a widgets que han sido destruidos. Y vamos a verlo con el siguiente ejemplo:

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

import wx

class mi_frame(wx.Frame):
    def __init__(self, parent):
        wx.Frame.__init__(self, parent)
        self.SetTitle("Ejemplo de PyDeadObject")
        # 2 botones.
        self.boton1 = wx.Button(self, -1, u"Botón 1")
        self.boton2 = wx.Button(self, -1, u"Botón 2")
        sizer = wx.BoxSizer(wx.HORIZONTAL)
        sizer.Add(self.boton1, 0, wx.ALL, 1)
        sizer.Add(self.boton2, 0, wx.ALL, 1)
        self.SetSizer(sizer)
        # Binding.
        self.boton1.Bind(wx.EVT_BUTTON, self.OnBoton1)
        self.boton2.Bind(wx.EVT_BUTTON, self.OnBoton2)

    def OnBoton1(self, event):
        self.boton1.SetLabel("Hola Python")

    def OnBoton2(self, event):
        self.boton1.SetLabel("Hola wxPython")

app = wx.PySimpleApp()
f = mi_frame(None)
f.Show()
app.MainLoop()

Como se puede observar este script es una ventana que contiene dos botones. Al hacer click en cada uno de los botones se va cambiando el Label del primer botón. Esto es:

Hacemos click en el botón de la izquierda:

Hacemos click en el botón de la derecha:

Ahora vamos a hacer una pequeña modificación en el método OnBoton2: vamos a incluir una instrucción para que cuando se haga click en el botón 2 se elimine el botón 1:

    def OnBoton2(self, event):
        self.boton1.SetLabel("Hola wxPython")
        self.boton1.Destroy()

Si volvemos a hacer la misma operativa de arriba, cuando hagamos click en el boton 2 al intentar hacer el SetLabel nos dará un error PyDeadObject, ya que estamos intentando acceder a un widget que ya ha sido eliminado. Es decir:

Hacemos un primer click en el botón derecho:

Y al hacer un segundo click sobre el botón derecho nos da el siguiente error:

wx._core.PyDeadObjectError: The C++ part of the Button object has been deleted, attribute access no longer allowed.
File "c:\Users\Angel Luis\Desktop\ej_pydeadobject.py", line 30, in
app.MainLoop()
File "c:\Python26\Lib\site-packages\wx-2.8-msw-unicode\wx\_core.py", line 8010, in MainLoop
wx.PyApp.MainLoop(self)
File "c:\Python26\Lib\site-packages\wx-2.8-msw-unicode\wx\_core.py", line 7306, in MainLoop
return _core_.PyApp_MainLoop(*args, **kwargs)
File "c:\Users\Angel Luis\Desktop\ej_pydeadobject.py", line 24, in OnBoton2
self.boton1.SetLabel("Hola wxPython")
File "c:\Python26\Lib\site-packages\wx-2.8-msw-unicode\wx\_core.py", line 14610, in __getattr__
raise PyDeadObjectError(self.attrStr % self._name)

Que corresponde con la línea wx _core.py:

¿Solución?

En ciertas áreas de nuestro código wxPython que sepamos que son susceptibles de ser eliminadas y después con posibilidad de ser referenciadas de nuevo (por un proceso, por un hilo o por cualquier otra cosa), podemos evaluar primero el widget para ver si realmente existe y luego realizar las operaciones pertinentes. En nuestro ejemplo vamos a cambiar de nuevo el método OnBoton2:

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

import wx

class mi_frame(wx.Frame):
    def __init__(self, parent):
        wx.Frame.__init__(self, parent)
        self.SetTitle("Ejemplo de PyDeadObject")
        # 2 botones.
        self.boton1 = wx.Button(self, -1, u"Botón 1")
        self.boton2 = wx.Button(self, -1, u"Botón 2")
        sizer = wx.BoxSizer(wx.HORIZONTAL)
        sizer.Add(self.boton1, 0, wx.ALL, 1)
        sizer.Add(self.boton2, 0, wx.ALL, 1)
        self.SetSizer(sizer)
        # Binding.
        self.boton1.Bind(wx.EVT_BUTTON, self.OnBoton1)
        self.boton2.Bind(wx.EVT_BUTTON, self.OnBoton2)

    def OnBoton1(self, event):
        self.boton1.SetLabel("Hola Python")

    def OnBoton2(self, event):
       if not self.boton1:
            wx.MessageBox(u"El botón se destruyó")

       else:
            self.boton1.SetLabel("Hola wxPython")
            self.boton1.Destroy()

app = wx.PySimpleApp()
f = mi_frame(None)
f.Show()
app.MainLoop()

¿Por qué?

Pues porque cuando un widget se elimina pasa a ser un _wxPyDeadObject el cual gana un método __nonzero__ que siempre devuelve False.

Si volvemos a ejecutar nuestro nuevo script y hacemos dos veces click en el botón de la derecha tendremos el siguiente resultado:

Espero que este artículo os sirva para escribir aplicaciones wxPython más robustas.

Un saludo.

Redes sociales: ¿Dónde debes enviar tu estado?

2011-11-04T09:57:00.001+01:00

Chuleta para recordar donde hay que enviar nuestro estado...

...y es que es mejor prevenir que curar...

vipera tester 1.0.0

2011-10-27T12:09:00.002+02:00

Hola. Estas son las grabaciones de vipera, un diseñador de aplicaciones para Python. Este programa será mi proyecto fin de carrera (o de grado como se llama ahora). En este primer vídeo hago una simulación muy sencilla de creación de clases de manera gráfica, y como se genera el código Python correspondiente.

https://www.facebook.com/video/video.php?v=1889051804429

En los siguientes links se muestran como hacer prototipos de funciones:

https://www.facebook.com/video/video.php?v=1889100005634

https://www.facebook.com/video/video.php?v=1889147406819

Estos vídeos los he creado con recordMyDesktop. Perdón por no tener sonido el primero de ellos, estaba en fase de pruebas...

Por último decir que vipera puede crear módulos con clases, funciones, registros (emulados con funciones o clases), constantes y código de ejecución para pruebas de módulo.

Además incluye un diseñador de packages visual estilo árbol, un generador de documentación de proyecto y un sistema de generación de licencias. Además tiene un módulo de ingeniería inversa, en donde a partir de código Python se muestran las clases y sus relaciones.

Se puede imprimir el código generado, así como los diagramas diseñados. En próximos vídeos más.

Espero publicar este programa bajo las condiciones de GPL 3, a la espera que me de permiso la Universidad.

Un saludo.

Dennis Ritchie

2011-10-16T15:38:00.001+02:00

Dennis Ritchie murió el pasado Miércoles 12 de Octubre.

http://es.wikipedia.org/wiki/Dennis_Ritchie

Una de "sus pocas contribuciones" fue (junto con Ken Thompson) la creación del lenguaje de programación C, base de la mayoría de las tecnologías de las que ahora disfrutamos. Será por ello que no sale en televisión.

Descanse en paz.

Taller tutorial de wxFormBuilder, en español

2011-06-13T13:33:00.000+02:00

Hola. En este post os presento un material sobre wxFormBuilder, el diseñador de interfaces gráficas para wxPython, que se utilizará en el taller Caldum de esta tarde 13 de Junio.

El material lo podéis bajar, como siempre, del repositorio de este blog:

https://sites.google.com/site/elviajedelnavegante/documentacion

Es un zip, Taller_wxFB.zip, que contiene un PDF con la explicación/teoría/presentación del taller, así como carpetas con proyectos wxFB hechos. De la misma forma se incluyen ficheros Python que utilizan el código generado por wxFB para crear las interfaces.

Espero os sirva este material para vuestros intereses.

Un cordial saludo.

Taller Caldum: wxFormBuilder (wxPython)

2011-06-04T14:25:00.000+02:00

Hola. Escribo este post para comunicar que se ha retrasado el taller CALDUM de wxFormBuilder, y se impartirá el día 13 de Junio (Lunes), de 16:00 a 20:00 horas.

El taller se podrá seguir online por videoconferencia. Más información en la página de CALDUM.

Enlace

Taller de wxFormbuilder en la Universidad de Murcia

2011-05-22T12:39:00.001+02:00

Hola. El día ~~10 de Junio~~ 13 de Junio (Lunes), de 16:00 a 20:00 impartiré un taller CALDUM sobre wxFormBuilder en la Universidad de Murcia,

Es necesario saber Python así como tener clara la programación orientada a objetos, ya que veremos, no solamente el diseño de pantallas en wxFormBuilder, también el código que genera, para modificarlo mediante herencia, en lo que se refiere a manejadores de eventos.

En este taller se verá fundamentalmente:

0) Generación de proyectos.
1) Contenedores de alto nivel: Frames, Paneles
2) Sistemas de menús.
3) Componentes:
3.1) AUI_Notebook
3.2) Controles de texto y etiquetas.
3.3) Etc...
4) Posicionamiento de widgets mediante Sizers (BoxSizer y FlexGridSizer).
5) Herencia y override de métodos del código generado.
6) Aplicaciones FrontEnd en wxPython.
7) Bibliografía.

De lo que se trata en este taller es que el asistente tenga una idea clara de las posibilidades de wxFormBuilder como diseñador de interfaces gráficas basado en wxPython. El taller es eminentemente práctico, en donde se abarcarán la mayoría de conceptos de wxPython, a saber, widgets principales, binding, manejadores de eventos y herencia y override de métodos.

Saludos.

wxPython: Obtener datos de las hojas de un AUI_Notebook

2011-05-19T23:03:00.001+02:00

Hola. En este post vamos a ver el componente de wxPython AUI Notebook, y en especial su instanciación, creación de hojas y forma de recorrerlas para obtener la información que pudiera haber sido introducida por el usuario.

Hay un ejemplo muy completo en la Demo de wxPython. Aquí se verá lo mismo, más simplificado y con el plus del recorrido de las hojas del AUI Notebook.

El código fuente de esta aplicación se puede encontrar en el repositorio de este blog, en:

https://sites.google.com/site/elviajedelnavegante/

Para poder entender bien como funciona un AUI_Notebook es necesario realizar un ejemplo, ya que es la mejor manera posible. De lo que se trata es de crear un módulo (fichero) que contendrá 2 clases. Una de ellas será el diseño de una hoja (que hereda de wx.Panel), y la segunda clase será un frame que heredará de wx.Frame. Cada hoja del AUI_Notebook será una instanciación de la clase hoja.

Comenzamos...

Lo primero de todo es importar los módulos necesarios:

import wx
import wx.aui

A continuación diseñamos la clase que representará cada hoja de nuestro AUI_Notebook:

class hoja_notebook(wx.Panel):
    def __init__(self, parent, nombre_hoja):
        # Constructor.
        wx.Panel.__init__(self, parent)
        # Sizer.
        sizer = wx.BoxSizer(wx.VERTICAL)
        # Etiqueta.
        self.c0 = wx.StaticText(self, -1, nombre_hoja)
        # Cajas de texto.
        self.c1 = wx.TextCtrl(self, -1)
        self.c2 = wx.TextCtrl(self, -1)
        # Posicionamos las cajas de texto y la etiqueta en el sizer.
        sizer.Add(self.c0, 0, wx.EXPAND|wx.ALL,5)
        sizer.Add(self.c1, 0, wx.EXPAND|wx.ALL,5)
        sizer.Add(self.c2, 0, wx.EXPAND|wx.ALL,5)
        # Añadimos el sizer al frame.
        self.SetSizer(sizer)

Esta clase hereda de un wx.Panel, por lo que es un panel. Vemos que dentro tiene un sizer vertical que posiciona una etiqueta y dos cajas de texto. En la instanciación de la clase pasamos el texto que se presentará en la etiqueta.

Bien, ahora crearemos el diseño de la clase frame que contendrá el AUI_Notebook y que contendrá hojas a través de la instanciación de la clase anterior.

class frame_principal(wx.Frame):
    def __init__(self, parent):
        # Constructor.
        wx.Frame.__init__(self, parent, title = "Trabajando con el AUI NoteBook")
        # Sizer.
        sizer = wx.BoxSizer(wx.VERTICAL)
        # Botón para obtener datos.
        self.boton = wx.Button(self, -1, "Devolver datos")
        # Incluimos el botón en el sizer.
        sizer.Add(self.boton, 0, wx.EXPAND|wx.ALL, 5)
        # Panel de NoteBook.
        self.panel = wx.aui.AuiNotebook(self, -1)
        # Hojas.
        hoja1 = hoja_notebook(self.panel, "Primera hoja")
        hoja2 = hoja_notebook(self.panel, "Segunda hoja")
        hoja3 = hoja_notebook(self.panel, "Tercera hoja")
        # Añadimos las hojas al NoteBook.
        self.panel.AddPage(hoja1, "Hoja 0")
        self.panel.AddPage(hoja2, "Hoja 1")
        self.panel.AddPage(hoja3, "Hoja 2")
        # Incluimos el panel en el sizer.
        sizer.Add(self.panel, 1, wx.EXPAND|wx.ALL, 5)
        # Y añadimos el sizer al frame.
        self.SetSizer(sizer)
        # Binding.
        self.boton.Bind(wx.EVT_BUTTON, self.OnClickBoton)

    # Manejador de eventos.
    def OnClickBoton(self, event):
        # Hoja actual.
        hoja_actual = self.panel.GetSelection()
        # Número total de hojas.
        total_hojas = self.panel.GetPageCount()
        # Algo de información antes de buscar datos.
        cadena = "Este AUI NoteBook tiene %s hojas. Estás en la %s" % \
        (total_hojas,hoja_actual)
        wx.MessageBox(cadena,"Info",wx.OK)
        # Recorremos las hojas, obteniendo la información requerida.
        texto = ""
        for i in range(0,total_hojas):
            # Texto en la etiqueta de la hoja.
            texto_etiqueta = self.panel.GetPageText(i)
            # Datos de las cajas de texto de la hoja i.
            dato1 = self.panel.GetPage(i).c1.GetValue()
            dato2 = self.panel.GetPage(i).c2.GetValue()
            # Info.
            texto += u'''
            La hoja número %s, con etiqueta "%s"
            contiene los datos:
            Caja de texto: %s
            Caja de texto: %s
            ''' % (i, texto_etiqueta, dato1, dato2)
        # Mostramos los datos por pantalla.
        wx.MessageBox(texto, "Datos", wx.OK)

Puff!. Vaya, esta clase es algo más larga. Pero no hay problema, la comentamos poco a poco, que es muy fácil de entender. Se puede decir que esta clase implementa la creación de hojas por una parte y el recorrido de dichas hojas a partir de la generación de un evento por hacer click en un botón. Bien, veámoslo por partes.

Esta clase hereda de wx.Frame, por lo que es un frame (una ventana típica de Windows). En dicho frame se ha utilizado un sizer vertical para posicionar un botón (wx.Button) y un componente AUI_Notebook. Si vemos el código, justo después de instanciar el AUI_Notebook, instanciamos tres hojas del modo:

hojai = hoja_notebook(self.panel, "XXX hoja")

Esto es, hemos utilizado la clase hoja_notebook para crear 3 hojas. Darse cuenta que el padre de las hojas es el propio AUI_Notebook. Mediante el método AddPage se añaden las hojas. Además, se ha creado un binding para cuando se genere el evento de hacer click en el botón.

Dicho evento (wx.EVT_BUTTON) lanza el manejador de eventos OnClickBoton, que se encargará de realizar el recorrido entre todas las hojas, así como mostrar información sobre el posicionamiento de las mismas. Mediante los métodos GetSelection() y GetPageText(i) se obtiene la hoja actual, así como el texto de la etiqueta.

Lo que se hace en realidad es recorrer todas las hojas y buscar la información entre los objetos de cajas de texto, mediante:

self.panel.GetPage(i).c1.GetValue()

Como el lector puede observar con GetPage se obtiene el objeto hoja_notebook. Únicamente hay que acceder a sus atributos (c1, c2) y con el método GetValue() (de wx.TextCtrl) se obtiene el texto que recoge.

El código para hacer funcionar este programa podría ser tal que así:

app = wx.PySimpleApp()
frame = frame_principal(None)
frame.Show()
app.MainLoop()

Veamos capturas del ejemplo para ver que efectivamente funciona...

Ejecutamos.

Incluimos datos.

Al hacer click en el botón "Devolver datos", teniendo en cuenta que estamos en la última hoja, tenemos...

CONCLUSIONES

En este artículo hemos visto de una manera muy sencilla el componente AUI_Notebook, que podemos ver en más profundidad en la Demo de wxPython. Se ha creado una aplicación muy sencilla, que se compone de una clase de tipo wx.Panel que define una hoja y una clase wx.Frame que incluye un componente AUI_Notebook. Las hojas del AUI_Notebook son instanciaciones de la clase hoja que hemos creado. Además se han visto algunos métodos para acceder a las hojas, así como la manera de obtener los datos que un posible usuario hubiera incluido en las hojas.

Saludos.

Lorca muy tocada...

2011-05-12T17:45:00.000+02:00

Hola. Como el lector debe de saber ya soy de Lorca. Ayer sufrimos 2 terremotos que han dejado la ciudad con un 80% de daños en infraestructuras. Mi casa no ha sido una excepción, por lo que no se cuando volveré a escribir. Lo primero es lo primero.

Espero que sea pronto.

Un cordial saludo.

Charla sobre Python y wxPython en Almería (IES Al-Andalus)

2011-04-14T00:04:00.000+02:00

Hola. El Jueves 14 de Abril daré una charla de una hora (prometo no sobrepasarme en el tiempo) sobre Python y wxPython, en el IES Al-Ándalus, en Almería ciudad, en las Jornadas SLCENT 7.0.

El programa está aquí.

La hora es a las 20:30 de la tarde. Lo que pretendo es dar una visión general de Python, sin entrar en ningún tipo de matiz, y ver por encima la plataforma de desarrollo de interfaces gráficas wxPython, con ejemplos.

Será una charla de ver por donde empezar para llegar a buen puerto.

El material que expondré lo dejo como siempre en el repositorio de este blog. Es muy parecido a la charla de la Lan Party 2010, pero he quitado muchas cosas (código) y añadido otras (capturas de pantalla de wxPython), con lo que creo la presentación gana en legibilidad y soltura.

Saludos.

Algoritmos de clasificación y problema de cambio de monedas, en C

2011-03-29T10:26:00.000+02:00

Hola. Revisando el disco duro de hace algunos años me he encontrado con unas prácticas de la carrera (del 2003-2004), el análisis y diseño de algoritmos de clasificación y la resolución del ejercicio (mediante ciertas técnicas) de cambio de monedas. Bien , pues ya es hora de compartir este trabajo, por si alguien lo necesita. Estos trabajos están hechos en C, en plataforma Linux.

Se pueden descargar del repositorio de este blog, en:

https://sites.google.com/site/elviajedelnavegante/documentacion

Los ficheros son ALGORITMOS DE ORDENACION.zip y PROBLEMA DEL CAMBIO DE MONEDAS.zip.

Algoritmos de ordenación

Este trabajo recoge el análisis, diseño e implementación, en C, de los algoritmos de clasificación más importantes, a saber:

- Algoritmo de selección directa.
- Algoritmo de burbuja.
- Algoritmo de inserción directa.
- Algoritmo de burbuja mejorado.
- Algoritmo de QuickSort.
- Algoritmo de MergeSort.
- Algoritmo de QuickSort no recursivo.
- Algoritmo de MergeSort no recursivo.
- Algoritmo de QuickSort con elección de pivote.

Aquí se incluyen estudios de coste promedio, estudio teórico del tiempo de ejecución, estudios experimentales de todos los algoritmos de clasificación, etc.

Cambio de monedas

Resolución del problema de cambio de monedas por backtracking (árbol de soluciones, tiempos de ejecución, reducción de número de nodos e implementación) y por programación dinámica (ecuación de recurrencia y solución óptima, estudio teórico del tiempo de ejecución e implementación).

Por último comentar que los ficheros .zip contienen tanto la documentación como los fuentes, incluidos los Makefile.

Saludos.

Script para pasar código Python a HTML

2011-03-22T21:58:00.001+01:00

Hola. En este artículo vamos a crear un script para pasar código fuente Python (.py) a formato HTML (y de esta manera mostrar dicho código en una página web). Además vamos a darle coloración al código Python. Debe de haber formas más simples, sin duda, de resolver este tipo de problemáticas, ... a mí se me ha ocurrido esta.

Como siempre, el fichero .py que contiene el script se puede obtener del repositorio de este blog, en:

https://sites.google.com/site/elviajedelnavegante/

El fichero se llama mi_tokenize.zip, el cual contiene el script mi_tokenize.py.

En este problema no se ha utilizado programación orientada a objetos, esto es, no se implementa ninguna clase. Todo se resuelve con programación imperativa (mediante funciones).

Al grano...

El funcionamiento es sencillo, en términos generales. De lo que se trata es que, a partir de un fichero de código fuente Python, se genera otro (con extensión html) con código HTML, que representa el código Python formateado (con indentación y coloreado de código).

Un ejemplo sería el siguiente:

La captura de arriba es del Stani's Python Editor. Abajo nos encontramos el mismo código, formateado en HTML y coloreado, en Firefox.

¿Cómo enfocar el problema?

Pasar código Python a html es casi trivial. Únicamente hay que abrir un fichero .py, leerlo, crear otro fichero con una cabecera html, incluir dicho código Python y cerrar el html. Listo, ya tenemos el código en una página web.

El verdadero problema es el coloreado del código, ya que se tiene que identificar los diferentes bloques de código a los que se quieren dar color. En nuestro caso, daremos color a los comentarios, a las cadenas y a las palabras clave de la versión que utilicemos de Python.

¿Cómo hacerlo? Mediante los módulos cStringIO y tokenize, que se pueden encontrar en cualquier distribución de Python.

cStringIO sirve para crear, a partir de una cadena, un buffer de cadena. tokenize es el módulo que nos permite analizar código Python e identificar componentes del mismo (comentarios, cadenas, etc) a partir de un buffer de cadena. Mejor lo vemos con los pasos que debe de dar nuestro script:

1) Cargamos en memoria un fichero .py con el método read() de open.

2) Mediante cStringIO creamos un fichero en memoria ó buffer de cadena, el cual es necesario para utilizar el tokenize. En realidad esto sirve para iterar, línea a línea sobre una cadena con varias líneas (con saltos de línea). Por ejemplo:

import cStringIO

cadena = '''

Este es un ejemplo

de la potencia del

módulo cStringIO

'''

texto = cStringIO.StringIO(cadena)

for i in texto: print i

Devuelve:

Este es un ejemplo

de la potencia del

módulo cStringIO

3) Mediante tokenize, y a partir del buffer de cadena creado en el paso anterior, podemos obtener los token (elementos de código), iterando sobre ellos, e identificando los elementos de código Python.

En la documentación de Python tenéis una explicación muy buena (en inglés) de estos dos módulos:

http://docs.python.org/library/stringio.html#module-cStringIO

http://docs.python.org/library/tokenize.html

Puff!!! Una explicación algo extraña. Veámoslo con un ejemplo. Imaginemos que hemos cargado mediante el método read() de open un fichero con código Python con el siguiente contenido:

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

# Código Python.

for i in range(0,5):

print "Número ", i

Mediante los pasos anteriores vamos a identificar los elementos del código, a saber, comentarios, palabras clave y cadenas. El código que haría esta operación podría ser el siguiente:

# Creamos buffer de cadena.

texto = cStringIO.StringIO(cadena)

# Creamos tokens.

tokens = tokenize.generate_tokens(texto.readline)

for a,b,c,d,_ in tokens:

if a == tokenize.STRING:

print "Cadena: %s en posición [%s,%s]" %( b,c,d)

if a == tokenize.NAME and b in keyword.kwlist:

print "Palabra clave: %s en posición [%s,%s]" % (b,c,d)

if a == tokenize.COMMENT:

print "Comentario: %s en posición [%s,%s]" % (b,c,d)

Dando como resultado:

Comentario: # -*- coding: utf-8 -*- en posición [(1, 0),(1, 23)]

Comentario: # Código Python. en posición [(2, 0),(2, 17)]

Palabra clave: for en posición [(3, 0),(3, 3)]

Palabra clave: in en posición [(3, 6),(3, 8)]

Palabra clave: print en posición [(4, 2),(4, 7)]

Cadena: "Número " en posición [(4, 8),(4, 18)]

Por tanto, mediante el módulo tokenize podemos identificar todos los elementos de los que se compone un código Python. La idea fundamental es esta. Aparte, mediante operaciones de transformación entre listas y cadenas, y demás operaciones se llega al resultado esperado.

¿Y cómo se colorea el texto? Pues mediante código HTML del tipo:

Así el otro hándicap es que a partir de las coordenadas de los elementos de código a colorear hay que insertar código HTML.

El script mi_tokenize.py

Tal como antes se ha comentado, el lector puede obtener el código de este script en el repositorio de El viaje del navegante. Aquí se presentan capturas de pantalla del código, debido principalmente a que se utiliza sintaxis html en el código Python, y no mezclar cosas.

Módulos que se cargan y estructuras que se definen:

Importamos los módulos necesarios y creamos un diccionario para colorear los elementos de código Python.

El código principal que ejecuta el script:

Podemos observar que el script pide dos argumentos para funcionar, el primero el fichero Python y el segundo el nombre del fichero html que se generará (se le da extensión .html si esta se omite) . A continuación llamamos a la función cargar_fichero que devuelve, mediante read() una cadena con el contenido del fichero. Finalmente, mediante la función tokenizar_codigo se crea una cadena con sintaxis html y Python, que se guarda en el fichero identificado por f_html_nombre.

Función para cargar el fichero .py:

Darse cuenta que reemplazamos ciertos caracteres especiales en html.

La función que analiza el código creando una cadena con html y código Python es la siguiente:

Esta función podría haberse escrito de otra forma, para ahorrar código, pero me ha parecido más pedagógico realizarlo de esta forma. Como se puede observar se utilizan cStringIO y tokenize. Devuelve una cadena con código html. Esta última función utiliza dos funciones auxiliares, a saber:

La función para insertar los elementos de html:

Y la función para incluir la cabecera y pie del documento de la página web:

Pero como no es lo mismo andar el camino que conocer el camino, es mejor probar el script. El lector puede pensar que sería mucho mejor utilizar CSS para estos menesteres, y en cierta manera, es verdad, pero no es objetivo de este post hacer un tratado sobre web y CSS. Lo verdaderamente importante es el parseo de código Python y el tratamiento de cadenas.

Se insta al lector a mejorar el código.

Saludos.

Mis antiguos juegos DOS en mi nuevo Linux Ubuntu

2011-03-20T12:12:00.000+01:00

Hola. Este no es un post sobre Python, pero tenía que escribirlo, ya que llevo emocionado toda la mañana jugando a mis antiguos juegos de MS-DOS.

Mi primer PC fue allá por 1988 ú 89, ya no recuerdo. Un 8086 de 640 Kb, diskettera de 5 un cuarto y otra de 3 y medio. Monitor CGA monocromo (luego cambiaría a un TARGA VGA, todo un lujo). Por supuesto, un sistema operativo MS-DOS 3.22, que era lo máximo.

Hacía mis pinitos con Logo (AV, GD, GI, ...) y luego GW-BASIC (return, goto's, ...). Ahí es donde empezó mi curiosidad por la profesión, que ya viene de lejos.

Pero lo mejor, de verdad, lo mejor, eran los videojuegos. Unas auténticas joyas de programación, con los recursos hardware tan limitados que había por aquel entonces (comparado con ahora, claro) .

Yo no soy ningún entusiasta de los juegos de hoy día (de hecho, no juego), pero sí de los de mi época ochentera y noventera (el último el PC-FUTBOL 6.0, ¡qué maravilla!).

En mi nuevo Linux he descubierto que también está el DOSBox (que ya utilicé alguna vez en Windows), el cual es un emulador de entornos MS-DOS. Lo he instalado desde el Centro de software de Ubuntu. Hay muchas posibles configuraciones de esta aplicación. Aquí hay algunas guías:

http://www.arcades3d.com/textos/tutdosbox_uso.var

http://manualinux.my-place.us/dosbox.html

http://www.dosbox.com/DOSBoxManual.html

Lo único que he configurado para hacer funcionar DOSBox ha sido modificar la etiqueta [autoexec] del fichero de configuración dosbox-0.73.conf, que se encuentra en el directorio ./dosbox de la carpeta de usuario.

Como se puede observar he incluido la configuración del teclado al español:

keyb sp 437

y he montado la unidad C: en el directorio donde tengo todos mis juegos DOS, mediante:

mount c /home/angel/juegos/dos

Arrancas el emulador DOSBox...

Increíble la sensación de jugar a juegos DOS desde un Linux!!!! Y lo mejor de todo, que funcionan a la velocidad de tu antiguo PC.

Xenon 2

Un clásico de arcades. Y menuda música que tiene (el altavoz echaba chispas)!!!

Digger

¿Quién no ha jugado a este juego? ¿Y la música del Pop-corn? Bestial!!!

Y otros clásicos como Arkanoid, Volfied, Pacman, Striker, Rampage, Tetris (el auténtico de 1986), Sol Negro, .... En total tengo unos 118 juegos de los ahora denominados Abandonware.

Y no sé porqué, pero estos juegos, para mí, son mucho más adictivos e impresionantes que los de hoy día, ¡Y TODO EN MI LINUX!

Saludos.

Me cambio a Linux

2011-03-15T10:41:00.002+01:00

Hola. Después de algunos años en sistemas Windows XP (desde 2003, en donde dejé abandonada a su suerte a mi fabulosa RedHat 6), me vuelvo a Linux, a Linux Ubuntu definitivamente, con Python 2.6.6 y como IDE de desarrollo el Stani's Python Editor (SPE).

A partir de este post, todo lo que escriba se realizará en esta plataforma. La razón para el cambio es el intento de trabajar con Windows 7, en mi PC. La consecuencia: Un SO tiene que ayudar al desarrollador, y en mi caso, con mi máquina, eso es muy complicado (¡tarda más en ponerse en marcha que ejecutar NetBeans en un 486!).

No intento desprestigiar la familia de SO's Windows 7 ni nada parecido. Únicamente, que no es bueno para mí. Y como mi Linux Ubuntu 10.04 no me da problemas de rendimiento, pues me quedo aquí.

Por último decir que si por alguna excepción escribiera algo para Windows, sería con Windows XP SP3, y con el IDE PyScripter, uno de los entornos de desarrollo más potentes para Python en plataformas de Microsoft.

Saludos.

Pasar parámetros entre frames en wxPython

2011-03-01T21:48:00.002+01:00

Hola. En este artículo vamos a ver una forma muy sencilla de pasar parámetros entre 2 frames en wxPython, uno padre de otro. El paso de mensajes ó parámetros entre objetos se puede hacer de varias formas, siendo la que vamos a ver una de las más fáciles.

Aunque lo vamos a ver con un ejemplo (esto es, código), no está de más explicar el funcionamiento. La aplicación es un fichero .py donde tenemos una aplicación wxPython, que instancia una clase (frame_principal). Dicha clase, al hacer click en un botón instancia una segunda clase (frame_secundario). Cuando se introducen datos en el frame_secundario (objeto) y se hace click en un botón, se devuelve dicha información al frame_principal, que lo muestra. Es decir, se introducen datos en un frame y los devuelve al frame maestro desde que fue instanciado (llamado).

¿Cómo se ha hecho? La cuestión es que cuando se instancia el frame_secundario en el frame_principal, se le pasa como parámetro una referencia de él mismo. En frame_secundario se crea un atributo (self.padre), que contiene la referencia al frame padre en donde fue creado.

Este ejemplo se ha realizado en Linux Ubuntu y el editor joe. El código es el siguiente:

# -*- coding: utf-8 -*-
# El viaje del navegante.
# Ejemplo de paso de parámetros entre 2 frames en wxPython.

# Importamos las wx
import wx

# Creamos una clase frame que pide un dato.
class frame_secundario(wx.Frame):
def __init__(self, parent):
    # Este es el constructor. Darse cuenta que se pasa como
    # parámetro parent, esto es, la referencia del frame que instancia
    # a esta clase. La guardamos.
    self.padre = parent
    # Llamamos al constructor de la clase de la que hereda.
    wx.Frame.__init__(self, None, -1, title = "Introduce un valor")
    # Creamos un sizer horizontal.
    sizer = wx.BoxSizer( wx.HORIZONTAL )
    # Creamos una caja de texto.
    self.caja_texto = wx.TextCtrl(self, -1)
    # Creamos un botón.
    self.boton = wx.Button(self, -1,"ACEPTAR")
    # Añadimos al sizer la caja y el botón.
    sizer.Add(self.caja_texto, 0, wx.ALL, 5)
    sizer.Add(self.boton, 0, wx.ALL, 5)
    # Incluimos el sizer en el frame.
    self.SetSizer(sizer)
    # Creamos el binding. Cuando se haga click en el
    # botón se lanzará el manejador de eventos correspondiente.
    self.boton.Bind(wx.EVT_BUTTON, self.OnClickBoton)

# Manejador de eventos.
def OnClickBoton(self, event):
    # Obtenemos datos de la caja de texto.
    dato = self.caja_texto.GetValue()
    # Podríamos escribir directamente en el objeto
    # que se desease.
    self.padre.caja_texto.SetValue(dato)
    # Nos vamos.
    self.Destroy()

# Creamos la clase de la ventana principal.
class frame_principal(wx.Frame):
def __init__(self):
    # Constructor. Llamamos al constructor de la clase wx.Frame.
    wx.Frame.__init__(self, None, -1, title = 'Ventana Principal')
    # Creamos un sizer horizontal.
    sizer = wx.BoxSizer( wx.HORIZONTAL )
    # Creamos un botón.
    self.boton = wx.Button(self, -1, "Crear Frame Secundario")
    # Creamos una caja de texto de solo lectura.
    self.caja_texto = wx.TextCtrl(self, -1, style = wx.TE_READONLY)
    # Añadimos al sizer la caja y el botón.
    sizer.Add(self.boton, 0, wx.ALL, 5)
    sizer.Add(self.caja_texto, 0, wx.ALL, 5)
    # Asociamos el sizer al frame.
    self.SetSizer(sizer)
    # Creamos el binding. Cuando se haga click en el
    # botón se lanzará el manejador de eventos correspondiente.
    self.boton.Bind(wx.EVT_BUTTON, self.OnClickBoton)

# Manejador de eventos.
def OnClickBoton(self, event):
    # Si se hace click se crea una instancia del frame_secundario.
    frame = frame_secundario(self)
    # Mostramos.
    frame.Show()

# Creamos una aplicación wxPython.
aplicacion = wx.PySimpleApp()
# Instanciamos el frame principal.
frame = frame_principal()
# Y por supuesto, no olvidar mostrarlo.
frame.Show()
# Esperamos a capturar eventos.
aplicacion.MainLoop()


El código está muy comentado, pero volvemos a analizarlo. Se crea una aplicación wxPython, que instancia la clase frame_principal.

Si hacemos click en el botón "Crear Frame Secundario" se instancia la clase frame_secundario, creando un segundo frame:

Incluimos un texto en la caja de texto, PYTHON!!!, y hacemos click en el botón Aceptar.

Tal como se aprecia en el código, se envía el dato al frame padre y se destruye la instancia del frame_secundario.Y el resultado es:

En el código se ha resaltado en verde el paso de la referencia del frame padre.

Saludos.

Manual de introducción a Python, en español

2011-02-25T12:19:00.000+01:00

Hola. Con motivo del taller sobre Python en la Universidad de Murcia que se impartirá hoy, he creado un manual de introducción a Python. No tiene ningún tipo de licencia, así que se puede copiar y modificar libremente. No es necesario mencionarme si lo modificáis.

El documento se encuentra en:

https://sites.google.com/site/elviajedelnavegante/documentacion

Hay muchos manuales de referencia, y en español los hay muy buenos (aunque pocos). Este manual no es tan bueno como aquellos, pero deja la puerta abierta para que el lector saboree las capacidades básicas de Python.

Se han incluido 3 ejemplos (loterías, agenda, contar) en el documento, que se pueden descargar de:

https://sites.google.com/site/elviajedelnavegante/codigo

Al ser una introducción dejo muchas cosas en el camino, así que espero podáis entenderlo.

Saludos cordiales.

Curso de introducción a Python en la Universidad de Murcia

2011-02-14T11:42:00.002+01:00

Hola. Os comunico que el día 25 de Febrero realizaremos un curso de introducción a Python, en la Universidad de Murcia. Toda la información la tenéis en el siguiente enlace:

http://um.sym.posium.com/event_detail/434/detail/taller-caldum:-introduccion-al-lenguaje-de-programacion-python.html

La charla durará unas 3 horas, y es una introducción al lenguaje, para empezar en el estupendo mundo de desarrollo de software. La impartirá Antonio Mario Molina Saorín y un servidor. Aquí os presento un descriptor de lo que queremos ver:

1) Lenguajes de programación.
1.1) Tipos.
1.2) Python.
1.2.1) Historia.
1.2.2) Características principales.
2) Herramientas disponibles en Python
2.1) Editores, GUI's, IDE's.
2.2) Frameworks.
2.3) Módulos.
4) Introducción al lenguaje.
4.1) Intérprete de Python.
4.2) Hola mundo: print y raw_input.
4.3) Tipos de datos: números, booleanos, listas, tuplas, t.hashing, ficheros.
4.4) Estructuras de control de flujo (if, for, while).
4.5) Ficheros .py, pyc, pyw y pyo.
5) Scripts en Python.
6) Módulos más utilizados (os, datetime, sys) y namespaces en Python.
7) POO en Python.
7.1) Clases y objetos.
7.2) Herencia, polimorfismo, encapsulación, abstracción.
8) cPickle: persistencia de objetos.
9) Recursos en Internet (sheets, cards).
10) Creación de una agenda personal, en Python.
11) Aplicaciones gráficas: wxPython/Tkinter.
12) Propuestas para nuevos talleres Python.
13) Preguntas.

En unas 3 horas te haces con el lenguaje básico, si te lo comentan mejor que si lo haces solo. Si no sabéis nada de Python y sí de programación, os sorprenderá este lenguaje, por lo sumamente sencillo de aprender y la sintaxis tan clara que tiene. Una vez que lo pruebas, de verdad que se hace muy difícil desengancharse. Se pueden hacer cosas muy rápidas y sencillas, ya que Python es un lenguaje de muy alto nivel (gran nivel de abstracción).

Aquíi tenéis el lugar en donde se impartirá:

link

Saludos.

Persistencia de imágenes con Python: SQLServer y cPickle

2011-01-27T21:00:00.000+01:00

Hola. En este artículo vamos a ver cómo guardar y recuperar imágenes de una base de datos Microsoft SQLServer 2005 Express Edition, con Python, así como guardar y recuperar también, imágenes, en un objeto que se serializa, guardando dicha información en disco, mediante cPickle.

Antes de nada comentar que en este blog se han tratado varios tipos de SGBD, tales como MySQL, Firebird, ó SQLServer 2008. El elegir SQLServer 2005 Express Edition es simplemente para probar que Python funciona, mediante pyodbc, con la mayoría de los sistemas gestores de bases de datos actuales. Y para ver si funciona lo mejor es probarlo uno mismo, ya que no es lo mismo conocer el camino que andar el camino.

NOTA: Este post lo he escrito en la plataforma Microsoft Windows XP SP3, con Python 2.6.6.

Imágenes en SQLServer 2005 con Python

Lo primero de todo es descargar el SGBD Microsoft SQLServer 2005 Express Edition.

Se puede hacer desde aquí:

http://www.microsoft.com/downloads/details.aspx?FamilyID=220549b5-0b07-4448-8848-dcc397514b41&displayLang=es

También (recomendable) es posible descargarse el Microsoft SQL Server Management Studio Express, el cual es un entorno gráfico para gestionar las bases de datos que vayamos creando, de la siguiente URL:

http://www.microsoft.com/downloads/details.aspx?displaylang=es&FamilyID=c243a5ae-4bd1-4e3d-94b8-5a0f62bf7796#filelist

Instalamos los dos paquetes de software....

Una vez instalado, nos vamos al Management Studio y creamos una base de datos, llamada imagenes, con una tabla, llamada registro.

Como podemos observar, se crea una tabla con tres campos, un int, un nvarchar y un tipo image.

Una vez tenemos instalado SQLServer 2005, con nuestra base de datos y nuestra tabla, vamos a instalar pyodbc, el software de Python para crear conexiones ODBC a orígenes de datos, en este caso, el software de Microsoft. Para ello, descargamos el pyodbc, desde http://code.google.com/p/pyodbc/. Creamos a continuación, mediante las Herramientas Administrativas/Orígenes de datos (ODBC), nuestra conexión:

NOTA: El lector debe de tener en cuenta que existe un módulo específico para la conexión de SQLServer con Python, llamado pymssql, que se puede obtener de http://code.google.com/p/pymssql/.

NOTA 2: Pudiera ser que con SQLServer 2005 Express Edition aparezcan ciertos errores a la hora de crear la conexión ODBC referidos a la configuración del mismo, con el propósito de permitir conexiones remotas. Bien, la solución la tenéis aquí: http://support.microsoft.com/kb/914277/es.

Una vez creado el ODBC y la conexión correctamente realizada, ya tenemos todo listo para programar en Python.

El código para crear una conexión desde Python a SQLServer 2005, mediante pyodbc, podría ser tal que así:

import pyodbc

# Cadena de conexión.
cadenaConexion = 'DSN=imagenes;UID=ABUSIMBEL\familia'

try:
   conexionSQLServer = pyodbc.connect(cadenaConexion)
   cursorSQLServer = conexionSQLServer.cursor()
   print "Conectado con SQLServer 2005 Express!"
except:
   print "No he podido conectar con base de datos SQLServer!"

# Cerramos cursor y conexión.

print "Cerrando conexiones!"

cursorSQLServer.close()

conexionSQLServer.close()

Si todo ha ido bien, debe de aparecer algo como esto:

Conectado con SQLServer 2005 Express!

Cerrando conexiones!

A continuación vamos a insertar una imagen en la tabla registro de la base de datos imagenes. El código podría ser tal que así:

import os

fichero_imagen = os.path.realpath('alvaro.jpg')

imagen = open(fichero_imagen,'rb').read()

Cargamos un fichero jpg, y lo referenciamos mediante imagen. Se supone que el fichero ha de existir. El código para insertar una imagen en la base de datos es el siguiente:

# Cadena SQL a ejecutar.

cadenaSQL = "insert into registro values (1,'alvaro',?)"

# Lanzamos Sentencia.

cursorSQLServer.execute(cadenaSQL, (pyodbc.Binary(imagen),))

# Confirmamos escritura.

conexionSQLServer.commit()

Cabe destacar que transformamos en binario la imagen cargada del fichero. Además hacemos commit, no olvidarlo. Si nos vamos al Management Studio y hacemos una consulta a la tabla tenemos la solución:

Bien, ya sabemos como insertar imágenes en la base de datos. Ahora toca como recuperar la información, mediante el select correspondiente. El código para hacer esto podría parecerse a lo siguiente:

# Creamos el nombre de un fichero destino.

fichero_destino = os.path.realpath('destino.jpg')

# Lanzamos la consulta de selección SQL.

imagen = cursorSQLServer.execute('SELECT * FROM registro WHERE id = 1')

# Creamos un fichero de destino (temporal).

fichero_final = open(fichero_destino,'wb')

# Escribimos en el fichero y lo cerramos.

fichero_final.write(imagen.next()[2])

fichero_final.close()

Cabe destacar que se crea un fichero de salida temporal (destino.jpg) para obtener en disco el fichero seleccionado de la base de datos. También decir que utilizamos next() para iterar sobre el cursor y obtener la imagen, que se encuentra en la posición 3 de la tupla (es decir, imagen.next()[2]), ya que la tabla tiene 3 campos y el campo imagen es el tercero.

Decir que si se quiere que se vea automáticamente la imagen recuperada, se puede utilizar:

fichero_destino = os.path.realpath('destino.jpg')

os.startfile(fichero_destino)

En mi sistema Windows, automáticamente se abre el programa asociado a ficheros de imágenes, Visor de imágenes y faz de Windows, dando como resultado:

Imágenes serializadas en objetos con Python

Bien. Estamos en la segunda parte del post. Ahora lo que vamos a hacer es guardar una imagen dentro de un objeto y dicho objeto guardarlo en disco. Sería así como un wrapper de la imagen que se guardará en disco. Lo bueno que tiene esto es que se pueden guardar múltiples imágenes en cualquier tipo de contenedor (lista, tupla, diccionario) y guardarla directamente en disco, a capón. Para ello vamos a crear primero una clase, llamada persistencia, que tendrá la funcionalidad de cargar y guardar un objeto.

El código que define la clase persistencia es el siguiente:

import cPickle

class persistencia(object):
   def nombre_clase(self):
   return str(self).split(' ')[0].split('.')[1]

   def cargar(self, nombre_fichero = None):
   if nombre_fichero is None:
   nombre_fichero = self.nombre_clase()
   manejador_fichero = open(nombre_fichero,'r')
   objeto = cPickle.load(manejador_fichero)
   manejador_fichero.close()
   return objeto

   def salvar(self, objeto, nombre_fichero = None):
   if nombre_fichero is None:
   nombre_fichero = self.nombre_clase()
   # Fichero que contendrÃ¡ el objeto.
   manejador_fichero = open(nombre_fichero,'w')
   # Volcamos el objeto de memoria al fichero.
   cPickle.dump(self, manejador_fichero)
   # Cerramos fichero.
   manejador_fichero.close()

Ahora, únicamente hay que crear una clase que herede de persistencia, para obtener su funcionalidad, e implementar las estructuras necesarias para guardar imágenes. Para ello implementamos la clase registro, tal que así:

class registro(persistencia):
   def __init__(self):
   self._registro = []

   def insertar_persona(self, nombre, foto):
   self._registro.append([nombre, foto])

   def devolver_persona(self, nombre = None):
   if nombre is None:
   return self._registro
   else:
   for i in self._registro:
   if i[0] == nombre:
   return i
   return None

Ahora falta, por fin, utilizar las clases que hemos diseñado, para poder ver que efectivamente funciona la idea. El código para serializar una imagen en un objeto podría tener el siguiente:

import os

# Cargamos imagen.

fichero_imagen = os.path.realpath('alvaro.jpg')

imagen = open(fichero_imagen,'rb').read()

# Instanciamos la clase que contendrá el registro de personas.

personas = registro()

personas.insertar_persona('alvaro',imagen)

personas.salvar(personas)

Como podemos observar la funcionalidad heredada nos permite guardar la imagen en un fichero, mediante la serialización del objeto. Decir que hemos incluido una imagen únicamente. Podríamos incluir tantas imágenes como quisiéramos. Evidentemente se crea un fichero, llamado registro, el cual tiene el siguiente contenido:

El formato del fichero nos da igual. Lo importante es que podamos recuperar la información guardada en las estructuras de datos de alto nivel que dispone Python. Vamos por último a ver cómo recuperar la información guardada en el objeto serializado. Podríamos utilizar un código como este:

import os

# Obtenemos datos.

personas = registro()

personas = personas.cargar()

individuo = personas.devolver_persona('alvaro')

# Creamos fichero.

fichero_destino = os.path.realpath('destino.jpg')

imagen = open(fichero_destino,'wb')

imagen.write(individuo[1])

imagen.close()

# Y lo mostramos por pantalla, para ver que efectivamente funciona la idea.

os.startfile(fichero_destino)

Esto es todo por el momento. Saludos.

Ejercicios resueltos de programación, en Python y en español, I.

2011-01-09T14:07:00.005+01:00

Hola. Este es el primero de la serie de artículos que presentaré estos días sobre una colección de ejercicios muy básicos de programación, para resolver con Python (o cualquier otro lenguaje). Decir que son muy sencillos y sirven para afianzar conocimientos básicos de sintaxis y razonamiento. Si eres novel en programación ó en Python, este post es para tí. De lo contrario, te resultarán triviales los planteamientos expuestos.

Los enunciados los he obtenido del libro Esquemas Algorítmicos Fundamentales - Secuencias e Iteración, de P.C. Scholl y J.P. Peyrin, editorial Masson.

Ejercicio 1.

Escribir un algoritmo que, para cualquier número de segundos inferior a un millón, calcule su equivalente en días, horas, minutos y segundos.

En este ejercicio tenemos que tener en cuenta que:

1 minuto = 60 segundos.
1 hora = 60 minutos = 3600 segundos.
1 dia = 24 horas = 1440 minutos = 86400 segundos.

# Pedimos datos.
dato = raw_input(u'Número de segundos: ')

# Hacemos un cast, convirtiendo la cadena en un número largo.
dato = long(dato)

# Comprobamos si el número introducido es menor a un millón.
if dato >= 1000000:
   print "El número debe de ser menor a 1000000"
else:
   # Días.
   ndias, aux = divmod(dato, 86400)
   # Horas.
   nhoras, aux = divmod(aux, 3600)
   # Minutos y segundos.
   nmin, nseg = divmod(aux, 60)
   # Mostramos resultado.
   print '%d días, %d horas, %d minutos, %d segundos' % \
   (ndias, nhoras, nmin, nseg)

Ejercicio 2.

Escribir un algoritmo que imprima el mínimo, el máximo y la media de tres números.

# Obtenemos números.
numeros = []
for i in ['primer', 'segundo','tercer']:
   texto = u'Introduce el %s número: ' % (i)
   numeros.append(float(raw_input(texto)))

# Ordenamos.
numeros.sort()

# Obtenemos máximo y mínimo.
minimo = numeros[0]
maximo = numeros[2]

# Obtenemos la media aritmética.
media = round((numeros[0] + numeros[1] + numeros[2]) / float(3),3)

# Visualizamos resultados.
cadena = u'Mínimo: %d, Máximo: %d, Media: %f' % (minimo, maximo, media)
print cadena

Ejercicio 3.
Escribir un algoritmo que, dado el infinitivo de un verbo regular de la primera conjugación, obtenga la conjugación en singular y plural de presente de indicativo. Por ejemplo, para el verbo cantar el resultado es yo canto, tu cantas, el canta, nosotros cantamos, vosotros cantáis, ellos cantan.

pronombre = ['yo','tu','el','nosotros','vosotros','ellos']

terminaciones = {'yo':'o',
   'tu':'as',
   'el':'a',
   'nosotros':'amos',
   'vosotros':u'áis',
   'ellos':'an'}

# Pedimos datos.
palabra = raw_input(u'Verbo regular 1ra. conjugación: ')

# Recorremos la tabla hashing (diccionario), construyendo la conjugación verbal.
for i in pronombre:
   print i, palabra[0:len(palabra)-2] + terminaciones[i]

Ejercicio 4.
Escribir un algoritmo que, para un número binario de 4 cifras, imprima su valor en base 10. Se estudiarán dos formas del problema según la representación de los datos:
   -forma 1: los datos son cuatro enteros (0 ó 1). Por ejemplo: 1,1,0,1.
   -forma 2: el dato es un entero cuya representación decimal con cuatro
   cifras no contenga más que 0 ó 1: Por ejemplo: 1101.

# Obtenemos datos.
nbinario = raw_input(u'Número binario (4 cifras): ')

# Obtenemos los dígitos.
nbinario = nbinario.split(',')
if len(nbinario) == 1: nbinario = list(nbinario[0])

# Inicializamos algunos contadores.
decimal = 0
potencia = 0

# Le damos la vuelta al número binario.
nbinario.reverse()

# Calculamos el número decimal, a partir del número binario.
for i in nbinario:
   decimal += pow(2,potencia) if i == '1' else 0
   potencia += 1

# Visualizamos resultado.
cadena = u'Su representación decimal es %d' % (decimal)
print cadena

Ejercicio 5.
Escribir un algoritmo que decodifique fechas del siglo XXI. El dato es un entero comprendido entre 10100 y 311299. El resultado es una secuencia de caracteres: número del día dentro del mes, del mes dentro del año y del año dentro del siglo. Por ejemplo, para el dato 30485, el resultado es el texto 3-4-2085.

# Obtenemos dato.
dato = raw_input('Introduce dato: ')

# Decodificamos año dentro del siglo XXI.
anyo = 2000 + int(dato[len(dato)-2:])

# Decodificamos mes.
mes = int(dato[len(dato)-4:len(dato)-2])

# Decodificamos día.
dia = int(dato[:len(dato)-4])

# Mostramos resultado.
cadena = '%d-%d-%d' % (dia, mes, anyo)
print cadena

Ejercicio 6.
Escribir un algoritmo que, para una suma de dinero dada, indique cómo descomponerla en billetes y monedas corrientes. Se desea utilizar el mínimo de billetes y monedas. No hay ninguna limitación respecto al número de billetes y monedas disponibles.

# Declaramos datos básicos (euros) con los que trabajar.
billetes_y_monedas = [500,200,100,50,20,10,5, 2, 1, 0.50, 0.20, 0.10,
0.05, 0.02, 0.01]

# Creamos un monedero, donde meter el dinero.
monedero = []

# Pedimos la cantidad.
dato = raw_input(u'Introducir importe (euros): ')

# Buscamos parte decimal y entera.
dato = dato.split('.')

# Decimal...
try: parte_decimal = float('0.'+dato[1])
except: parte_decimal = 0.0

# Entera...
parte_entera = long(dato[0])

# Algoritmo de asignación de dinero.
for i in billetes_y_monedas:
   # Obtenemos número de billetes ó monedas y los guardamos.
   unidades, resto = divmod(parte_entera, i)
   if unidades != 0:
   monedero.append((i,unidades))
   # Asignamos lo que nos queda.
   parte_entera = resto

if parte_decimal > 0:
   for i in billetes_y_monedas:
   # Obtenemos número de monedas y los guardamos.
   unidades, resto = divmod(parte_decimal, i)
   if unidades != 0:
   monedero.append((i,unidades))
   # Asignamos lo que nos queda.
   parte_decimal = round(resto,2)

# Visualizamos el resultado.
cadena = ''
for i in monedero:
   if i[0] >= 5: cadena += '%d billete/s de %d euros' % (i[1],i[0])
   if i[0] < 5: cadena += '%d moneda/s de %s euros' % (i[1],i[0])
   cadena += '\n'
print cadena

Ejercicio 7.
Escribir un algoritmo que simule el funcionamiento de una calculadora. El dato es una serie de tres caracteres: una cifra, un símbolo de operación y otra cifra. El resultado es el valor de la expresión dada.

# Pedimos datos.
dato = raw_input(u'Introduce operación: ')

# Inicializamos resultado.
resultado = 0

# ¿Suma?
serie = dato.split('+')
if len(serie) == 2: resultado = long(serie[0]) + long(serie[1])
else:
   # ¿Resta?
   serie = dato.split('-')
   if len(serie) == 2: resultado = long(serie[0]) - long(serie[1])
   else:
   # ¿Multiplicación?
   serie = dato.split('*')
   if len(serie) == 2: resultado = long(serie[0]) * long(serie[1])
   else:
   # ¿División?
   serie = dato.split('/')
   if len(serie) == 2: resultado = long(serie[0]) / long(serie[1])

# Mostramos resultado.
print "El resultado es",resultado

Ejercicio 8.
Consideremos una hora expresada en forma de tripleta . Escribir un algoritmo que imprima la hora correspondiente al siguiente segundo. Por ejemplo, para la entrada 13,43,24 tiene que devolver 13,43,25.

Se supone que lo que introducimos es una hora correcta. Darse cuenta que no se chequean los datos introducidos, por cuestión de simplicidad.

# Pedimos datos.
tiempo = raw_input('Introduce tiempo: ')

# Obtenemos datos.
aux = tiempo.split(',')
horas = int(aux[0])
minutos = int(aux[1])
segundos = int(aux[2])

# Aumentamos un segundo.
segundos += 1

# Casos.
if segundos != 60:
   tiempo = (horas, minutos, segundos)
else:
   if minutos == 59 and horas == 23:
   tiempo = (0, 0, 0)
   else:
   if minutos == 59:
   tiempo = (horas + 1, 0, 0)
   else:
   tiempo = (horas, minutos + 1, 0)

# E imprimimos resultado (una tupla).
print tiempo

Ejercicio 9.
Escribir una función que determine si una letra dada es consonante.

A la función le faltaría controlar las letras con acentuación (tildes, diéresis, etc).

def es_consonante(letra):
   if letra.lower() not in ['a','e','i','o','u']:
   return True
   else:
   return False

Ejercicio 10.
Escribir una función que calcule el factorial de un número. Por ejemplo, 5! = 5*4*3*2*1 = 120.

def factorial(numero):
   return 1 if numero <=0 else numero * factorial(numero -1)

Saludos.

Python, de programadores para programadores

2011-01-01T12:09:00.004+01:00

Yo no soy un programador web, aunque tenga idea, ni soy diseñador web, que no tengo idea. Pero si soy desarrollador de software desde hace algunos años.

Python es ~~framework~~ un lenguaje de programacion de desarrollo multidimensional, esto es, sirve tanto para crear scripts de mantenimiento de sistemas (Windows, Unix, Mac), como creación de aplicaciones para móviles (Android, Symbian), aplicaciones gráficas de escritorio (wxPython, Qt, GTK, Tkinter), desarrollo web (Django, web2py, TurboGears, …).

En el mercado de desarrollo de software hay cantidad de productos, tales como PHP para programación web, y frameworks como Symfony, muy potentes, y todo lo hacen con MVC, como debería ser. Al igual que está C++, que es el mejor lenguaje de programación, referido en cuestiones de potencia y flexibilidad, y el más difícil de aprender para mi.

Evidentemente, cada problemática tiene una solución, y cada lenguaje aporta ciertas características técnicas que lo hacen ideal para la solución propuesta.

Ahora bien, como lenguaje general, con aportes a web y demás, Python es uno de los lenguajes de programación más completos, que se diferencia en ciertos aspectos a otros lenguajes del mercado, y que algunas personas tenemos muy en cuenta, a saber:

1) Sintaxis fácil de aprender.

2) POO integrada desde sus inicios.

3) Multiparadigma y multiplataforma.

4) Dinámico, fuertemente tipado.

5) Multidimensional (referido a su campo de aplicación).

6) Ampliamente documentado.

7) Proyecto vivo (multitud de módulos, packages).

8) Respaldado por empresas grandes (Google, etc.).

Esta afirmación que hago es muy personal. Cuando se apuesta por un lenguaje como Python (y más en España, donde apenas existen programadores en comparación con otros países, como Argentina), significa varias cosas. Primero, que posiblemente la persona que se inicia en esta andadura ya haya visto muchas cosas en su vida (lenguajes), y necesita hacer las cosas bien. Segundo, los tiempos de desarrollo se acortan (y no me refiero a que un framework lleve CRUD incorporado), tanto para cualquier script como aplicación de la naturaleza que sea. Esto es debido a que es un lenguaje de muy alto nivel (de abstracción): lenguaje dinámico y estructuras de alto nivel, como listas y tablas hashing (también llamadas diccionarios).

Yo he trabajado con herrramientas de Microsoft (Visual Basic 6) y Sybase (PowerBuilder). No se mucho de desarrollo de software, es más, cada día que pasa y leo y leo sé que sé menos…

…pero al esforzarme por hacer las cosas bien, veo que Python me ayuda… y un lenguaje que implementa ciertos paradigmas de programación como POO tan fácilmente, ó en donde los bloques de código se escriben con tanta naturalidad (y esta palabra es muy importante en el desarrollo de software)… no se… da que pensar…

…y es que la legibilidad cuenta, que ya vendrán otros a mantener tu software, y deben saber lo que has hecho.

Yo he sido muy fanático de PowerBuilder, para gestión empresarial, donde sinceramente digo que no hay actualmente herramientas más potentes que los DataWindows para acceso a datos. Sin embargo, PB se ha hecho más complicado con el tiempo. Desde la versión 6 (la mejor) hasta la 12 (la más complicada), ha pasado mucho. Y yo necesitaba mejorar como desarrollador de software. Python hace mejor al desarrollador, ya que ayuda a escribir mejor, esto es, a escribir menos, para hacer lo mismo, lo que indica recortar tiempos de desarrollo, y en definitiva, acortar proyectos, lo que implica a su vez, dinero.

Pero la verdad, la realidad, es muy distinta. En España por lo menos. Python se utiliza muy poco, PHP lo que más, junto a las herramientas de Microsoft y Java.

Después de llevar con Python un año, de escribir en este blog por puro amor al arte, me niego a emprender otra andadura diferente en la que estoy. Creo firmemente que apostar por Python y sucedáneos, tales como Django para web, wxPython para escritorio, Plone para CMS, etcétera, es una apuesta a caballo ganador.

Las distancias hoy día no son barreras para asociarse y trabajar juntos, para eso está Internet...

Si eres una persona responsable, muy comprometida, que quiere embarcarse en algo diferente, apostar por el talento, el esfuerzo y hacer las cosas de la forma correcta, aquí espero para que hablemos.

Resumiendo, Python, siempre desde mi punto de vista, es un ~~framework~~ lenguaje de programación de desarrollo, de programadores para programadores, donde prima el hacer las cosas de la manera correcta, en el menor tiempo posible (¡y en este orden!).

Saludos.

wxPython: Crear un editor simple, en Python

2010-12-23T23:44:00.001+01:00

Hola. En este post os presento un editor de texto básico escrito en Python y wxPython, para que veáis el funcionamiento, cómo se heredan clases de las wx, así como el uso de la impresión en wxPython.

El código, como siempre, se puede descargar del repositorio de este blog, en:

https://sites.google.com/site/elviajedelnavegante/codigo

Fichero editor_ejemplo.zip.

Estamos hablando de un editor de texto, no de un procesador de texto, por tanto no podemos incluir texto enriquecido ni nada parecido. Es lo más parecido al bloc de notas de Windows, pero escrito en Python y wxPython.

Se implementa un sistema de impresión, en donde podemos encontrar la configuración de página, vista preliminar de impresión e impresión directa.

Algunas capturas de pantalla de la aplicación a continuación:

Cosas que faltan...

En la impresión, no se hace un wrapper del texto, es decir, no se tienen en cuenta los márgenes, por lo que si no se incluyen retornos de línea (Enter) el texto se saldrá del área de impresión. Esto habría que arreglarlo...

Saludos.

pyLorca en pruebas...

2010-12-23T21:13:00.004+01:00

Hola. Esta tarde he publicado pyLorca, un software para crear clases Python a partir de sintaxis Yaml. Bien, este programa está en fase de desarrollo, y dicho desarrollo lo he hecho en Windows. Se supone que Python funciona bien tanto en Windows como en Linux, sin apenas hacer cambios.

Hay veces que hay que hacer cambios...

He tenido un primer problema con las codificaciones, ya que en Windows tenía una estructura de constantes de cadenas con la u delante y en Linux me ha dicho que nada de nada. El problema surge al pedir la ayuda de la aplicación, mediante python pyLorca.py -h. En principio, para Linux, da un problema de codificación.

¿Dónde lo arreglamos?

Simplemente omitiendo las u:

Ahora ya funciona la ayuda:

El problema está en Windows, donde si no ponemos la u, salen caracteres extraños, aunque tengamos utf-8 configurado en el módulo y en el sitecustomize.py. La verdad que no se donde puede estar el fallo (...bueno, sí que lo sé, es de Microsoft).

Si eres usuario de Linux y no te funciona la ayuda por un tema de codificación, únicamente tienes que hacer los cambios que he comentado.

Saludos.

pyLorca: Diseño y diagrama de clases, en Python

2010-12-23T14:52:00.022+01:00

Hola. En este post os presento una pequeña aplicación, desarrollada en Python, para diseñar clases en Python de manera rápida, mediante sintaxis Yaml, y con la opción de poder visualizarlo gráficamente, al estilo UML, aunque no es UML. Este software se puede descargar del site de El viaje del navegante:

https://sites.google.com/site/elviajedelnavegante/codigo

Los requisitos para que funcione pyLorca (a día de hoy) es tener instalado pyYAML, que podéis descargar desde su página web, http://pyyaml.org/. Opcionalmente, si se quiere utilizar el entorno gráfico, se ha de tener instalado wxPython, que se puede conseguir en http://www.wxpython.org/.

Al grano...

Con pyLorca de lo que se trata es crear código ó partes de código que normalmente se repiten a la hora de crear clases bases, de las cuales más tarde se heredará (o no). La cuestión es crear, en un fichero Yaml, las especificaciones de las clases y opcionalmente sus atributos, métodos y propiedades, así como comentarios. Automáticamente se generará un fichero Python con el código resultado de dicha especificación.

¿Por qué Yaml? Pues porque tiene una sintaxis fácil de leer y comprensible, apta para poder ser manipulada de manera rápida. Esta es la principal baza de crear scripts en Yaml: poder diseñar jerarquías de clases de manera sencilla y muy rápida.

Un ejemplo sencillo...

Imagina que estás diseñando un problema... defines ciertas clases e identificas sus atributos. Claro, a dichos atributos se les tiene que poder asignar un valor y devolver dicho valor. Bien, podríamos utilizar propiedades en este caso. Otros atributos quizás no interese que sean propiedades, pero como buen programador quieres que sean atributos ocultos. Evidentemente, las clases tienen métodos. ¿La mejor manera de representar esta información? Vamos a verlo...

Se nos plantea un problema que está definido por una clase, padre, que tiene ciertos atributos que podrían accederse como propiedades, esto es, se les aplicará un get y un set. Hay otra clase, hijo, que hereda de la clase padre, y que tiene propiedades suyas. Podríamos escribirlo tal que así:

clase: padre
propiedades:
  - altura
  - peso
  - edad
  - etnia
clase: hijo
hereda_de: padre
propiedades:
  - color_ojos

Bien, si esto lo escribimos en código Python tendríamos algo parecido a esto:

class padre(object):

   # Constructor
   def __init__(self):
   self.__altura = None
   self.__peso = None
   self.__edad = None
   self.__etnia = None

   # Getters
   def __getAltura(self):
   return self.__altura
   def __getPeso(self):
   return self.__peso
   def __getEdad(self):
   return self.__edad
   def __getEtnia(self):
   return self.__etnia

   # Setters
   def __setAltura(self, altura):
   self.__altura = altura
   def __setPeso(self, peso):
   self.__peso = peso
   def __setEdad(self, edad):
   self.__edad = edad
   def __setEtnia(self, etnia):
   self.__etnia = etnia

   # Properties
   altura = property(fget = __getAltura,fset = __setAltura)
   peso = property(fget = __getPeso,fset = __setPeso)
   edad = property(fget = __getEdad,fset = __setEdad)
   etnia = property(fget = __getEtnia,fset = __setEtnia)

class hijo(padre):

   # Constructor
   def __init__(self):
   padre.__init__(self)
   self.__color_ojos = None

   # Getters
   def __getColor_ojos(self):
   return self.__color_ojos

   # Setters
   def __setColor_ojos(self, color_ojos):
   self.__color_ojos = color_ojos

   # Properties
   color_ojos = property(fget = __getColor_ojos,fset = __setColor_ojos)

Bien, como podemos observar hay una pequeña diferencia de número de líneas de código entre la notación de arriba y la de abajo, en Python. Pues bien, la primera notación es sintaxis Yaml.

pyLorca lo que hace es, a partir de un fichero con la notación Yaml, generar en un fichero Python (.py) el segundo código expuesto.

Un ejemplo algo más completo

El fichero de configuración Yaml tiene dos secciones diferenciadas, una para la configuración del código que se genera en el fichero .py y otra compuesta por un conjunto de documentos que identifican a cada una de las clases que estamos definiendo. ¿Difícil? Más sencillo ahora...

Fichero Yaml con todos los parámetros posibles:

# YAML
fichero_python_a_generar:
comentario:
indentacion:
prefijo_clases:
---
clase:
hereda_de:
propiedades:
atributos:
metodos:
comentario:
...

La primera sección, como podemos ver, sirve para configurar el nombre del fichero Python que se generará, un comentario que se incluirá al principio del módulo, el nivel de indentación que se quiere para el código y un prefijo que se puede incluir en el nombre de las clases cuando se generan.

La segunda sección se denomina conjuntos de documentos. Vemos que podemos definir el nombre de la clase, de qué clase ó clases hereda, la lista de propiedades, la lista de atributos, la lista de métodos y un comentario sobre lo que hace dicha clase.

Si queremos definir 2 clases, tendremos que tener dos documentos:

---

clase:

hereda_de:

propiedades:

atributos:

metodos:

comentario:

---

clase:

hereda_de:

propiedades:

atributos:

metodos:

comentario:

...

Fijarse que un documento (definición de clase) se separa de otro mediante tres guiones ---. Además, para terminar se los documentos utilizamos tres puntos ....

Ahora que sabemos la teoría vamos a crear el mismo ejemplo de antes, pero algo más completo. Decir que no es necesario escribir todos los elementos ó campos Yaml, aunque sí que es obligatorio escribir al menos un elemento para definir las dos secciones.

Fichero ejemplo_navegante.yaml:

# YAML
fichero_python_a_generar: ejemplo_navegante.py
comentario: |
  Este es el módulo de prueba de pyLorca,
  escrito para el blog de El viaje del navegante.
indentacion: 6
prefijo_clases: base
---
clase: padre
propiedades:
  - altura
  - peso
  - edad
  - etnia
comentario: |
  Esta es la clase padre, de la cual
  hereda la clase hijo.
---
clase: hijo
hereda_de: padre
propiedades:
  - color_ojos
comentario: |
  Este es un ejemplo de una clase que hereda
  de otra clase.
...

Código generado en el fichero ejemplo_navegante.py:

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

'''

Código generado por pyLorca v0.0.1

Fecha creación: 2010-12-23

Definición: Este es el módulo de prueba de pyLorca,

escrito para el blog de El viaje del navegante.

'''

class base_padre(object):

'''

Esta es la clase padre, de la cual

hereda la clase hijo.

'''

# Constructor

def __init__(self):

self.__altura = None

self.__peso = None

self.__edad = None

self.__etnia = None

# Getters

def __getAltura(self):

return self.__altura

def __getPeso(self):

return self.__peso

def __getEdad(self):

return self.__edad

def __getEtnia(self):

return self.__etnia

# Setters

def __setAltura(self, altura):

self.__altura = altura

def __setPeso(self, peso):

self.__peso = peso

def __setEdad(self, edad):

self.__edad = edad

def __setEtnia(self, etnia):

self.__etnia = etnia

# Properties

altura = property(fget = __getAltura,fset = __setAltura)

peso = property(fget = __getPeso,fset = __setPeso)

edad = property(fget = __getEdad,fset = __setEdad)

etnia = property(fget = __getEtnia,fset = __setEtnia)

class base_hijo(base_padre):

'''

Este es un ejemplo de una clase que hereda

de otra clase.

'''

# Constructor

def __init__(self):

base_padre.__init__(self)

self.__color_ojos = None

# Getters

def __getColor_ojos(self):

return self.__color_ojos

# Setters

def __setColor_ojos(self, color_ojos):

self.__color_ojos = color_ojos

# Properties

color_ojos = property(fget = __getColor_ojos,fset = __setColor_ojos)

Vale... comentamos lo que hemos hecho. En el fichero Yaml hemos indicado que queríamos que el código Python tuviera una indentación de código de 6 espacios en blanco, que las clases tuvieran un prefijo con el vocablo "base", y que al principio del módulo incluyese un comentario: "Este es el módulo de prueba de pyLorca, escrito para el blog de El viaje del navegante." Ver también que se incluye en el fichero .py el tipo de codificación utf-8, así como una reseña que el código ha sido generado por pyLorca y la fecha de generación.

Con respecto a la definición de las clases, hace exactamente lo que hemos indicado. La clase padre tiene una serie de propiedades (get y set) que hemos diseñado y se ha generado todo el código correspondiente para su utilización, además de un comentario al principio de la clase. La clase hijo, tal como se ha especificado, hereda de la clase padre (mira el __init__), además de tener otras propiedades suyas (...decir propiedades propias suena redundante...).

Sintaxis Yaml

La sintaxis Yaml es muy sencilla, es por ello que he escogido este sistema para definir las clases y no otros, como XML, que resulta algo más tedioso de leer y escribir. Con Yaml es como si hiciéramos la lista de la compra. En San Google hay multitud de manuales sobre Yaml, pero aquí os indico cómo definir ficheros Yaml para pyLorca, que de verdad que es muy fácil.

En el inicio del fichero Yaml incluir la etiqueta siguiente:
#YAML

Una cadena de información es una etiqueta, dos puntos, espacio y el valor de esa etiqueta.
etiqueta: información de la etiqueta

Una lista de parámetros es una etiqueta y dos puntos, y en las líneas siguientes, dos espacios, guion, espacio, elemento de la lista:
lista:
  - elemento1
  - elemento2

Un comentario es una etiqueta con dos puntos, espacio, carácter |, y en las líneas siguientes, dos espacios y el comentario, que se puede dividir en varias líneas, pero al iniciar cada línea, siempre con dos espacios en blanco.
comentario: |
  Comentario de El viaje del navegante
  para los usuarios de Python.

Cosas a tener en cuenta. Mucho cuidado con los espacios en blanco, hay que dejarlos tal como comento, ya que de lo contrario Yaml no funciona, es muy estricto en este tema, al igual que Python con la indentación de código.

Bien, en pyLorca, los elementos propiedades, atributos y metodos son listas. Los elementos comentario son comentarios. Los demás son elementos de cadena.

NOTA IMPORTANTE: Para gente que ya conozca Yaml puede resultar extraño cómo me refiero a algunos elementos, pero este post está orientado al público en general. Perdonad mi simpleza...

Más cosas...

En la definición del fichero Yaml hay elementos que puedes obviar ó no. Por ejemplo, si defines una clase que no hereda de nadie, no es necesario incluir hereda_de:. Aunque si o haces no pasa nada. Incluso si escribes hereda_de: object sigue sin pasar nada. Con esto quiero decir que pyLorca es flexible a la hora de buscar información, pero ten en cuenta que lo que escribas tiene que ir en perfecta sintaxis Yaml.

El ejemplo más completo, herencia múltiple, ¡¡¡más madera!!!

Ahora vamos a incluir todos los parámetros de configuración en un ejemplo y además, vamos a incluir otra clase, para comprobar que pyLorca soporta herencia múltiple.

El fichero Yaml tiene el siguiente contenido:

# YAML
fichero_python_a_generar: ejemplo_navegante.py
comentario: |
  Este es el módulo de prueba de pyLorca,
  escrito para el blog de El viaje del navegante.
indentacion: 6
prefijo_clases: base
---
clase: padre
propiedades:
  - altura
  - peso
  - etnia
atributos:
  - dinero
metodos:
  - jugar_con_peque
comentario: |
  Esta es la clase padre, de la cual
  hereda la clase hijo.
---
clase: madre
hereda_de: object
propiedades:
  - nivel_inteligencia
atributos:
  - saber_estar
  - cordura
metodos:
  - trabajar
  - amar
comentario: |
  Clase que define a la madre
  que es la reina.
---
clase: hijo
hereda_de: padre, madre
propiedades:
  - color_ojos
atributos:
  - edad
metodos:
  - jugar_con_osito
comentario: |
  Esta clase hereda de papá y mamá
  y se hará mayor y grande.
...

Y pyLorca lo interpreta y genera dentro del fichero ejemplo_navegante.py lo siguiente:

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

'''

Código generado por pyLorca v0.0.1

Fecha creación: 2010-12-23

Definición: Este es el módulo de prueba de pyLorca,

escrito para el blog de El viaje del navegante.

'''

class base_padre(object):

'''

Esta es la clase padre, de la cual

hereda la clase hijo.

'''

# Constructor

def __init__(self):

self.__altura = None

self.__peso = None

self.__etnia = None

self.__dinero = None

# Métodos

def jugar_con_peque(self): pass

# Getters

def __getAltura(self):

return self.__altura

def __getPeso(self):

return self.__peso

def __getEtnia(self):

return self.__etnia

# Setters

def __setAltura(self, altura):

self.__altura = altura

def __setPeso(self, peso):

self.__peso = peso

def __setEtnia(self, etnia):

self.__etnia = etnia

# Properties

altura = property(fget = __getAltura,fset = __setAltura)

peso = property(fget = __getPeso,fset = __setPeso)

etnia = property(fget = __getEtnia,fset = __setEtnia)

class base_madre(object):

'''

Clase que define a la madre

que es la reina.

'''

# Constructor

def __init__(self):

self.__nivel_inteligencia = None

self.__saber_estar = None

self.__cordura = None

# Métodos

def trabajar(self): pass

def amar(self): pass

# Getters

def __getNivel_inteligencia(self):

return self.__nivel_inteligencia

# Setters

def __setNivel_inteligencia(self, nivel_inteligencia):

self.__nivel_inteligencia = nivel_inteligencia

# Properties

nivel_inteligencia = property(fget = __getNivel_inteligencia,fset = __setNivel_inteligencia)

class base_hijo(base_padre,base_madre):

'''

Esta clase hereda de papá y mamá

y se hará mayor y grande.

'''

# Constructor

def __init__(self):

base_padre.__init__(self)

base_madre.__init__(self)

self.__color_ojos = None

self.__edad = None

# Métodos

def jugar_con_osito(self): pass

# Getters

def __getColor_ojos(self):

return self.__color_ojos

# Setters

def __setColor_ojos(self, color_ojos):

self.__color_ojos = color_ojos

# Properties

color_ojos = property(fget = __getColor_ojos,fset = __setColor_ojos)

¿Cómo llamar a pyLorca?

pyLorca funciona en modo texto, simplemente escribiendo python pylorca.py -h tendremos la ayuda en línea de cómo funciona. Si ya tenemos creado nuestro fichero Yaml, python pylorca.py fichero.yaml y genera el fichero Python descrito dentro del fichero Yaml. Si queremos que pyLorca nos genere de forma automática una plantilla, python pylorca.py -p fichero.yaml. Más información en la ayuda.

pyLorca en modo gráfico...

pyLorca también tiene la posibilidad de trabajar en modo gráfico, si se tiene instalado wxPython 2.8.11 ó versión compatible. Se invoca mediante python pylorca.py -g.

El funcionamiento gráfico es mucho más intuitivo, si cabe, que en modo texto. Podemos cargar ficheros Yaml desde el botón de que vemos abajo (Fichero conf. YAML). Una vez cargado podemos generar el diagrama gráficamente (botón Generar diagrama) y/o generar el código Python (botón Generar código Python), el cual podemos previsualizar una vez generado. También podemos editar el código Yaml haciendo click en el botón Editor. Como se puede observar podemos imprimir los diagramas que hagamos (botones de impresión).

Una última consideración... ó dos...

Hay veces en las cuales el atributo (no propiedad) de una clase es una instanciación de otra clase. pyLorca lo contempla. Es más, se pueden inicializar los atributos ó propiedades en el propio fichero Yaml. Así por ejemplo, para el siguiente fichero Yaml tenemos:

# YAML
fichero_python_a_generar: ejemplo2.py
---
clase: ubicacion
propiedades:
  - direccion
  - poblacion
  - provincia
  - cp
---
clase: persona
atributos:
  - nombre
  - apellidos
  - nif
---
clase: usuario
hereda_de: persona
propiedades:
  - clave_acceso = 123456
atributos:
  - direccion = ubicacion()
...

Darse cuenta del atributo direccion de la clase persona, el cual está inicializado con una instanciación de la clase ubicacion. Gráficamente pyLorca lo representa de la siguiente forma:

El código Python, generado en el fichero ejemplo2.py, es el siguiente:

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

'''
Código generado por pyLorca v0.0.1
Fecha creación: 2010-12-23
'''

class ubicacion(object):

   # Constructor

   def __init__(self):
   self.__direccion = None
   self.__poblacion = None
   self.__provincia = None
   self.__cp = None

   # Getters

   def __getDireccion(self):
   return self.__direccion

   def __getPoblacion(self):
   return self.__poblacion

   def __getProvincia(self):
   return self.__provincia

   def __getCp(self):
   return self.__cp

   # Setters

   def __setDireccion(self, direccion):
   self.__direccion = direccion

   def __setPoblacion(self, poblacion):
   self.__poblacion = poblacion

   def __setProvincia(self, provincia):
   self.__provincia = provincia

   def __setCp(self, cp):
   self.__cp = cp

   # Properties

   direccion = property(fget = __getDireccion,fset = __setDireccion)
   poblacion = property(fget = __getPoblacion,fset = __setPoblacion)
   provincia = property(fget = __getProvincia,fset = __setProvincia)
   cp = property(fget = __getCp,fset = __setCp)

class persona(object):

   # Constructor

   def __init__(self):

   self.__nombre = None
   self.__apellidos = None
   self.__nif = None

class usuario(persona):

   # Constructor

   def __init__(self):
   persona.__init__(self)

   self.__clave_acceso = 123456

   self.direccion = ubicacion()

   # Getters

   def __getClave_acceso(self):
   return self.__clave_acceso

   # Setters

   def __setClave_acceso(self, clave_acceso):
   self.__clave_acceso = clave_acceso

   # Properties

   clave_acceso = property(fget = __getClave_acceso,fset = __setClave_acceso)

¿Cómo se ha programado pyLorca?

pyLorca era al inicio un conjunto de ficheros, donde cada módulo desempeñaba su papel: vista, pyyaml, tratamiento de sintaxis, editor. Lo he juntado todo en un único fichero por simple comodidad por parte del usuario.

La parte gráfica de pyLorca, escrita en wxPython, utiliza OGL para el diseño de las cajas divididas. Las rutinas de impresión las he sacado de la Demo de wxPython. Es más, si entráis en el código veréis algunas partes (muy pocas) comentadas en inglés, y es porque las he sacado iguales a las originales. Lo importante de aprender wxPython es fijarse en el código, ver y comprender cómo funciona, para poder modificarlo y hacer lo que nosotros queremos que haga.

Mejoras...

Esta aplicación debe de tener muchos bugs, que conforme pase el tiempo iré detectando y corrigiendo. Como mejoras para la siguiente versión caben destacar:
- Creación gráfica de clases.
- Creación gráfica de relaciones entre clases.
- Generación de código Yaml a partir de la creación gráfica de clases.
- Wrapper a la impresión de texto y gráficos, ya que no se controlan los márgenes.

CONCLUSIONES

pyLorca es una aplicación escrita en Python, para crear scripts Python, que utiliza ficheros de sintaxis Yaml para generarlos. Sirve para diseñar con muy pocas líneas de código y en una sintaxis muy fácil, clases y relaciones, para generar el consiguiente código Python.

Saludos.

wxPython: herencia, parámetros y otras hierbas con wxFormBuilder, en español

2010-12-22T20:27:00.000+01:00

Hola. Continuando con la serie de posts sobre wxPython y wxFormBuilder vamos a ver ahora cómo pasar información entre widgets, así como la utilización de la herencia entre objetos y otras cosas. El ejemplo completo (muy comentado) está en el repositorio de El viaje del navegante:

https://sites.google.com/site/elviajedelnavegante/codigo

El fichero es Gestión de almacén.zip.

Lo que vamos a construir es una pequeña aplicación que va a simular un gestor de almacén específico, con familias, modelos y submodelos de productos. Además se incluye un sistema de reports (informes) en HTML. La aplicación es muy sencilla, lo que da mucho juego a la hora de completarla. Es más, incluso para guardar los datos en disco se utiliza la persistencia de datos, para ser lo más aséptico posible, y que el propio lector pueda comprender y asimilar lo verdaderamente importante, el uso de los widgets en wxPython y el paso de información entre los mismos. Para ello, hay que tener muy claro el concepto de herencia, ya que para utilizar wxPython es indispensable.

Esta aplicación es para aprender, ya que le faltan muchas cosas, pero lo básico lo tiene. Faltaría por ejemplo estadísticas, control de stock, relación de lotes con sus correspondientes albaranes de entrada, y un sin fin más. La búsqueda de información se podría hacer implementando reports para tal uso, parametrizando la llamada de los mismos. Se deja al lector esta tarea. Aquí únicamente se muestra el camino.

IMPORTANTE: Decir que el ejemplo está muy comentado, por lo que es muy conveniente descargarse el código, para leer los comentarios y poder saber el porqué hago lo que hago.

¿Qué compone el proyecto? De las siguientes partes:

MODELO DE DATOS

- clases_gestion_almacen.py: Código generado con pyLorca, una aplicación (escrita por mí) para crear a partir de ficheros Yaml, módulos de clases bases, con propiedades, métodos y atributos.

- gestion_almacen_modelo.py: Este módulo contiene las clases que contendrán la información que se guardará en disco y algunas funciones más que nos serán de ayuda. Este modelo importa clases_gestion_almacen.py.

VISTA

- gestion_almacen_vista.py: Código generado automáticamente por wxFormBuilder (a través del fichero de proyecto gestion_almacen.fbp), en donde se diseña por completo todo el frontend gráfico de la aplicación.

APLICACIÓN

- gestion_almacen.py: Este módulo importa clases de los demás módulos y es la aplicación principal. Junta el modelo de datos con la vista.

¿Cómo funciona?

Se ejecuta con: python gestion_almacen.py.

Lo primero es crear familias, modelos y submodelos. Nos vamos al menú Clasificación y a insertar datos...

Podemos incluir tantos elementos como queramos. El único requisito es que no pueden repetirse, ya que el sistema no lo permite (un requisito para no tener problemas de duplicidades...).

Importante: Siempre dar al botón Guardar.

Podemos ver los datos incluidos en el wx.Choice...

Mediante la referencia entre widgets, dichos elementos pasan al frame principal...

También hay que crear los almacenes... Si queremos crear un producto hay que dar valores a todos los campos, y a continuación darle al botón Guardar...

Podemos ver lo que hemos hecho en los informes...

Este tipo de informe es una página html...

¿Dónde se guardan los datos? He utilizado persistencia de datos con cPickle. Se nos generarán los siguientes ficheros...

CONCLUSIONES

En este post se ha presentado un ejemplo para ver cómo se pasan parámetros (información) entre widgets (wx.Choice, etc.). Se ha utilizado pyLorca para la generación de las clases bases, así como wxFormBuilder para la generación íntegra del entorno gráfico. Si no disponemos de un sistema de reports siempre podemos utilizar páginas web para lanzar informes. Se deja al lector la parametrización de los mismos para implementar un sistema de búsqueda. Por último decir que se ha utilizado el módulo cPickle para la persistencia de datos.

Saludos.

Recursos documentales en la red, y 4

2010-12-21T17:35:00.002+01:00

Hola. Como viene siendo habitual en este blog, cada cierto tiempo hago una recopilación de sitios en donde he estado y que me han servido para algo. Fiel a mi costumbre de compartirlo todo (...mmm casi todo), os dejo enlaces en donde encontraréis cosas curiosas (ó no) relacionadas con Python y otras hierbas.

Como siempre, hago una distinción por áreas, para que sea más fácil ir a buscar lo que se quiere encontrar, cosa que no siempre se puede esperar.

PYTHON

Índice de paquetes para Python: Lugar donde se pueden encontrar el listado oficial de paquetes disponibles para Python (módulos de extensión).

Tutoriales de programación y ejemplos de código fuente: Sitio de lo más interesante, ya que no solamente se habla de Python, sino de una gran variedad de lenguajes de programación. Lo bueno de esta web es la cantidad de ejemplos que hay, algo a tener muy en cuenta, ya que para aprender Python, y cualquier lenguaje en general, es necesario ver ejemplos de código reales. Dentro de este sitio podemos encontrar:

Herramientas de desarrollo para Python: Lista de herramientas para desarrollar en Python, esto es, editores, gui's e ide's, del sitio oficial de Python, www.python.org.

Recursos documentales para Python en español: Material, webs y blogs de recursos documentales sobre Python, en español.

Tutoriales para Python - Centro de aprendizaje: Sitio web, en inglés, en donde podemos encontrar recursos para aprender Python, inlcuyendo niveles básico y avanzado.

Tutorial Python: Tutorial, en español, de Python. Creado por PyAr.

El blog de Jesse Noller: Blog de programación Python. Está en inglés, pero este hombre cuenta cosas muy interesantes.

El blog de Mike Driscoll: Blog de un gurú de Python, también en inglés. Muy buenos posts sobre todo lo que escribe Mike. Gracias a monoBOT, ¡por mostrarme el camino del samurai!, supe de la existencia de Mike Driscoll.

Página de Spinecho: Código fuente de aplicaciones Python. Para aprender.

Linux Plátanos: Sitio web en donde encontrar temática GNU y Python.

El libro de Django: Pues eso, el libro online de Django. En inglés.

RAD ESCRITORIO

DABO: Sitio en donde nos encontramos el software Dabo, para crear de manera rápida aplicaciones de escritorio en Python y wxPython.

CAMELOT: Sitio en donde nos encontramos el software Camelot, para crear de manera rápida aplicaciones de escritorio en Python, Qt y SQLAlchemy.

WXPYTHON

Tutorial de sizers: Tutorial, en inglés, de uso de sizers (algoritmo de posicionamiento de widgets) en wxPython. Muy interesante.

La web de Andrea Gavanna: Sitio de Andrea Gavanna, uno de los desarrolladores de widgets para wxPython. Muy buena la sección de software.

Python en un minuto: Blog donde explica muy bien como crear una aplicación wxPython.

INGENIERÍA DEL SOFTWARE

Web de Andy Bulka: Software de patrones de diseño y UML.Cabe destacar la aplicación PyNsource, que crea un diseño gráfico UML a partir de código Python.

Tigris: Herramientas de ingeniería del software de código abierto.

Case Tools: Sitio web en donde se pueden encontrar cantidad de herramientas CASE.

Pymerase: Herramienta para diseño de modelo de objetos, en Python.

Modeling Languages: Sitio web de analistas, diseñadores y arquitectos de software. Muy interesante e instructivo. En español. Recomendado. Me quedo con la cita del principio de esta página web:

Se supone que el Modelado de Software es una de las actividades más importantes en cualquier proceso de desarrollo del software. Al menos esta es la creencia entre la comunidad científica de ingeniería del software. Sin embargo, en la práctica del día a día la modelización está considerada, básicamente, una pérdida de tiempo.

SERVICIOS WEB

http://www.tuopcion.com/desarrollo_web/servicios_web/servicios_web_utiles.php

http://www.remotemethods.com/

http://pywebsvcs.sourceforge.net/

IMÁGENES

Open Clip Art: Librería de imágenes libre. Muy buena.

Icons Pedia: Librería excepcional de iconos, con varios tamaños. Realmente buena.

Theme world: Sitio web sobre temas de escritorio y wallpapers.

MISCELÁNEA

Comparativas entre lenguajes de programación: Artículo muy bueno de Jason Voegele, sobre una comparativa técnica de los lenguajes de programación actuales, incluido Python, por supuesto. En inglés. Muy bueno.

Packt Publishing: Editorial técnica de informática. Sección sobre Python impresionante. Muy recomendado.

Small Basic: Proyecto de Microsoft para enseñar/aprender a programar. Bastante interesante.

Proyecto Euler: Conjunto de problemas matemáticos, para ser resueltos mediante algoritmos. Se puede utilizar Python para resolver dichos ejercicios y practicar para aprender. monoBOT así lo ha hecho (y sigue haciendo). Gracias de nuevo Héctor.

Dilandau: Búsqueda y descarga (mp3) de música en Internet.

Saludos.

JUPP: joe de Linux para Windows

2010-12-21T15:06:00.000+01:00

Hola. Como ya he comentado en más de una ocasión, trabajo en entornos Windows XP (aunque prefiero Linux Ubuntu). En mi linux siempre he trabajado con el editor de textos joe, y en Windows evidentemente no... sin embargo hace unos meses descubrí JUPP.

JUPP es la versión portable de Joe's Own Editor (joe), uno de los editores de texto-ASCII más antiguos de sistemas Linux. En los tiempos en los que yo programaba en C, en vez de utilizar Emacs ó vi, usaba joe, sobretodo por la utilización de teclas imitando a WordStar, un procesador de textos de los años 80 y 90, que sucumbió, como no, a la serie Office de Microsoft, como tantos otros (WordPerfect, etc).

JUPP es software libre, así que se puede distribuir y modificar bajo los términos de la GNU GPL.

JUPP (ó joe para Linux) es un editor de texto para consola, donde prima mucho la utilización de teclas para operar sobre bloques de texto. Si eres de mi época, seguro que te acuerdas de las guerras entre los procesadores de textos WordStar, WordPerfect, un tal Word que asomaba la cabeza... y todo en un fantástico entorno MS-DOS (yo utilizaba DR-DOS, de Digital Research, adquirido luego por Novell).

JUPP no es lo ideal para programar, aunque se puede hacer perfectamente (es un editor para programación), no es el ideal para escribir textos y documentación, pero se puede realizar, ... JUPP e simplemente uno de los editores más fáciles de utilizar, donde prima la rapidez, sin complicaciones.

En Linux, solo con invocar joe ya entramos en el editor. Con las conbinaciones de teclas Ctrl+K+H obtenemos la ayuda, que es un cuadro situado arriba de la pantalla. En JUPP, si quieres que aparezca la ayuda tienes que ejecutar en el intérprete de comandos (cmd.exe), jupp -help.

Como se puede observar, con JUPP (joe) podemos operar sobre bloques de código, ir a posiciones a partir del cursor, línea ó fichero , búsqueda, etcétera. Es decir, lo mínimo, utilizando combinaciones de teclas Ctrl+..., rápido y sencillo.

Una de las cosas que tiene realmente buenas JUPP (joe) es que es muy configurable, donde podemos cambiar la matoría de los parámetros en su fichero de configuración jupprc. Más información sobre esto en su ayuda (manpages en Linux, y html en Windows).

INSTALAR JUPP EN WINDOWS

En la página web de jupp podemos encontrar, para entornos Microsoft, dos versiones, una para MS-DOS (jupp 2.8) y otra para Windows (jupp 3.1). Si queremos que jupp reconozca sintaxis Python tendremos que instalar la versión para Windows.

En Linux, joe funciona perfectamente. En Windows hay que hacer algunas cosas. Se descarga desde la siguiente URL:

https://www.mirbsd.org/jupp.htm

Nos vamos a la etiqueta Binaries, en el punto jupp 3.x for Unix, sección JOE 3.1jupp14 for Windows. Descargamos el fichero JWIN31E.EXE.

Lo ejecutamos, y se descomprime el ejecutable en una carpeta JWIN31.EXE:

Nos ponemos encima del fichero SETUP.INF, botón derecho y seleccionamos del menú emergente Instalar.

El programa se instala en C:\WINDOWS\system32\joe. Para ejecutarlo hay que ir al intérprete de comandos (cmd.exe) y escribir jupp32.

Esta versión de jupp soporta sintaxis Python, que está en un fichero de configuración joe (JFS), y que se puede encontrar en C:\WINDOWS\system32\joe\syntax\python.jfs. Se puede modificar dicho fichero. Por ejemplo, si se dispone de una versión Python con palabras clave nuevas, se pueden agregar.

También se puede cambiar tanto la indentación, como la codificación y otros valores en el fichero de configuración jupp32rc, en la sección de Python:

NOTA: Si se te da el caso que trabajando con ficheros .py no puedes escribir acentos, eñes y demás caracteres latinos, prueba a cambiar la codificación en jupp32rc, cambiando utf8 por iso8859, tal que así:

...resumiendo

Gracias a Joseph H. Allen por este programa, tan pequeño, con el que se pueden hacer cosas tan grandes.

La nostalgia y los buenos recuerdos programando en este editor me han hecho escribir este post.

Saludos.

Palabras clave y funciones integradas en Python

2010-12-18T13:39:00.001+01:00

Si queremos saber las palabras clave que tiene nuestra versión actual de Python podemos acceder al módulo keyword, el cual recoge dicho conjunto de vocablos. Tal que así:

import keyword

print "Palabras clave", keyword.kwlist

Si nos ponemos algo más puntillosos, podemos mejorar la presentación, bien utilizando el módulo pprint, ó creando una presentación por columnas, tal que así:

import keyword

tab = '\t'

enter = '\n'

contador = 0

cadena = ''

for i in keyword.kwlist:

cadena += i + tab

if contador == 5:

contador = 0

cadena += enter

else:

contador += 1

print cadena

Devolviendo las palabras clave (versión 2.6.6):

Python trae consigo ciertas funciones que vienen de serie, esto es, no es necesario cargarlas desde ningún módulo, como raw_input ó abs. Dichas funciones dependen de la versión Python que tengamos instalada en nuestro sistema. Podemos encontrar (en perfecto inglés) las built-in Functions en:

http://docs.python.org/library/functions.html

Aprender tanto las funciones integradas como las palabras clave en Python es importante.

Saludos.

Certificación en Python

2010-12-17T21:07:00.001+01:00

Hola. Hoy he leído en el blog de Mike Driscoll (http://www.blog.pythonlibrary.org/), gurú de Python, un artículo (http://www.blog.pythonlibrary.org/2010/12/14/the-new-python-certificate/) muy interesante sobre un programa de certificación en Python, por la Universidad de Illinois (EEUU). Evidentemente a los navegantes de la península nos queda algo "retirado", incluso a nuestros hermanos de América del Sur. El artículo está en inglés, pero os recomiendo su lectura.

Un paso hacia la certificación en Python. Ojalá instituciones (universidades, por ejemplo) nacionales ó empresas de nivel mundial ( ...mmm, ¿Google?) creasen este tipo de certificaciones.

Más información en http://www.oreillyschool.com/certificates/python-programming.php.
Saludos.

Área de descargas de El Viaje del Navegante

2010-12-13T11:21:00.000+01:00

Hola. Me he dado cuenta que cada vez que escribo un post que contiene mucho código no suele ser una buena idea, ya que el lector tiende a no leerlo (yo tampoco lo haría). Es por ello que conforme vaya escribiendo artículos de aplicaciones sencillas, colgaré el código generado (zip con ficheros .py) de los ejemplos en la siguiente dirección web:

https://sites.google.com/site/elviajedelnavegante/

Voy a intentar colgar todo el código posible. A día de hoy tenéis en la sección de código, un ejemplo del FoldPanelBar y wxFormBuilder del artículo http://elviajedelnavegante.blogspot.com/2010/12/wxpython-disenar-un-mantenimiento-con.html.

Además colgaré documentación referida a Python en la sección de documentación (a día de hoy está la presentación en PDF de Python y wxPython).

Una última cosa... Yo normalmente comento abundantemente el código que diseño ó escribo (¡el motivo fundamental es que tengo memoria de pez, se me olvida!), por lo que bajar los ficheros no solamente es para verificar que funciona, sino para una guía de cómo llegar al resultado. Esta técnica es fundamental para aprender. Es más, yo aprendo Python de ejemplos que comentan otros autores, modificando dicho código e indagando en la cuestión.

Saludos.

wxPython: Diseñar un mantenimiento con FoldPanelBar y wxFormBuilder

2010-12-11T20:59:00.002+01:00

Hola. En este artículo vamos a ver como diseñar un mantenimiento sofisticado en wxPython, con la ayuda del componente de wxPython, el FoldPanelBar, y el diseñador wxFormBuilder.

¿Qué es un FoldPanelBar? Es un conjunto de paneles colapsables, para presentar la información en un Frame de manera parcial, activando y desactivando paneles colapsables. Es lo más parecido a wx.CollapsiblePane, pero en vez de un panel puede haber varios. Tenéis un ejemplo completo en el wxPython 2.8 Docs Demos and Tools, que se puede obtener de http://www.wxpython.org/download.php#stable.

Como podemos ver este componente está dentro de un SplitterWindow, que es un Frame que se puede dividir en zonas, tal como se ve en la imagen. La cuestión es hacer un mantenimiento de datos, que utilice dicho componente de paneles colapsables. El diseño del FoldPanelBar se hará en base al código que está disponible en la documentación de wxPython. Lo único que nos falta es diseñar el contenido de los paneles colapsables. Para ello vamos a utilizar wxFormBuilder. ¿Cómo? Pues diseñando cada panel según los datos que queremos que aparezcan. Esto lo podemos resumir en el siguiente gráfico:

Con wxFormBuilder vamos a construir gráficamente todos los paneles necesarios, cuya sintaxis Python generada se guardará en el fichero design_vista_usuarios.py. En el fichero vista_usuarios.py crearemos una instancia del componente FoldPanelBar e importaremos los paneles creados que están en el fichero design_vista_usuarios.py. Una vez realizado esto, simplemente incluiremos los paneles en su lugar correspondiente dentro del FoldPanelBar, ...y ¡listo!, ya lo tendremos todo hecho.

¿Por qué así? ¿Por qué no crear el FoldPanelBar dentro de design_vista_usuarios.py? Pues por la sencilla razón que si queremos cambiar en wxFormBuilder algo y volvemos a generar el código cabe la posibilidad de eliminar las modificaciones pertinentes. Además, trabajar con herencia es algo fundamental en el diseño de aplicaciones wxPython, ya que nos ahorramos código y tiempo. Es decir, podemos volver a generar el código en el diseñador, sin tocar otras partes que ya están hechas y funcionan.

NOTA: Vamos a crear un mantenimiento de gestión de usuarios de una aplicación genérica.

wxFormBuilder

Lo primero de todo es crear un proyecto. Después se especifica el fichero que contendrá el código Python generado, y a continuación, ¡¡¡a diseñar!!!.

Como podemos observar en el árbol de objetos (Object Tree), nuestro diseño se basa en un Frame, barra de menú, un menú y una serie de paneles, que contienen cada uno de ellos más widgets (botones, cajas de texto, etc.), todos ellos dispuestos posicionalmente mediante Sizers.

A continuación, diversas capturas de pantalla del diseño de paneles y demás widgets:

NOTA: Los iconos que aparecen en el menú de herramientas los he bajado de http://www.iconspedia.com/.

NOTA2: Como podéis observar en la imagen hay un panel llamado PanelUsuario. A este panel no hay que hacerle caso, es una prueba que realicé y se me ha colado ahí. Disculpadme.

Una vez realizados todos los diseños de los paneles, frames y menús se genera el código Python, guardándose en el fichero especificado en el proyecto, design_vista_usuarios.py.

Heredando el diseño...

Bien, ya tenemos prácticamente terminado nuestro viaje. Únicamente nos falta crear una clase que instancie el componente FoldPanelBar de wxPython, e incluir los paneles generados por wxFormBuilder en su sitio. Aunque al lector le parezca un trabajo en exceso o demasiado enrevesado, en realidad no lo es... es más, es la mejor forma de cambiar código con la mínima repercusión. El contenido del fichero vista_usuarios.py es el siguiente:

import wx
import wx.lib.agw.foldpanelbar as fpb
from design_vista_usuarios import FrameGenerico, BarraMenuGenericoPersona
from design_vista_usuarios import MenuGenerico, PanelUsuarioNick
from design_vista_usuarios import PanelUsuarioLocalizacion, PanelUsuarioExtra
from design_vista_usuarios import PanelUsuarioPersona

class frame_usuario(FrameGenerico):
   def __init__(self):
   # Llamamos al constructor del FrameGenerico.
   FrameGenerico.__init__(self, None )
   # Incluimos título al frame.
   FrameGenerico.SetTitle(self, u"Gestión de usuarios")
   # Creamos una barra de herramientas en el frame.
   self.SetToolBar(BarraMenuGenericoPersona(self))
   # Creamos menú generico.
   menu = MenuGenerico()
   # E incluimos dicho menú en el frame.
   self.SetMenuBar(menu)
   # Creamos un Fold Panel Bar.
   self.panel = fpb.FoldPanelBar(self, wx.ID_ANY, wx.DefaultPosition,
   wx.DefaultSize, agwStyle=fpb.FPB_VERTICAL)
   # Creamos subpanel de datos de identificación del usuario.
   subpanel = self.panel.AddFoldPanel(u"Identificación", collapsed=False)
   # Incluimos panel de nick, foto y contraseña de usuario.
   panel = PanelUsuarioNick(subpanel)
   self.panel.AddFoldPanelWindow(subpanel, panel, fpb.FPB_ALIGN_WIDTH)
   # Creamos subpanel de datos personales del usuario.
   subpanel = self.panel.AddFoldPanel(u"Datos personales", collapsed=True)
   # Incluimos panel de datos personales.
   panel = PanelUsuarioPersona(subpanel)
   self.panel.AddFoldPanelWindow(subpanel, panel, fpb.FPB_ALIGN_WIDTH)
   # Creamos subpanel de datos de localización del usuario.
   subpanel = self.panel.AddFoldPanel(u"Dirección", collapsed=True)
   # Incluimos panel de dirección personal.
   panel = PanelUsuarioLocalizacion(subpanel)
   self.panel.AddFoldPanelWindow(subpanel, panel, fpb.FPB_ALIGN_WIDTH)
   # Creamos subpanel para datos extra.
   subpanel = self.panel.AddFoldPanel(u"Teléfono y correo electrónico",
   collapsed=True)
   # Incluimos panel de teléfonos y correos electrónicos.
   panel = PanelUsuarioExtra(subpanel)
   self.panel.AddFoldPanelWindow(subpanel, panel, fpb.FPB_ALIGN_WIDTH)

# Lanzamos aplicación.
aplicacion = wx.PySimpleApp()
frame_usuario = frame_usuario()
frame_usuario.Show()
aplicacion.MainLoop()

Y listo!!!! Con solo ejecutar python vista_usuarios.py ya tenemos nuestro diseño de mantenimiento de gestión de usuarios genérico. Darse cuenta de las pocas líneas de código que hemos tenido que escribir, ya que la mayoría del trabajo ha sido diseñado en wxFormBuilder, generándose el código Python automáticamente.

wxPython: FoldPanelBar

Como se puede observar hemos creado un mantenimiento bastante "moderno" con un componente, el FoldPanelBar, que nos da bastante juego en la presentación de datos, ofreciendo más por menos. Los paneles, diseñados con wxFormBuilder, contienen todos los widgets mínimos necesarios, dispuestos con sizers (BoxSizer y FlexGridSizer). Trabajar con sizers nos ahorra tiempo... con wxFormBuilder es un juego, os lo aseguro.

Todo el código, tanto del proyecto wxFormBuilder (usuarios.fbp), como los ficheros Python design_vista_usuarios.py (código generado por wxFormBuilder) y vista_usuarios.py los podéis encontrar en un ZIP, FoldPanelBar.zip,en el repositorio de este blog:

https://sites.google.com/site/elviajedelnavegante/codigo

Una pequeña observación... ó dos...

wxFormBuilder está disponible tanto para Windows, Linux como Mac. La versión con la que yo trabajo de wxFormBuilder es 3.1.70. Os lo digo por si intentáis abrir el fichero del proyecto y os dice que nada de nada. En Ubuntu Lucid la versión disponible es la 3.1.59-beta, con lo que necesitaréis instalaros desde su web la más reciente.

No está mal recordar que el proyecto de wxFormBuilder genera un fichero .py específico en una ruta determinada. Es decir, si quieres volver a generar el código Python del diseño no estaría mal cambiar la ruta donde tengas tu fichero .py.

Espero pueda serviros. Saludos.

Herencia múltiple en Python, ¡el orden importa!

2010-12-10T12:41:00.001+01:00

Hola. En este artículo vamos a ver la importancia de definir bien la herencia múltiple, esto es, el orden en el cual se llama a los constructores (__init__, que no es el constructor, aunque sí es el sitio donde escribiremos el código que ejecutaría el constructor) de las clases heredadas, ya que es fundamental, así como la importancia de nombrar bien a los atributos, para que no se sobreescriban (override); en Python no hay polimorfismo entendido como sobrecarga de métodos, aunque hay maneras de emularlo.

NOTA: Si se quiere entender con más profundidad como Python resuelve el tema de la herencia múltiple aconsejo que miréis el tema de MRO en http://www.python.org/download/releases/2.3/mro/.

Comenzamos...

Imaginemos que declaramos dos clases que heredan de object: clase1 y clase2. Creamos una tercera clase, clase3, que hereda de clase1 y clase2. Tal como aparece en la imagen de abajo:

Al instanciar la clase3 vemos que ha heredado los métodos de las clases clase1 y clase2 pero únicamente el atributo de la clase1. ¿Por qué? Si nos damos cuenta en la clase3 no hemos llamado a ningún constructor, esto es, hacemos pass, por tanto Python resuelve por el orden en el que se ha declarado la herencia múltiple en clase3, es decir class clase3(clase1, clase2). Obtiene el atributo de la primera clase que se encuentra de izquierda a derecha, esto es, clase1.

Ahora si en el constructor de la clase3 llamamos a los constructores de las clases clase1 y clase2 tenemos que:

clase3 hereda tanto los métodos como los atributos de las clases clase1 y clase2. Esto es lo que esperábamos.

Ahora lo que vamos a hacer es renombrar los atributos de la clase1 y clase2 con el mismo nombre, es decir, van a tener un atributo cada una de las dos clases, que se va a llamar "atributo". Mira lo que pasa ahora:

¡Vaya! ¿Python no sabe distinguir entre dos atributos con el mismo nombre? La respuesta es que no sabe. ¿Y cual elige? Pues el atributo que sea el último en inicializarse. Como clase3 la hemos inicializado primero con el constructor de la clase1 y por último con el de la clase2, será el atributo de la clase2 el que existirá (esto es, hace un override al atributo de la clase1). Hacemos la prueba llamando a los métodos que nos devuelvan el valor de los atributos de las clases:

Y tenemos:

Es decir, el método devolver_atributo2() hace lo correcto, pero el método devolver_atributo1() lo que hace es devolver el atributo que está inicializado, esto es, el que se inicializó el último, es decir, el de la clase clase2. ¡Vaya! ¡Parece un lío, pero no lo es! Si lo piensas bien tiene su lógica (aunque no tanto su gracia).

¿No me crees? Vamos a hacerlo al revés. Ahora vamos a llamar a los constructores de la clase3 cambiando el orden, de manera que ahora llamamos primero al constructor de la clase2 y por último al constructor de la clase1. Mira lo que pasa:

Y tenemos que:

...como cabría esperar.

Tan solo con nombrar bien a los atributos de las clases heredadas todo funciona a las mil maravillas:

Y el resultado es:

Vamos a ver un último caso. Creamos una tercera clase, llamada clase25, que también hereda de object, y vamos a modificar clase3, que ahora va a heredar de clase25, clase1 y clase2. Todo queda como sigue:

Como vemos todo es normal; clase3 hereda tanto métodos como atributos. Pero... ¿y si cambiamos la forma en la que heredan las clases? Vamos a declarar que ahora clase25 hereda de clase2 y que clase3 ahora solo hereda de clase25 y clase1. ¡PUFF! ¡Vaya comida de cabeza!. Mira la siguiente imagen:

¿Ein? El lector, si ha entendido (que seguro que sí) lo expuesto en este post debe saber porqué no aparece el atributo2 si la clase clase25 hereda de clase2, que contiene dicho atributo. Evidentemente, porque en el constructor de la clase clase25 no se ha llamado al constructor de la clase clase2. Si hacemos la llamada entonces clase3 tiene todos los atributos que se esperaba heredar:

Bueno, espero que este artículo os sirva de ayuda a la hora de utilizar la herencia múltiple, con cuidado.

Saludos.

Python en Murcia, la primera y no la última...

2010-12-10T11:10:00.000+01:00

Hola. En este post os dejo el enlace para que os descarguéis la presentación (lo he convertido a PDF) que realicé en la Murcia Lan Party 2010, el pasado martes. Siento los que no podáis haber ido, ya que me hubiera gustado conoceros en persona, cambiar impresiones y plantearnos nuevas "quedadas", con más tiempo, para hablar de Python, hacer talleres sobre tecnologías adyacentes (wxPython, Django, móviles), es decir, aprender los unos de los otros. Sería una buena idea, creo yo.

La gente que fue a la presentación estuvo genial, ya que permanecieron sentados y a excepción de una persona, ¡¡¡no se fue nadie!!!!. Tengo que decir que me alargué en exceso intentando explicar código Python, algo que no volverá a suceder, ya que en vez de una hora me alargué a hora y media, algo que no puede ser, ya que me hice "algo pesado" en algún momento. Pero como de los errores se aprende, en la siguiente exposición (espero que esta sea la primera de muchas) seré mucho más conciso, para que todo sea más liviano.

De todas formas estoy contento de haber ido, e incluso nos dió tiempo a una "mini" rueda de ruegos y preguntas sobre Python y wxPython.

El enlace donde podéis descargar la presentación es:

https://sites.google.com/site/elviajedelnavegante/documentacion

Saludos.

Python en la Murcia Lan Party 2010, ¡¡¡ya tenemos hora!!!

2010-12-05T21:17:00.000+01:00

Hola. Ya me he puesto de acuerdo con la gente de la Lan Party. Daré una charla de introducción a Python y wxPython, en Murcia, en el Pabellón Príncipe de Asturias (junto a la Biblioteca Regional de Murcia), a las 19:00 del martes 7 de Diciembre, en el Aula 9.

La charla rondará la hora de duración.

Mi objetivo prioritario es conoceros, para ponernos en contacto, hablar de Python, de cosas que se podrían hacer. Como ya he comentado en el anterior post, daré una charla introductoria sobre Python (no un tutorial) y wxPython, sobretodo por falta de tiempo, ya que 1 hora es algo apretado, y no quiero aburrir a la gente.

Voy a exponer un Impress (exposición en OpenOffice) y alguna que otra cosa más. Dicha presentación la colgaré estos días en el blog, para que podáis echarle un vistazo.

Bueno, espero que os guste.

Saludos.

Conferencia de Python en la Murcia Lan Party 2010

2010-12-02T21:16:00.002+01:00

Hola. Os comento que el martes 7 de diciembre, a las 19:00, daré una charla sobre Python y wxPython en Murcia, en la Murcia Lan Party 2010.

He hablado hoy mismo con el coordinador de la Lan Party y me ha comentado que me daba cierta libertad, así que presentaré (si me da tiempo) el siguiente contenido:

DISEÑO Y DESARROLLO DE APLICACIONES DE ESCRITORIO CON PYTHON Y WXPYTHON

1) Breve historia de Python.

2) Breve introducción a Python: estructura, sintáxis y filosofía [ZEN de Python].

3) Conceptos de programación fundamentales, POO y persistencia de datos, en Python.

4) El framework gráfico wxPython: breve introducción.

5) Construcción de aplicaciones de escritorio con wxPython.

7) IDE's, editores y GUI's para Python.

Bueno, si a alguien le interesa y puede venir, encantado de encontrarme con vosotros, para hablar un poco de Python, de la vida, y de esta bendita profesión.

Saludos.

Analfabetismo político

2010-11-10T19:02:00.001+01:00

El peor analfabeto es el analfabeto político. Él no oye, no habla, no participa de los acontecimientos políticos.

Él no sabe que el costo de vida, el precio del poroto, del pan, de la harina, del vestido, del zapato y de los remedios, dependen de decisiones políticas.

El analfabeto político es tan burro que se enorgullece y ensancha el pecho diciendo que odia la política.

No sabe que de su ignorancia política nace la prostituta, el menor abandonado y el peor de todos los bandidos que es el político corrupto, mequetrefe y lacayo de las empresas nacionales y multinacionales.

Bertolt Brecht.

Me cambio de versión Python

2010-10-20T22:50:00.006+02:00

Hola. Hace aproximadamente un año que empecé a barajar la opción de aprender un lenguaje de programación nuevo, lo suficientemente bueno para mí, que respondiera a lo que exijo, ya que las plataformas actuales no me terminaban de convencer (y todavía siguen sin convencerme del todo), como PHP, Java ó .NET. Entonces probé Ruby y Python, y me quedé con el último. Había multitud de versiones, y me decidí por Python 2.5.4 por la cantidad de software de terceros que estaba programado para esta versión.

Una gran versión de Python la 2.5.4. Pero hay que seguir (¡y evolucionar!), así que me cambio a la última versión de Python que no sea 2.7 ó 3.XX, esto es, Python 2.6.6. ¿Por qué? La 2.7 sinceramente no me da confianza suficiente y necesito aplicaciones que corran en la 2.6. Y Python 3000, todavía está en fase de desarrollo ó pruebas ó test o como lo quieran llamar. Es una opinión personal mía, claro, y cualquier navegante podrá decir lo contrario.

A partir de este post, todo lo que escriba se hará con Python 2.6.6, y salvo excepciones, en plataforma Microsoft Windows XP SP3. Puesto que Python es multiplataforma, no hay problemas para Mac ó Linux.

Saludos.

Herramientas (IDE, GUI, EDITOR) para desarrollar en Python

2010-10-18T01:36:00.001+02:00

PRUEBA, COMPARA Y SI ENCUENTRAS ALGO MEJOR, INSTÁLALO

Hola. Desde que estoy programando en Python siempre he estado buscando esa aplicación para programar en este estupendo framework de desarrollo. Y después de varios meses me he dado cuenta que mi búsqueda ha sido futil. Esto es, no hay un editor ó IDE mejor que otro, cada uno tiene sus características, y en la mayoría de los casos hacen lo mismo. Además, también cuenta la experiencia previa. Así, gente que venga del mundo de Linux con programación en C puede ser que sean forofos de Emacs ó de vim. Si se viene del mundo de Java, pues NetBeans (con el plugin correspondiente) es una opción excelente. Con esto quiero decir que no hay un IDE óeditor definitivo para Python, solamente la experiencia en la utilización así como nuestras vivencias anteriores son las que marcarán la elección del mismo. Es más, se puede trabajar con más de un editor, aunque en Python, por el tema de la indentación de código, quizás no sea lo más recomendable.

En este post voy a describir los IDE's, editores y GUI's que he probado y he estado utilizando durante casi un año. Solamente voy a incluir los que me han gustado. Omito los que menos me han convencido, puesto que no quiero desmerecer el trabajo de nadie, ya que este artículo es subjetivo teniendo en cuenta que aquí entran los gustos de programación de cada uno. Por ejemplo, no quiero hablar de Eclipse (con el plugin Pydev), que aunque sé que es un IDEestupendo, tengo otras preferencias. Evidentemente no he visto todos, así por ejemplo, el IDEMonkeyStudio no lo he probado, por varias razones (una de las cuales se encuentra que no trabajo con Qt), al igual que Spyder (también utiliza Qt) que está orientado para científicos,PIDA, Leo, eric, etc. También se ha dado el caso de productos que he visto pero por ser de pago no he podido seguir indagando, como es el caso de wxDesigner, un GUI para desarrollo de interfaces gráficas en wxPython. Tiene muchos widgets y Sizers, sin embargo la versión de prueba no deja guardar el fichero generado, así que no me deja evaluar el producto correctamente, y en consecuencia puedo hablar muy poco de él. Y por último hay software que quizás debería terminarse antes de lanzarse al mercado como herramientas de desarrollo enPython, como es el caso de FarPy, otro GUI que sencillamente explota cuando menos te lo esperas, así como IronPython Studio, un despropósito para desarrollar en IronPython, que no es que estalle, sencillamente se derrumba.

En la página oficial de Python se puede encontrar toda una relación de las mejores herramientas de desarrollo para Python, tanto IDE's, GUI's como editores, en todas las plataformas (Linux,Mac, Windows).

Dejando algunos conceptos claros

¿Qué es un IDE? IDE son las siglas de entorno de desarrollo integrado. Es una aplicación (entorno de programación) para desarrollar software que está compuesto normalmente por un editor de código, un compilador ó un intérprete, herramientas auxiliares de desarrollo (creación de documentación, tests, empaquetado de software), un depurador y algunas veces un diseñador de interfaces gráficas incorporado.

¿Qué es un GUI? GUI son las siglas de interfaz gráfica de usuario. Son herramientas para crear interfaces gráficas, esto es, componentes gráficos con los cuales el usuario interacciona con la aplicación. Hay algunos IDE's que contienen GUI's integrados.

¿Qué es un editor? Un editor es una aplicación para escribir código de programación en el lenguaje deseado, en nuestro caso, Python. Contiene todas las herramientas de edición necesarias, y algunas veces características propias de IDE's. Hay veces que cuesta distinguir entre un IDE y un editor por la cantidad de opciones que tiene este último.

¿Qué es un RAD? RAD son las siglas de desarrollo rápido de aplicaciones. Dependiendo del autor sirve para designar a las aplicaciones de desarrollo de interfaces gráficas ó a los IDE's conGUI's integrados, o a las dos cosas. Es un término dado a plataformas de desarrollo comoPowerBuilder, Visual Studio ó Delphi, por poner ejemplos.

Herramientas de desarrollo en Python

A continuación presento las herramientas de desarrollo que he evaluado durante estos meses y que más me han gustado. ¿La herramienta perfecta? Un compendio de todas ellas.

IDE con GUI integrado: BOA Constructor, SharpDevelop

IDE: IDLE, NetBeans, Stani's Python Editor, PyScripter, Geany, Pyragua,Wingware Python IDE, PythonWin

GUI: wxGlade, wxFormBuilder

Editor: Editra, Notepad++, Jedit, Gedit, BlueFish, SciTE

Shell interactivo: Dreampie

SciTE

Scite es un editor de texto para programadores, con un amplio abanico de lenguajes, incluidoPython, por supuesto. Su potencial reside en su gran capacidad de configuración. Permite exportar a PDF, Latex, RTF, XML y HTML. A nivel de edición está extraordinariamente completo. Además se puede compilar en el propio editor (e incluir parámetros ) y ver la salida del script. Tiene coloreado e indentación de código. Muy buen software, basado en Scintilla. Aunque originalmente está en inglés, se puede traducir al español mediante un fichero, que hay que descargarlo.Hay que copiar el archivo locale.es.properties en la carpeta de SciTE y renombrarlo como locale.properties.

BOA Constructor

BOA Constructor es un IDE y un GUI para wxPython. Podría considerarse como un RAD. Es lo más parecido a Microsoft Visual Studio ó Delphi, pero para Python. Tiene un editor, con coloreado, indentación y completitud de código (basado en Scintilla), así como un GUI para diseñar interfaces gráficas en wxPython. El posicionamiento de widgets del diseñador gráfico se puede realizar mediante coordenadas con wx.Point ó con Sizers. Tiene inspector de código, se puede crear packages, módulos, setup's, etc. Tiene vista UML, generación de código y un largo etcétera. Además incluye una ayuda en línea muy potente y agradecida. Una herramienta RADcompleta que aunque es algo antigua (2006) está muy probada y es una excelente opción para desarrollar en Python. Muy recomendada.

Bluefish

Bluefish es un editor para diseñadores web experimentados y programadores, soporta varios lenguajes de programación y de marcado, pero se centra en crear sitios web dinámicos e interactivos. Aunque tiene su fuerte en la creación de páginas web también soporta Python, con indentación, coloración y completitud de código. Muy ligero y elegante. Una herramienta a tener en cuenta si además estamos creando diseños web.

Wingware Python IDE

Wingware Python IDE es quizás el mejor IDE para Python que hay actualmente, y digo quizás, con permiso de Komodo, porque lo tiene todo, realmente todo, lo que se le puede pedir a un IDE para desarrollar en Python. El único problema que tiene este software es que es de pago. Solo lo he podido evaluar con pequeños scripts, pero me ha convencido desde el primer momento. Lo tiene todo, excepto que la licencia ronda los 200 dólares.

Stani's Python Editor

Stani's Python Editor ó SPE es el IDE pythónico gratuito más completo que he visto, exclusivo para programar en Python. Incluye lo típico en edición, más coloreado (resaltado), indentación y completitud de código, depurador (winpdb), ejecución de scripts, chequeo de sintaxis, incluye el diseñador wxGlade, generación automática de documentación, visualización de clases mediante diagramas UML, etc. Un IDE muy potente y pythónico. Muy recomendado.

wxGlade

wxGlade es un GUI para diseño de interfaces gráficas en el framework gráfico wxPython. Todo un clásico en entornos Linux, desde hace ya bastante tiempo, y una herramienta muy válida y potente. Permite crear código wxPython a partir del diseño gráfico, mediante la utilización de Sizers (es obligatorio), no pudiendo utilizar el posicionamiento con wx.Point. En este blog se ha escrito bastante sobre wxGlade, por lo que os presento un artículo de cómo diseñar una interfaz gráfica, así como el código de ejemplo de la creación de un mantenimiento típico. Recomendable.

Geany

Geany es un IDE rápido y ligero, muy recomendable para proyectos pequeños y medianos, por su rapidez y sencillez. Lleva un completo arsenal de opciones de edición, así como la posibilidad de ejecución de scripts. Contiene un árbol de navegación de elementos (clases, métodos, etc), así como indentación, coloración y completitud de código. Dentro de los IDE's es el más básico, ya que contiene lo mínimo y necesario para desarrollar en Python de manera rápida. Geany es el típico caso de un IDE que pudiera considerarse un editor avanzado con llamada al intérprete dePython para ejecutar código Python. Todo depende del criterio a la hora de definir lo que es uneditor ó un IDE. Este producto es recomendable.

Jedit

Jedit es un editor de texto para programadores escrito en Java (es necesaria la máquina virtualJava). Para programar en Python hay que instalarse 2 plugins desde el Plugin Manager que lleva incorporado. Es un editor muy configurable, de grandes prestaciones.

Gedit

Gedit es el editor oficial del entorno de escritorio Gnome de Linux. Existe versión paraWindows. Su simplicidad y el reconocimiento de código Python lo hace una opción muy interesante para escribir scripts rápidos. Es un editor muy simple y efectivo.

Dreampie

Dreampie es un shell interactivo para Python, no pudiéndose enmarcar ni como editor ni como IDE (ni mucho menos GUI). Lo he incluido en este artículo ya que no sería completo del todo sin nombrar al menos a un intérprete de Python. Existen otras aplicaciones de este estilo, como PyCrust ó PyShell, sin embargo Dreampie es bastante singular ya que la ventana principal se divide en dos, un área de histórico, que permite ver el código procesado así como su resultado y un área donde escribir el código. Esto permite editar cualquier cantidad de código, y ejecutarlo cuando esté listo. También se puede copiar el código desde cualquier lugar, editar y ejecutar al instante. Tiene coloreado, indentación y completitud de código (muy rápido). Se puede exportar los resultados a HTML. La verdad que un producto muy bueno, que utilizo normalmente. Muy recomendado.

NOTA: PyCrust tiene la misma funcionalidad que Dreampie, e incluso es más potente, sin embargo, por cuestiones de gusto y comodidad (y aquí entra mucho la subjetividad) prefieroDreampie.

Notepad++

NotePad++ es un viejo conocido de los editores de programación, y de los más populares en toda la comunidad de desarrollo. En el área de plugins se puede bajar uno específico paraPython. No lleva completitud de código si nos referimos a la búsqueda en el namespace de módulos, pero si te sugiere vocablos mientras se escribe. A nivel de edición de texto, lo lleva todo (búsquedas, sangrías, etc). Una de las características más relevantes es su grado elevado de configuración. Una buena herramienta, de toda la vida.

NetBeans

NetBeans es un tremendo y muy potente IDE desarrollado por Sun, que ahora es de Oracle. En origen NetBeans estaba pensado para Java, pero mediante plugins podemos programar en varios lenguajes, tales como Ruby, PHP ó Python entre otros. No se sabe muy bien que rumbo tomará NetBeans (ni Java) con la compra de Sun por parte de Oracle. Este IDE es de los más completos que existen en el mercado actualmente y gratuitos, siendo también muy pesado (si no tienes una máquina potente, mejor pensar en otra opción). Lleva de todo, indentación, completitud y coloreado de código, debugger, gestión de repositorios de versiones como Mercurial, CVS o Subversion, y un largo etcétera. Para entornos profesionales (empresas) de programación en Python recomiendo este IDE. Lo lleva todo y más, a excepción de un GUI integrado. Una vez instalado este software es necesario descargarse el plugin dePython (se hace desde el propio IDE).

IDLE

IDLE es un IDE que viene de serie en cualquier distribución de Python, escrito en Tkinter. Para empezar a programar y aprender Python es la herramienta más recomendada. Con completitud de código e indentación automática y configurable, coloración de código, un depurador integrado (debugger) y todas las características propias de un editor de código. No es recomendable para proyectos grandes y no debe de utilizarse con wxPython, ya que son incompatibles y los resultados son impredecibles. El gran potencial de IDLE es su shell integrado.

PyScripter

PyScripter es un IDE desarrollado en Delphi para la plataforma Windows. Es una excelente opción alternativa a otros IDE's de alto nivel, como Eclipse, Wingide ó NetBeans. Este es sin lugar a dudas una extraordinario IDE para desarrollos grandes en Python. Contiene todo lo que se puede desear, depurador, gestión de proyectos, múltiples ficheros abiertos, indentación, coloreado y completitud de código, codificación de ficheros, y un sin fin de opciones que lo hacen una alternativa muy fiable y completa. Yo, que trabajo normalmente en la plataformaMicrosoft Windows, lo he adoptado como software para desarrollar en Python. Excelente producto. Muy recomendable.

Editra

Editra es un editor avanzado de desarrollo, escrito en Python y wxPython. Excelente herramienta. Tenéis más información en el artículo de El Viaje del Navegante sobre Editra, que escribí hace unos meses. Recomendado.

Pyragua

Pyragua es un IDE creado en Python para desarrollar en Python. Todavía está en fases tempranas de desarrollo, pero las perspectivas son realmente buenas. Hay que darles tiempo a los chicos de Pyrox. En este blog hay un post sobre este IDE que escribí hace unos meses. Un trabajo que sigo. Muy prometedor.

SharpDevelop

SharpDevelop es un RAD, un IDE con GUI incorporado, al estilo de Visual Studio, con el que se puede desarrollar en IronPython, esto es, Python para acceder al framework de .NET. En este blog hay varios artículos en los que se utiliza esta fantástica herramienta. Aquí os presento un link sobre IronPython y SharpDevelop que escribí hace unos meses. Excelente y muy recomendado para utilizar IronPython.

wxFormBuilder

wxFormBuilder es un GUI para diseñar interfaces gráficas que genera código C++ y códigoPython con el framework gráfico wxPython. Es una herramienta con una interfaz amigable, que utiliza Sizers de manera obligatoria para la gestión del posicionamiento de widgets dentro de los contenedores. Lo bueno de este producto es la inclusión de widgets actualizados, así como la posibilidad de ampliarlos. Muy buena opción para diseñar pantallas y entender la filosofía en la utilización de Sizers. En este blog se han escrito algunos artículos sobre wxFormBuilder (1 y2). Muy recomendable.

PythonWin

Python Editor for Windows ó PythonWin es un IDE que viene incluido en el Python for Win32, de Mark Hammond, una extensión de Python para Windows. Con esta herramienta se puede analizar objetos COM y acceder a sus clases, entre otras cosas. Soporta completitud, coloración e indentación de código. Incluye PyChecker, para analizar la sintaxis antes de ejecutar un script. Hace unos meses escribí un post sobre como interactuar con objetosCOM por medio de la utilidad COM Makepy que lleva esta aplicación. Lo podéis encontrar aquí. Todo un clásico, rápido y eficaz.

CONCLUSIONES

¿Qué es lo que se necesita? Un GUI, un IDE ó un editor. Si se va a programar interfaces gráficas sería interesante el uso de un GUI para diseñar ciertas plantillas o pantallas, de manera visual, para ir más rápido y tener las cosas más claras, aunque no es necesario si no se quiere. Aquí se ha visto GUI's para wxPython, pero se debe de dejar claro que para plataformas comoQt ó GTK también hay GUI's, y muy buenos, como GTK Glade ó MonkeyStudio. Si se va a crear un proyecto largo y grande lo mejor, desde mi punto de vista, es seleccionar un IDE, ya que tiene una serie de herramientas que nos van a facilitar la vida. Si el proyecto es mediano ó pequeño, o simplemente se está empezando en el mundo de Python, un editor es una opción muy recomendable, ya que no necesitamos tantas opciones como nos puede brindar un IDE. De todas formas hay veces que no hay diferencia entre editores e IDE's por la cantidad de opciones que tienen los primeros.

Lo mínimo que se le debe de pedir a cualquier IDE ó editor, para desarrollar en Python, es laindentación, coloreado y completitud de código.

Una lista completa de editores, gui's e ide's se puede encontrar en la siguiente dirección web

http://wiki.python.org/moin/PythonEditors.

PRUEBA, COMPARA Y SI ENCUENTRAS ALGO MEJOR, INSTÁLALO

Saludos.

Las propiedades (Property) de Python

2010-10-14T17:30:00.008+02:00

Cuando estamos trabajando con clases, en Python, lo normal es crear unos atributos y unos métodos que accedan a dichos atributos, para modificar, asignar o devolver su valor. Para ello se aconseja que los atributos sean ocultos, de manera que únicamente, a través de los métodos, se pueda acceder a sus valores. Por ejemplo, una clase que defina a una persona puede ser la siguiente:


class ser_humano(object):
   def __init__(self, edad, altura, peso):
       self.__edad=edad
       self.__altura=altura
       self.__peso=peso

   def getPeso(self):
       return self.__peso

   def setPeso(self, peso = None):
       self.__peso = peso

   def getAltura(self):
       return self.__altura

   def setAltura(self, altura = None):
       self.__altura = altura

   def getEdad(self):
       return self.__edad

   def setEdad(self, edad = None):
       self.__edad = edad

Como se puede observar al instanciar la clase se tienen que pasar los valores de los atributos para la inicialización. Para modificar los valores de los mismos se ha implementado, para cada atributo un método del tipo set****, y para devolver el valor del atributo se implementa el get****. Podemos ver en nuestro shell favorito al instanciar la clase, de lo que disponemos en el objeto creado:

persona = ser_humano(32,1.70,70)

En Python hay otra alternativa al uso de set**** ó get**** y es envolver dichos métodos dentro de propiedades.

Una propiedad (property) en Python es un mecanismo que se utiliza para dar propiedades
a la instanciación de clases (a los objetos). Las propiedades realizan tareas parecidas a las que realizan __getattr__, __setattr__ y __delattr__, pero más rápido y fácil. Una propiedad se crea llamando a property y vinculando su resultado al atributo de clase. La sintaxis es la siguiente:

atributo = property(fget = None, fset = None, fdel = None, doc = None)

Veamos la creación de propiedades en la clase anterior:


class ser_humano(object):
   def __init__(self, edad, altura, peso):
       self.__edad=edad
       self.__altura=altura
       self.__peso=peso

   def __getPeso(self):
       return self.__peso

   def __setPeso(self, peso = None):
       self.__peso = peso

   def __getAltura(self):
       return self.__altura

   def __setAltura(self, altura = None):
       self.__altura = altura

   def __getEdad(self):
       return self.__edad

   def __setEdad(self, edad = None):
       self.__edad = edad

   peso = property(fget = __getPeso, fset = __setPeso, doc = 'Peso')
   edad = property(fget = __getEdad, fset = __setEdad, doc= 'Edad')
   altura = property(fget = __getAltura, fset = __setAltura, doc = 'Altura')

Lo que ahora hemos hecho ha sido ocultar todos los métodos get**** y set**** y crear 3 propiedades nuevas, de manera que sólo ellas sean públicas. Nos vamos al shell y vemos que únicamente aparece como interfaz pública del objeto creado peso, edad y altura.

Haciendo:
a = ser_humano(29,1.65,98)

a es una instancia de ser_humano. Cuando se hace referencia a a.atributo, Python llama en a al método que se declara como argumento fget. Así, print a.altura devolverá 1.65. Cuando asignamos a.atributo = valor, Python llama al método que definimos como argumento fset, esto es, a fset se le pasa valor. Podemos modificar el peso haciendo a.peso = 70. Para finalizar, cuando ejecutamos del x.atributo, Python llama al método que declaramos como argumento en fdel. Python utiliza el argumento doc como cadena de documentación del atributo.

Cuando un argumento no se declara la operación correspondiente se impide. Así, por ejemplo, si queremos que el atributo edad sea de sólo lectura tendremos que declarar la propiedad tal que así: edad = property(fget = __getEdad, doc= 'Edad') Es decir, hacemos que el atributo edad sea de solo lectura porque definimos el argumento fget y no definimos fset ni fdel. Si quisiéramos dar un valor a la propiedad edad daría error (AttributeError: can't set attribute), como cabría esperar:

Mediante las propiedades podemos hacer públicos los atributos de forma completamente segura, como parte de la interfaz pública de la clase.

Cuidado con la herencia

Las propiedades se heredan como cualquier otro atributo. Sin embargo los métodos que se utilizan en las propiedades son los que se definen en la clase en la que la propiedad se define. Veámoslo con el siguiente ejemplo:


class numero_pi(object):
   def pi(self):
       return 3.14
   pi_magico = property(pi)

class numero_pi_mejorado(numero_pi):
   def pi(self):
       return 3.14159

a = numero_pi_mejorado()
print a.pi_magico

El lector esperaría 3.14159, pero en realidad es 3.14, ya que la propiedad hace referencia a los métodos de la clase en la que está definida ella misma. Para solventar el problema podemos envolver el método pi en otro método, tal que así:


class numero_pi(object):
   def pi(self):
       return 3.14
   def pi_envuelto(self):
       return self.pi()
   pi_magico = property(pi_envuelto)

class numero_pi_mejorado(numero_pi):
   def pi(self):
       return 3.14159

a = numero_pi_mejorado()
print a.pi_magico

Saludos.

Script (mejorado y configurable) para contar caracteres de ficheros en Python

2010-10-12T16:23:00.005+02:00

Y el definitivo script para contar caracteres en ficheros de texto pasados como parámetro. Ahora, se puede incluir flags, de manera que se puede configurar si se quiere contar caracteres especiales. Así, por ejemplo, si queremos contar los caracteres que un fichero, sin contar los espacios en blanco, simplemente haremos: python script.py fichero.txt -SPACE, donde es el script.py es el fichero que contiene el script y fichero.txt el archivo al cual queremos contar los caracteres.


# Script para contar caracteres en un fichero de texto dado, pasado
# como parámetro. ¡Tercer intento!

import sys

# Declaramos algunas constantes.
FF = '\f' # Form Feed
LF = '\n' # Line Feed
CR = '\r' # Carriage Return
TAB = '\t' # Tabulador
SPACE = ' ' # Blanco

try:
    excepcion = 0
    lista_excepcion = []
    fichero = sys.argv[1]
    opciones = sys.argv[2:]
    if '-FF' in opciones: lista_excepcion.append(FF)
    if '-LF' in opciones: lista_excepcion.append(LF)
    if '-CR' in opciones: lista_excepcion.append(CR)
    if '-TAB' in opciones: lista_excepcion.append(TAB)
    if '-SPACE' in opciones: lista_excepcion.append(SPACE)
    f = open(fichero,"r")
    caracteres = f.read()
    for i in caracteres:
        if i in lista_excepcion: excepcion += 1
    f.close()
    print "El fichero %s tiene %d caracteres" \
    %(fichero, len(caracteres) - excepcion)
except: print "Error al abrir el fichero."

Saludos.