PDF de programación - Interfaces múltiples en Python

Interfaces múltiples en

Python

Marcos Sánchez Provencio

[email protected]

Este artículo es una breve introducción a las posibilidades dinámicas de
Python. Generaremos rápidamente módulos intercambiables de interfaz
para un sencillo servidor de datos. En concreto, veremos una interfaz
interactiva (con tkinter) y un servidor de aplicaciones HTTP. El código
funciona sin modificación alguna en cualquier plataforma en la que
funcione Python, ya que se han utilizado sólo las bibliotecas estándar de
Python.

1. Sobre Python

Python es un lenguaje de programación interpretado, orientado a objetos y de sintaxis
sencilla. Se ha implementado sobre muchos sistemas operativos (incluyendo Linux,
Windows, VMS, AmigaOS...) y para los entornos más variados (incluyendo .NET de
Microsoft y Java, de Sun).

Los usuarios de Python destacan su legibilidad (incluyendo el código ajeno) y su
versatilidad (en cuanto a funciones y a escalabilidad). Es poco común encontrar
programadores que hayan pasado del Python (dentro de su rango de aplicación, claro) a
otro lenguaje. Las aplicaciones de Python más conocidas son:

• Zope, un servidor de aplicaciones de alto nivel

• Mailman, el gestor de listas de correo de GNU

1

2. Arquitectura de la aplicación

Interfaces múltiples en Python

La arquitectura de la aplicación, a pesar de hacer todas las concesiones a la brevedad,
intentará emular la de un servidor de datos a medida. Nuestra base de datos utilizará el
servicio más simple de datos persistentes de Python, dbm.

La primera capa, precisamente, nos independizará del servicio de datos subyacente a
nuestra aplicación, ofreciendo una interfaz orientada a objetos especializada en el tema
de interés de nuestra aplicación. Como ejemplo sencillo, hemos tomado una agenda de
direcciones de correo electrónico. Dispone de funciones para añadir direcciones y
buscarlas posteriormente a partir de la clave exacta (búsqueda rápida) o a partir de
cualquier parte de la clave (búsqueda lenta).

La segunda capa (versión tkinter) implementa una interfaz de programa interactivo
clásico. En general, las interfaces de este tipo son mucho más rápidas que las interfaces
web, aunque exigen al cliente tener instalado cierto software. La ventaja de Python en
este caso es que está incluido en todas las distribuciones de Linux, y que la instalación
en Windows se hace de una vez por todas, sin exigir instalaciones posteriores en ningún
caso. Es posible generar ejecutables autocontenidos (que incluyen su propio intérprete)
si se desea asegurar que la ejecución es correcta (sería parecido a una compilación
estática).

La segunda capa (versión HTTP) implementa un servidor de aplicaciones mínimo, pero
completo. Lo único que hace es esperar peticiones en el puerto 8000. Si alguna de las
peticiones es al documento /busca, con el parámetro CGI param, se ejecuta el método
homónimo sobre el objeto agenda (que abre la BD una sola vez, lo que le permite
responder con más rapidez que un CGI) y se devuelven los resultados con un formato
HTML presentable.

3. La capa de datos

A continuación se presenta el listado íntegro del módulo que implementa la capa de
datos.

#agendadb.py
import anydbm
import string
import pickle

class agenda:

#Gestión de datos persistentes
#Gestión de cadenas de texto
#Conversión de objetos a cadena (serialización)

def __init__(self,fich=’agenda.db’):

self.db=anydbm.open(fich,’c’)

#Abrimos la BD al instanciar el objeto

def encuentra(self, clave):

#Búsqueda rápida

clave=string.upper(str(clave))

2

Interfaces múltiples en Python

try:

#Recuperamos el objeto a partir de la representación interna
return pickle.loads(self.db[clave])

except:

#Si no se encuentra, se devuelve None (el nulo de Python)
return None

def busca(self, clave):

#Búsqueda lenta, por contenido

ret=[]
clave=string.upper(str(clave))
for k in self.db.keys():

if string.find(k,clave)>-1:

#Añadimos el elemento al resultado
ret.append( (k,pickle.loads(self.db[k])) )

return ret

def nuevo(self,clave,contenido):

#Nuevo elemento de la BD

nombre=string.upper(str(clave))
picContenido=pickle.dumps(contenido)
self.db[nombre]=picContenido

#Las claves independientes de mays/minus

#Convertimos lo que venga a cadena
#Lo guardamos en la BD con su clave

if __name__==’__main__’:

#No es un módulo, hacemos una prueba unitaria

ag=agenda()
if not ag.db:

#Agenda vacía, metemos contenido inicial

ag.nuevo(’ErnestoBKE’, (’Ernesto Molina’,’[email protected]’))
ag.nuevo(’Ernesto’, (’Ernesto Molina’,’[email protected]’))
ag.nuevo(’MarcosBKE’, (’Marcos Sánchez’,’[email protected]’))
ag.nuevo(’Marcos’, (’Marcos Sánchez’,’[email protected]’))

print ag.encuentra(’Ernesto’)
print ag.busca(’BKE’)

#Recuperamos unos cuantos datos

3.1. Comentarios al listado

No se ha incluido en este módulo nada de código de interfaz, salvo lo trivial de print,
que presenta en la consola texto sin formato.

El módulo pickle es responsable de la serialización, es decir, convertir a cadena (de
manera reversible) cualquier objeto. pickle es muy flexible y normalmente funciona sin
tener que preocuparse de cómo lo hace.

De momento, es posible pasar a la base de datos cualquier objeto y cualquier clave. Es
costumbre en Python dejar cuantas más características posibles abiertas, para no
restringir la utilidad de los módulos para un uso posterior.

Python dispone de interfaces de datos muy variadas, desde la interfaz minimalista que
vemos aquí, hasta el acceso a servidores de datos multidimensionales. Cuenta con
bibliotecas nativas para los servidores más comunes y con puentes con ODBC/JDBC
para cubrir el resto de los servidores.

Si es la primera vez que ves un listado en Python, habrás observado que los niveles de
anidamiento se marcan simplemente por el margen izquierdo.

3

Interfaces múltiples en Python

No es necesario declarar las variables, aunque es ilegal utilizarlas sin asignarles
anteriormente un valor. Los tipos de las variables en Python se determinan en el
instante en que se definen asignándoles su valor.

Se utiliza el latiguillo if __name__==’__main__’: para detectar que el módulo está
actuando como programa autónomo. Se acostumbra a poner funciones de prueba del
propio módulo en este caso (si el módulo no tiene una utilidad por sí solo).

El argumento self de los métodos indica el propio objeto, a la manera de this (Java) o
Me (Visual Basic). En Python este argumento es explícito y no se puede omitir en
ningún caso.

4. La capa de interfaz gráfica (tkinter)

A continuación se presenta el listado íntegro del módulo que implementa la capa de
datos.

Figura 1. La interfaz tkinter

from Tkinter import *

class agendatk:

def __init__(self,tipo_bd):

#Nuestra capa de BD es una clase que nos pasan en el constructor
self.db=tipo_bd()
#Contruimos el interfaz gráfico
self.r=Tk()
self.t=Entry(self.r)
self.t.pack()
self.res=Label(self.r,text=’Sin resultados’)
self.res.pack()
Button(self.r,text=’Buscar’,command=self.busca).pack()

4

Button(self.r,text=’Encontrar’,command=self.encuentra).pack()

Interfaces múltiples en Python

def run(self):

self.r.mainloop()

def busca(self):

texto=self.t.get()
ret=self.db.busca(texto) or []
for elem in ret:

texto = texto + ’\n%s = %s - %s ’ % (elem[0] , elem[1][0], elem[1][1])

self.res.configure(text=texto)

def encuentra(self):

texto=self.t.get()
ret=self.db.encuentra(texto)
self.res.configure(text=’%s - %s’ % ret)

if __name__==’__main__’:

import agendadb
agtk=agendatk(agendadb.agenda)
agtk.run()

4.1. Comentarios al listado

En Python es posible pasar casi cualquier cosa como parámetro: Una variable simple,
un objeto cualquiera, atributos de un método, funciones, métodos, módulos, clases...
Además, el modo de hacerlo es el más intuitivo posible. En este caso estamos pasando
una clase de acceso a datos al constructor de nuestra interfaz y las funciones de
respuesta a los sucesos.

No hay nada privado ni protegido en Python. Todos los atributos de una clase y sus
métodos son públicos. Esto fomenta la cooperatividad entre colaboradores y elimina
horas de trabajo empleadas en decidir qué es publico o privado, y en permitir acceso a
valores privados.

La interfaz tkinter está fuertemente basada en tcl/tk, hasta el punto de que lo utiliza
internamente. Por supuesto, esto provoca un descenso en el rendimiento, pero es
inapreciable en la mayoría de las aplicaciones, como en ésta. Si se conoce tcl/tk, todo el
conocimiento de construcción de interfaces es inmediatamente aplicable a tkinter. Tan
sólo hay que hacer la traducción inmediata a Python. En Python se pueden realizar
interfaces gráficas con wxWindows, la más pujante, con swing y awt en el caso de
Jython y otras menos conocidas.

Vemos que se importa el módulo agendadb (el módulo de acceso a datos creado antes)
sólo si es ése el que vamos a utilizar. En el caso del módulo realizando sus funciones de
auto-prueba (ejecutándose de manera autónoma), utilizamos este acceso a datos por la
sencilla razón de que es el único que tenemos hasta ahora. En otras palabras, no hace

5

falta que el módulo agendadb esté disponible si disponemos de otro módulo de acceso
a datos que sea conforme a la interfaz (no definida explícitamente, sino por su uso) de
agendadb.

Interfaces múltiples en Python

5. La capa de interfaz HTTP

A continuación se presenta el listado íntegro del módulo que implementa el servidor de
aplicaciones.

Figura 2. La interfaz web

from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer,test
import cgi
import string

class AgendaHTTP(BaseHTTPRequestHandler):
def do_GET(self):
self.do_HEAD()
if self.response==404:
self.wfile.write(’404 El método no existe’ )
return
if self.metodo==’/busca’:
try:
ret=db.busca(self.dicParams[’param’][0])

6

Interfaces múltiples en Python

except:
ret=[]
retHTML=”
for elem in ret:
retHTML=retHTML+’<li>%s = %s-%s’ % (elem[0],elem[1][0],elem[1][1])
self.wfile.write(”’<html><body>
<form><input name="param"> <input type="submit"></form>
<p>Resultados</p>
<ul>%s</ul>
</body></h