Este artículo está dedicado a aquellas personas que quieran dar sus primeros pasos en el desarrollo de aplicaciones web, y para aquellos que desarrollan aplicaciones sencillas, sin demasiadas complicaciones. Antes de redactar este artículo he estado probando y evaluando diversos frameworks para crear sitios web, tales como
Bobo,
Web2Py,
CherryPy,
Django, etc., pero al final me he decantado por
WebPy, por su extrema sencillez para empezar, y por la similitud que tiene con otros frameworks de otros lenguajes, con lo que la curva de aprendizaje es óptima.
Más adelante, si los proyectos web se vuelven muy complejos y se requiere de elementos prefabricados y avanzados (como objetos persistentes a bases de datos, encriptación, modelo vista controlador, etc.), recomiendo utilizar los otros frameworks citados anteriormente (hay muchos más, pero éstos son más populares y potentes).
Se asume que el lector tiene conocimientos básicos de
Python y que previamente tiene instalado el intérprete de
Python en su máquina:
Configuración del servidor Web
WebPy, a diferencia de otros frameworks, no posee un servidor de aplicaciones potente propio, y por ello, es mejor apoyarse en uno que ya esté funcionando. Entre los posibles candidatos se encuentran
Apache,
Lighttpd y
nginx. Para este artículo he optado por
Apache, dada su gran popularidad.
Una vez instalado
Apache en nuestra máquina, es necesario agregar el módulo
mod_wsgi, que permite hacer uso de Apache como servidor para aplicaciones escritas en
Python. Este proyecto está alojado en:
http://code.google.com/p/modwsgi
Una vez descargado, si estamos usando
Windows, renombrar el archivo a
mod_wsgi.so y copiarlo al directorio
modules de Apache. En el caso de
Linux, compilar el módulo
mod_wsgi (consultar:
http://code.google.com/p/modwsgi/wiki/QuickInstallationGuide)
Una vez instalado el módulo, hay que configurar Apache para que reconozca dicho módulo. Para ello, editar el archivo
httpd.conf (en el directorio
conf de Apache), y agregar la siguiente línea en la misma parte en que Apache utiliza otras cargas
LoadModule:
LoadModule wsgi_module modules/mod_wsgi.so
Al arrancar Apache desde la terminal debería dar un mensaje similar a éste:
Apache/2.2.2 (Unix) mod_wsgi/1.0 Python/2.3 configured
Si se lanzó desde Windows, el Apache Service Monitor, debería dar el mensaje en la parte inferior:
Instalación de WebPy
Hay varias maneras de instalar
WebPy (consultar
http://webpy.org/download).
Se puede descargar directamente la última versión desde la siguiente URL (consultar
http://webpy.org/download para conocer cuál es la última versión):
http://webpy.org/static/web.py-0.34.tar.gz
También se puede descargar desde el repositorio en
github:
http://github.com/webpy/webpy
Una vez descargado, descomprimir el archivo
tar.gz, y ejecutar la siguiente sentencia para instalarlo como librería en
Python:
python setup.py install
Primera aplicación Web
Para ilustrar la sencillez de desarrollo de una página Web con
WebPy, vamos a crear la típica aplicación
“Hola, Mundo”.
import web
urls = (
'/', 'index'
)
app = web.application(urls, globals())
class index:
def GET(self):
return "Hola, Mundo"
if __name__ == "__main__":
app.run()
La variable
urls es una
tupla que contiene pares de direccionamientos URL y nombres de clase. En este ejemplo, el direccionamiento
“/” (
root), estará asociado a la clase
index. Se pueden definir tantos pares como sean necesarios para la aplicación Web.
El objeto
app contendrá la definición de la aplicación Web. En este ejemplo se asocian las URL’s de la aplicación a namespace global.
La clase
index contiene un método
GET, el cual se lanzará cuando se invoque a la página, pudiendo recibir parámetros. En su interior, retornará el literal
“Hola, Mundo”, el cual se imprimirá en el navegador. Existe también un método
POST, que funciona como
GET, pero ofuscando los parámetros. Estos dos métodos son los medios habituales de invocar a una página Web pasando (o no) parámetros.
Por último, las dos últimas líneas indican a
WebPy que comience a servir páginas web con la configuración indicada.
Una vez se ejecuta este programa, el intérprete de
Python se queda en modo de espera. El servicio Web está en marcha, esperando peticiones. Para probarlo, abrimos un navegador web e introducimos la URL:
http://localhost:8080
Debería aparecer nuestro bien conocido mensaje
“Hola, Mundo”.
Parámetros y HTML
En una aplicación Web introduciremos elementos HTML para formatear el aspecto de las páginas. Además, añadiremos dinamismo permitiendo que las páginas muestren datos parametrizados (por ejemplo, recogidos de un formulario, o capturados de una base de datos).
Vamos a añadir más funcionalidad a nuestra aplicación anterior:
import web
urls = (
'/hola', 'Saludo'
)
app = web.application(urls, globals())
class Saludo:
def GET(self):
data = web.input()
return """
<html>
<head></head>
<body background='#AAAAFF'>
<h1>Hola, %s %s %s</h1>
</body>
</html>""" % (data.nombre, data.apellido1, data.apellido2)
if __name__ == "__main__":
app.run()
El primer cambio lo hemos realizado en la sección de
urls, donde ahora, el mapeo a la página Web será el siguiente:
http://localhost:8080/hola
Cuando se apunta a
/hola, se invocará a la clase
Saludo, concretamente a su método
GET, en donde hemos agregado varios cambios. El primero de ellos ha sido definir una variable
data, la cual recogerá los parámetros que se pasen por URL, lo que se consigue mediante la función
input() del módulo web. Estos parámetros se recogerán en formato de diccionario, y son pares de parámetro y valor.
A la hora de retornar la salida, se retornará HTML, en donde hemos añadido un mensaje con formato de título (
<h1>), un saludo con nombre y apellidos (extraídos de los parámetros pasados), los cuales se formatean mediante
%s, e indicando después qué parámetros extraer.
Para invocar a la nueva página se pasan los parámetros en la misma URL, tal y como haría una llamada desde un formulario:
http://localhost:8080/hola?nombre=Carmen&apellido1=Martinez&apellido2=Salguero
El resultado es el siguiente:
Plantillas
En el último ejemplo comenzamos a utilizar HTML, que, al fin y al cabo, es el medio por el cual presentaremos la información en el navegador. El problema que tenemos es que se mezcla el código de
Python y de
HTML, y a la hora de depurar o realizar modificaciones, se vuelve enfarragoso y complejo. La forma ideal de trabajar sería separando la
presentación (HTML) del
código de negocio (el que procesa la información (Python)). Por un lado estarían las etiquetas
HTML que ponen la información, y por otro el código
Python que accede a la base de datos y la prepara en estructuras de datos (por ejemplo).
WebPy posee la característica de utilizar
plantillas, que son directivas especiales embebidas en un código HTML, y que permiten conmutar valores que se pasan desde la capa de negocio o interactuar directamente con código
Python.
Para estructurar nuestro código, vamos a crear un directorio donde se van a guardar las plantillas que vamos a necesitar. En nuestro caso la llamaremos
plantillas. Dentro de este directorio crearemos un fichero llamado (por ejemplo)
plantilla.html, y cuyo contenido será el siguiente:
$def with (nombre, apellido)
<HTML>
<HEAD></HEAD>
<BODY>
$if (nombre!='' and apellido!=''):
<H1>Hola, $nombre $apellido</H1>
$else:
<b>ERROR:</b> No ha facilitado el nombre y el apellido
</BODY>
</HTML>
La primera línea
$def with (nombre, apellido)
debe ser la primera de la plantilla, y se encarga de recoger los parámetros enviados desde el código de negocio, los cuales serán presentados en la página HTML.
A continuación se crea el código HTML. Cuando es necesario presentar la información, hemos creado una estructura de control
if para comprobar los datos pasados. En nuestro caso comprobamos si
nombre y
apellido contienen datos, en cuyo caso imprimirá en un título el mensaje
“Hola, “ seguido del nombre y del apellido. Si uno de los dos datos no se ha facilitado, entonces (
else) se mostrará un mensaje de error.
Ha de notarse que anteponiendo el símbolo
$ (dólar) a una línea en
Python, esta se procesará como código
Python. Asimismo, este símbolo también se utiliza dentro del HTML para sustituir una variable por su valor.
Esta plantilla, por sí misma no hace nada. Debe ser asociada a la capa de negocio. Para ello crearemos el código en un fichero situado fuera del directorio
plantillas, justo en el nivel anterior. El código será el siguiente:
import web
urls = (
'/hola', 'Saludo'
)
render = web.template.render('plantillas')
app = web.application(urls, globals())
class Saludo:
def GET(self):
data = web.input()
nombre = data.nombre if 'nombre' in data else ''
apellido = data.apellido if 'apellido' in data else ''
return render.plantilla(nombre, apellido)
if __name__ == "__main__":
app.run()
El objeto
render apuntará al directorio donde se encuentran nuestras plantillas, creando internamente un objeto por cada plantilla encontrada.
En el método
GET de la clase
Saludo, hemos reforzado el código (a prueba de errores) en cuanto a los parámetros. Si se pasa el parámetro especificado, recogerá su valor. Si no se pasa, le asignará una cadena vacía. Los parámetros pasados están en formato diccionario, por lo que es posible averiguar si el parámetro (clave) está dentro del mismo (
‘clave’ in diccionario).
Por último, se retorna lo generado por la plantilla. Para ello se invoca a la plantilla:
render.plantilla(nombre, apellido)
Como se comentó anteriormente, internamente,
WebPy toma las plantillas dentro del directorio al que apuntaba, y generará un objeto accesible por cada una de ellas. A la plantilla le facilitará los parámetros
nombre y
apellido, que serán recogidos por la primera línea de éste (
$def with).
Un ejemplo más complejo
Los ejemplos anteriores han sido muy básicos. Vamos a ver un poco más a fondo cómo podemos aprovechar todo lo anterior. Imaginemos que queremos hacer una consulta a un catálogo de productos. Esta consulta puede ser general (muestra todos los productos), o bien específica (muestra un producto determinado). La solución pasaría por implementar un acceso a base de datos. Pero para no extender demasiado este artículo, vamos a tenerlo completamente en memoria (para más información sobre cómo acceder a bases de datos desde Python, recomiendo ver mi anterior artículo:
http://rafinguer.blogspot.com/2010/10/conceptos-basicos-de-python-y-sqlite.html.
El código de negocio quedaría como sigue:
import web
urls = (
'/ejemplo', 'Consulta'
)
render = web.template.render('plantillas')
app = web.application(urls, globals())
class Consulta:
def GET(self):
criterio = web.input()
# Tuplas de diccionaris con datos de consulta.
# Puede ser una carga de datos de una bbdd
datos = (
{'producto':'Tornillo', 'precio':0.45, 'marca':'Acme'},
{'producto':'Tuerca', 'precio':0.55, 'marca':'Solme'},
{'producto':'Clavo', 'precio':0.30, 'marca':'Calme'},
{'producto':'Remache', 'precio':0.60, 'marca':'Acme'},
{'producto':'Clavija', 'precio':0.95, 'marca':'Acme'},
{'producto':'Grapa', 'precio':0.25, 'marca':'Tecme'}
)
registro=''
if criterio:
for i in range(0,len(datos)):
if datos[i]['producto'] == criterio.producto:
registro = datos[i]
break
if registro =='':
registro = datos
return render.productos(registro)
if __name__ == "__main__":
app.run()
La llamada a la página puede hacerse sin parámetros (mostraría todos los productos), o bien pasando el parámetro
producto, especificando cuál queremos consultar.
En ambos casos, a la hora de invocar a la plantilla, se pasaría la lista de productos o un único producto, que se almacena en la variable
registro.
El código de la plantilla (
productos.html) sería el siguiente:
$def with (registro)
<HTML>
<HEAD></HEAD>
<BODY>
<TABLE BORDER='1'><TR BGCOLOR='#AAAAFF'>
<TD><B>PRODUCTO<B></TD>
<TD><B>PRECIO<B></TD>
<TD><B>MARCA<B></TD></TR>
$if 'producto' in registro:
<TR>
$for i in range(0,len(registro)):
<TD> $registro.values()[i] </TD>
</TR>
$else:
$for i in registro:
<TR>
<TD> $i['producto'] </TD>
<TD> $i['precio'] </TD>
<TD> $i['marca'] </TD>
</TR>
</TABLE>
</BODY>
</HTML>
En el caso de que se pase un único registro (la consulta se hizo por un único producto), éste será en sí un diccionario, por lo que al consultar si tiene una clave llamada
producto, retornará el valor
True. En tal caso, la función
len() retorna el número de pares clave/valor del diccionario. Conociendo este valor, se recorre cada campo del diccionario en el bucle
for y se extrae su valor, visualizándolo en una columna.
En el caso de pasar el catálogo completo, la función
len() retornaría el número de filas (diccionarios) que contiene la lista. El acceso a la lista debe realizarse mediante un iterador (
i), el cual recoge, una a una, cada fila (diccionario). El valor se extrae invocando el nombre de su clave.
El resultado final sería el siguiente:
Conclusiones
Este breve tutorial cubre los aspectos más básicos, pero, a la vez, más potentes y flexibles, para comenzar a desarrollar aplicaciones Web mediante
Python. A partir de las nociones vistas anteriormente, podremos empezar a desarrollar complejas web dinámicas de una forma sencilla y eficaz.
Referencias
Lenguaje Python: http://www.python.org
mod_wsgi: http://code.google.com/p/modwsgi
WebPy: http://webpy.org
Apache: http://httpd.apache.org
