Power Systems computation which were being computed so far using MATLAB, OCTAVE and other closed software packages could be solved using Python. There are various open source tools availa…Full description
Programacion de computadora mediante PythonDescripción completa
Descripción completa
Full description
Mario Essert, Domagoj Ševerdija, Ivan Vazler Digitalni udžbenik Python - osnove - Odjel za matematiku Sveučilišta Josipa Jurja Strossmayera Osijek, 2007. Sadržaj Sadržaj 1 Python interpreter 1...
PythonDescripción completa
python programmingDescrição completa
Full description
PythonDescripción completa
PYTHON
.Descrição completa
Descripción: Python programming
python programmingFull description
htftrh
python
Python
Descrição: a very good book to learn Python as a beginner, from http://www.swaroopch.com/notes/Python
PythonDescrição completa
PythonDescripción completa
PythonFull description
Good to adquire basic Python programming skills.Full description
DVD GRATIS
Debian 6
MANUAL PRÁCTICO ENERO 2012 Península y Baleares 6,95 � Canarias 7,05
�
PROYECTOS COMPLETOS Y FUNCIONALES
��
a l E s p e c i a
�� BÁSICO
Introducción a Python con ejemplos prácticos
�� INFRAESTRUCTURAS
Explota los motores tras Facebook, Google y Twitter
�� MÓDULOS
Descubre cómo programar para 3D y a manipular datos e imágenes
3RF..com 123RF o - 12 Babenko Denis Babenk
Tu Guía Práctica Aprende de desarrollador desarrolladores es profesionales y de sus ejemplos del mundo real
Automatiza formularios web ■ Integra Python con Java, .Net y Qt O pen/LibreOfficee ■ Amplía Open/LibreOffic ■ Crea y manipula PDFs ■ Maneja grandes volúmenes de datos ■
6 0 0 0 0 9 2 5 4 9 5 2 4 0 3 1 4 8
WWW.LINUX
- M A G A Z I N E . E S
En la tienda de Linux Magazine (www.linux-magazine.es/tienda ( www.linux-magazine.es/tienda ) vendemos revistas y libros que pueden ser de interés a nuestros lectores. Recuerda también que con una subscripción Digital o Club, podrás acceder a las ofertas (www.linux-magazine.es/digital/ofertas (www.linux-magazine.es/digital/ofertas ) de Linux Magazine Magazine donde donde puepuedes conseguir software, gadgets, libros y servicios.
Manual LPICLPIC-1 1 El único manual en castellano para la certificación completa LPIC-1 (exámenes 101 y 102). Más de 250 páginas de ejemplos reales tomados de ambos exámenes explicados en todo detalle con ejercicios para prácticas y sus soluciones. Preparado para el nuevo programa que entra en vigor a partir del 2009, aprobado y recomendado por LPI International y con la garantía de Linux Magazine. ■
”La guía perfecta en castellano para preparar el examen para cualquier persona que tenga conocimientos de Linux.”
■
”Se ciñe muy bien a los objetivos del nivel 1 de LPI (LPIC-1) actualizados en Abril de este año, cosa que es de agradecer agradecer.” .”
■
”Un avance muy importante en el desarrollo de los programas de certificación LPI en España.”
www.lpi.org.es
Consíguelo en nuestra tienda.
Este mes en nuestra tienda...
DVD/EDITORIAL
Debian 6
Especial Python al grupo de cómicos británicos Monty Python, Guido Von Rossum concibió este lenguaje en los años 80, comenzando su implementación en 1989. Gracias a su sencillez y a la idea de que el código bello se consigue siendo explícito y simple, Python se ha convertido en sus poco más de 20 años de existencia en el lenguaje favorito para scripts, aunque también para grandes infraestructuras y aplicaciones. Así, la mayor parte de los servicios de Google y Facebook se construyeron utilizando Python, las aplicaciones de diseño Inkscape o Blender (entre muchas otras) utilizan un motor Python para sus plugins. También También se utiliza ampliamente en la investigac investigación ión en entidades que van desde CERN hasta la NASA. Además, su clara y bien pensada sintaxis, su modularidad y su sobresaliente rendimiento – a pesar de ser interpretado – hacen de Python un excelente lenguaje educativo, ideal para enseñar programación del mundo real a todos los niveles. Con este especial pretendemos que el lector pueda descubrir Python desde el principio, creando para ello artículos que abordan desde tutoriales introductorios, hasta programación de alto nivel y para usos avanzados. Cada sección viene con varios ejemplos prácticos, código y soluciones extraídas del ■ mundo real. Bautizado en honor
DVD: Debian 6.0.3
Formato del Código en este Especial Aunque la norma en el sangrado de código en Python es que las tabulaciones a principio de línea sean múltiplos de cuatro espacios, para favorecer la legibilidad de los listados en este especial, cada tabulación se ha reducido a un solo espacio. De esta manera, código que normalmente se escribiría como: for i in range (1, 5): if ((i % 2) == 0): print i,” es par” else: print i,” es impar”
WWW.LINUX MAGAZINE.ES
-
Se reproduce así en los artículos: for i in range (1, 5): if ((i % 2) == 0): print i,” es par” else: print i,” es impar” A pesar de ser técnicamente correcto, animamos a que, si se transcribe código para su ejecución, se utilice la convención de los 4 espacios. En todo caso, todo el código está disponible, con su formato convencional, en el sitio de Linux Magazine en [1].
En el DVD de este especial encontrarás la versión Live de la última iteración estable de Debian [2] para arquitecturas de 32 bits (la más universal). Al ser Debian la más completa de las distros GNU/Linux, GNU/ Linux, podrás encontrar en sus repositorios todas las herramientas, módulos e infraestructuras que necesitarás para seguir los artículos de este especial.
Recursos [1] Todo el código de este especial: http:// www.linux-magazine. www. linux-magazine.es/ es/Magazine/ Magazine/ Downloads/Especiales/ Downloads/ Especiales/ 06_Python [2] Debian: http:// http://www. www.debian. debian.org/ org/index. index. es.html es. html
PYTHON
3
CONTENIDO
Introducción
Python 01
06 Pri Prime mero ross Pas Pasos os Python es un lenguaje potente, seguro, flexible… pero sobre todo sencillo y rápido de aprender, que nos permite crear todo lo que necesitamos en nuestras aplicaciones de forma ágil y eficaz
Avanzado
Integración
19 Sin No Nombre
33 Li Limp mpie ieza za Tot Total al
Python es un lenguaje de programación multiparadigma, y las funciones lambda son parte fundamental de él, aunque como veremos, existen buenas razones para no abusar de ellas.
AJAX es la palabra de moda, Google usa AJAX, Yahoo usa AJAX… todo el mundo quiere usar AJAX pero ¿lo usas tú? y más importante aún ¿qué demonios es AJAX?
Integración 23 Pyth Python on no hay hay más que UNO
10 Ál Álbum bum Fot otogr ográf áfic icoo
¿Has visto alguna vez a los brokers de bolsa y sus sofisticados y caros programas para ver las cotizaciones de las empresas en bolsa en tiempo real? Nosotros haremos lo mismo con Python, OpenOffice y la tecnología UNO de OpenOffice.
Siguiendo con nuestro paseo por Python, vemos características básicas, y concretamente en este artículo, el tratamiento de ficheros creando un programa para la ordenación de colecciones de fotos.
39 De Serpi Serpient entes es y Pri Primat mates es .NET está avanzando, y Python no se ha quedado atrás. En lugar de combatirlo, ha entrado en simbiosis con ella. Con Ironpython podremos hacer uso de toda la potencia de .NET desde nuestro lenguaje favorito.
15 De Desp spar aras asit itan ando do Serpie Serpient ntes es Da igual lo buenos programadores que seamos, tarde o temprano daremos con ese BUG que será nuestro peor enemigo. Veamos cómo podemos emplear herramientas para derrotarlo con mayor facilidad.
43 ¡De ¡Desar sarrol rollo lo Ráp Rápido ido!!
28 Cua Cuando ndo los los Mundo Mundoss Choca Chocann
Otras Secciones 03
DVD Debian 6
82
Información de Contacto
4
PYTHON
Os descubrimos Jython, la forma mas sencilla de desarrollar vuestras aplicaciones Java como si las programárais con Python.
Ha llegado el cliente y te lo ha dejado claro: necesita el programa para ayer. Ha surgido un problema enorme y es necesario resolverlo en tiempo récord. La desesperación se palpa en el ambiente y todos los ojos miran a tu persona. Devuelves una mirada de confianza y dices con tono tranquilo: «No te preocupes, tengo un arma secreta para acabar con el problema».
WWW.LINUX MAGAZINE.ES
-
Python 01
CONTENIDO
V ER S IÓ N D VD G NO M E L I VE
Infraesctructuras 48 Pyramid Uno de los rivales de peso de Django está creciendo en popularidad poco a poco.
Librerías 65 Gráficas 3D Crear gráficos 3D no es nada difícil en Python... sobre todo si tenemos a mano la librería VTK.
52 Guitarrazos Los creadores del proyecto Django nos hablan de la formación de la Django Software Foundation y mostramos cómo comenzar con esta infraestructura web.
55 Seriales Hacer que distintos servicios se comuniquen entre ellos es todo un problema que Facebook ha tratado de solucionar con Thrift.
69 Vigilantes del planeta ¿Quién no ha querido alguna vez sentirse como esos informáticos de la NASA en su centro de control? Hoy nos construiremos el nuestro y controlaremos el planeta y sus alrededores.
73 Enredados Podemos automatizar comandos y programas gráficos, ¿por qué no automatizar la interacción con páginas web? En este artículo crearemos un pequeño script que puede ahorrarnos mucho trabajo con el ratón.
77 ReportLab
Librerías 59 Cuaderno de Bitácora ¿Te acuerdas de cuando cambiaste la versión de Firefox por última vez? ¿ y de por qué instalaste ese programa tan raro que parece no servir para nada ? Yo tengo mala memoria, así que uso un cuaderno de bitácora.
WWW.LINUX MAGAZINE.ES
-
Hoy en día se hace imprescindible disponer de herramientas que permitan generar informes en PDF de alta calidad rápida y dinámicamente. Existen diferentes herramientas para esta finalidad, entre ellas cabe destacar ReportLab, biblioteca gratuita que permite crear documentos PDF empleando como lenguaje de programación Python.
g. 3 á p e n n ó i a c m r o i n f V e r
PYTHON
5
INTRODUCCIÓN
Primeros Pasos
Aprende a programar con este lenguaje de programación multiplataforma
Primeros Pasos
A n i t a P a t t e r s o n m o r g u e f i l e . c o m
Python es un lenguaje potente, seguro, flexible… pero sobre todo sencillo y rápido de aprender, que nos permite crear todo lo que necesitamos en nuestras aplicaciones de forma ágil y eficaz. Por José María Ruíz
Para empezar, debemos saber por qué Python es interesante, por qué es tan famoso y cada vez más utilizado. Mirando un poco por Internet se pueden encontrar multitud de aplicaciones que nos muestran parte de las capacidades de este lenguaje de alto nivel. Vamos a enumerar algunas de sus sorprendentes características: • Orientado a objetos – Esto no significa que sea exclusivamente orientado a objetos, podemos utilizarlo como queramos, aunque le sacaremos más provecho si usamos su implementación de OOP (Programación Orientada a Objetos). • Libre y gratuito – Desde la red, podemos descargar el interprete y su código fuente, y al ser un lenguaje de script, viene con la mayoría de las distros GNU/Linux de manera predeterminada, siendo posible ver el código de una enorme parte del software desarrollado para Python. • Portable – Al ser interpretado, podemos ejecutar nuestros programas en cualquier S.O. y/o arquitectura simplemente teniendo instalado previamente el intérprete en nuestro ordenador . • Potente – Realizar un programa bajo este lenguaje seguramente nos costaría entre la mitad o la cuarta parte del tiempo que tardaríamos en desarrollar el mismo programa en C/C++ o Java. • Claro – Puede que ésta sea una de las características más alabadas de Python:
6
PYTHON
Los programas escritos en este lenguaje tienden a ser fáciles de comprender y, por tanto, de mantener por terceros. Una enorme ventaja frente a lenguajes como C o Perl. Pero veamos una breve comparativa con otros lenguajes: Hola Mundo en C: main () { printf(“Hola Mundo”); }
Hola Mundo en Java: public static void U main(String args[]) { System.out.println(“Hola U Mundo”); }
Hola Mundo en Python: print “Hola Mundo”
Aunque los “Hola Mundo” no son muy indicativos de nada, nótese la ausencia de puntos y comas, llaves, declaración de funciones y otros “trastos” que entorpecen el código. Esto es incluso más obvio en programas más largos. Python dispone de otras características que lo convierten en el lenguaje favorito
de una comunidad de desarrolladores cada vez más amplia. Por ejemplo, permite la declaración dinámica de variables, es decir, no tenemos que declarar las variables ni tener en cuenta su tamaño, ya que son completamente dinámicas. Además, dispone de un gestor de memoria que, de manera similar al de java, se encargará de liberar memoria de objetos no utilizados. Sin embargo, y al igual que Java, no permite usar la memoria a bajo nivel como C, con el que nos podíamos referir a zonas de memoria directamente. Además se puede combinar con otros múltiples lenguajes de programación. Podemos mezclar en nuestras aplicaciones Python y Java (Jython – ver el artículo al respecto en la página 28 de este especial), por ejemplo. O Python con C/C++, lo cual hace que resulte mas potente si cabe. Python también cuenta con una amplia biblioteca de módulos que, al estilo de las bibliotecas en C, permiten un desarrollo rápido y eficiente. La sencillez de Python también ayuda a que los programas escritos en este lenguaje sean muy sintéticos. Como podemos ver en el ejemplo “Hola Mundo” anterior, la simplicidad llega a ser asombrosa. Si este programa ya supone ahorrarte 4 ó 5 líneas de código, con una sintaxis tan sencilla y ordenada podemos imaginar que un programa de 1000 líneas en Java, en Python se redujeran unas 250.
W W W . L I N U X- M A G A Z I N E . E S
INTRODUCCIÓN
Primeros Pasos
Uso Para empezar a matar el gusanillo, podemos ir haciendo algunas pruebas interesantes. Vayamos al intérprete Python. Para ello, basta con escribir ‘python’ en el prompt de una terminal (por ejemplo, Bash en GNU/Linux o Powershell en Windows) y probar nuestro “Hola Mundo”: >>> print ‘Hola Mundo’ Hola Mundo
Ahora probemos a utilizar algunas variables: >>> suma = 15 + 16 >>> >>> print ‘el resultado de la suma es: ‘, suma el resultado de la suma es: 31
forma. En Python todo se hace de un solo modo, de hecho es parte de su filosofía: “Solo Hay Una Manera de Hacer Las Cosas”. Comencemos con lo más simple en todo lenguaje, la asignación a una variable: cantidad = 166.386
(Para los que no lo recuerden, 166,386 era la cantidad de pesetas que hay en un euro). Lo primero que hay que apreciar es que no se usa el ;. Esto es una característica de las muchas que hacen a Python diferente. Una sentencia acaba con el retorno de carro, aunque el ; se puede usar cuando dos sentencias están en la misma línea:
al igual que if … if ()
¿Por qué no he puesto cuerpos de ejemplo en esos bucles? Pues porque ahora viene otra novedad. En Python no se usan las famosas { y } para delimitirlas. Se decidió (y no a todo el mundo le gusta) que se usaría la posición como delimitador. Esto, así, suena algo extraño, pero si se ve es mucho más sencillo: >>> cantidad = 2 >>> for i in range(1,10): print cantidad*i
cant = 166.386; ptas = 3000
Es recomendable trastear un poco con esto antes de ponernos a programar algo más complicado, ya que de esta manera es más sencillo hacerse con la sintaxis mucho más rápidamente viendo los resultados de cada prueba. Veamos ahora alguna propiedad interesante de Python. Los ficheros en Python no tienen por qué llevar extensión ninguna, pero seguramente querremos tenerlos diferenciados del resto de ficheros que tengamos. Por ello se suele utilizar la extensión .py. Pero ¿cómo sabe el sistema que intérprete utilizar cuando queramos ejecutar nuestros scripts? Sencillo: Imaginemos que tenemos un ejemplo.py , al ser un lenguaje tipo script, debemos poner #! seguido de la ruta del intérprete de Python en la cabecera del fichero. De esta manera, y dándole permisos de ejecución (chmod +x ejem plo.py en GNU/Linux), obtenemos un programa listo para su ejecución. Si nuestro intérprete Python se halla en /usr/bin/, el contenido de ./ejemplo.py quedaría, pues, como sigue:
Como es un lenguaje dinámico, no hay que declarar el tipo de las variables, pero una vez que una variable ha sido definida (lo que se hace asignándole un valor), esa variable guarda su tipo y no lo cambiará a lo largo de la ejecución del programa. También tenemos a nuestra disposición los operadores habituales de otros lenguajes: +, -, *, /, etc. Y una vez que sabemos cómo manejar operadores y asignaciones, se pueden hacer cosas útiles, pero sólo de manera lineal. Para que la ejecución no sea lineal necesitamos los bucles y los condicionales. El tema de los bucles en Python es algo especial. Puede que estemos acostumbrados a los que son de tipo C: for (a = 1; a < 10; a++) U printf(“%d\n”,a);
Sin embargo, en Python se toma un enfoque funcional prestado de otros lenguajes como Lisp o Haskell. Se utiliza una función especial llamada «range». La función «range» genera una lista de números: range(1,10)
#! /usr/bin/python print ‘Hola Mundo’
Después de toda la introducción técnica va siendo hora de que veamos cómo es el formato de los programas en Python. Esto es importante porque, mientras la norma en la mayoría de los lenguajes es dejar al programador la decisión de la manera en que deben ser formateados los archivos fuente, en Python es obligatorio hacerlo de cierta
W W W . L I N U X- M A G A Z I N E . E S
while()
generará una ristra de números del 1 al 9. De esta manera, podemos utilizar una función range para crear un bucle for en Python de la siguiente manera: for i in range(1,10)
Este bucle iteraría con i desde 1 a 9, ambos inclusive. La versión del bucle while en Python es más normal…
WWW.LINUX- MAGAZINE.ES
Comencemos mirando a ese :. Los dos puntos marcan el inicio de un bloque de código Python. Ese bloque aparecerá en bucles, funciones o métodos. Si nos fijamos bien en la sangría de la siguiente línea, vemos una serie de espacios (logrados pulsando la tecla TABULADOR) y una sentencia. Esos espacios son vitales, ya que marcan la existencia de un bloque de código. Además, son obligatorios. Este es uno de los hechos más controvertidos de Python, pero también mejora mucho la legibilidad del código. Sólo existe una manera de escribir Python, así que todo el código Python se parece y es más fácil de entender. El bloque acaba cuando desaparecen esos espacios: >>> for i in range(1,10): ... print cantidad*i ... cantidad = cantidad + 1 ... >>>
Funciones y Objetos Ya tenemos las piezas fundamentales para entender las funciones y los objetos. La declaración de una función en Python tiene una sintaxis muy simple: def nombre_funcion U ( ):
Fácil ¿no? Al igual que las variables, a los argumentos no se les asignan tipos. Existen muchas posibilidades en los argumentos, pero los veremos más tarde. De momento examinemos un ejemplo simple:
Vuelve a ser sencillo. ¿Y los objetos? Pues también son bastante simples de implementar. Podemos ver un ejemplo en el Listado 1. Con class declaramos el nombre de la clase, y los def de su interior son los métodos. El método __init__ es el constructor, donde se asignan los valores iniciales a las variables. __init__ es un método estándar y predefinido, lo que quiere decir que tendremos que usar ése y no otro para inicializar el objeto. Todos los métodos, aunque no acepten valores, poseen un parámetro self . Este es otro punto controvertido en Python; self es obligatorio, pero no se usa al invocar el método. ¿Cómo se crea el objeto? >>> a = Objeto(20)
Es como llamar a una función. A partir de este momento a es una instancia de Objeto, y podemos utilizar sus métodos: >>> print a.getCantidad() 20 >>> a.setCantidad(12) >>> print a.getCantidad() 12
No hay que preocuparse por la administración de la memoria del objeto ya que, cuando a no apunte al objeto, el gestor de memoria liberará su memoria. Ya tenemos las bases para construir algo interesante. Por supuesto, nos dejamos infinidad de cosas en el tintero, pero siempre es mejor comenzar con un pequeño conjunto de herramientas para empezar a usarlas. En todo caso, tendremos tiempo de profundizar en los siguientes artículos de este especial.
Estructuras de Datos Una de las razones por las que los programas scripts de Python resultan tan potentes, es que nos permiten manejar estructuras de datos muy versátiles de manera muy sencilla. En Python estas estructuras son las Listas y los Diccionarios (también llamados Tablas Hash). Las listas nos permiten almacenar una cantidad ilimitada de elementos del mismo tipo. Esto es algo inherente a casi todos los programas, así que Python las incorpora de fábrica. Las listas de Python también vienen provistas de muchas más opciones que sus semejantes en otros lenguajes. Por ejemplo, vamos a definir una lista que guarde una serie de palabras: >>> a = [“Hola”, “Adios”, “Buenas Tardes”] >>> a [‘Hola’, ‘Adios’, U ‘Buenas Tardes’]
U
Python indexa comenzando desde 0, de manera que ‘Hola’ es el elemento 0, ‘Adios’ el 1 y ‘Buenas Tardes’ el 2, y la longitud de la lista es 3. Podemos comprobarlo de esta forma: >>> a[1] ‘Adios’ >>> len(a) 3
Es posible añadir elementos a las listas de varias maneras. Si miramos el Listado 2, veremos la más sencilla. Las listas también se pueden comportar como una Pila, con las operaciones append y pop. Con insert introducimos un elemento en la posición especificada (recuerda que siempre comenzamos a contar desde 0). La facili-
dad con la que Python trata las listas nos permite usarlas para multitud de tareas, lo que simplificará mucho nuestro trabajo. A pesar de su potencia, las listas no pueden hacerlo todo, existiendo otra estructura que rivaliza con ellas en utilidad, los Diccionarios. Mientras las listas nos permiten referenciar a un elemento usando un número, los diccionarios nos permiten hacerlo con cualquier otro tipo de dato. Por ejemplo, con cadenas, de hecho, casi siempre con cadenas, de ahí que su nombre sea diccionario (véase el Listado 3). Las listas y los diccionarios se pueden mezclar: diccionarios de listas, listas de diccionarios, diccionarios de listas de diccionarios, etc. Ambas estructuras combinadas poseen una enorme potencia.
Algoritmos + Estructuras de Datos = Programas Ahora nos toca poner todo esto en práctica. Lo normal es hacer un programa sencillo. Pero en lugar de eso vamos a implementar algo que sea creativo. Este programa es el que se usa en el libro “La práctica de la programación” de Pike y Kernighan para ilustrar cómo un buen diseño sobrepasa al lenguaje que usemos para eje-
cutarlo. En el libro se implementa el diseño en C, C++, Java, Perl y AWK. Nosotros lo haremos en Python (ver Listado 4). El programa acepta un texto como entrada y genera un texto como salida, pero este segundo texto no tiene sentido. Lo que queremos hacer es generar texto sin sentido pero con estructuras que sí lo tengan. Puede parecer algo muy complicado, pero no lo es tanto si usamos la técnica de cadenas de Markov. La idea es coger 2 palabras, elegir una palabra que suceda a cualquiera de las dos y reemplazar la primera por la segunda y la segunda por la palabra escogida. De esta manera vamos generando un texto que, aunque carece de sentido, normalmente se corresponde con la estructura de un texto normal aunque disparatado.
Para hacer las pruebas es recomendable conseguir un texto de gran tamaño. En textos pequeños no surtirá tanto efecto. En el proyecto Gütenberg podemos conseguir infinidad de textos clásicos de enorme tamaño en ASCII. Pero somos conocedores de que no todo el mundo entiende el idioma anglosajón, así que en lugar de ir al proyecto Gütenberg, podemos coger cualquier texto que queramos modificar, por ejemplo, alguna noticia de política de un diario digital o alguna parrafada de algún blog. Este programa es interesante porque permitirá utilizar las estructuras de datos que Python implementa, en particular en los diccionarios, que generan una tabla donde los índices serán cadenas de texto.
Listado 4: markov.py Genera un Texto No-Tan-Aleatorio 01 #!/usr/local/bin/python 02 03 #Importamos dos módulos 04 #random [que hace] 05 #y sys [que hace] 06 import random 07 import sys 08 09 no_palabra = “\n” 10 w1 = no_palabra 11 w2 = no_palabra 12 13 # GENERAMOS EL DICCIONARIO 14 dict = {} 15 16 for linea in sys.stdin: 17 for palabra in linea.split(): 18 dict.setdefault( (w1, w2), [] ).append(palabra) 19 w1 = w2 20 w2 = palabra 21
22 # Fin de archivo 23 dict.setdefault((w1, w2), [] ).append(no_palabra) 24 25 # GENERAMOS LA SALIDA 26 w1 = no_palabra 27 w2 = no_palabra 28 29 # puedes modificarlo 30 max_palabras = 10000 31 32 for i in xrange(max_palabras): 33 nueva_palabra = random.choice(dict[(w1, w2)]) 34 35 if nueva_palabra == no_palabra: 36 sys.exit() 37 38 print nueva_palabra; 39 40 w1 = w2 41 w2 = nueva_palabra
Listado 5: Salida de markov.py Para empezar, debemos saber por qué Python es obligatorio hacerlo de una manera. Como es un lenguaje tipo script, debemos poner ‘#!’ seguido de la ejecución del programa. También tenemos a nuestra disposición los operadores habituales de otros lenguajes: +, -, *, /, etc. Y una vez que sabemos cómo manejar operadores y asignaciones, se pueden mezclar: diccionarios de listas de diccionarios, diccionarios de listas, listas de Python también vienen provistas de muchas más opciones que sus semejantes en otros lenguajes. Por ejemplo, vamos a definir una lista que guarde una serie de espacios (logrados pulsando la tecla TABULADOR) y una sentencia. Esos espacios son vitales , ya que marcan la existencia de un texto que, aunque carece de sentido, normalmente se correspond e con la que Python trata las listas de diccionarios, diccionarios de listas, listas de Python resultan tan potentes, es que nos permiten referenciar a un elemento en la sangría de la OOP. - Es potente. Realizar un programa de 1000 lineas en Java, en Python es obligatorio hacerlo de una manera. Como es un diccionario con dos palabras como índice y las palabras que les siguen en el que muchas entradas referenciarán a una lista de más de un bloque de código Python. Ese bloque aparecerá en bucles, funciones o métodos . Si nos fijamos bien en la sangría de la memoria a bajo nivel como C con el tamaño del texto que se usa en el Listado 1.
W W W . L I N U X- M A G A Z I N E . E S
Veamos cómo funciona. Lo primero es ir introduciendo en el diccionario dos prefijos como índice y las palabras que les siguen en el texto dentro de una lista referenciada por ellos. Eso es un diccionario con dos palabras como índice que contiene una lista: DICCIONARIO[ palabra 1, U palabra 2] -> U LISTA[palabra,...]
O sea, si tenemos las palabras “ La gente está … La gente opina”, crearemos un diccionario de la siguiente forma: >>> dict[‘La’, ‘gente’] = U [‘está’] >>> dict[‘La’, ‘gente’].U append(‘opina’) >>> dict[‘La’, ‘gente’] [‘está’,’opina’]
Vamos haciendo esto de manera sucesiva con todos los conjuntos de dos palabras, y obtendremos un diccionario en el que muchas entradas referenciarán a una lista de más de un elemento. La magia aparece cuando generamos el texto, puesto que lo que hacemos es comenzar por las dos primeras palabras, y cuando existan varias posibilidades para esa combinación (como con el ejemplo de ‘La’,’gente’), escogeremos aleatoriamente entre ellas. Imaginemos que escogemos ‘opina’, entonces escribimos ‘opina’ por la pantalla y buscamos en ‘gente’, ‘opina’ y así sucesivamente, hasta llegar a no_palabra. Para entender mejor el funcionamiento del programa recomendamos copiar el código fuente y pasarle unos ejemplos cat texto.txt | (pongamos, con ./markov.py) y ver los resultados. En el Listado 4 vemos un ejemplo de la salida utilizando el texto de este artículo. El texto generado casi tiene sentido, pero no del todo. Después podemos intentar cambiar cosas en el programa, por ejemplo, en lugar de utilizar 2 palabras como índice del diccionario, podemos probar con 1 o con 3, y también con el tamaño del texto que se le pase. Se pueden conseguir cosas muy ■ interesantes.
Recursos [1] Python: http://www.python.org
PYTHON
9
INTRODUCCIÓN
Ficheros
Manejo básico de ficheros
Álbum Fotográfico
R u s l a n O l i n c h u k 1 2 3 R F . c o m
Siguiendo con nuestro paseo por Python, vemos características básicas, y concretamente en este artículo, el tratamiento de ficheros. Por José Mari Ruíz
En nuestro primer artículo vimos algo
sobre cómo trabajar con objetos en Python. Fue muy simple, pero ya nos daba la posibilidad de organizar nuestro código en torno a ellos. Python hace un uso extensivo de los objetos en sus APIs, y especialmente del control de errores mediante excepciones, lo que nos da la opción de lanzarlas cuando algo va mal. Una excepción es un mensaje que podemos capturar cuando se ejecuta cierta función o método y aparece un error de algún tipo. Normalmente controlamos estos errores mediante el valor devuelto por la función (como por ejemplo en C). Esta técnica es engorrosa, pero al igual que todo, tiene sus virtudes y sus desventajas. Pero Python hace uso de las excepciones en su lugar. Cuando una función genera una excepción, decimos que eleva una excepción. Es muy normal tener que controlar las excepciones en las operaciones que realicemos con recursos que pueden no estar disponibles. Por eso las vamos a ver, puesto que aquí vamos a trabajar con archivos y conexiones a Internet. Crearemos un objeto que gestione un recurso que puede no estar disponible. En este caso el objeto gestiona una variable (véase el Listado 1). Alguien puede crear un objeto de la clase obj_variable y llamar al método set_variable(23), pero ¿cómo puede estar seguro de que la variable var tiene el valor 23 después de la llamada? Puede que var no tuviese el valor inicial de 0, porque otra llamada anterior ya podría haberla asignado. Lo único que podría-
10
PYTHON
mos hacer es llamar a reset_variable() y así asegurarnos de que nuestro valor sea asignado, pero entonces destruiríamos el valor anterior y no sabríamos qué podría pasar. Por lo tanto, necesitamos un mecanismo de comunicación para darle a conocer al usuario que esa variable ya está asignada. Esto lo podemos hacer con las excepciones. En el Listado 2 aparece una clase que hereda de la clase Exception llamada Var_Asignada. Cuando en la clase obj_variable intentamos asignar un valor a la variable var y ésta no es 0, entonces se dispara, se eleva, la excepción Var_Asignada . Si no controlamos la porción de código en la que se encuentra set_variable() y aparece una excepción, el programa se detendrá y acabará. La idea detrás de las excepciones es que es posible tratarlas y evitar males mayores, pudiendo en ocasiones incluso recuperarnos de ellas. Para ello está la estructura try—except , con la cual rodeamos el código que puede disparar excepciones (Véase el Listado 3). A partir de ahora, y hasta que no expliquemos con más profundidad el tema de las excepciones, cuando digamos que una función genera una excepción, significará que ese código deberá estar rodeado con una estructura try—except .
Trabajo con Ficheros Ya que hemos conseguido cierta soltura con los conceptos de objetos en Python, ahora vamos a ver cómo se manejan los accesos a ficheros en él.
Para acceder a un fichero, primero necesitamos crear un objeto file. El objeto file es parte de la librería base de Python, así que no es necesario importar ninguna librería. >>> archivo = file(‘texto.txt’)
Por definición, file abre los ficheros en modo de sólo lectura. Eso significa que si el fichero no existe, obtendremos un error. Para verificar si el fichero existe podemos usar la función exists() de la librería os.path. >>> import os.path >>> os.path.exists(‘texto.txt’) True >>> os.path.extsts(‘algopeludo-y-feo.txt’) False
Por lo tanto, si vamos a abrir un fichero, podemos asegurarnos de que ya existe. Si en lugar de leerlo lo que queremos es crearlo, deberemos invocar al constructor de file con los parámetros: >>> archivo = file(‘texto.txt’,U ‘w’)
Este segundo parámetro opcional nos permite definir el tipo de acceso que vamos a realizar al fichero. Tenemos varias posibilidades: podemos leer (r ), escribir (w), añadir al final del fichero (a) y también tenemos el acceso de lectura/escritura (r+w). Disponemos también del modificador b para indicar acceso binario. Por defecto, Python con-
W W W . L I N U X- M A G A Z I N E . E S
Ficheros
sidera todos los ficheros de texto. Vemos todas las combinaciones en el Listado 4. Si todo ha ido bien, con cualquiera de estas llamadas tendríamos en archivo un objeto que gestiona el archivo indicado. Ahora podemos operar sobre él. Las operaciones más típicas son las de leer desde el archivo y escribir en él. Para ello, el objeto file dispone de los métodos read(), readline() , write() y writeline(). Todos ellos operan con cadenas de caracteres: readline() y writeline() trabajan con líneas de texto (acabadas en retorno de carro), mientras que read() y write() lo hacen con cadenas sin restricciones. Lo que vemos en el Listado 5 son algunas manipulaciones sobre un fichero. Lo primero que tenemos que hacer es crear el fichero, para lo cual lo abrimos en modo de escritura, w, que lo creará o truncará el existente (lo borrará para crearlo de nuevo. Si lo hubiéramos querido añadir al final, habríamos usado a). Posteriormente escribimos en él una cadena con un retorno de carro en mitad (para hacer nuestras pruebas) y cerramos el fichero. Es importante cerrar los ficheros cuando dejemos de usarlos, pero en este caso la razón para cerrarlo es que vamos a volver a abrirlo en modo de lectura. Ahora volvemos a abrir el fichero en modo de lectura, y leemos 4 bytes que almacenamos en la variable cadena. Cuando leemos con read(), avanzamos en el fichero, siendo esta la razón de que readline() que viene a continuación lea la cadena “ mundo\n” en lugar de “Hola mundo”. También vemos que se para en el retorno de carro en lugar de continuar. El segundo readline() ya nos permite leer la cadena “Adiós mundo”. Pero… ¿qué ocurriría si en una de las lecturas nos encontrásemos con el fin de fichero? En el caso de que leyésemos una cadena con el fin de fichero (EOF), al final simplemente nos quedaríamos con
Listado 1: Una Clase Python
>>> import os >>> os.remove (texto.txt) >>>
Directorios y Sistema de Ficheros Con estos pocos métodos tenemos ya a nuestro alcance la manipulación básica de ficheros. Pero vamos a necesitar para nuestro programa la posibilidad de crear directorios. ¿Cómo lo haremos? Pues mediante la función mkdir(), que acepta una cadena y crea un directorio con ese nombre. Si queremos crear un directorio que esté dentro de otros directorios también nuevos tenemos que usar makedirs() . Ambas funciones pertenecen al módulo os, por lo que para usarlas tendremos que hacer: >>> import os >>> os.mkdir(‘uno’) >>> os.makedirs(‘dos/tres’)
y cuando la función fuese a borrar el directorio “dos”, se encontraría con que no puede porque existe dentro de él un directorio llamado “cuatro” y pararía. Imaginemos ahora que necesitamos cambiar el directorio en el que estamos trabajando. En el momento de arrancar el programa, el llamado “directorio de trabajo” – es decir, el directorio donde de manera predeterminada se realizarán todos los cambios – es el directorio que alberga el programa o bien el directorio desde el que se ejecutó. Pero, claro, no siempre querremos que el programa utilice ese directorio. Hay que tener en cuenta que, a no ser que utilicemos rutas absolutas, cualquier referencia a un fichero se tomará con relación al directorio de trabajo inicial. Para poder cambiar el directorio de trabajo, el módulo os tiene la función chdir(). Si lo invocamos dentro de nuestro programa: >>> os.chdir(‘/tmp’)
Desde ese momento, cualquier referencia a un fichero será direccionada a “/tmp”. Ahora podemos: • abrir, cerrar, modificar ficheros • crear, eliminar un directorio • cambiar el directorio de trabajo Vamos a ir un poco más allá.
Llamadas a Otros Programas A veces es más sencillo usar una utilidad del sistema operativo que crearla noso-
Listado 2: Uso de Excepciones Para borrar esos directorios usaremos las funciones rmdir() y removedirs(). La primera borra un directorio, mientras que la segunda borra una ruta d e directorios. Vamos a ver esto con más detenimiento. >>> os.rmdir(‘uno’) >>> os.removedirs(‘dos/tres’) rmdir() borrará el directorio “uno”, que no contiene ningún otro objeto en su interior (ni directorios, ni ficheros). En caso de tenerlo, la llamada devolvería un error. La función removedirs() comenzaría a borrar desde el directorio que está más a la derecha de la ruta (“tres”) hacia el que está más a la izquierda (“dos”). Pero imaginemos que dentro de “dos” también hay un directorio “cuatro”. Entonces se borraría el directorio “tres”,
01 class obj_variable: 02 __init__(this): 03 var = 0 04 05 set_variable(this, valor): 06 if (var == 0): 07 var = valor 08 09 reset_variable(this): 10 var = 0
W W W . L I N U X- M A G A Z I N E . E S
la cadena hasta el EOF. En cambio, si sólo leemos el EOF, entonces obtenemos una null. Esto es importante para comprobar que hemos acabado con el fichero. Así, un bucle que escriba por pantalla el contenido del fichero comprobaría en cada vuelta si la cadena que devuelve readline() es null. Ahora que ya sabemos crear archivos, tenemos que aprender a borrarlos. Esto se realiza mediante la función remove() de la librería os. Esta función acepta la ruta de un fichero y lo borra. Si en lugar de un fichero le pasamos un directorio elevará una excepción OSError .
INTRODUCCIÓN
WWW.LINUX- MAGAZINE.ES
01 class Var_Asignada(Exception): 02 “”“ Excepción que se dispara al intentar asignar una variable ya asignada en obj_variable”“” 03 pass 04 05 class obj_variable: 06 “”“ Administra una variable “”“ 07 def __init__(self): 08 self.var = 0 09 10 def set_variable(self, valor): 11 if (self.var == 0): 12 self.var = valor 13 else: 14 raise Var_Asignada 15 def reset_variable(self): 16 self.var = 0 17 18 a = obj_variable() 19 a.set_variable(12) 20 a.set_variable(34)
PYTHON
11
INTRODUCCIÓN
Ficheros
Listado 3: Más Excepciones 01 >>> try: 02 ... set_variable(12) 03 ... set_variable(34) 04 ... except: 05 ... print “ERROR: Se ha intentado asignar” 06 ... print “un valor a una variable ya asignada” 07 ... 08 ERROR: Se ha intentado asignar 09 un valor a una variable ya asignada 10 >>>
tros, como por ejemplo, un procesado usando tuberías en UNIX. Puede que simplemente tenga que acceder a alguna información como la que nos da uname. El caso es que siempre es importante tener la posibilidad de ejecutar otros p rogramas desde nuestro programa Python. Para ello usamos la función system del módulo os. Por ejemplo: >>> import os >>> os.system (‘uname -a’) Linux rachel 3.1.2-1.fc16.x86_64 #1 SMP Tue Nov 22 09:00:57 UTC 2011 x86_64 x86_64 x86_64 GNU/Linux 0 >>>
El parámetro que le pasamos a system es una cadena con la instrucción Bash (en este caso) y sus switches y flags. system nos devuelve la salida de la instrucción ( Linux rachel 3.1.2-1.fc16.x86_64 #1 SMP Tue Nov 22 09:00:57 UTC 2011 x86_64 x86_64 x86_64 GNU/ Linux) y el estado de salida resultante de la ejecución de la instrucción (0 – recuérdese que 0 indica que la instrucción ha acabado sin errores).
Python y la Web Python posee gran cantidad de librerías para trabajar con recursos de Internet. De hecho, Django [1] , un servidor de aplicaciones con gran éxito, está creado en Python y hace uso de todas sus características. Mailman [2] o Bittorrent [3] son también buenos ejemplos. Debido a su flexibilidad, Python es usado como lenguaje de implementación para multitud de aplicaciones de red así como aplicaciones distribuidas. Por eso, no es de extrañar que Python suela ser el lenguaje en el que se implementan muchas de las más novedosas tecnologías de red.
12
PYTHON
En este apartado vamos a comenzar Listado 4: Acceso a Ficheros con lo básico. Queremos traer un recurso de la red a nuestra máquina, y para ello 01 archivo = file(‘texto.txt’,’r’) 02 archivo = file(‘texto.txt’,’w’) emplearemos una URL del estilo http:// 03 archivo = file(‘texto.txt’,’a’) www.algunaweb.algo/imagen. jpg . Pero 04 archivo = primero necesitamos crear una conexión file(‘texto.txt’,’r+w’) con el servidor. 05 archivo = file(‘texto.txt’,’r+b’) Para ello vamos a utilizar la librería 06 archivo = file(‘texto.txt’,’rb’) httplib que viene de serie con Python. Esta librería nos permite establecer una conexión con un servidor http y manprogramas. En UNIX es algo común. darle comandos. Los comandos http Pero… ¿cómo podemos obtener los paráson simples, y de todos ellos sólo nos metros de ejecución en Python? De interesa uno, el comando GET . Cuando nuevo tenemos que recurrir a una libreaccedemos a un servidor http, por ría: la librería sys. sys nos proporciona el acceso a los ejemplo para ver una página web, lo que hacemos es pedirle objetos. Esto se argumentos a través de su variable argv. hace mediante el comando GET Esta variable es en realidad una lista, p or . Por ejemplo, si queremos la lo que podemos obtener los argumentos página index.html de la web http:// accediendo a las posiciones de la misma. www. pyth on.org , primero conectamos La posición 0 contiene el nombre del con el servidor http y después, una vez programa que estamos ejecutando y, a conectados, le enviamos el comando partir de la posición 1, encontraremos GET index.html. En ese momento el los parámetros pasados. Al ser una lista, servidor nos devuelve por el mismo podemos conocer la cantidad de parámecanal el contenido del archivo tros llamando a len(). index.html . Programa Dicho así parece muy fácil, pero es una tarea que en un lenguaje de más Ahora es el momento de poner todo lo bajo nivel requeriría gran cantidad de aprendido en práctica con un programa librerías y control de errores. que puede ser útil. En este caso vamos a Lo primero es importar la librería crear uno que realizará las siguientes httplib. Creamos entonces una conexión tareas: con el host en cuestión y pedimos el • El programa aceptará un parámetro de archivo index.html. Esa conexión genera entrada que le indicará el nombre de una respuesta. La respuesta está forun fichero. mada por varias partes, entre ellas un • El programa abrirá ese fichero y lo código numérico (como el famoso 404), leerá línea por línea. Cada línea del un texto que describe el error y una fichero será la dirección URL de una conexión al archivo que pedimos. En el imagen. caso de una conexión correcta recibire• Cada URL será introducida dentro de mos un 200, un OK y una conexión con una lista para su uso posterior. el fichero. De esa conexión leemos con read() el contenido y Listado 5: Lectura y Escritura de Ficheros lo almacenamos en una varia01 >>> archivo = file(‘/tmp/texto.txt’,’w’) ble que llamamos dato. Enton02 >>> archivo.write(“Hola mundo\nAdios ces podremos cerrar la conemundo”) 03 >>> archivo.close() xión como si de un fichero se 04 >>> tratara. 05 >>> archivo = file(‘/tmp/texto.txt’,’r’) En ese momento ya tenemos 06 >>> cadena = archivo.read(4) la información que queríamos 07 >>> cadena en dato y el canal cerrado. No 08 ‘Hola’ es muy difícil, ¿no? Veremos un 09 >>> cadena = archivo.readline() ejemplo en el programa final de 10 >>> cadena 11 ‘ mundo\n’ este artículo.
Paso de Parámetros Estamos acostumbrados a poder pasar parámetros a los
Listado 6: Agarrafotos.py 001 #!/usr/bin/python 002 003 # ---NOTA--------------------------- ----------004 # El fichero que debe ser pasado como argumento 005 # debe consistir en un listado con una url por 006 # línea. 007 # ---------------------------------- ----------008 009 class Lista_URLs: 010 “”“Recibe un fichero y carga sus cadenas en una lista. Provee de métodos para obtener de nuevo las cadenas desde la lista.”“” 011 012 def __init__(self,nombre): 013 # La lista donde guardaremos las URLs 014 self.lista= [] 015 # El contador que usaremos para comprobaciones 016 self.contador = 0 017 018 # pasamos el nombre del fichero menos el último carácter 019 self.archivo = file(nombre) 020 self.cadena = self.archivo.readline() 021 022 while(self.cadena != ‘\n’): 023 #Metemos la cadena en la lista 024 self.lista.append(self.cadena) 025 self.cadena = self.archivo.readline() 026 self.archivo.close() 027 028 029 def rebobina(self): 030 # Hace que se comience de nuevo 031 # por el principio en la lista. 032 self.contador = 0 033 034 035 def siguiente(self): 036 # Devuelve el siguiente elemento o 037 # ‘’ en caso de llegar al final. 038 if ( self.contador >= len(self.lista)): 039 return ‘’ 040 else: 041 self.valor = self.lista[self.contador] 042 self.contador = self.contador + 1 043 return self.valor 044 045 def fin(self): 046 # Comprueba que hemos llegado al final 047 # de la lista. Preguntamos si hemos llegado 048 # al final antes de avanzar. 049 return (self.contador == len(self.lista)) 050 051 def crea_directorio(cadena): 052 # Comprueba si el directorio especificado por 053 # cadena existe, en caso contrario lo crea 054 # y cambia el directorio de trabajo 055 # al directorio creado. 056 057 componentes = cadena.split(‘.’) 058 059 if(os.path.exists(componentes[0])): 060 print “Error: el directorio ya existe” 061 sys.exit() 062 else: 063 # Creamos el directorio
W W W . L I N U X- M A G A Z I N E . E S
064 os.makedirs(componentes[0]) 065 os.chdir(componentes[0]) 066 print ‘Creando directorio ‘ + componentes[0] 067 068 def descarga_urls(lista): 069 # Recorre la lista de urls usando el objeto 070 # Lista_URLs, las descarga y después las 071 # guarda en ficheros con el mismo nombre que 072 # el de la imagen. 073 074 lista.rebobina() 075 076 while( not lista.fin() ): 077 url = lista.siguiente() 078 079 # dividimos la url en dos partes 080 # lo que descargamos y la url http 081 082 # Componentes es una lista que contiene 083 # las cadenas resultantes de trocear la 084 # cadena de texto de la URL usando ‘/’ 085 # como separador. Por ejemplo: 086 # http://www.python.org/index.html 087 # componentes = [‘http:’, ‘’, ‘www.python.org’, 088 # ‘index.html’] 089 componentes = url.split(‘/’) 090 servidor = componentes[2] 091 092 # Construimos la ruta de la imagen, que 093 # consiste en toda la ruta si eliminamos 094 # al servidor y a http:// 095 ruta_imagen = ‘/’ 096 for i in range( 3, len(componentes)): 097 ruta_imagen = ruta_imagen + ‘/’ + componentes[i] 098 099 # Descarga el fichero y lo guarda con el nombre. 100 # El nombre se saca de la URL. 101 # url[:-1] es la cadena url menos el último carácter. 102 print ‘Descargando imagen: ‘ + url[:-1] 103 conexion = httplib.HTTPConnection(servidor) 104 conexion.request(“GET”, ruta_imagen) 105 respuesta = conexion.getresponse() 106 # datos contiene ahora la imagen y la guardamos 107 datos = respuesta.read() 108 conexion.close() 109 110 # el nombre del fichero es el último elemento 111 # de la lista componentes 112 nomb_fichero = componentes[len(componentes) -1] 113 # eliminamos el \n final 114 nomb_fichero = nomb_fichero[:-1] 115 116 # Abrimos el fichero, escribimos y cerramos 117 archivo = file(nomb_fichero ,’w’) 118 archivo.write(datos) 119 archivo.close() 120 121 def genera_index(lista): 122 123 # Crea un fichero index.html. 124 # Genera la cabecera, recorre la lista de URLS 125 # y por último escribe el pie. 126 # Es posible mejorarlo introduciendo separadores 127 # o títulos entre las imágenes ;) 128
\n’) # siempre antes de recorrer: lista.rebobina() url = lista.siguiente() # Dividimos la URL para poder utilizar # partes de ella. componentes = url.split(‘/’) imagen = componentes[len(componentes) - 1]
# Recorremos las urls while( url != ‘’): # Imagen en HTML archivo.write(‘
\n’) 155 url = lista.siguiente() 156 componentes = url.split(‘/’) 157 imagen = componentes[len(componentes) - 1] 158 159 # ... y por último el pie. 160 161 archivo.write(‘
• Una vez que hayamos acabado de leer el fichero, lo cerraremos y entraremos en la segunda parte del programa. • Crearemos un directorio con el nombre del archivo que nos hayan dado. • Cambiaremos el directorio de trabajo a ese directorio. • Descargaremos cada una de las URLs dentro del directorio. • Generaremos un archivo index.html que muestre las imágenes. ¿Mucho trabajo? Para eso están los programas. Evidentemente no realizaremos todas las comprobaciones que serían necesarias, ya que en tal caso el programa se alargaría demasiado, por lo que se deja al lector la opción de incluir mejoras. Pensemos ahora en su diseño. Tenemos varias partes: • Comprobar y almacenar la opción con el nombre del archivo.
14
PYTHON
168 # Main 169 #-----------------------------------------------170 171 # Esta es la técnica estándar para organizar el 172 # código en Python, se usa la siguiente construcción 173 # como punto de arranque. 174 175 if __name__ == ‘__main__’: 176 177 import httplib 178 import os 179 import os.path 180 import sys 181 182 # Comprobamos los argumentos... 183 184 if len(sys.argv) == 2: 185 #Pasamos el fichero al constructor 186 lista = Lista_URLs(sys.argv[1]) 187 188 189 crea_directorio(sys.argv[1]) 190 191 descarga_urls(lista) 192 193 genera_index(lista) 194 195 elif len(sys.argv) == 0: 196 # Vaya, han ejecutado sin poner argumentos... 197 # les recordaremos como va esto ;) 198 print ‘La sintaxis del programa es:\n’ 199 print sys.argv[0] + ‘ archivo\n’ 200 print ‘El archivo debe contener una URL por línea’ 201 202 else: 203 # Alguien se ha quedado corto y se ha pasado 204 # con el número de argumentos. 205 print “ERROR: la sintaxis es “ + sys.argv[0] + “ ”
• Leer las URLs. • Crear Directorio y cambiar el directorio de trabajo. • Descargar las URLs. • Generar el archivo HTML. Seguiremos estos puntos para crear las funciones. Las URLs las almacenaremos en una lista. ¿Deberíamos usar objetos? Esta es una de las cosas maravillosas que ofrece Python: NO estamos obligados a usar objetos. Y no digo que los objetos sean malos, sino que en ocasiones pueden llegar a ser engorrosos. Por ejemplo, podríamos crear un objeto Lista_URLs que aceptase como parámetro en su constructor el nombre de un fichero y que después nos permitiese ir cogiendo las URLs una detrás de otra. También podemos hacer lo mismo usando una función que cargue las URLs en una variable global. Aquí vamos a hacerlo
con un objeto. Es en este momento cuando se deja al lector que explore la posibilidad de sustituir el objeto por una variable global y las funciones de lista. Este programa es muy simple, pero de nuevo retamos a los lectores a mejorarlo y a introducirle, por ejemplo, control de excepciones. Suerte. ■
Recursos [1] La infraestructura Django para aplicaciones web: https://www.djangoproject.com/ [2] El programa administrador de listas de correo Mailman: http://www.gnu. org/software/mailman/ [3] El programar para administración de Torrente BitTorrent: http://bittorrent.com/
W W W . L I N U X- M A G A Z I N E . E S
Debugging
INTRODUCCIÓN
Eliminación de bugs de programas Python
S e b a s t i a n K a u l i t z k i 1 2 3 R F . c o m
Desparasitando Serpientes Da igual lo buenos programadores que seamos, tarde o temprano daremos con ese BUG que será nuestro peor enemigo. Veamos cómo podemos emplear herramientas para derrotarlo con mayor facilidad. Por José María Ruíz
Equivocarse es humano, y a pesar de
todo el mito que rodea a los programadores, hasta el mejor de ellos comete errores diariamente. En muchas ocasiones es mucho más complicado eliminar un BUG que crear el propio programa. Cuenta le leyenda que el nombre de BUG viene de la misma palabra que en inglés significa bicho. Dicen que los primeros ordenadores eran grandes máquinas que generaban gran cantidad de calor, por lo que innumerables insectos y otras alimañas se introducían en ellos. De vez en cuando, alguno tocaba dos cables y quedaba frito, provocando un fallo en el sistema. Actualmente se conoce como BUG a todo error o situación no controlada que impida a un programa realizar tu tarea con normalidad. Lo cierto es que estamos bastante acostumbrados a que los BUGS sean parte de nuestra vida. Ventanas que no se cierran, programas que consumen todo el espacio en memoria o videojuegos que se quedan bloqueados. Python es un lenguaje dinámico, como muchos otros. La principal ventaja es que nos permite programar a alto nivel, desentendiéndonos de toda la gestión de recursos a bajo nivel que hace tan
W W W . L I N U X- M A G A Z I N E . E S
pesada la programación en otros lenguajes como por ejemplo C. Pero no todo el monte es orégano. También hay una parte negativa: Python no es un lenguaje demasiado estricto. Podemos hacer lo que queramos con las variables sin que el intérprete se queje hasta el último momento. Esta característica impide la posibilidad de verificar automáticamente todo el código en el momento en que es compilado. Un código totalmente erróneo, en el que por ejemplo se suman letras y números, puede pasar desapercibido en nuestro programa hasta el día que se ejecuta y genera un error que dejará al usuario con la boca abierta, y ciertas dudas sobre nuestra valía como programadores. Casi a la vez que surgieron los lenguajes de programación aparecieron unos programas que han ido unidos a ellos: los debuggers. Exiten muchos debuggers diferentes. GNU desarrolló DDD, pero hace tiempo que no se ve actividad en este proyecto (ver Recurso [1]). Valgrind ha conseguido mucha fama en proyectos que emplean C++ ( ver Recurso [2]). En este artículo vamos a echar un vistazo a las herramientas que podemos usar para localizar los fallos en nuestros
programas Python, y en particular a la que viene de serie con Python: el PDB, Python DeBugger (podemos ver la documentación de PDB en el Recurso [3]).
Un Bug, Dos Bugs, Tres Bugs… Los lenguajes dinámicos, como decíamos antes, tienen sus propias virtudes y desventajas. Los programadores más duros suelen decir que programar con lenguajes dinámicos es como jugar con juguetes: no hay bordes cortantes con los que cortarse ni partes pequeñas con las que atragantarnos. Vamos, que son poco menos que una versión infantil de los lenguajes “serios”. Lo cierto es que hay mucha gente que no entra en estos debates. Yo, por lo menos, prefiero hacer un programa tan rápido como sea posible y espero que funcione casi a la primera. ¿De dónde salen los BUGS? Lo más probable es que haya siempre una variable implicada. La explicación es simple: las variables son la única parte del programa que realmente no controlamos. Mientras el resto del código hace exactamente lo que le indicamos que haga, por ejemplo abrir un fichero, en las variables suceden todo tipo de cosas mientras el
PYTHON
15
INTRODUCCIÓN
Debugging
programa está en ejecución. El problema es que no vemos esas variables mientras el programa está funcionando, así que tenemos que imaginarnos qué está pasando. En condiciones ideales se puede perder el tiempo tratando de localizar los fallos a ojo de buen cubero, pero bajo estrés y con plazos, toda ayuda es poca. Python además nos permite almacenar cualquier valor dentro de una variable. Las variables en los lenguajes dinámicos como Python son casi mágicas. En ellas podemos almacenar un número: >>> mivariable = 32
Y punto seguido almacenar un objeto: >>> class Persona: ... def __init__(this,nombre): ... this.nombre = nombre ... >>> mivariable = PersonaU (‘Carlos’)
Y sigue siendo la misma mivariable , pero de alguna manera su naturaleza ha cambiado. Ahora imagina que esta situación ocurre en un programa que has creado. Mientras tecleas piensas, “‘mivariable’ contiene una distancia” y operas con ella, sólo que, sin que te des cuenta, en realidad mivariable contiene un objeto de la clase Persona ¿qué pasara si intentas sumarle 18? >>> a + 18 Traceback (most recent call last): File “”, line 1, in ? TypeError: unsupported operand type(s) for +: ‘instance’ and ’int’ >>>
¡ERROR! El intérprete de Python nos advierte de que algo no marcha bien: hay un error de tipo, no es posible sumar un número entero y una instancia de un objeto tal como hemos definido la clase. Desagradable ¿verdad? Por lo menos este tipo de BUG, que es tan fácil de encontrar que el propio intérprete de Python lo encuentra. ¿Qué ocurría si el programa no fallase, sino que no nos diese el resultado esperado? ¿Y si el programa le dijese a un cliente que su edad actual es -323134.32 años? Este es sin duda el peor tipo de BUG existente: el semántico. El intérprete de Python es perfecto localizando errores sintácticos, aquéllos que tienen que ver con las propias palabas que escribimos. Si hacemos referencia a una variable que no está definida, Python trata de buscar su valor, ve que no existe la variable y se queja. Los errores semánticos son harina de otro costal, porque se refieren a fallos que aparecen debido a que no se entiende lo que está pasando. Un ejemplo simple es el que hemos visto antes, cuando hemos tratado de sumar una variable con una instancia de un objeto que no responde a la suma con un número. Solucionar un BUG semántico puede llevar desde segundos a años. De hecho, existe mucho software, tanto comercial como libre, con BUGS que no han sido resueltos en años. Ahora que el problema ha sido planteado con más detenimiento, conviene ver con qué arsenal contamos en nuestra batalla contra los BUGS.
Depurando Código Digamos que estamos haciendo un script para mostrar, usando como caracteres las
Listado 1: El Código Nefasto 01 #!/usr/local/bin/python 02 03 import pdb 04 05 def vacaciones (l): 06 cadena = “” 07 for i in range(1,31): 08 encontrado = False 09 max = len(l) 10 k=0 11 while(not(encontrado) or k
16
PYTHON
14 if ((i >= inf) and (i <= sup)): 15 encontrado = True 16 else: 17 k+=1 18 19 if (encontrado): 20 cadena += “#” 21 else: 22 cadena += “ “ 23 24 return cadena 25 26 pdb.run(‘vacaciones([(1,3),(6,10)])’)
Figura 1: ¿A quién dejaremos sin vacaciones?
vacaciones que han escogido una serie de empleados de una empresa. Como no queremos que el código sea largo ni demasiado complicado, lo hemos reducido al mínimo. La función tomará una lista de tuplas, que representa las vacaciones de una persona en un mes. Cada tupla representa un periodo de vacaciones, con una fecha de inicio y una fecha de fin. La idea es muy simple, aceptamos esa lista y después devolvemos una cadena donde los días de trabajo se representan por un espacio, y los de vacaciones con un “#”. No es muy complicado ¿verdad? Así que nos ponemos manos a la obra, es algo sencillo, no nos llevará ni 10 minutos, acabamos escribiendo el código del Listado 1. Pero nos interrumpen antes de probar la función, y cuando volvemos al ordenador y ejecutamos un programa de prueba ¡se queda bloqueado! ¡No puede ser!, en tan pocas líneas de código no puede haber un error tan grave. Después de unos minutos de frustración, abandonamos la inspección visual y pasamos a trabajar PDB. PDB es el Python DeBugger y viene de serie con Python. Eso está muy bien, porque en caso de necesitarlo siempre lo tendremos a mano. A diferencia de otros debuggers, PDB se puede usar como si fuese una librería. Podemos integrarla en nuestros programas y eliminarla cuando ya los hayamos arreglado. Como es posible observar en el Listado 1, hemos importado PDB y hemos pasado como parámetro a pdb.run() una cadena en la que invocamos la función vacaciones() con un argumento acorde. Si ejecutamos el programa, veremos lo siguiente en nuestro terminal: josemaria@linuxmagazine$U ./p.py > (1)?() (Pdb)
W W W . L I N U X- M A G A Z I N E . E S
Debugging
INTRODUCCIÓN
Podemos ver lo que hace un comando usando de nuevo la letra h:
Figura 2: IDLE no es bello, pero es práctico.
Muy bien, el PDB comienza a hacer su trabajo. En lugar de no hacer nada, como haría la función vacaciones() si el programa se limitase a ejecutarla, entramos en lo que parece el prompt del shell de PDB. Esta shell tiene sus propios comandos, no tiene nada que ver con Python. Para ver los comandos disponibles podemos emplear el comando h: (Pdb) h Documented commands (type help ): ================================ EOF break condition disable help list q step w a bt cont down ignore n quit tbreak whatis alias c continue enable j next r u where args cl d exit jump p return unalias 09 b clear debug h l pp s up Miscellaneous help topics: ========================== exec pdb Undocumented commands: ====================== retval rv (Pdb)
¡Buff! estos son demasiados comandos. Como suele ocurrir la primera vez que un principiante en Linux pulsa dos veces tabulador en BASH, lo que vemos nos asusta. En este caso no son tantos comandos (en un Linux estándar hay miles de ejecutables), pero sí más extraños. Debuggear es algo que SIEMPRE se hace bajo presión, por lo que todo el tiempo que ahorremos es oro. Así que los creadores de PDB nos ahorran segundos reduciendo los comandos a letras.
W W W . L I N U X- M A G A Z I N E . E S
(Pdb) h l l(ist) [first [,last]] List source code for the current file. Without arguments, list 11 lines around the current line or continue the previous listing. With one argument, list 11 lines starting at that line. With two arguments, list the given range; if the second argument is less than the first, it is a count. (Pdb)
El comando l sirve para mostrar visualmente en qué parte del código estamos en un momento dado; como nos pica la curiosidad ejecutamos l: (Pdb) l [EOF]
Vaya, resulta que no hemos comenzado aún, por lo que no estamos en ninguna parte. El comando que probablemente usemos más a menudo es s ¿Por qué? pues porque es el comando que hace que PDB avance una línea y la ejecute: (Pdb) s --Call-> /home/josemaria/p.py(5)U vacaciones() -> def vacaciones (l):
Muy bien, comenzamos a ejecutar el trozo de código Python que pasamos a pdb.run(). Por el momento no pasa nada interesante, aunque estaría bien ver qué contiene la variable l, para ello podemos usar el comando p que hace las funciones de print : (Pdb) p l [(1, 3), (6, 10)]
Efectivamente, l contiene el parámetro que hemos pasado a la función. Ya estamos en ruta, así que avancemos unos cuantos pasos más: (Pdb) s > /home/josemaria/p.py(6) vacaciones() -> cadena = “”
Figura 3: El depurador de IDLE.
(Pdb) s > /home/josemaria/p.py(7) vacaciones() -> for i in range(1,31): (Pdb) s > /home/josemaria/p.py(8) vacaciones() -> encontrado = False (Pdb) s > /home/josemaria/p.py(9) vacaciones() -> max = len(l) (Pdb)
Hemos avanzado 4 pasos y puede que nos hallamos perdido. ¿Dónde estamos? ¿Qué estamos haciendo? ¿Hacia dónde vamos? El comando l resuelve todas nuestras dudas: (Pdb) l 4 5 def vacaciones (l): 6 cadena = “” 7 for i in range(1,31): 8 encontrado = False 9 -> max = len(l) 10 k=0 11 while(not(encontrado) or k= inf) and (i <= sup)): (Pdb)
Ya me sitúo, acabamos de entrar en el bucle for , avancemos un poco más: (Pdb) s > /home/josemaria/p.py(10)U vacaciones() -> k=0 (Pdb) s > /home/josemaria/p.py(11)U vacaciones() -> while(not(encontrado) orU k
PYTHON
17
INTRODUCCIÓN
Debugging
Bueno, llegamos a una encrucijada. Cuando ejecutamos la función sin PDB, parece como si el programa nunca acabase. Esto implica que hay algo que se repite eternamente. En este programa hay dos bucles, que son los únicos elementos que pueden repetirse eternamente. El primero es un bucle for con un principio, 1, y un fin, 31, por lo que podemos descartarlo como culpable. El segundo sospechoso es ese bucle while, que en un primer momento no tiene porqué acabar, puede que jamás pare. Si un bucle while no para es porque las condiciones que lo controlan siempre se dan. En este código se supone que el if dentro del bucle while hace que éste pare alguna vez, así que algo debe fallar ahí dentro. Comencemos comprobando los valores de las variables que controlan el bucle: (Pdb) p encontrado False (Pdb) p k 0 (Pdb) p max 2 (Pdb)
De acuerdo, todo parece en su sitio. Si avanzamos un poco: > /home/josemaria/p.py(12) vacaciones() -> rango = l[k] (Pdb) s > /home/josemaria/p.py(13) vacaciones() -> inf,sup=rango (Pdb) s > /home/josemaria/p.py(14) vacaciones() -> if ((i >= inf) and (i <= sup)): (Pdb) s > /home/josemaria/p.py(15) vacaciones() -> encontrado = True (Pdb) s > /home/josemaria/p.py(11) vacaciones() -> while(not(encontrado) or k
Resulta que hemos entrado en una tupla que representa unas vacaciones, el día representado por i pertenece a las vacaciones. Por tanto, hemos hecho que la
18
PYTHON
variable encontrado sea True. Si todo va bien, el siguiente paso después de evaluar las condiciones del while será salir del mismo y pasar a las siguiente instrucción fuera del while: (Pdb) s > /home/josemaria/p.py(12)U vacaciones() -> rango = l[k] (Pdb)
¿Pero qué ocurre aquí? Esto no debería pasar. La única explicación posible es que la condición del while esté… ¿es eso un or ? ¡Debería ser un and! Deberíamos salir si hemos encontrado que el día pertenece a un rango, o si no quedan rangos que comprobar. Ahí estaba nuestro BUG, tres simples letras, se cambian y problema solucionado. Ahora que ya sabemos lo que pasa, sólo queda salir del debugger usando el comando q. Nuestro nuevo código ya está listo para ser usado (ver Figura 1).
Y Ahora de Forma Fácil ¿No hay una manera más «moderna» de conseguir esto mismo? Pues sí, gracias a IDLE (ver Recurso [4]). IDLE es el entorno de desarrollo que viene, también, junto a Python. En la Figura 2 se puede observar el aspecto que tiene IDLE una vez que se ejecuta. No es ninguna belleza, pero es práctico, reemplaza al intérprete de comandos de Python y simplifica algunas tareas. En particular, estamos interesados en cómo puede simplificar el debugging. Para ello sólo tenemos que ir al menú Debug que aparece en la barra de menú de IDLE y activar Debugger . Aparecerá una ventana como la que puede observarse en la Figura 3. El lector no debe extrañarse demasiado con esta nueva ventana, viene a condensar en un solo lugar todo lo que hemos visto sobre PDB: hay un botón llamado STEP , que nos permitirá avanzar en el código paso a paso, y también hay un área llamada Locals , donde iremos viendo el valor de las variables que se vayan declarando en el código, de forma que podremos ir controlando la evolución del programa de un solo vistazo. Para ello sólo tenemos que cargar el programa en IDLE y veremos cómo se abre una especie de editor de textos como el de la Figura 4, en el que debere-
Figura 4: El seudo-editor de IDLE.
mos seleccionar en el menú Run la opción Run Module. Con este paso cargaremos el fichero y comenzaremos a ejecutarlo. Como antes seleccionamos la opción Debugger , IDLE se cargará en la ventana de debugging y podremos comenzar a visionar la evolución del programa conforme pulsemos sobre el botón Step. No es que IDLE sea un gran avance respecto al uso de PDB, pero desde luego simplifica el debugging.
Conclusión Los debuggers no son una excusa para crear programas sin fijarnos demasiado en los problemas. Pero si no tenemos claro qué está ocurriendo o si ya no sabemos qué hacer, entonces un debugger como PDB puede ayudarnos a tener una imagen más clara de lo que pasa en nuestro programa. Existen bugs que no pueden cazarse con PDB, pero son tan extraordinariamente raros, que es posible que jamás nos encontremos con uno. Los debuggers nos permiten programar sin miedo a no entender lo que estamos haciendo, y es precisamente eso lo que nos permitirá avanzar y aprender más rápidamente. ¡Perdámosle el miedo a los BUGS! ■
Recursos [1] Documentación del depurador PDB: http://docs.python.org/lib/module- pdb.html [2] Valgrind captura errores que comprometen la memoria en: http://valgrind.org/ [3] Data Display Debugger: http://www.gnu.org/software/ddd/ [4] El entorno de desarrollo IDLE: http://www.python.org/idle/
Python es un lenguaje de programación multiparadigma, y las funciones lambda son parte fundamental de él, aunque como veremos, existen buenas razones para no abusar de ellas. Por José María Ruíz
Existe un gran misticismo en torno a los conceptos de función lambda y al concepto de cierre. Siempre que aparece un nuevo lenguaje de programación suele venir acompañado de una discusión que demuestra que el nuevo lenguaje es mejor porque incorpora alguno de estos dos conceptos. Quien esté un poco al tanto de los últimos «avances» habrá escuchado decir que C# incorpora las funciones lambda y que la próxima versión java al fin las tendrá entre su arsenal. Las funciones lambda reciben su nombre de la teoría del cálculo lambda de Alonzo Church [1], que junto a Alan Turing, sentaron las bases de la teoría de computación. Mientras Turing utilizó en su teoría una máquina abstracta e imaginaria a la que se llamó Máquina de Turing, Alonzo utilizó un enfoque más tradicional, creando una serie de reglas que permitían realizar computaciones. Su sistema requería de un tipo de fun-
W W W . L I N U X- M A G A Z I N E . E S
ción especial, para la que usó la letra lambda. Las funciones lambda que veremos comparten sólo algunas de las características que Alonzo definió para las suyas, y podemos decir que lo que las define es que son anónimas: las funciones lambda no tienen nombre. ¿Cómo es esto posible? ¿Para qué querríamos algo así? Son sólo dos preguntas que trataremos de resolver en este artículo mientras desmitificamos un concepto tan abstracto a primera vista.
Las Funciones Lambda Las funciones lambda son el concepto más sencillo de los que vamos a ver en este artículo. Python las soporta desde hace un buen tiempo, y se encuentran integradas en la librería base de Python. También conocidas como funciones anónimas, no son más que funciones sin nombre que podemos crear en cualquier momento y pasar como argumento a otras funciones:
>>> a = lambda x : x + 1 >>> a(2) 3 >>>
Recordemos que en Python las variables no son más que nombres que asignamos a cosas y no contenedores de esas cosas. Esta diferencia es vital para comprender por qué podemos asignar una función a una variable y posteriormente asignar un valor a la misma (ver Figura 1). En este sencillo ejemplo hemos creado una función que suma el número 1 al número que pasemos como argumento. La definición de una función lambda siempre comienza con la palabra lambda seguida de los argumentos que vamos a aceptar. Detrás de los argumentos usamos el símbolo : para separar la definición del cuerpo de la función. Las funciones lambdas, al ser anónimas, deben almacenarse en una variable si queremos reutilizarlas, y se comportarán
PYTHON
19
AVANZADO
Funciones Lambda
como una función tradicional a la que podremos llamar pasándole parámetros entre dos paréntesis (). Existen varias restricciones en el uso de las funciones lambda. La primera es que siempre deben devolver un valor. Son funciones en el sentido estricto de las matemáticas, aceptan valores, los transforman y devuelven algún valor. En Python podemos devolver varios valores si lo deseamos: >>> b = lambda x: (x,x+1) >>> b(2) (2,3) >>>
La segunda restricción es que sólo pueden contener una expresión. Esta restricción limita bastante el poder de las funciones lambda en Python. En Ruby, por ejemplo, las funciones lambda (también llamadas bloques) pueden contener tantas expresiones como deseemos. En Python se decidió añadir esta restricción para que los desarrolladores terminaran empleando las funciones lambda allí donde una función tradicional podría valerles (en Javascript es algo que se hace habitualmente). Cuando violemos una de estas restricciones, Python generará una excepción: >>> c = lambda x: y = x+1 File “”, line 1 c = lambda x: y = x+1 ^ IndentationError: unexpected U indent
En este caso hemos tratado de realizar una asignación dentro de una función lambda. Lo que sí podemos hacer es pasar más de un parámetro a la función:
>>> d = lambda x,y: x*y >>> d(2,3) 6 >>>
Podemos, de forma limitada, emplear sentencias condicionales, puesto que Python nos permite usar la fórmula if...else como si fuese una expresión: >>> d = lambda x: ‘Yuju’ U if x > 2 else ‘ooooh’ >>> d(2) ‘ooooh’ >>> d(3) ‘Yuju’
Pero… ¿Para qué Sirven? Las limitaciones a las funciones lambda en Python tienen un objetivo bien definido: evitar el mal uso que se puede hacer de ellas. Se restringe su uso a aquellas funciones donde es necesario pasar operaciones sencillas que el diseñador original de una función no puede predecir de antemano. Por ejemplo, si queremos ordenar una lista, la función de ordenación sorted() intentará comparar los elementos de la misma usando los métodos que existen por defecto. Pero ¿qué ocurre si los datos a ordenar son algo especiales? Imaginemos que tenemos una lista de datos donde cada elemento es un tupla con el nombre y la edad de una serie de personas: >>> l = [(‘Luis’, 65), U (‘Juan’,28),U (‘Montse’, 33)]
¿Cómo podemos indicar a sorted que queremos ordenar la lista por edades? El diseñador de sorted no puede predecir todas las posibles estructuras de datos que se pasarán a la función. Existen tres opciones, u obligamos a la persona que pasa los datos a encapsularlos en objetos con un método que nos permita comparar dos objetos: 01 from functools import total_ordering 02 03 @total_ordering 04 class Edad(object):
O bien definimos una función que nos permita extraer el valor a comparar de los objetos: >>> def mi_ordenacion (x): U return x[1] >>> sorted(l, key = U mi_ordenacion) [(‘Juan’,28),(‘Montse’, 33), U (‘Luis’, 65)] >>>
O bien podemos emplear una función lambda para generar los valores a comparar: >>> sorted(l, key = U lambda x: x[1]) [(‘Juan’,28),(‘Montse’, 33), U (‘Luis’, 65)] >>>
La primera opción, más clásica de lenguajes como Java o C#, y (supuestamente) más limpia, tiene un gran problema. ¿Qué ocurre si queremos ordenar los datos de varias maneras diferentes? El diseñador de sorted sólo empleará una de ellas. Es un enfoque bastante inflexible, es preferible que la función que selecciona el criterio de ordenación sea externa al objeto a ordenar. Además, como se puede observar, esta opción es bastante más compleja.
W W W . L I N U X- M A G A Z I N E . E S
Funciones Lambda
La segunda opción implica el uso de una función externa que nos d evuelve el valor a comparar para cada objeto. Indicamos a sorted qué función usar para seleccionar los valores a comparar mediante el parámetro key . Por último vemos cómo se haría lo mismo con una función lambda. Salta a la vista que la tercera opción es la corta, fácil de leer y elegante (o lo que es lo mismo, la más «pythonic»). El lenguaje de programación Common Lisp se enfrentó a este mismo problema cuando se diseñó su sistema de objetos, y la solución fue la misma: sacar fuera del objeto y de la función de ordenación el código que genere los datos a comparar. Python empleó la misma técnica, por lo que mucha gente ve semejanzas entre ambos lenguajes de programación.
Cierres Otro de los conceptos que puede provocar más de un dolor de cabeza es el de cierre. Lenguajes como Javascript giran en torno a este concepto, ya que les permite crear algo parecido a objetos, ver Figura 2. En Python, sin embargo, los cierres son la base de una de las características más usadas del lenguaje últimamente: los decoradores. Un cierre es un trozo de código fuente que depende de variables, algunas de las cuales han sido «capturadas» junto al trozo de código y quedan aisladas de cualquier interferencia externa. En el caso de Javascript, que no posee objetos propiamente dichos, se usan cierres para que una serie de funciones compartan unas variables que no pueden ser accedidas desde fuera y que por tanto están protegidas. En Python los cierres no funcionan exactamente como lo hacen en otros lenguajes. Siguiendo con las funciones lambda, vamos a crear un cierre con una de ellas: >>> def crea_cierre(num): ... return lambda x=num: x+1 ... >>> cierre = crea_cierre(3) >>> cierre() 4 >>> 4
Analicemos este código. La función crea_cierre() acepta un parámetro num y devuelve una función lambda, por lo que
W W W . L I N U X- M A G A Z I N E . E S
AVANZADO
el valor devuelto puede almacenarse en una variable y se comportará como una función. El secreto está en pasar a la función lambda el valor num que queda definido como valor por defecto para x. Lo curioso es que en este caso Python no nos permite pasar ningún valor a la función lambda una vez definida. Si tratamos de pasar un valor: >>> cierre(10) 4 >>>
¡Nos sigue devolviendo 4! Figura 2: Cómo funciona un cierre en torno a una función. No importa qué valor pasemos a la función, el contenido de x ha 07 >>> saludo = Saluda(‘Hola’) 08 >>> saludo(‘mundo’) quedado completamente cerrado y blo09 Hola mundo queado. Por así decirlo, su valor se ha 10 >>> saludo = Saluda(‘Hello’) vuelto inaccesible. Si quisiéramos poder 11 >>> saludo(‘world’) cambiar el valor de una variable cerrada, 12 Hello world deberíamos usar una función normal en 13 >>> lugar de una función lambda, porque como ya vimos, las funciones lambda no aceptan asignación de variables. Creamos un objeto tradicional con la ¿Tiene sentido usar cierres en Python? única diferencia de poseer un método El sistema de objetos de Python es muy llamado __call__, que será el que se ejesencillo y nada engorroso, por lo que es cute cuando invoquemos la instancia de muy extraño ver el uso de cierres en la clase como si fuese una función. PriPython, salvo por una excepción: los mero debemos generar una instancia a la decoradores. Un decorador es una funque pasamos la variable de se «cerrará» y ción que intercepta los parámetros de posteriormente podemos invocar la insotra función, hace algo y devuelve la tancia como si fuese una función que función original. Normalmente no se cieacepta parámetros como cualquier otra rran variables en un decorador, pero es función. posible hacerlo. Funciones de Primer Orden La respuesta de Python a los cierres de funciones son los objetos callable . En Como ya hemos dicho, las funciones Python es posible crear un objeto que se lambda no son especialmente potentes comporte como una función. La función en Python – en Ruby lo son más – pero tendrá acceso a una serie de variables de nos permiten pasar comportamientos a instancia que se pasan en el constructor otras funciones. En teoría de lenguajes de la misma: de programación, se llama función de primer orden a aquella función que 01 >>> class Saluda(object): acepta otra función como parámetro, 02 ... def __init__(self, acepta comportamientos además de saludo): datos, lo que la hace especialmente 03 ... self.saludo = potente y flexible. saludo En Python es absolutamente normal 04 ... def __call__(self, usar funciones como parámetros: nombre): 05 ... print “{0} {1}” .format(self.saludo, nombre) 06 ...
Al fin y al cabo, las variables en Python no son más que nombres que apuntan a «cosas», sin importar demasiado qué son esas cosas. No hay gran misterio en las funciones de primer orden vistas así. Es lo que haces con ellas lo que las vuelve interesantes. Python nos provee de un conjunto de funciones de primer orden, heredadas de otros lenguajes de programación funcionales, que nos permiten emplear funciones en sus operaciones.
Map y Reduce Cuando las funciones lambda realmente brillan es cuando se usan en conjunción con las funciones de filtrado y mapeo. Con todo el revuelo generado por Google y otras empresas en torno a las té cnicas Map/Reduce, es interesante recordar los humildes comienzos de estas técnicas. El filtrado y mapeo son técnicas heredadas de la programación funcional, ver Figura 3. En este estilo de programación se evita modificar los datos originales, y en lugar de ello se realizan una serie de transformaciones sobre los datos para ir reduciéndolos y operando sobre los resultados hasta conseguir el resultado deseado. El código resultante suele ser conciso, aunque no siempre fácil de leer y entender. La programación funcional también hace uso de las funciones de primer orden que hemos visto antes. Comencemos por echar un vistazo a la función map: >>> map(lambda x,y: (x,y),U [‘Luis’, ‘Juan’,’Montse’], U [65,28,33]) [(‘Luis’, 65), (‘Juan’, 28), U (‘Montse’, 33)] >>>
map aplica una función a dos listas de valores, recorriendo ambas listas de valores y pasando los valores como pará-
22
PYTHON
metros. Primero aplicará la función a «Luis» y «65», después a «Juan» y «28»… y así indefinidamente. map no está limitada a dos listas, podemos emplear tantas listas como queramos: >>> map(lambda x: x.upper(),U [‘Luis’, ‘Juan’U , ‘Montse’]) [‘LUIS’, ‘JUAN’, U ‘MONTSE’] >>> map(lambda x,y,z:U (x, y*z),U [‘Luis’, U ‘Juan’,’Montse’],U [65,28,33], [1,2,3]) [(‘Luis’, 65),U (‘Juan’, 56),U (‘Montse’, 99)] >>>
Aunque podríamos pasar Figura 3: Map y Reduce en acción. cualquier función previamente definida, estamos pasando funciomayor de ellos. Por lo tanto, map aplica nes lambda. Es la manera más sencilla y una función a una gran cantidad de rápida de aplicar map , aunque como ya datos y reduce realiza alguna operación hemos dicho antes, si necesitamos más sobre los datos que los convierte en un de una operación o el código es complejo solo valor. es mejor definir la función. A pesar de toda la fanfarria existente Este map es el mismo que el del alrededor de Map/ Reduce , lo cierto es famoso Map/Reduce de Google, con la que en Python se usan poco. De hecho, diferencia de que el de Google se aplica a reduce dejará de ser una función primicientos o miles de máquinas, que aplican tiva del sistema en Python 3 y pasará a map funciones muy complejas a gran ser una función de la librería functools, cantidad de datos. Pero el concepto es el por lo que ha sido degradada a ciudamismo. dano de segunda fila. Si este es el map … ¿dónde está Conclusión reduce? Estamos tan acostumbrados ya a la pro>>> reduce(U gramación orientada a objetos, que se lambda x,y: x if x[1] > y[1] U nos olvida que Python en sus inicios else y,U tomó prestados gran cantidad de conceptos y técnicas de otros modelos de pro[(‘Luis’, 65), (‘Juan’, 56),U (‘Montse’, 19)]) gramación. Las funciones lambda no (‘Luis’, 65) están muy vistas como técnica de pro>>> gramación, pero las restricciones a las que las somete Python las ha domestireduce va a aplicar una función de 2 cado lo suficiente como para que en variables a los elementos de una lista lugar de entorpecer nuestro código lo con el objetivo de acabar devolviendo un hagan más ligero y sencillo de compren■ solo elemento. Como su propio nombre der. indica, reduce una lista a un elemento. Aquí estamos buscando el valor más Recursos grande de los presentes en la lista, por lo [1] Alonzo Church: http://es.wikipedia. que la función reductora compara los org/wiki/Alonzo_Church dos parámetros y siempre devuelve el
W W W . L I N U X- M A G A Z I N E . E S
OpenOffice
INTEGRACIÓN
PyUNO: Explota todo el potencial de OpenOffice
Python no hay más que UNO ¿Has visto alguna vez a los brokers de bolsa? ¿Recuerdas sus sofisticados y caros programas para ver las cotizaciones de las empresas en bolsa en tiempo real? Nosotros haremos lo mismo con 70 lineas de código Python, OpenOffice y la tecnología UNO de OpenOffice. Por José María Ruíz
No es ni será la última
vez que desde esta sección recordemos que la idea original de Stallman era la de que cada programa libre estuviese construido sobre librerías de funciones, de manera que su código fuese reutilizable por cualquier otro programa. Quizás en un programa pequeño no sea muy útil este tipo de diseño, pero ¿qué pasa con esos monstruos consumidores de memoria que rondan por nuestros discos duros? Nos referimos a programas o entornos del calibre de Gnome, KDE, Mozilla u OpenOffice. Todo el mundo se queja de su tamaño excesivo, su alto consumo de recursos y su inexplicable complejidad. Quizás con este artículo desmintamos este mito y hagamos que el lector mire con nuevos ojos a estos maravillosos programas.
Grandes Sistemas de Componentes El diseño de un gran programa puede llevar años y cientos o miles de programadores. Organizar tal cantidad de per-
W W W . L I N U X M A G A Z I N E . E S
-
sonas supone ya una locura sólo por el hecho de asegurarse que todos cobren. Pero vayamos a nuestro mundillo ¿cómo podemos organizarlos para que el desarrollo no acabe en un fiasco? Esta es la gran cuestión no resuelta de la informática, pero, aunque no hayamos encontrado una solución fiable, sí se disponen de técnicas que aumentan la probabilidad de que, al menos, se cree algún software útil. Una de estas técnicas consiste en emplear un sistema de componentes como base para el desarrollo. Un componente es una cantidad de software que ofrece un servicio bien definido y que es reutilizable. Además debe ser posible reutilizarlo «de verdad»: desde cualquier lenguaje y cualquier sitio. Cualquiera que tenga conocimiento sobre cómo funcionan los lenguajes de programación a bajo nivel sabrá que esto es muy muy complicado. Por ello se han desarrollado infraestructuras que nos permiten interactuar con los componentes de manera indirecta. A este software se le suele llamar “middleware” (algo así como “software de en medio”). Ejemplos famosos de Middleware son J2EE, que muchos conocerá n, y CORBA, que a muchos les gustaría no conocer. Ambos son sistemas enormes y costosos que relegan al programador a mera herramienta en manos de ingenieros, denominados arquitectos, que conocen su compleja infraestructura.
Pero los sistemas de componentes también se emplean en software libre y han dado buenos resultados. Quizás el más desconocido es UNO, de Universal Network Objects, el sistema que emplea OpenOffice, ver Listado [1], y que SUN desarrolló para su precursor: StarOffice.
PyUNO Un sistema de componentes con el que sólo se pueda programar en un lenguaje no tiene mucha utilidad. Por eso en OpenOffice se han asegurado de fomentar la creación de interfaces a distintos lenguajes de programación. Podemos acceder a UNO usando Javas cript, Java, Ruby, Perl o Python (ver Recurso [2]). PyUNO es el nombre de la interfaz y podremos encontrarlo sin problemas en nuestra distribución de Linux. Evidentemente, necesitamos también tener instalado OpenOffice. En este artículo hemos realizado los programas usando OpenOffice 2.0, que cambió la interfaz respecto a la versión 1.0, y la versión de PyUNO 0.7.0.
Un Ejemplo Rápido Vamos a crear el famoso «Hola mundo» con PyUNO. Para ello primero debemos arrancar OpenOffice con el siguiente comando desde el directorio donde esté instalado: $> ./sofficeU "-accept=socket,U
Al arrancar OpenOffice se arranca su sistema de componentes. Podemos pensar en este proceso como en el arranque de un servidor, sólo cuando esté funcionando podrán los clientes trabajar con él. Las opciones que pasamos son para que se cree un socket y se escuche en localhost en el puerto 2002. Por defecto
OpenOffice no abre el socket, de manera que no podrán controlar nuestro OpenOffice sin nuestro consentimiento. OpenOffice incorpora de serie varios intérpretes de lenguajes, entre ellos uno de Python que ya viene preconfigurado para poder hacer uso de la librería UNO. Está junto al resto de ejecutables de OpenOffice, así que lo ejecutaremos desde allí. El programa que usaremos se encuentra en el Listado [2].
El proceso es el siguiente: • Obtenemos un contexto local (un sitio donde guardar los datos de la conexión) • Arrancamos el componente UnoUrl Resolver que nos sirve para acceder a otro OpenOffice en otro equipo (en nuestro caso accederemos a nuestro propio equipo) • Emplearemos el objeto resolver para acceder al OpenOffice remoto • Arrancamos un «Desktop» (escritorio) de OpenOffice (esto es, una instancia de OpenOffice vacía) • Arrancamos un SWriter (es decir, el procesador de textos) en el escritorio • Obtenemos un cursor, con el que podremos posicionarnos dentro del texto • e insertamos texto en el cursor El resultado, no muy espectacular, podemos verlo en la Figura [1]. Ya tenemos nuestro «hola mundo» insertado en SWriter. ¿Demasiado código? Piensa por un momento lo que estamos haciendo.
Listado 2: «OfficeBroker» 01 import uno 02 import random 03 import time 04 import httplib 05 import csv 06 07 class Calc: 08 def __init__(self): 09 self.conecta() 10 11 def conecta (self): 12 self.local = uno.getComponentContext() 13 self.resolver = self.local.ServiceManager. createInstanceWithContext (“com.sun.star.bridge.UnoUrlResolve r”, self.local) 14 self.context = self.resolver.resolve(“uno:socket,host= localhost,port=2002; urp;StarOffice.ComponentContext”) 15 self.desktop = self.context.ServiceManager. createInstanceWithContext (“com.sun.star.frame.Desktop”, self.context) 16 #self.doc = self.desktop.getCurrentComponent() 17 self.doc = self.desktop.loadComponentFromURL (“private:factory/scalc”,”_blank”,0,()) 18 self.hojas = self.doc.getSheets() 19 self.s1 = self.hojas.getByIndex(0) 20 21 def actualiza(self, cotizacion, fila): 22 23 i = 0 24 for entrada in cotizacion: 25 if (i == 0) or (i == 2) or (i ==3): 26 self.s1.getCellByPosition(i,fila).
29 30 i = i + 1 31 32 def getSimbolo(simbolo): 33 c = httplib.HTTPConnection(“finance.yahoo.c om”) 34 c.request(“GET”, ”/d/quotes.csv?s=”+simbolo+”&f=sl1d1t1c1ohgv& e=.csv”) 35 r = c.getresponse() 36 cad = r.read() 37 reader = csv.reader([cad]) 38 resultado = [] 39 for row in reader: 40 resultado = row 41 return resultado 42 43 if __name__ == ‘__main__’: 44 45 simbolos = [“GOOG”,”MSFT”,”RHAT”] 46 47 c = Calc() 48 49 while(1): 50 i = 0; 51 for s in simbolos: 52 c.actualiza(getSimbolo(s),i) 53 i = i + 1 54 55 time.sleep(10)
W W W . L I N U X M A G A Z I N E . E S
-
OpenOffice
INTEGRACIÓN
Figura 1: Un documento de Write de OpenOffice con el ineludible
Figura 2: El programa examina los valores de la bolsa NASDAQ de
“Hello World” generado a partir de PyUNO.
Yahoo a intervalos regulares y los inserta en una hoja de cálculo.
Hemos levantado dos componentes y hecho acceso remoto a otro OpenOffice. Este segundo OpenOffice puede estar en una máquina al otro lado del mundo. Es algo bastante impresionante, pero por el momento poco útil. Veamos un poco más sobre UNO antes de realizar un programa más útil.
lar ese servicio a algún componente gráfico, como por ejemplo un botón o menú. Comenzaremos por realizar un programa que funcionará de manera externa a OpenOffice, y después crearemos un componente con él y lo integraremos en OpenOffice.
Arquitectura de UNO
Nuestro Programa de Stocks
OpenOffice está implementado en C++. UNO se usa internamente para realizar cualquier cosa. Básicamente, OpenOffice no es más que una gran cantidad de componentes que interactúan entre sí. Todo dentro de OpenOffice es un componente, así que podemos acceder a cualquier parte de la aplicación, ¡incluso reconstruir OpenOffice en Python! Los sistemas de componentes usan un registro de componentes al que se le puede pedir que arranque componentes. El registro localiza el componente en disco y lo carga en memoria, de manera que puede ser usado. Las llamadas a las funciones no se realizan directamente, sino que se suele emplear algún sistema no dependiente de lenguaje o plataforma, como puede ser XML o un formato ASCII. El registro también debe ser capaz de gestionar los recursos que consume el componente, descargándolo de memoria cuando ya no sea necesario. Los componentes pueden ser programados en cualquier lenguaje con el que se tenga interfaz. Un componente es un conjunto de ficheros que proporcionan un servicio. Se acompañan de un fichero XML que describe su funcionalidad. Lo mejor es que podemos vincu-
Comencemos con la parte útil, ver Listado [2]. Vamos a crear un sistema que nos permita controlar las acciones de una serie de empresas que están en bolsa dentro de un índice tecnológico, el Nasdaq (para algo estamos en una revista de informática), usando la hoja de cálculo SCalc y un programa Python. Nuestro programa accederá usando Internet a un sitio web donde podrá recoger los datos en CSV (Valores Separados por Comas), los procesará y los introducirá en SCalc. Comenzaremos por crear una función que recoja el fichero CSV y lo procese. Lo que hacemos es conectarnos con la página web finance.yahoo.com . Yahoo tiene un sitio web bastante avanzado sobre cotizaciones de bolsa, y uno de sus servicios nos permite recoger los datos de cotización de una empresa en tiempo real en formato CSV. Sin embargo, Yahoo no nos permitirá acceder a los datos demasiado a menudo, ya que dispone de un servicio de pago para ello, así que puede cortarnos el «grifo» en cualquier momento si hacemos demasiadas consultas por minuto. Por eso recogeremos los datos cada 10 segundos. La función get Sim bol o() se encargará de ello.
W W W . L I N U X M A G A Z I N E . E S
-
Ahora ya tenemos los datos, tenemos que mandarlos a SCalc. Hemos creado un objeto llamado Calc para gestionar el acceso. Hemos metido en el método constructor (__init__ ) el código que conecta con OpenOffice, puesto que sólo lo haremos una vez. Una hoja de cálculo posee varias «hojas», así que tendremos que solicitar una usando el método get Sheets() , que nos devuelve una lista con las distintas hoja s. Dentro de esta lista usaremos getByIndex() para seleccionar la primera hoja, que es la que se ve cuando arrancamos SCalc. El método actualiza() admite una lista con los datos de cotización y número que representa la fila donde aparecerá en SCalc. Una hoja de cálculo se compone de celdas, y éstas tienen un tipo. La función getCel lByPosition() nos permite acceder a una celda pasándole la columna y la fila (al revés de lo normal, así que cuidado). Una vez localizada la celda, tenemos varias funciones para poder asignar un valor: • setString(): para poner una cadena • setValue() : para poner un número • setFormula() : para poner una fórmula El dato cotización es la lista de parámetros de cotización, pero vienen dados como cadenas de caracteres. Las posiciones 0, 2 y 3 son realmente cad enas, pero el resto son números. Por eso tenemos que convertir ciertos valores al tipo float() mediante la función float(). El resultado se puede ver en la Figura [2]. Observamos cómo se abre una ventana de SCalc y se rellena con los val-
PYTHON
25
INTEGRACIÓN
OpenOffice
ores de las contizaciones, además de cómo se actualizan cada 10 segundos. Si creamos un gráfico que use esos valores, se actualizará con ellos. Pero este es un programa externo… estaría bien que pudiésemos hacer eso pulsando un botón
Creamos un Componente UNO Los componentes UNO no son más que código debidamente empaquetado. Los
paquetes que OpenOffice admite tienen una estructura fija. Son ficheros ZIP que contienen los ficheros con el código fuente, recursos (como imágenes) y un fichero de configuración XML. Los ficheros deben tener nombres especiales. El fichero de configuración debe llamarse Addons.xcu y permite asignar el código fuente del paquete con el widget que deseemos, un botón,
una entrada de un menú… Ver Listado [3]. La sintaxis del fichero parece bastante complicada, cuando en realidad no es muy difícil de entender. Básicamente decimos que queremos que nuestro componente se asocie con una entrada en el menú «Addons» que está en Tools o Herramie ntas en castellano. Nuestro componente tiene una ruta que especificaremos después y que es:
model = desktop.getCurrentComponent() self.hojas = model.getSheets() self.s1 = self.hojas.getByIndex(0) simbolos = [“GOOG”,”MSFT”,”RHAT”] i = 0; for s in simbolos: self.actualiza(getSimbolo(s),i) i=i+1
def actualiza(self, cotizacion, fila): i=0 for entrada in cotizacion: if (i == 0) or (i == 2) or (i ==3): self.s1.getCellByPosition(i,fila).setString (entrada) 48 else: 49 self.s1.getCellByPosition(i,fila).setValue (float(entrada)) 50 51 i = i + 1 52 53 g_ImplementationHelper = unohelper.ImplementationHelper() 54 55 g_ImplementationHelper.addImplementatio n( StockJob, “org.openoffice.comp.pyuno.linuxmagazine.Stock”, (“com.sun.star.task.Job”,),)
W W W . L I N U X M A G A Z I N E . E S
-
OpenOffice
org.openoffice.comp.pyuno. U linuxmagazine.Stock
Esta ruta la hemos creado nosotros y tenemos que tener cuidado de que sea única, por eso hemos incorporado linuxmagazine en ella ;). Definimos un título, que puede estar en varios idiomas, y una imagen, que hemos escogido de entre las que proporciona OpenOffice. El fichero con el código fuente Python en sí se puede ver en el Listado 4. Tenemos un objeto llamado StockJob que será el que se invocará en caso de pulsar la entrada en el menú. Ese objeto se vincula a la ruta que vimos antes. Cada vez que se pulse sobre la entrada del menú se ejecutará el método trigger , que descargará de Internet las cotizaciones y las mostrará en la hoja de cálculo. Es posible hacer que sólo se muestre el menú cuando arrancamos la hoja de cálculo SCalc, pero por motivos de espacio no hemos puesto la restricción. Aún así, si no estamos en una hoja de cálculo no sucederá nada, simplemente no funcionará.
Manejo de Paquetes en OpenOffice Ahora tenemos que generar nuestro paquete UNO. Para ello necesitaremos el programa ZIP, gzip no nos vale, y crear un fichero: $> zip stock.zipU stock_comp.py Addons.xcu updating: ...../Addons.xcuU (deflated 59%) updating: ...../stock_comp.pyU (deflated 57%) >
Este fichero debe ser integrado en OpenOffice, iremos al directorio donde esté instalado y ejecutaremos como root: $> sudo ./unopkg addU stock.zip >
Con esto concluye la instalación del paquete…¡no ha sido tan difícil! Cuando arranquemos de nuevo OpenOffice podremos seleccionar la hoja de cálculo SCalc, y en el menú
INTEGRACIÓN
Tools/Herramientas, veremos cómo ha aparecido al final un nuevo submenú: «Complementos (add-ons)». Dentro del mismo aparecerá una nueva entrada llamada «Cotización de Bolsa». Si la pulsamos aparecen los datos de 3 compañías (Google, Microsoft y Redhat) del Nasdaq en nuestra hoja de cálculo.
Conclusión Python nos permite un uso nuevo de algo tan trillado como puede ser un paquete ofimático. OpenOffice entero es accesible desde Python; no es difícil imaginarse programas que podrían facilitarnos mucho la vida y no son tan difíciles de crear gracias a PyUNO. No hemos explorado la posibilidad de actuar sobre un OpenOffice remoto por falta de espacio, pero es una nueva opción que abre un camino para aplicaciones muy interesantes, como puede ser la edición distribuida de documentos o un uso más creativo de la hoja de cálculo. Todo un mundo de posibilidades se abre ante nosotros gracias a Python. ■
INTEGRACIÓN
Java
Y v o n n e L e s s - 1 2 3 R F . c o m
No has encontrado tu lector RSS? Hazte uno tú mismo con Jython.
Cuando los Mundos Chocan Os descubrimos Jython, la forma mas sencilla de desarrollar vuestras aplicaciones Java como si las programárais con Python
.
Por Pedro Orantes y José María Ruíz
Muchos os preguntaréis qué es Jython.
Bien, empecemos desde el principio. Un grupo de programadores, Jim Hugunim (su creador) y Guido van Rossum (personalidad dentro del mundo de Python) entre otros, decidieron que la simpleza y la limpieza del código de Python haría que programar en Java fuera perfecto, así que se pusieron manos a la obra y crearon Jython. Jython es la implementación de Python en la plataforma Java, combinando la potencia de los paquetes de Java, como JavaBeans, con la facilidad y rapidez de desarrollo de aplicaciones de Python. Recordad que desarrollar una aplicación es por lo menos dos veces más corto en Python que en Java. Jython posee las mismas características de Python y además posee la característica de poder trabajar con las librerías de Java, de forma que, por ejemplo, podemos disponer del bonito swing de Java o utilizar JavaBeans e incluso programar applets. En la Web de Jython en [1] aparecen algunos ejemplos de applets desarrollados en Jython. Esto hace de él un lenguaje muy potente, ya que nos ahorramos tiempo, líneas de código y resulta menos engorroso de leer que Java. Incluso podemos compilar el código para no tener la necesidad de instalar Jython antes de ejecutar nuestra aplicación en cualquier ordenador, ya
28 PYTHON
que es capaz de generar Bytecode Java (aunque sí necesitamos tener Java, obviamente). Aunque ciertamente no todo es positivo. Las aplicaciones desarrolladas con Jython suelen ser bastante más lentas que las desarrolladas con Java, algo de lo que se quejan muchos programadores, pero aún así, la potencia y rapidez de los ordenadores de hoy hace que apenas se note la diferencia. Muchos os preguntareis si hace falta saber Java para programar Jython. En principio, no. Sí es conveniente tener
idea de su funcionamiento y disponer de la API de Java, disponible en la web de Sun [2], para saber qué queremos hacer y cómo lo queremos hacer, pero la sintaxis y la forma de programar es muy diferente. Programar en Java sin la API de Sun resulta, en la mayor parte de los casos, imposible. En cambio, para programar en Jython sí es necesario saber programar en Python, así pues, damos por sabido todo lo que hayáis aprendido en los artículos anteriores de esta revista.
Listado 1: Tres Botones 01 import javax.swing as swing 02 import java.awt as awt 03 04 cuadroTexto = swing.JTextField(10) 05 06 def __init__(): 07 win = swing.JFrame(“Ejemplo con botones”) 08 acciones = [‘uno’, ‘dos’, ‘tres’] 09 10 pnlBotones = swing.JPanel(awt.FlowLayout()) 11 12 pnlBotones.add(cuadroTexto) 13 for cadaBoton in acciones: 14 pnlBotones.add (swing.JButton(cadaBoton,actionPerformed=a ccion))
Figura 1: Nuestra utilidad busca-palabras en marcha.
En este artículo aprenderemos a usar elementos básicos de Java en Jython, trabajaremos con swing , y usaremos algunos objetos de Java como son los
vectores, entre otras cosas. Para el ejemplo de este artículo nos valdremos de una aplicación externa ligeramente modificada (el código original lo encontraréis en la web de xml.com en [3]) desarrollada en Python, para que podáis echarle un ojo al código si os apetece, desde la cual parsearemos el xml de un documento RSS para leer las últimas noticias de los blogs que más frecuentemente visitemos. Más adelante explicaremos esto detalladamente.
Instalación de Jython Para trabajar con Jython, necesitamos tener Java instalado en nuestro orde-
INTEGRACIÓN
nador. Podemos usar el Java Runtime Edition ( j2re ) o el Java Developers Kit ( j2sdk ), en su version 1.4.2 como mínimo, descargables desde [2]. Además necesitamos instalar el intérprete de Jython disponible en [1], en su última versión estable (la jython-2.1 ) y, por último, para ejecutar nuestra aplicación, deberemos tener instalado el intérprete de Python (versión 2.3). Una vez hemos descargado el intérprete de Jython, debemos proceder a la instalación del mismo. Ejecutamos java jython-21 y nos saldrá el instalador (Figura 1), que nos pedirá confirmar una serie de opciones y un directorio, y ya
Type "copyright", "credits" orU "license" for more information. >>> print 'Hola Mundo' Hola Mundo >>>
tendremos Jython instalado en nuestro ordenador. Adicionalmente podemos enlazar los ejecutables de Jython a nuestro directorio de binarios del sistema (ln -s jython-2.1/jython /usr/bin/jython y
Bien, vamos a empezar a ver algunos ejemplitos en java. En primer lugar, ¿qué tal el típico Hola mundo con swing ? Este ejemplo mostrará una ventana llamada ln -s jython-2.1/jythonc /usr/bin/jythonc Hola Mundo , con un cuadro de texto. en nuestro caso) para no tener que eje- Para cerrarla tendréis que cerrar el intércutar los binarios desde el directorio prete con Control + C, ya que en el donde lo tengamos instalado. Esto últi- ejemplo no implementamos la salida de mo es recomendable, además de que la aplicación. resulta mucho más cómodo.
Primeros Pasos Bueno, ya está todo preparado en nuestro sistema. Es hora de ver cómo funciona Jython. Para empezar, podéis trastear un poco con el intérprete como lo habéis hecho con el de Python, y así podréis ver que el funcionamiento es idéntico. $ jython Jython 2.1 on java1.4.2_05U (JIT: null)
01 $ jython 02 Jython 2.1 on java1.4.2_05 (JIT: null) 03 Type "copyright", "credits" or "license" for more information. 04 >>> import javax.swing as swing 05 >>> win = swing.JFrame("Hola mundo") 06 >>> texto = swing.JLabel("Hola mundo")
Como podéis ver resulta muy sencillo, a la vez de que swing resulta muy agradable para la vista. Java incluye también un sistema para cambiar la apariencia de la interfaz por si no os gusta la que arranca por defecto.
Programación Al igual que en Python, para nuestras aplicaciones lo mas cómodo es hacer que el intérprete ejecute un fichero (o varios) de código. Jython no tiene ningún tipo de extensión establecida para los ficheros, y lo más normal es usar la misma que Python .py para tener nuestros ficheros de código bien diferenciados de los demás. Para usar las librerías de Java, lo primero que tenemos que hacer es importarlas al estilo de siempre de Python. Como hemos visto en el ejemplo de antes, para importar las librerías de swing basta con importar lo que necesitemos. Imaginad que necesitamos la clase Vector , que está dentro del paquete de utilidades, bien podemos hacer import java.util as util o bien directamente import java.util.vector as vector , y ya tendremos acceso a esa clase. Para utilizarla bastaría con llamar a su constructor (os recuerdo que tengáis siempre a mano la documentación del API de Java) con él, crearemos una ocurrencia vector (en este caso), pepe = util.vector() y una vez creada, podemos acceder a cualquiera de sus métodos directamente en la ocurrencia que acabamos de crear, ‘pepe.add(“Hola”)‘ que, para los que no estén muy familiarizados con Java, añade un objeto de tipo String (cadena de caracteres) al vector. Cada ocurrencia de Java tiene el mismo funcionamiento en Jython. Es importante que tengáis esto en cuenta.
W W W . L I N U X - M A G A Z I N E . E S
Ahora vamos a mezclar un poco de cada (Figura 2). Para ello voy a crear tres botones, a cada uno lo llamaremos de una forma distinta y les añadiremos un listener (para coger los eventos que produce cada botón), de forma que al pulsar en cada uno, se escriba su nombre en un cuadro de texto. Veamos cómo se hace esto en el Listado 1. Es sencillo ¿verdad?, si os dais cuenta, para crear los botones he usado código propio de Python usando una lista con los nombres de los botones y creándolos con un bucle for , dentro del cual llamo al constructor de JButton, pasándole unos argumentos, y añadiéndolos en el panel mediante el método .add() que implementa JPanel. Bueno, espero que os haya gustado el ejemplo, porque ahora viene nuestra aplicación en serio.
Lector de Noticias RSS -JyRSSPuede que algunos de vosotros os preguntéis qué es RSS. RSS no es más que un fichero .xml con una serie de etiquetas. Éstas siguen un estándar definido por xml.com para transmitir pequeñas noticias, por ejemplo, a través de Internet, de forma que no haga falta abrir un navegador para leerlas, sino que sólo bastaría con usar una aplicación que descargue y prepare la noticia para que la podamos leer, como hace nuestra aplicación JyRSS. Para empezar, necesitamos el código que hemos mencionado al principio del artículo. Este código será el encargado de descargar y parsear el fichero RSS con las noticias, de forma que guardará en un fichero el contenido ya parseado del documento RSS para que nuestra aplicación pueda cargar su contenido dentro de un cuadro de texto. Tiene algunas limitaciones, y es que no soporta todas las codificaciones de texto, por lo que os recomiendo que cuando lo probéis, uséis direcciones extranjeras, a ser posible en inglés, como Slashdot.com (http://www.slashdot.com/ index.rss), ya que con algunos blogs en castellano, como barrapunto.com, no funciona correctamente debido a una serie de caracteres contenidos en el documento. JyRSS constará de varias partes. Un JFrame (ver Listado 1) donde irán embebidos el Panel de botones y los cuadros de texto. Uno de los cuadros de texto es un JList, donde mostraremos los nombres de los sitios que contienen las noticias, y el otro un JEditorPane, donde se mostrarán las noticias. Además ambos hacen uso de JScrollPane para que puedan hacer scroll en caso de que haya texto que ocupe toda la pantalla. También hacemos uso del JMenu y de JMenuBar para crear el pequeño menú archivo, donde está la opción de guardar , que guardará en dos ficheros (uno con los nombres de los sitios y otro con las urls de cada sitio) todos los sitios web que le hayamos añadido. Este menú no es nada necesario, pero queríamos incluirlo para que viérais lo f ácil que es crearlo. El panel de botones tendrá tres JButtons, uno para añadir una nueva url a la lista, uno para borrar una url de la lista y otro que lanzará el pequeño parser de RSS (lrss.py) y nos mostrará las noticias de cada sitio que aparecerán en el JEditorPane. También se hace uso de la clase Vector . Usaremos dos vectores, uno para guardar los nombres y otro para las
W W W . L I N U X - M A G A Z I N E . E S
INTEGRACIÓN
Java
direcciones. El vector de nombres se lo pasaremos a la ocurrencia JList para que añada todos los nombres de los sitios en pantalla. Usaremos el paquete java.lang para implementar la función de salir de la ventana al pulsar la x de nuestra aplicación (no se implementa por defecto). De Python, haremos uso del paquete os , desde el que nos valdremos de os.path.exists() para comprobar si existe el fichero de nombres al arrancar la aplicación y de os.system(), que ejecutará el script Python que leerá las noticias. Éste guardará las noticias en un fichero, que luego leerá nuestra aplicación. No os preocupéis si veis que tarda un poco, eso es por dos motivos, tiene que descargar el fichero de Internet, y además tiene que parsearlo, y las librerías que utiliza (minidom) son bastante lentas. Usaremos también las utilidades de escritura y lectura de ficheros ( open(), write(), read(), etc…) para manejarnos con ellos. Podemos ver el resultado en la Figura 3. Como véis, programar java con Jython no resulta para nada difícil, al contrario, resulta muy cómodo, y desde luego mucho mas sencillo que Java. En el Listado 3 encontraréis el código Python de la pequeña aplicación externa.
Pongo los nombres de las clases y paquetes de Java que se van a usar, para que os vayan sonando cuando vayáis leyendo el código. Así podréis buscar más rápido en la API de Java y no tendréis problemas para encontrarlas. Vuelvo a hacer hincapié en que es necesario que lo tengáis.
Mejoras para JyRSS Es obvio que a este código le faltan muchas cosas, además de que debe tener varios bugs, como por ejemplo que al pulsar el botón Leer cuando no hay ninguna url y/o ningún nombre, Java lanza una excepción. Os animamos a que lo depuréis. Os sugerimos que le hagáis algunas mejoras, ya que de esta manera os servirá para practicar con el código que os dejamos. Por ejemplo, hacer que el cuadro JEditorPane os cambie la apariencia del texto ( negrita, cursiva , etc…), que cada vez que pulséis sobre un nombre en la JList lea la noticia directamente (deberéis trabajar con el listener de JList ), añadir la opción de guardar las noticias del sitio que más os gusten, etc…
Entornos de Programación Jython Mucha gente prefiere trabajar con IDE’s (interfaz para el desarrollo de aplica-
ciones) a la hora de programar. Actualmente no he encontrado aún ninguno que sea exclusivamente para desarrollar en Jython. Lo que sí existe, son plugins que instalamos en otros IDE’s y que nos permiten trabajar con este lenguaje. Podemos encontrar diferentes plugins para dos de los IDE’s más populares, uno para Netbeans (ver [4]), que os podéis bajar desde la aplicación de actualización que lleva implementada. Y luego tenéis otro para Eclipse (ver [5]) llamado Red Robin, que podéis encontrar en [6]. Tanto en la web de Netbeans como en la web de Red Robin, se explica cómo debemos insta■ larlos.
Recursos [1] Página de Jython: http://www. jython.org [2] Descarga de Java: http:// java.sun.com [3] Código original del programa: http://www. xml.com/lpt/a/2002/12/18/ dive-into-xml.html [4] Plugins de Netbean: http://www.netbeans.org [5] IDE Eclipse: http://www.eclipse.org [6] Plugin Jython para Eclipse: http://home.tiscali.be/redrobin/ jython/
Limpieza Total AJAX es la palabra de moda, Google usa AJAX, Yahoo usa AJAX… todo el mundo quiere usar AJAX pero ¿lo usas tú? y más importante aún ¿qué demonios es AJAX? Por José María Ruíz y Pedro Orantes
G u n n a r P i p p e l 1 2 3 R F . c o m
(“Un Mundo Feliz”) es el nombre de la famosa novela de Aldous Huxley, en ella nos muestra un mundo distinto y aterrador pero que parecía, y parece, cada vez más cercano. Nosotros no tenemos una visión tan pesimista del mundo, pero es probable que ese título (que se podría traducir literalmente por «un nuevo y desafiante mundo») explique todo el revuelo que está levantando AJAX. El término fue acuñado por Jesse James Garrett en el artículo [1] del cuadro de Recursos. Durante mucho tiempo, las GUIs, las Interfaces Gráficas de Usuario, han dominado la informática. La gente que trabajaba en la Web siempre estaba intentando convencer a todo el mundo de que para la mayoría de los programas, una interfaz web bastaba. Pero los usuarios estaban acostumbrados a ciertas características, como el auto-completado A Brave New World”
W W W . L I N U X - M A G A Z I N E . E S
de campos o el arrastrar y soltar, que eran imposibles en la Web. Conforme avanzaba el tiempo, numerosas empresas y personas proponían soluciones. La lista es interminable: JavaScript, Java Applets, ActiveX, Tcl, VBScript, Macromedia Flash… Pero todas fallaban de uno u otra manera. En el caso de Java, para ejecutar el Applet necesitabas tener instalado el Java Runtime Environment, y la mayoría de los usuarios no sabían ni qué era aquello que se le pedía. Lo mismo ocurría con Flash. Lo peor era que cuando estaba solucionado el tema de la instalación del software adecuado, los desarrolladores creaban, y crean, páginas horribles llenas de cosas moviéndose que distraen e irritan. Se sentían impulsados a usar hasta la última capacidad de las nuevas herramientas y acababan generando monstruosidades.
Esta fase ya casi ha pasado y ahora se busca la sencillez, y en el momento justo surgió AJAX. Para más información ver url [2] del cudro de Recursos.
¿Pero Qué es AJAX? Muy buena pregunta. Lo cierto es que AJAX ha estado delante de nuestras narices todo el tiempo, esperando a que alguna mente despierta lo redescubriese. El acrónimo «AJAX» se compone de las palabras «Asynchronous JavaScript and XML», término acuñado por Jesse James Garrett, y curiosamente su existencia se debe a una de esas famosas violaciones de los estándares que suele realizar Microsoft con sus productos. Allá por 1998, Microsoft introdujo dentro de sus productos una librería que le permitía hacer consultas usando el protocolo HTTP de manera autónoma y asíncrona. Cuando tu navegador accede a una página y ésta contiene código
PYTHON
33
INTEGRACIÓN
Ajax
Javascript, este código a su vez puede traer información de esa u otras páginas de manera independiente. Si además se hace que este código permanezca en ejecución respondiendo a eventos, tenemos entre manos la posibilidad de traer información al navegador sin recargar la página. Esto es útil para algunas tareas, pero no demasiado, ya que a nuestro puzzle le faltan piezas. La primera pieza es la adopción de esta librería por casi todos los navegadores, por lo tanto el código pasa a ser de aplicación universal. Además resulta que podemos modificar el contenido de la página en tiempo real usando el denominado árbol DOM. Y por si fuese poco, cuando AJAX fue definido, los programadores comenzaron a usar protocolos XML para comunicarse con los servidores. ¿Qué quiere decir esto? Pues que ahora, con AJAX, podemos cargar una página y, sin tener que recargarla, traernos información, modificar la página en tiempo real e interactuar con servidores remotos usando protocolos XML. Básicamente, una vez cargada la página web tenemos entre manos todas las posibilidades de programación de una
Figura 1: Esquema de nuestra aplicación AJAX con todos sus compenentes.
GUI tradicional. Y todo esto sin necesidad de plugins ni instalaciones; toda esta tecnología está en nuestros navegadores esperando ser usada.
¿Cómo Encaja Python? Pues vamos a realizar un pequeño servidor de contenidos en Python que pueda ser consultado usando AJAX. Crearemos una web con algo de código Javascript, que a intervalos accederá a nuestro servidor Python y modificará el aspecto de la página web.
Los 5 Ingredientes Los cinco ingredientes necesarios para elaborar nuestro producto son CSS, Javascript, HTML, XML y Python, como aparecen en la figura 1, y cada uno tiene su función en esta obra. HTML es la base sobre la que vamos a trabajar, y así definimos una página web en la que todo ocurrirá. De hecho, con el paso del tiempo el propio HTML ha acabado convirtiéndose en una especie de plantilla donde campan a sus anchas CSS y Javascript.
Listado 1: server.py (Cont.) 58 def contenido(self): 59 return self.texto 60 61 def tipo(self): 62 tipo = “html” 63 ext = self.nombre[-4:] 64 if (ext == “html”): 65 tipo = “html” 66 elif (ext == “.xml”): 67 tipo = “xml” 68 elif (ext == “.css”): 69 tipo = “css” 70 return tipo 71 72 class Comando: 73 def __init__(self,comando): 74 self.tuberia = os.popen(comando) 75 self.xml = “” 76 77 def contenido(self): 78 # fichero XML
CSS nos permite otorgar propiedades visuales a los elementos de HTML. Javascript es el encargado de actuar en la máquina cliente, en el navegador, y puede modificar tanto el HTML como las propiedades visuales que CSS define. Con la llamada XMLHttpResponse sus atribuciones se han disparado. Ahora se ve como un lenguaje de programación de pleno derecho. En los próximos años puede que adquiera mucha más importancia de la que ha tenido hasta ahora. XML es el nuevo lenguaje estándar de intercambio de información. Prácticamente cualquier lenguaje dispone ya de librerías para generar y analizar documentos XML. Dentro del mundillo, AJAX se ha convertido en el estándar para el intercambio de información con el servidor y para la serialización de objetos con protocolos como JSON . Y, como no, Python. En nuestro caso se va a encargar tanto de realizar las tareas de servidor HTTP, como de recolectar información importante y confeccionar con ella ficheros XML. Tenemos que compenetrar todos estos elementos para realizar nuestro proyecto. El objetivo es que los componentes HTML, Javascript, CSS y XML sean tan estáticos como sea posible, debido a que todos ellos interactúan con el usuario. Es en el servidor Python donde debemos aportar la flexibilidad necesaria como para añadir nuevas características
W W W . L I N U X - M A G A Z I N E . E S
79 80 81 82
if not self.xml: self.xml = “” self.xml += “” linea = self.tuberia.readline()[:-1] # para quitar el \n 83 while linea: 84 self.xml += “” + cgi.escape(linea) + “” 85 linea = self.tuberia.readline()[:-1] 86 self.xml += “” 87 return self.xml 88 89 def tipo(self): 90 return “xml” 91 92 def test(HandlerClass = AJAXHTTPRequestHandler, 93 ServerClass = BaseHTTPServer.HTTPServer): 94 BaseHTTPServer.test(HandlerClass, ServerClass) 95 96 if __name__ == ‘__main__’: 97 test()
sin tener que cambiar ninguno de los otros elementos.
La Parte de Python: BaseHTTPRequest Python dispone en sus librerías estándar de muchos «esqueletos» para distintos tipos de servidores. Entre ellos encontramos BaseHttpRequest . Esta clase nos permite construir servidores HTTP sin excesivo esfuerzo, así que la emplearemos. Pero no debemos usarla directamente, sino a través de la clase BaseHttp RequestHandler , que es la encargada de gestionar los eventos que se suceden en el servidor. Por tanto, heredaremos de ella y crearemos una clase llamada
AJAXHttpRequestHandler ,
ver Listado 1 (todos los listados de este artículo pueden descargarse del articulo [4] del cuadro de Recursos. Un servidor HTTP recibe distintos tipos de comandos, pero el que nos interesa es el comando GET . El cual se usa para solicitar información al servidor. Cada vez que se realice una petición GET se invocará el método do_GET de BaseHTTPRequestHandler, así que lo vamos a redefinir en nuestra clase. Cuando se invoque do_GET , en la variable de instancia self.path se encuentra la ruta solicitada por el cliente. Nosotros contrastaremos esta ruta contra las que aceptamos. Si no se encuentra entre ellas, devolveremos la célebre pági-
linea de salida ... linea de salida ... linea de salida Figura 2: La clase BaseHTTPRequest genera una entrada por comando.
na 404, indicando que la página solicitada no existe. La información se devuelve usando el método self.wfile.write(), lo que en él escribamos será devuelto al cliente que realizó la petición. Además del fichero index.html, ofreceremos una serie de servicios en forma de ficheros XML. Estos servicios consistirán en la ejecución de un comando de sistema, y la conversión de su salida en un fichero XML. El formato del fichero será muy sencillo:
Por lo que generaremos el fichero XML «a mano», sin hacer uso de librerías. De esta manera, cuando el cliente solicite el fichero ps.xml, nuestro servidor ejecutará el comando ps afx , creará el fichero ps.xml con la salida del comando y se lo enviará al cliente.
Definición de Servicios Para permitir que la definición de servicios sea lo más simple posible, basta con introducir una nueva entrada en el diccionario acciones de la clase AJAX HTTP RequestHandler con la siguiente estructura:
: [,U ],
Cuando se gestiona el comando HTTP GET , se busca en este diccionario la ruta. En caso de que esté presente, se ejecutará el método almacenado usando como parámetros la ruta y el comando. Esto nos da gran flexibilidad, añadir un nuevo servicio consiste en introducir una nueva linea de código. Existe un detalle importante, todo fichero devuelto usando HTTP debe tener una cabecera con una serie de líneas con formato llave: valor que dan información al cliente, el navegador, sobre el fichero devuelto. Debido a problemas de espacio hemos decidido devolver sólo el formato del fichero. Para ello se invoca el método envia_cabecera desde envia_respuesta antes de enviar el fichero en sí. Es de esta manera como el navegador determina el tipo de fichero que recibe y sus características.
Listado 3: Fichero ajax.js. 01 // GLOBALES 02 var http_request = false; 03 04 function hazPeticion(url) { 05 http_request = false; 06 http_request= new XMLHttpRequest(); 07 if (http_request.overrideMimeType) { 08 http_request.overrideMimeType(‘text/xml’); 09 } 10 11 if (!http_request) { 12 alert(‘Error al crear la instancia de XMLHttp Request.’); 13 return false; 14 } 15 16 // Esto es un callback, que se dispara al terminar de 17 // descargar el fichero xml. 18 http_request.onreadystatechange = modifica Contenido; 19 http_request.open(‘GET’, url, true); 20 http_request.send(null); 21 } 22 // Elimina todo elemento con id “linea” 23 function vaciaContenido(){ 24 var d = document.getElementById(“contenedor”); 25 while(document.getElementById(“linea0”) || document.getElementById(“linea1”)){ 26 nodo = document.getElementById(“linea0”); 27 if (! nodo){ 28 nodo = document.getElementById(“linea1”); 29 } 30 var nodo_basura = d.removeChild(nodo); 31 } 32 } 33 34 // Carga el resultado del XML
36 PYTHON
35 function modificaContenido() { 36 if (http_request.readyState == 4) { 37 if (http_request.status == 200) { 38 vaciaContenido(); 39 40 var xmldoc = http_request.responseXML; 41 var root = xmldoc.getElementsByTagName(‘salida’).item(0); 42 43 var fondo = 0; 44 45 for(var i = 0; i < root.childNodes.length; i++){ 46 var nodo = root.childNodes.item(i); 47 48 var contenedor = document.getElementById (“contenedor”); 49 var p = document.createElement(“p”); 50 51 // Truco para los colores ;) 52 if (fondo == 0) { 53 p.setAttribute(“id”,”linea0”);} 54 else { 55 p.setAttribute(“id”,”linea1”); 56 } 57 fondo = 1 - fondo; 58 59 var titulo = document.getElementById(“datos”); 60 p.textContent = nodo.firstChild.data; 61 62 contenedor.insertBefore(p,titulo); 63 } 64 65 } else { 66 alert(‘Hubo un problema con la petición.’); 67 } 68 } 69 }
W W W . L I N U X - M A G A Z I N E . E S
Figura 3: Nuestra página devolverá los resultados de la consulta sin reca rgar.
Cuando arranquemos el servidor, veremos que van apareciendo mensajes correspondientes a los distintos comandos que se le mandan. La clase BaseHTTPRequest genera una entrada por cada una. Ver figura 2.
Gestores de Servicios Para gestionar los servicios se han creado las clases Pagina y Comando, que responden a los mismos métodos. La primera, Pagina, se encarga de las peticiones de ficheros de texto, que en nuestro programa se reducen al fichero index.html y sus ficheros supletorios, fichero Javascript y CSS. Básicamente, los carga en una variable y, mediante el método contenido, las demás clases tienen acceso a los mismos. En este caso, el parámetro ruta no afecta a esta clase, pero se ha definido para que guarde compatibilidad con la clase Comando. La clase Comando ejecuta el comando especificado y permite el acceso al texto devuelto por él mismo mediante el mismo método que la clase Pagina. De esta manera son intercambiables. Ambas clases poseen un método tipo() que devuelve el tipo de fichero que almacenan. En el caso de Comando, siempre será un fichero XML, pero Pagina debe «adivinar» el tipo de los ficheros que devuelve. Para ello se comprueba la extensión de los mismos. En aras de la simplicidad, sólo consideraremos tres extensiones. Cuando un comando es ejecutado por Comando, se tiene especial cuidado en utilizar la función cgi.escape sobre cada línea. Esta función realiza algunas conversiones dentro del texto que se le pasa para que pueda ser correctamente visualizado por un navegador web. El problema radica en que ciertos caracteres, como pueden ser «<» or «”» son especiales y si no se «escapan», si no se preceden de un «\», causarán problemas. Y con esto, hemos definido un servidor web básico. Python nos permite realizar complejas tareas con poco código y este es uno de esos casos. Vayamos ahora a por AJAX para comprenderlo.
HTML Quizá éste sea uno de los artículos donde Python tenga menor protagonismo, pero con cinco actores suele ser complicado. Veamos el HTML. La página index.html se puede ver en el Listado 2.
W W W . L I N U X - M A G A Z I N E . E S
INTEGRACIÓN
Ajax
Básicamente, carga un fichero Javascript, un fichero CSS y muestra un título junto a unos cuantos botones. Estos botones invocan acciones en Javascript. Debemos fijarnos especialmente en el uso del atributo id en numerosas etiquetas HTML. Gracias a estos id s podremos manipularlas mediante Javascript.
Javascript, desde Otra Perspectiva Mucha gente ha tenido extraños encuentros con este lenguaje de programación. Es raro y, hasta hace no demasiado, no muy útil. Te permitía modificar colores en páginas web o poner insidiosos banners. Por no hablar de las famosas ventanas emergentes. Esto ha hecho que se haya ganado una fama muy mala, tal es así que casi todos tenemos restricciones en nuestro navegador en torno a qué acciones puede o no realizar Javascript. Lo más normal es que tengamos uno de esos famosos bloqueadores de popups. Pero Javascript se ha reinsertado en la sociedad de los programadores por la puerta grande gracias a un solo objeto.
referimos al ahora famoso XMLHttpRequest . Si vemos el código del Listado 3, veremos un lenguaje que quizá nos recuerda a Java. En realidad no tienen absolutamente nada que ver, aparte del nombre. En nuestro ejemplo observamos tres funciones: • hazPeticion() • modificaContenido() • vaciaContenido() Javascript, además de muchas de las características presentes en otros lenguajes (y algunas ausentes) dispone de una colección de objetos que le permiten realizar operaciones. A día de hoy los más importantes son: • Manipulación DOM • Manipulación XML • XMLHTTP DOM permite a Javascript manipular, en tiempo real, el contenido de la página web. Puede añadir, modificar o quitar etiquetas y atributos, por lo que podemos operar sobre el documento de cualquier forma posible. Javascript puede manipular un fichero XML de igual forma que hace DOM . Y la gran novedad, Javascript puede realizar conexiones ASÍNCRONAS con el servidor. Y resalto en mayúscula la palabra ASÍNCRONAS porque ahí está la clave. Esto significa que podemos hace conexiones, traernos documentos XML del servidor y realizar operaciones DOM o de cualquier otro tipo, ¡cuando queramos! El usuario carga su página web, y una vez cargada, sin necesidad de recargarla, podemos modificarla a nuestro antojo en base a información que podemos pedir al servidor en cualquier momento. Volviendo a nuestras funciones, la función hazPeticion() recibe una url, crea el objeto XMLHttpRequest y después de algunas comprobaciones, asigna una función para que sea invocada cuando el fichero que esa url especifica sea completamente descargado. Esto significa que mientras leemos nuestra web, Javascript estará bajando un fichero y, cuando finalice, llamará a la función modificaContenido. ¿Y qué hace esta función? Comprueba el estado de la petición, (el estado 200 el de «todo correcto» y el 404 el de «lo sentimos mucho, pero el fichero solicitado
no está disponible») y entonces obtiene el documento XML del objeto que gestionaba la conexión. Pero antes invoca a vaciaContenido() , que localiza toda etiqueta con las ids «linea0» o «linea1» y las elimina de la página. Hacemos esto porque a continuación las volvemos a introducir en la página, pero esta vez con los datos frescos del servidor. No queremos entrar en los detalles, ya que, en teoría, esto es un artículo sobre Python, no Javascript, pero básicamente esto es lo que hace el fichero ajax.js . El fichero estilo.c , que aparece en el listado 4, simplemente configura los colores y características de algunas de las etiquetas para que el aspecto mejore. Y se acabó, aquí tenemos nuestra aplicación AJAX. El resultado final será el que vemos en la figura 3. Cuando pulsemos cualquiera de los botones, se cargará la salida de texto de la ejecución asociada a cada uno de ellos en pantalla, pero sin recargar la página. Si queremos añadir un nuevo comando, sólo tenemos que introducir la línea correspondiente en acciones en server.py y añadir un nuevo botón como los que ya existen en index.html.
Conclusión ¿Es tan complicado eso de AJAX? ¡Por supuesto que no! Lo que ocurre es que es una palabra que se está convirtiendo en un mito, pero no deja de ser una astuta combinación de programación en el servidor y cliente además del uso intensivo de XMLHttpRequest . Poco a poco AJAX está poblando todas las páginas webs y la mayoría de los currículos vitae. Quién sabe, lo mismo dentro de dos años esa palabra tenga tanto poder como otra palabra de cuatro ■ letras: J2EE.
Recursos [1] Jesse James Garret define AJAX: http://adaptivepath.com/ideas/ ajax-new-approach-web-applications [2] Explicación de AJAX en Wikipedia: http://en.wikipedia.org/wiki/AJAX [3] Sarissa: http://sarissa.sourceforge.net/ doc/ [4] Listados de este artículo: http://www. linux-magazine.es/Magazine/ Downloads/Especiales/06_Python
W W W . L I N U X - M A G A Z I N E . E S
.Net
INTEGRACIÓN
.Net y Python con Ironpython
De Serpientes y Primates .NET está avanzando, y Python no se ha quedado atrás. En lugar de combatirla, ha entrado en simbiosis con ella. Con Ironpython podremos hacer uso de toda la potencia de .NET desde nuestro lenguaje favorito. Por José María Ruíz. En el año 2003,
Python sobre .NET Así que ni corto ni perezoso Jim se tomó el comentario como algo personal y se puso manos a la obra. Como resultado de su esfuerzo, el 5 de Septiembre de 2006 apareció la versión 1.0 de IronPython [1), nombre que dio a su intérprete [2]. Antes de la aparición de la versión 1.0, IronPython ya había llamado la atención de gran cantidad de desarrolladores. La posibilidad de crear aplicaciones gráficas o web multiplataforma aprovechando los recursos de .NET era demasiado interesante para dejarla escapar. Incluso Miguel de Icaza, de fama mundial gracias a Gnome y Mono, reconoció la importancia de IronPython para Mono en el artículo que aparece referenciado en el Recurso [3]: «Prácticamente cada nueva versión de IronPython ha expuesto las limitaciones de nuestro runtime (Mono), nuestras librerías de clases o nuestros compiladores.
W W W . L I N U X- M A G A Z I N E . E S
IronPython realmente ha contribuido para que Mono se convierta en un mejor runtime.» Vamos a echar un buen vistazo a las posibilidades de IronPython y veremos cómo nos permite explotar el poder de las librerías .NET, pero siempre desde nuestro lenguaje favorito.
Preparativos
Figura 1: Hola Mundo con WinForms.
Para poder hacer uso de IronPython necesitamos instalarlo. IronPython es una impletodo aquel que haya trabajado mucho en la mentación de Python sobre .NET, por lo que consola de Linux, porque Control z sirve necesitamos una implementación de .NET para mandar a un programa a background. para Linux. La secuencia sería: Mono es la implementación libre de .NET 01 IronPython 1.0 (1.0) on más famosa. Como vimos antes, Miguel de .NET 2.0.50727.42 Icaza está usando IronPython como banco 02 Copyright (c) Microsoft de pruebas para Mono. Esto nos asegura Corporation. All rights que IronPython funcionará bastante bien reserved. sobre Mono. Tenemos que instalar IronPy03 >>> quit thon y Mono. 04 ‘Use Ctrl-Z plus Return to exit’ Falta un componente en la ecuación: libgdiplus (ver Recurso [4]). En este artículo 05 >>> exit 06 ‘Use Ctrl-Z plus Return to exit’ haremos uso de la interfaz gráfica de usua07 >>> rio que .NET pone a disposición de sus des08 Suspended arrolladores. Este sistema, llamado Win09 > Forms, ha sido reimplementado en forma de 10 > software libre en la librería libgdiplus. Sin ella no podremos hacer uso de WinForms, y por ello necesitamos instalarla. Jim tuvo que crear este sistema para que Un detalle también algo molesto, ¿cómo funcionara tanto en Windows como en se sale del intérprete? La verdad es que es Listado 1: Mostrar el Contenido de un Fichero de Texto algo rebuscado. No 01 import clr funcionan ni exit ni 02 quit . Cuando ejecute03 from System.IO import * mos cualquiera de los 04 05 fichero = File.OpenText(“mifichero.txt”) dos, seremos infor06 mados de que debe07 linea = fichero.ReadLine() mos pulsar Control z 08 para salir del intér09 while s: prete. Esto puede 10 print linea resultar curioso para
PYTHON
39
INTEGRACIÓN
.Net
Copyright (c) MicrosoftU Corporation. All rightsU reserved. >>>
Figura 2: Visor de texto.
Linux. Si ya tienes todos estos paquetes instalados en tu distribución, podemos pasar al siguiente paso… el infame «Hola Mundo».
Hola Mundo Consola La primera sorpresa de IronPython es que realmente es casi igual a Python… pero más lento. Para ejecutar un programa .NET en Linux debemos emplear el comando mono que lo ejecuta dentro de la máquina virtual de .NET.
> mono miprograma.exe Probablemente, el comando ironpython de vuestra distribución sea en realidad un script shell que ejecuta el intérprete (llamado ipy.exe) empleando mono. El resultado será:
IronPython 1.0 (1.0) onU .NET 2.0.50727.42
¿Microsoft Corporation? ¡Tranquilos, tranquilos! IronPython posee una licencia casi libre, parte del Microsoft’s Shared Source. Aunque su licencia no está aprobada por OSI, Jim dice que la licencia que lo cubre sigue todas las normas de OSI (ver Recurso [5]). Vayamos al grano, nuestro «hola mundo» es reconocible:
>>> print “Hola Mundo” Hola Mundo >>> Como el lector podrá apreciar, no ha cambiado nada. IronPython mantiene una gran compatibilidad con Python. Pero no todo el monte es orégano. Debido a que se ejecuta sobre .NET, IronPython no puede acceder a librerías de Python escritas en C . Esto es un problema porque, por ejemplo, la librería sys está escrita en C . Otro detalle bastante molesto es que el intérprete de IronPython no tiene historia, ni autocompletación, ni … nada de nada. Esto puede poner a más de uno de los nervios, yo al menos me puse, por lo que es recomendable trabajar en un fichero y ejecutarlo con IronPython.
Librerías .NET Hasta el momento no hemos hecho nada especial, es hora de comenzar con lo interesante. IronPython está escrito en C# sobre .NET. Una de las virtudes de .NET es que una vez que ha sido compilado a su lenguaje intermedio, puedes hacer uso de cualquier librería escrita en cualquier lenguaje para .NET. IronPython tiene a su disposición todas las librerías del proyecto Mono. Esto incluye la librería para programación de aplicaciones gráficas WinForms, las librerías para programación web ASP.NET, estructuras de datos, librerías de cifrado…, a las que hay que sumar aquéllas que ha incorporado el proyecto Mono, como por ejemplo las que nos permiten empotrar el motor Gecko (de Firefox) en una aplicación gráfica, de forma que podemos crear un navegador web con muy poco código. Veamos un ejemplo de uso. Vamos a abrir un fichero y a mostrarlo e imprimirlo en el terminal, ver Listado 1. No es muy complicado ¿verdad? Lo más importante de este ejemplo es la sentencia:
import clr que nos permite hacer uso de todas las librerías de .NET.
Hola Mundo Winforms Hasta ahora todo lo que hemos hecho era fácilmente realizable con Python, a partir de este momento observaremos cambios. Vamos a realizar el mismo «Hola Mundo» pero empleando WinForms. Microsoft ha simplificado bastante el desarrollo de aplicaciones gráficas con esta librería. IronPython lo ha simplificado aún más. WinForms, ver Recurso [6], funciona de forma similar a como lo hacen otras librerías gráficas. Creas una ventana, dentro de la cual creas un panel, dentro del cual se pueden disponer widgets. Es muy parecido a las muñecas rusas Matroskas. Veamos el código en el Listado 2 y el resultado en la Figura 1. Comencemos por el principio. Una vez importado clr, hemos de hacer algo que no es normal en Python: debemos añadir referencias a las librerías de .NET que vamos a utilizar. Para ello utilizamos el método clr.AddReference() con el nombre de la librería que vamos a usar. Winforms hace uso de «System.Drawing» y de «System.Windows.Forms». Estas librerías contienen todos los widgets necesarios
W W W . L I N U X- M A G A Z I N E . E S
.Net
para crear aplicaciones gráficas. Una vez que añadamos las referencias a estas librerías, podemos usarlas como cualquier librería de Python. Importamos todos los widgets necesarios: Application, BorderStyle, Button… Para hacer referencias a posiciones en la pantalla emplearemos la clase Point de System.Drawing , expresando la posición en pixels. Con todas las librerías cargadas, podemos comenzar inicializando nuestra clase HolaMundo, que representa la ventana de la aplicación. Comenzamos dándole título, con self.Text , a la ventana. Definimos el tipo de ventana que utilizaremos con FormBorderStyle indicando que será fijo, nuestra ventana no se podrá redimensionar.
Calculamos el tamaño de la ventana en base al de la pantalla. Conseguimos los datos de la pantalla mediante el método Screen.GetWorkingArea(), y hacemos que nuestra ventana tenga un quinto de la altura (Height) y ancho (Width) de la pantalla. Podríamos haber indicado el tamaño mediante un número, digamos 100 pixels. Creamos un panel que pasará a contener todos los widgets que utilicemos. De nuevo ajustamos su altura y anchura, así como su posición dentro de la ventana. Como queremos que ocupe toda la superficie de la ventana lo posicionamos en (0,0), y le damos el mismo ancho y la misma altura que la ventana. He añadido un método, para simplificar el código, que genera una etiqueta donde realizamos el saludo. De nuevo el
INTEGRACIÓN
proceso es repetitivo: texto de etiqueta, posición, altura y anchura. Finalmente, añadimos la etiqueta al panel y el panel a la ventana (esto último mediante self.Controls.Add()). Con estas últimas sentencias terminamos de definir nuestra clase. Para poder hacer uso de ella creamos una instancia de HolaMundo y se la pasamos a Application.Run(), que es un bucle sin fin que se dedicará a gestionar los eventos sobre la ventana. La explicación es bastante más larga que el texto, pero el lector se habrá dado cuenta de lo simple que es realmente el proceso. Incluso llega a ser aburrido por repetitivo. Pero hemos logrado nuestro objetivo, realizar una aplicación gráfica con un mínimo
61 self.boton1.Name= ‘Botón 1’ 62 self.boton1.Text = ‘Abrir fichero’ 63 self.boton1.Location = Point(20,80) 64 self.boton1.Height = 25 65 self.boton1.Width = 100 66 self.boton1.Click += self.abreFichero 67 68 def abreFichero(self, sender, event): 69 color = OpenFileDialog() 70 color.Filter = “Ficheros txt (*.txt)|*.txt” 71 color.Title = “Selecciona un fichero de texto” 72 73 nombre = “” 74 75 if (color.ShowDialog() == DialogResult.OK ): 76 nombre = color.FileName 77 self.label2.Text = “Fichero seleccionado: “ + nombre 78 # cargamos el texto 79 fichero = File.OpenText (nombre) 80 texto = “” 81 82 s = fichero.ReadLine() 83 while s : 84 texto += s 85 s = fichero.ReadLine() 86 87 self.areaTexto.Text = texto 88 89 form = LectorTXT() 90 91 Application.Run(form)
PYTHON
41
INTEGRACIÓN
.Net
Figura 3: Diálogo de elección de fichero.
de líneas de código. Vayamos a algo más interesante.
Un Visor de Textos Vamos a crear un visor de ficheros de texto muy simple cuyo objetivo es explicar cómo funciona la gestión de eventos en WinForms. Este es quizá el punto débil de muchas librerías gráficas, pero en el caso de WinForms se ha simplificado mucho. Las aplicaciones gráficas están vivas. No son programas insensibles que realizan operaciones, generan una salida y mueren. El término exacto es «interactivas». Para poder interactuar con el usuario deben ser capaces de responder a acciones que el usuario realiza. A estas acciones se les denomina eventos. Cuando creas una aplicación gráfica debes responder ante estos eventos con acciones, por evento existe una acción. Esta es la teoría básica. En lo que difieren las diferentes librerías gráficas es en cómo se implementa la respuesta a los eventos. Los desarrolladores de WinForms estaban hartos de tener que escribir complicadas sentencias sólo para hacer que cuando pulses un botón cambie de color. Así que crearon el siguiente diseño. Cada widget de la aplicación posee una serie de eventos ante los cuales responde. Estos eventos vienen representados como variables dentro del widget que guardan listas de acciones a realizar cuando tal evento suceda. Así de simple. Veamos el código del Listado 3. En el método generaBoton1 aparece la sentencia de asignación de código a un evento:
self.boton1.Click +=U self.abreFichero
42
PYTHON
Hemos definido un botón, y queremos que cuando se pulse se ejecute el método abreFichero. El evento que se dispara cuando pulsamos un botón es Click, así que usamos el operador +=, que podríamos llamar «suma y sigue», para añadirlo a lista de funciones o métodos a llamar cuando aparezca ese evento. Es realmente sencillo. Pero, ¿qué hacemos cuando pulsamos el botón en el Listado 3? El objetivo de este programa es crear un editor de textos sencillo, ver Figura 2. Para ello, en la inicialización de la clase LectorTXT hemos puesto en la ventana un par de etiquetas, una para saludar, otra para decir qué fichero estamos abriendo, un botón y un área de texto. Cuando pulsamos en el botón aparecerá el cuadro de diálogo de la Figura 3. Para crearlo sólo hemos tenido que crear una instancia de OpenFileDialog dentro de abreFichero(). Este objeto define un cuadro de diálogo, pero no lo muestra, antes debemos configurarlo. Sólo queremos mostrar ficheros de texto, por lo que creamos un filtro que únicamente permite ver ficheros de texto. Para ello debemos almacenar en color.Filter una cadena con un formato especial:
* “Texto a mostrar | filtro” El filtro debe ser como los que empleamos cuando usamos el terminal de Linux. El símbolo * significa cualquier cadena de texto, por lo que nuestro filtro solo permitirá ver aquellos ficheros compuestos por cualquier cadena de texto y la terminación .txt , que generalmente se emplea con los ficheros te texto. El cuadro diálogo también tiene un título, puesto que aparece en una ventana independiente. Cuando todo está configurado invocamos color.ShowDialog(), que bloquea nuestra aplicación hasta que el usuario ha escogido un fichero. Esta llamada devuelve un resultado, que debemos comprobar. En nuestro caso, sólo seguimos si el resultado ha sido DialogResult.OK . Si el usuario cierra el cuadro de diálogo, no se hará nada por ejemplo. Si todo ha ido bien, entonces cogeremos de color.FileName el nombre del fichero seleccionado y emplearemos un código muy
parecido al que vimos en el Listado 1 para cargar el texto en una variable. Cuando lo tengamos, cargaremos el texto en la variable self.areaTexto.Text , lo que provocará que se modifique el contenido del área de texto.
Conclusión Poder acceder a la enorme librería de .NET con IronPython nos permite crear aplicaciones gráficas multiplataforma. Una posibilidad realmente esperanzadora para todos aquellos que quieran llevar sus desarrollos en Python de un equipo a otro. El lector puede profundizar en el desarrollo de aplicaciones que empleen WinForms desde IronPython en el Recurso [7]. Es un tutorial, en inglés, en el que se da un repaso a los conocimientos básicos de desarrollo de aplicaciones gráficas mediante WinForms. Python está consiguiendo con IronPython atraer a gran número de desarrolladores de otros sistemas operativos, de forma que se están comenzando a crear aplicaciones de las que nosotros podremos disfrutar en Linux gracias a Mono. .NET se va estableciendo poco a poco en el mundo empresarial como un estándar a tener en cuenta. Pero esto no debe atemorizar a los que usen Python. Tanto si triunfa .NET o Java, IronPython y Jython están ahí para que Python siga vigente y demostrando al mundo que la programación no ■ tiene por qué ser complicada.
Recursos [1] Sitio de IronPython: http://www. codeplex.com/IronPython [2] Jim Hugunin anuncia IronPython: http://blogs.msdn.com/hugunin/ archive/2006/09/05/741605.aspx [3] Miguel de Icaza anuncia la implementación libre de C#: http://tira- nia.org/blog/archive/2007/Jan-11- 1.html [4] API GDI+ para plataformas no Windows: http://www.mono-pro- ject.com/Libgdiplus [5] La licencia Apache de IronPython: http://www.codeplex.com/license?Pr ojectName=IronPython [6] WinForms: http://www.mono-pro- ject.com/WinForms [7] Tutoriales WinForms: http://www. voidspace.org.uk/ironpython/ winforms/index.shtml [8] Listados de este artículo: http://www.linux-magazine.es/ Magazine/Downloads/ Especiales/06_Python
W W W . L I N U X- M A G A Z I N E . E S
Qt
INTEGRACIÓN
QT4 trae a Python nuevas mejoras en la creación de programas
¡Desarrollo Rápido!
N e d e l c u S o r i n , w w w . s x c .h u
Ha llegado el cliente y te lo ha dejado claro: necesita el programa para ayer. Ha surgido un problema enorme y es necesario resolverlo en tiempo récord. La desesperación se palpa en el ambiente y todo s los ojos miran a tu persona. Devuelves una mirada de confianza y dices con tono tranquilo: «No te preocupes, tengo un arma secreta para acabar con el problema». Por José María Ruíz
Algunos deciden dejar la habitación, otros prefieren quedarse a tus espaldas, nerviosos, con los brazos cruzados y la mirada fija en ti. El problema está claro: viene en camino un gran envío, probablemente llegue hoy, con una gran cantidad de productos que se deben controlar porque en unos días saldrán con destino a un cliente. La última vez se hizo todo el proceso con hojas de cálculo, pero fue un desastre. Esta vez quieren estar preparados. Es necesario desarrollar una aplicación y que funcione en menos de 2 horas. Qt4 es la mejor opción.
Qt4 Qt4 es la librería sobre la que se basa el escritorio KDE4. Con licencia GPL, es una alternativa perfecta para desarrollar software libre. Posee algunas ventajas envidiables: • Es muy completa (incorpora código de acceso a base de datos, tratamiento svg, generación de PDF…) • Es integrada (sólo necesitas QT, no cientos de minipaquetes) • PyQT es un proyecto maduro
W W W . L I N U X M A G A Z I N E . E S
-
• Posee un entorno de desarrollo rápido de interfaces profesional: designer Estas características hacen de Qt4 una librería perfecta para el desarrollo rápido de programas. Además es una librería totalmente multiplataforma, podemos desarrollar una sola vez y ejecutar donde queramos.
cual debemos crear en primer lugar una ventana normal y corriente (llamada en inglés «MainWindow»), como la que aparece en la Figura 2, y con la que trabajaremos durante todo el artículo. Por defecto viene con un barra de estado y otra de menú, con la que comenzaremos. Para ello hay que pulsar dos veces
Designer Una de las ventajas de Qt4 (ver Recurso [1]) es su designer . Es una herramienta, curtida en desarrollos profesionales, que nos permite comenzar diseñando el aspecto gráfico de la aplicación. Para ello sólo tenemos que ejecutar el comando designer-qt4, y aparecerá un programa compuesto por distintas ventanas como las que aparecen en la Figura 1. Designer sirve para Figura 1: Designer permite crear interfaces de aplicaciones rápidacrear ventanas, para lo mente.
PYTHON
43
INTEGRACIÓN
Qt
Figura 2: Nuestro “MainWindow” vacía y sin widgets. con el ratón sobre «Type Here» y escribir «&Archivo». De esta forma habremos creado nuestro primer menú. Dentro de este menú introduciremos, de igual forma, la acción «&Salir». El símbolo «&» delante de las palabras indica que quere-
mos que Qt4 genere teclas rápidas para ellas. Por ejemplo, al poner un «&» delante de «Archivo» hacemos que su primera «A» sirva como tecla rápida, activando el menú cuando pulsemos alt-a. El resultado sería el que vemos en la Figura 3. Vamos a trabajar con datos, así que lo mejor que podemos hacer es emplear el widget Table View, que nos permite trabajar con datos tabulares y que podremos conectar, más adelante, con nuestra base de datos de forma casi directa. Para ello tenemos que ir a la ventana principal de Designer y buscar en Item Views el widget Table View. Debemos arrastrarlo hasta la ventana, quedando algo pare-
cido a lo que podemos ver en la Figura 4. ¿Queda mal, no? Lo ideal sería que ocupase todo el espacio visible, para lo cual tenemos que asignar un Layout (disposición) al espacio en el que pondremos nuestro Table View. Hay que pulsar con el botón derecho sobre el espacio gris que rodea al Table View, ver Figura 5, y pulsar en la última opción del menú: Lay out . En ella escogeremos Lay out Vertically, y nuestro Table View ocupará todo el espacio. Pulsamos dos veces con el ratón sobre el Table View y aparecerá una ventana que nos permitirá cambiar su nombre. Esto es muy importante, ya que posteriormente nos referiremos a Table View
Figura 3: Nuestro menú, esperando las opciones. por este nombre, por lo que lo bautizaremos con uno que sea claro y conciso (aunque no muy imaginativo): tabla. Nuestra tabla, tal como aparece aquí, nos permitiría ver datos, incluso editarlos, pero no añadir ni tampoco borrar. Para ello necesitamos botones que inicien acciones externas. Emplearemos Tool Buttons que nos permiten utilizar imágenes en su interior. Estos botones los solemos ver en las aplicaciones justamente debajo del menú. Dispondremos 3 de estos botones: uno para refrescar los datos, uno para añadir y otro para borrar. El botón de refresco es muy importante, puesto que al trabajar varias personas a la vez en la base de datos puede darse el caso de que necesitemos saber si se ha introducido ya algún dato en particular. Estos 3 botones los situaremos entre el menú y la tabla, quedando como puede apreciarse en la Figura 6. Pero, ¿por qué aparecen así? ¿No sería mejor que apareciesen a lo ancho? Sí, lo sería, pero hemos indicado a designer que disponga los widgets verticalmente. La solución consiste en indicarle ahora que los disponga horizontalmente, para lo cual sólo tenemos que seleccionarlos con el ratón (como si fueran ficheros, enmarcándolos en un cuadrado de selección), pulsar el botón derecho sobre ellos y en Lay outs seleccionar Break LayOut . Con esta acción deshacemos la disposición que elegimos anteriormente, pero para rehacerla, volvemos a pulsar el botón derecho, y para estos tres botones seleccionados elegimos Lay out Horizontally, dejándolos como aparecen en la Figura 7. Volvemos a pulsar con el botón derecho, aunque ahora sobre el área gris entre los botones y el Table View, y seleccionamos Lay Out Vertically , quedando todos los widgets como en la Figura 8, con lo que prácticamente hemos acabado con el diseño de la interfaz. Nos quedan unos retoques.
W W W . L I N U X M A G A Z I N E . E S
-
INTEGRACIÓN
A los botones hay que darles nombre. Para hacerlo sólo tenemos que pulsar el botón derecho sobre ellos y elegir Change objectName. Los llamaremos, respectivamente: «refrescar», «nuevaLinea», «eliminarLinea». El último retoque consiste en asignarles unos iconos, de forma que sean identificables visualmente. Para esto lo mejor es darse un paseo por los directorios de iconos de Gnome o Kde y seleccio- Figura 4: Table View descolocada hacia el lado izquierdo. nar los más acordes. Los copiamos a nuestro directorio de face), que llamaremos gui.ui . Este desarrollo, y en designer pulsamos la fichero describe la interfaz gráfica que combinación de teclas control-i . Aparehemos diseñado, aunque no lo podemos cerá el Property Editor que nos permite emplear directamente, sino que hay que cambiar los parámetros de los widgets. compilarlo. Para ello utilizamos el proEstamos interesados en los de los botograma pyuic4: nes, por lo que sólo tenemos que seleccionar un botón para que el Property Edijosemaria@rufus> pyuic4U tor cambie para mostrar los parámetros gui.ui > gui.py de ese botón. Vamos a cambiar el parámetro Icon, que está en la sección QAbsEl resultado de compilar este fichero es la tractButton . Si pulsamos en él veremos generación de un fichero Python que reaque a la derecha hay un botón que nos liza todo lo necesario para que tengamos permite seleccionar entre Choose nuestra interfaz gráfica funcionando. Resource y Choose File.... La primera Ahora necesitamos crear un programa opción sirve para guardar en un solo que, usando este fichero como librería, fichero, llamado de recursos, todos los gestione la aplicación que estamos creficheros que vaya a necesitar nuestra ando. aplicación, lo que simplifica la instalaMiramos nuestro reloj, sólo han ción. La segunda opción, más simple, pasado 15 minutos, nuestros compañeros nos permite indicar el nombre del fichero que emplearemos. Utilizaremos la segunda opción, Choose File... , por ser más simple. Seleccionamos un fichero gráfico con el icono, y hacemos lo mismo para los otros botones, ver Figura 9. Cuando guardemos nuestro diseño generaremos un fichero con extensión Figura 5: El menú Lay out nos permite colocar correctamente los ele.ui (User Inter- mentos.
PYTHON
45
INTEGRACIÓN
Qt
miran por encima de nuestro hombro tranquilos. Pero sabemos que esta interfaz necesita de un cerebro para controlarla, por el momento es sólo una fachada.
La Base de Datos Usaremos una base de datos remota Postgresql para almacenar los datos, de esta forma varias personas podrán trabajar a la vez en el programa. En lugar de emplear las librerías que existen para trabajar con Postgresql en Python usaremos Qt4. La tabla que crearemos será también sencilla:
create table inventario ( ean13 char(13) primary key, nombre varchar not null, cantidad int not nullU default 0, constraintU inventario_cantidad_positivoU check(cantidad >= 0) ) Qt4 trae consigo una librería de control de base de datos muy avanzada: QtSql. No se restringe a mandar código sql, además interactúa directamente con los widgets de Qt usando un patrón de diseño denominado MVC (modelo – vista – controlador).
Figura 6: Creamos tres nuevos botones…
Figura 7: … Y los alineamos a nuestro gusto.
46
PYTHON
Esta técnica consiste en separar el código de manipulación de los datos, el código que los muestra y el que toma las decisiones. Qt provee dos clases diferentes, una que representa los datos (el modelo) y otra que representa la visualización de los mismos (el visualizador), dejando el control de la apli- Figura 8: Ésta será la disposición final de los botones y cación en nuestras manos. El tabla. modelo es una entidad autónoma e independiente, no requiere de la La primera de ellas realiza un select sobre existencia de una base de datos. Podela tabla inventario, lo que no es muy mos crear un modelo con tablas y filas, extraño, pero la segunda línea emplea el con relaciones y llaves, tal y como si resultado del select para generar un prototuviésemos una base de datos. La razón tipo. Hacemos esto porque necesitamos detrás de este diseño es la de unificar la saber el formato de una fila de la tabla inventario, para saber el nombre de las manipulación de los datos en toda la aplicación, estandarizándola. Las aplicacolumnas y sus posiciones. Qt denomina ciones empresariales siempre tienen que a esta información Record, y nos permitirá interactuar con una base de datos, por lo realizar consultas posteriormente. que esta decisión de diseño es cada vez El método generaModelo() es más intemás común. resante. Una vez realizada la conexión a Por tanto, podemos crear nuestro la base de datos necesitamos generar un modelo de forma independiente, pero lo modelo de la tabla. Todos los modelos mejor no es eso. Lo realmente interedescienden de una clase común, de forma sante es que podemos conectar ese que son intercambiables. Existen dos modelo con una base de datos y seguiremodelos de base de datos: QSqlTableMomos manipulando los datos empleando del, más sencillo, y QSqlRelationalTablesólo el modelo. Esto quiere decir que no Model, que almacena también informatendremos apenas que escribir código ción sobre las relaciones entre distintas SQL, el modelo se encargará de ello tablas. Nos conformamos con QSqlTablepor nosotros. Nuestra aplicación Model, puesto que nuestra tabla no está estará totalmente desligada de la relacionada con otras. Una vez tenemos el forma en la que se representan los modelo, seleccionamos la tabla que quedatos. Hoy pueden estar en Postremos manipular con setTable(). Es muy gresql, mañana en MySQL y interesante que los productos que aparezpasado en un fichero XML, y no can en el Table View lo hagan ordenados tendremos que cambiar apenas el por EAN-13, lo que facilitará búsquedas y código. comprobaciones a los usuarios. Para ello ¿Cómo se hace todo esto? Veaordenamos el modelo con el método setSort(). Acepta dos parámetros, la posición mos el código del Listado 1. El método conectaDB() muestra cómo de la columna que se empleará para orderealizar la conexión a la base de nar y el tipo de ordenación. Aquí entra en datos Postgresql. El código de Qt4 juego el prototipo que generamos antes es sorprendentemente simple, comde las filas de la tabla, que posee el parado con otras librerías. Las últimétodo indexOf() que nos devolverá la mas dos líneas de código son algo posición de una columna dada. La ordeextrañas. nación puede ser QtCore.Qt.AscendingOrder (la primera fila tiene el valor más bajo query = y la siguiente uno más alto) o QtSql.QSqlQueryU QtCore.Qt.DescendingOrder (lo contrario). (“select * from Con el modelo listo pasamos a cargarlo inventario”,U con los datos, paso que realizamos invoself.db) cando select() , que realiza un select self.recordPrototipo =U sobre la tabla, y almacenando los datos query.record() en el modelo.
W W W . L I N U X M A G A Z I N E . E S
-
Qt
INTEGRACIÓN
realizan acciones cuando una señal los dispara. Así, cuando se hace click sobre un botón, la señal ”click ”click-ed()” se pasa a un slot por defecto del botón. Si queremos que el botón realice una acción diferente, podemos definir una conexión de ”clicked()” con una función o método que realice la Figura 9: Escogemos iconos representativos de las acción que deseamos. En acciones. C++ este proceso requería de la compilación del código Volvemos a mirar nuestro reloj, han fuente con un compilador de Figura 10: Nuestra aplicación en funcionamiento. pasado 40 minutos. Nuestros compañeTrollTech, llamado moc , y posteros se ponen nerviosos, no «ven» ningún riormente la compilación con un compiNuestros compañeros se levantan para avance. lador de C++. ver qué estamos haciendo y casi dan un En Python todo es más simple, sólo salto cuando observan que la aplicación Conectando Mundos tenemos que emplear el método está modificando la base de datos en QtCore.QObject.connect() para especifiTenemos que vincular nuestro código tiempo real y de forma correcta. Nos con la librería gui.py que generamos car el widget y la señal que emite con el miran y, con cara de emoción, nos espeantes. Para ello la importamos: método que la gestionará. tan: «¡Menos mal! creíamos que todo iba En nuestro diseño tenemos 3 botones, fatal, como no hiciste nada útil durante uno para refrescar, otro para añadir la última media hora…». Así de sufrida from gui import Ui_MainWindow líneas y otro para borrarlas. Por tanto, es la programación. Volvemos a mirar el y generamos un objeto de tipo Ui_Maintenemos que conectar la señal ”clicked()” reloj, todo listo en menos de una hora. Window al que nos conectamos de estos botones a métodos que realicen Ahora, con más tranquilidad nos dismediante el método setupUi(), ya que es estas acciones. ponemos a hacer de la aplicación algo nuestro programa quien lleva la batuta. La primera de ellas, refrescar, es la más más potente… y ¡a bautizarla! Pasamos a tabla nuestro modelo de simple. Sólo tenemos que decirles al Conclusión datos, de forma que modelo y vista tammodelo que vuelva a hacer un select() bién se contactan. A partir de ahora lo para recargarse. En muy pocas líneas de código, y gracias que haya en la base de datos se corresLa segunda, nuevaLinea(), invoca al al programa designer de Qt4, tenemos ponderá con lo que se vea en el Table método insertRow() del modelo para crear una aplicación multiusuario funcional View. El método reajusta() hace que el una línea vacía en el Table View. Cuando que interactúa con una base de datos. Table View ajuste el ancho de sus columse rellenen todos los campos de esta linea Qt4 ha dejado el listón muy alto para el nas para que se puedan ver todos los se guardará automáticamente en la base resto de frameworks de desarrollo. En datos. En caso contrario hará que las de datos; el modelo se encarga de todo. particular, es interesante su total integracolumnas sean todas del mismo tamaño, La tercera acción, eliminarLinea() , ción con Windows, MacOsX y Linux, y algunos datos aparecerán incompletos. incompletos. localiza la posición actual en la tabla permitiéndonos hacer uso de nuestro Qt posee un sistema propio de prograobteniendo el índice de la celda que software libre en cualquiera de las tres mación denominado «Señales y Slots». Qt tenga el foco, y a partir de él obtiene la plataformas de forma directa. se desarrolló en el lenguaje de programafila en la que se encuentra. Por seguridad Qt4 es, sin duda, un opción realmente ción C++, y pronto se dieron cuenta de no borraremos directamente, sino que interesante para prototipado de aplicalas deficiencias que poseía. En particular, presentaremos un cuadro de diálogo preciones o para desarrollo rápido, bajo prese dieron de bruces con la dificultad de la guntando al usuario si desea borrar la sión. Al fin y al cabo ha hecho que nuesprogramación de eventos en C++. fila, mostrando tanto el EAN-13 como el tro protagonista se convierta en un ■ Como resultado de estos problemas, nombre del producto. Para obtener héroe. TrollTech, la empresa creadora de Qt, ambos volvemos a hacer uso del protodecidió crear un compilador y una serie tipo para conseguir sus posiciones dentro Recursos de instrucciones que hicieran la prograde la fila y poder recuperar sus valores. [1] ¿Qué es PyQt?: mación de interfaces gráficas más simUna vez confirmada la eliminación, sólo http://www. http:// www.riverbankcomputing. riverbankcomputing.co. co. ple. Los detalles no son importantes, al tenemos que emplear el método removeuk/software/ uk/ software/pyqt/ pyqt/intro intro fin y al cabo este artículo es sobre Row() del modelo. [2] Listado de clases con sus explicaPython, pero el nuevo modelo de trabajo Poco más es necesario para que nueshttp://www. www. ciones y ejemplos: http:// se basa en eventos. Los objetos de Qt tra aplicación sea funcional, el resultado riverbankcomputing.co. riverbankcomputing. co.uk/ uk/static/ static/Docs/ Docs/ poseen una serie de slots o conectores a final puede verse en funcionamiento en PyQt4/html/ PyQt4/ html/classes. classes.html html los que pueden llegar señales. Estos slots la Figura 10.
W W W . L I N U X M A G A Z I N E . E S
-
PYTHON
47
INFRAESTRUCTURAS Pyramid
El framework que no fue construido por alienígenas
Pyramid Uno de los rivales de peso de Django está creciendo en popularidad poco a poco. Por José María Ruíz
Django es el framework que más está
contribuyendo a la extensión del uso de Python. Al igual que ocurrió con Ruby y Ruby on Rails, Django se ha convertido en una gran baza para la comunidad Python y la excusa perfecta para probar Python. Está bien documentado, dispone de gran número de extensiones y el respaldo de grandes empresas ¿por qué querría alguien crear un competidor? La comunidad Python dista mucho de ser monolítica, aparecen múltiples alternativas para casi todo. Lo curioso es que el novato en los frameworks web ¡es Django! Antes de su aparición ya existían otros distintos, y Pyramid es el descendiente directo de algunos de ellos [1].
Un “hola mundo” Minimalista o m c . l e i f u e r g
Podemos instalar Pyramid de muchas formas, pero la más cómoda desde el punto de vista de Python consiste en crear un virtualenv e instalar en su interior Pyramid: $ virtualenv --no-site-pack --no-site-packages ages U --distribute pruebas-pyrami pruebas-pyramid d $ cd pruebas-pyramid $ source bin/activate (pruebas-pyramid)$ (pruebas-pyram id)$ pip U install pyramid
Con estos cuatro pasos dispondremos de un virtualenv con las librerías que Pyramid necesita para funcionar. Es posible crear un proyecto Pyramid con el comando pa past ster er (u (un n proyecto como los que creamos con Django), pero como vamos a generar una primera aplicación minimalista, sólo necesitamos en principio un fichero con el contenido que aparece en el Listado 1. A diferencia de Django, Pyramid es un sistema bastante estructurado y centrado en componentes. La configuración se efectúa a través de una instancia de Configurator ,
48
PYTHON
donde vamos añadiendo rutas, vistas y (como ya veremos) muchos otros tipos de componentes. Configurator es la base sobre la que montamos nuestro sitio web. El concepto de vista es sencillo, al igual que en Django, pudiendo usarse una función cualquiera que admita como parámetro un objeto R Req eque uest st con la información de la petición. Se distingue entre declarar una vista y emplearla en distintas rutas. Cada ruta tiene un nombre, route_name, que nos permite conectarla con cualquier ruta. Así, los métodos add_route y add_view trabajan conjuntamente para definir el comportamiento de la web. Una vez hemos acabado con la configuración, podemos arrancar el servidor. Para este sencillo ejemplo hacemos uso de la función serve() de pa past stee, que implementa un servidor web en Python que acepta como parámetro una aplicación WSGI , que obtenemos llamando a make_wsgi_app() de Confi gura gu rato tor r . Las rutas pueden contener parámetros en su interior que podemos capturar de distintas formas, como ya veremos. Para poder arrancar el servidor sólo tenemos que ejecutar el fichero como un programa Python cualquiera e ir a la dirección 127.0. 127. 0.0. 0.1:8080 1:8080.
Creando un Proyecto La generación de código fuente, el llamado «scaffolding», es, a día de hoy, un elemento indispensable de la mayoría de los frameworks web. Pyramid no provee directamente un sistema de scaffolding, lo que iría en contra de su política de reutilización. En lugar de ello hace uso de pas paster ter , un sistema independiente de scaffolding que comparten otros proyectos. Cuando instalamos Pyramid con pip se instaló past paster er como dependencia, por lo que podemos usarlo directamente:
$past er create --list$paster --list-templat templates es Available templates: basic_package: A basic U setuptools-enabled package paste_deploy: A web application U deployed through paste.deploy pyramid_alchemy: pyramid U SQLAlchemy project using traversal pyramid_jinja2_starter: U pyramid jinja2 starter project pyramid_routesalchemy:U pyramid SQLAlchemy project using U url ur l dispatch (no traversal) pyramid_starter:pyramid starter U project pyramid_zodb: U pyramid ZODB starter project
Con la opción --list-templates podemos ver paster er puede generar. los proyectos que past Pyramid nos ofrece varias alternativas, desde la más tradicional, empleando routes y sqlalchemy, hasta otras más exóticas heredadas de Zope, como pyr pyrami amid_z d_zodb odb o pyr pyraamid_alchemy. La diferencia entre ambas posibilidades está en la forma en que se estructuran las urls y en la base de datos a usar. Zope permite el uso de un sistema llamado traversal que genera automáticamente las urls empleando para ello las relaciones entre los modelos de datos usados. La mayoría de frameworks web, en casi todos los lenguajes de programación, se decantan en su lugar por la definición de las urls de forma explícita, para así tener más control sobre ellas. Nosotros nos conformaremos con el enfoque tradicional, por lo que podemos crear el proyecto con: $ paster create -t U pyramid_routesalchemy U ejemplo
Como resultado obtendremos un directorio llamado ejemplo que albergará nuestro proyecto, y en su interior un módulo Python llamado también ejemplo. Para poder arrancar el proyecto tenemos que generar primero un fichero de configuración e instalar los paquetes necesarios mediante el comando: $ cd ejemplo $ python setup.py develop
Pyramid trae dos configuraciones: «develop» para desarrollo y «production» para el entorno
W W W . L I N U X- M A G A Z I N E . E S
Pyramid
Renderers, Vistas y Plantillas Pyramid permite configurar diferentes renderers que pueden convivir en el mismo proyecto. Por ejemplo, podemos configurar varios sistemas de plantillas a la vez (Mako, Chamaleon, Jinja2,…) Figura 1: Página por defecto de Pyramid y debug_toolbar. y hacer que Pyramid seleccione el de producción. Cada una aparecerá como un correcto basándose en la extensión de la fichero con extensión .ini que nos permitirán plantilla a usar. configurar el proyecto. Mientras que otros fraEn este ejemplo usaremos Jinja2, un sismeworks, como Django, prefieren que la tema de plantillas muy parecido al empleado configuración se haga usando código Python, por Django pero más flexible y potente. Prien Pyramid decidieron optar por seguir mero tenemos que instalar la extensión de usando ficheros de configuración .ini. Pyramid para Jinja2: Una vez haya finalizado el proceso podemos arrancar el servidor web con pa past ster er : $ pp install pyramid_jinja2 $ paster serve U development.ini
Podemos ver la página generada en la ruta http://localhost:6543. Esta página incluye a la derecha una pestaña que nos da acceso al development toolbar de Pyramid, el cual nos proporcionará información muy valiosa durante el desarrollo de la aplicación, así como enlaces a la documentación de Pyramid.
Una vez instalada debemos indicar a Pyramid que cargue la extensión y con qué ficheros queremos que use Jinja2 (en nuestro caso los que acaben en «.html»). Debemos modificar el fichero ejemplo/ ejemplo/ __init__. py, que alberga la configuración para nuestro proyecto, y poner dentro de main: config = U Configurator(settings=settings)
La llamada a add_renderer() es la que nos permite indicar a Pyramid que las plantillas con extensión .html deberán ser renderizadas empleando Jin Jinja2 ja2. Además llamamos a scan(), que se encargará de buscar las vistas que definamos y nos ahorrará el tener que añadirlas una a una con add_view(), como vimos en el Listado 1. Pero para que esto sea posible, nuestra nuestra vista debe cambiar la forma de trabajar; debemos poner el siguiente código en ejemplo/ejemplo/views.py: from pyramid.view imp import ort U view_config @view_config (route_name = U ”portada”, renderer = U ’ejemplo:templates/portada.html’) def portada(request): return {‘saludo’:‘Hola mundo!!’}
Para indicar el route_name y la plantilla que usaremos en la vista por portad tada a usaremos el decorador @view_config(). En él podemos definir todos los parámetros que necesita Pyramid para usar la vista. Con el parámetro renderer indicamos que queremos la plantilla porta po rtada da.h .htm tmll, que debe estar dentro del directemplates torio del módulo ejemplo. Cada
Listado 1: Ejemplo de Pyramid Básico 01 from paste.httpserver import serve 02 from pyramid.configuration import Configurator 03 from pyramid.response import Response 04 05 def hola_mundo(request): 06 nombre = request.matchdict.get(‘nombre’, ‘mundo’) 07 return Response(‘Hola {0}!’.format(nombre)) 08 09 if __name__ == ‘__main__’:
Listado 2: Vista que Procesa Parámetros 01 from pyramid.view import view_config 02 03 @view_config(route_name=”portada”, 04 renderer=’ejemplo:templates/portada.html’) 05 def portada(request): 06 saludo = ‘Hola mundo!!’ 07 if request.POST: 08 nombre = request.params. get (‘nombre’, saludo) 09 if nombre:
módulo puede disponer de sus propias plantillas independientes, lo que aumenta la modularidad del diseño. Además, como la plantilla acaba en .html, Pyramid empleará el renderer render er Jinja2. Jinja2 Jin ja2 permite establecer herencia entre plantillas, por lo que crearemos una plantilla ejemplo/ejemplo/templates/base.html:
Bienvenido
{% block contenido %} {% endblock %}
Y otra plantilla más llamada ejemplo/ejem plo/t pl o/tem empl plat ates es/po /port rtad ada. a.htm htmll: {% extends “ejemplo:U templates/ base.html” %} {% block U contenido %}
{{saludo}}U
{% endblock %}
La extensión py pyra rami mid_ d_ jinj ji nja2 a2 se encarga de convertir la ruta ejemplo:tem plat pl ates es /b /bas ase. e. ht html ml en una ruta del sistema de ficheros que Ji Jinj nja2 a2 pueda utilizar. Vamos Vamos a añadir una nueva vista para demostrar cómo funcionan los enlaces y los formularios (ver Listado 2, Listado 3 y Listado 4). Figura ra 2: El comando “ top” funcionando en nuestro navegador. navegador. Creamos una nueva Figu vista que apuntamos a la ruta por defecto de nuestro proyecto. De procese el formulario. De esta forma podeesta forma la página principal mostrará un mos decidir cambiar qué vista lo procesará formulario para que podamos pasar un nom- siguiendo cualquier criterio que queramos, bre. En el Listado 4 podemos ver el código de puesto que la asignación de un route_name a la plantilla ejemplo/ejemplo/templates/for- una vista puede variar durante la ejecución mulario.html, donde generamos la url que de la llamada (por ejemplo, empleando criteprocesará el formulario así: rios de seguridad, o si el usuario está registrado o no). En el Listado 2 podemos observar que el 09 {% endblock %}
más conocidas son FormEncode y FormAlchemy [5] [6] . En nuestro caso he decidido procesar «a mano» la petición.
Un Ejemplo Más Potente ¿De verdad compensa la flexiblidad que nos aporta Pyramid? Con Django es todo mucho más sencillo, puesto que las decisiones sobre qué librerías emplear ya han sido tomadas. Además, todas las librerías están controladas por el proyecto, por lo que su integración es perfecta. Personalmente creo que Pyramid comienza a rendir cuando necesitamos hacer cosas que no son tradicionales. Uno de los problemas de Django consiste en que fue diseñado en un entorno muy bien definido: un periódico. Django no se encuentra muy bien preparado para el entorno actual, donde tecnologías como HTML5 o websockets comienzan a ser cada vez más importantes. Como ejemplo final de Pyramid vamos a crear una página que empleará socket.io [7] para mandar datos a nuestro navegador en tiempo real, lo que definitivamente no es la típica página web tradicional. Instalamos las librerías necesarias: pip install gevent U gevent-websocket gevent-socketio
Éstas nos permitirán arrancar nuestro proyecto con un servidor basado en gevent en lugar de usar paster , lo que nos permitirá responder a consultas continuadas sin necesidad de cerrar el canal de comunicación con el navegador.
En el Listado 5 podemos ver el código de la plantilla htop.html. En ella cargamos tanto jquery como la librería socket.io.js, que se encarga de establecer un canal continuo de comunicación entre el navegador y el servidor. Si el navegador soporta websockets, los usará, pero en caso contrario tratará de interactuar usando otros mecanismos. Lo mejor de socket.io es que nos permite programar toda la interacción mediante mensajes. Cuando recibimos un mensaje showdata, cambiamos el texto de la etiqueta con id htop por el que recibimos del servidor. Realmente sencillo ¿verdad? No tenemos que ser conscientes ni siquiera sobre cómo se recibe el mensaje o cómo se procesa. El Listado 6 muestra el código donde realmente ocurre la magia. Creamos una subclase de SocketIOContext, donde conectamos y mandamos un mensaje connected al navegador remoto. Seguidamente definimos la función sendhtop, que será ejecutada por gevent como si fuese una hebra independiente para cada conexión que recibamos. En dicha función ejecutamos htop con dos parámetros que le indican que sólo nos muestre el estado de los procesos una vez y pare su ejecución. De esta manera podemos obtener una instantánea de la situación de nuestro ordenador. La salida de htop la mandamos en un mensaje showdata al navegador e indicamos a gevent que espere 1 segundo. Todo esto se ejecutará en un bucle infinito mientras el navegador esté conectado, cosa que sabremos con el resultado de self.io.connected(). De esta forma nuestro navegador
mostrará
htop como en la url http://127.0.0.1:6543/htop ¡como si se estu-
viese ejecutando en él! Es fácil imaginar las posibilidades de esta tecnología (ver Listado 7 para configuración).
Conclusión Si bien Django es el framework web dominante en Python, Pyramid puede ser una alternativa muy interesante si necesitamos realizar una aplicación web que no sea tradicional. Su sistema basado en componentes nos da acceso a librerías de alta calidad y realmente potentes que normalmente son un fastidio integrar. En este artículo sólo hemos rascado la superficie de Pyramid – que cuenta con librerías realmente avanzadas para autenticación, por ejemplo – pero espero que el lector haya podido dar sus primeros pasos con el framework… ¡que no ha ■ sido construido por alienígenas! [8].
Guitarrazos Los creadores del proyecto Django nos hablan de la formación de la Django Software Foundation. Y mostramos cómo comenzar con esta infraestructura web. Por Frank Wiles En el verano de 2005 surgió en el mundo
del código abierto un nuevo web framework [1]. Sólo tres años después desde su publicación, Django tiene ya el suficiente atractivo como para alentar la formación de la Django Software Foundation [2]. Con la formación de la DSF, Django pasa a formar parte de una impresionante lista de proyectos con fundación propia, entre los que se encuentran Apache, Perl y Python.
¿Qué es Django? Django es un “framework” para el desarrollo web con Python. Se trata de un juego de librerías que permiten al desarrollador trabajar en las partes de una aplicación que verdaderamente importan sin tener que preocuparse por la infraestructura subyacente. Django usa el patrón MVC como otros muchos frameworks ( Ruby on Rails y los distintos frameworks en Perl y PHP ). Una de las funcionalidades punteras de Django es su increíble interfaz de administración, que se construye automáticamente para nosotros. En este artículo recorremos los pasos necesarios para la creación de una pequeña aplicación de tipo Twitter, con la que veremos en acción esta interfaz de administración. Son muchos los sitios web de alto nivel que emplean Django en su desarrollo [3], como EveryBlock.com, Pownce.com o Tabblo.com. Además, es el framework predeterminado incluido en el AppEngine de Google
52
PYTHON
(tenemos entendido que Google lo usa también internamente en algunas tareas). Django es, además, la fundación del gestor de contenidos comercial Ellington, usado en varias organizaciones de gran tamaño del mundo de las noticias, como por ejemplo el Washington Post . Jacob Kaplan-Moss, presidente de la Django Software Foundation y uno de los creadores de Django, dijo que la fundación fue creada con el fin de que el proyecto pudiese dar el siguiente paso en su ciclo de vida como proyecto de código abierto. “Obviamente hemos tenido éxito a la hora de atraer a una comunidad grande, vibrante, por lo que sentimos que era hora de que Django perteneciese a la comunidad. Con la fundación se garantiza su perpetuidad, incluso aunque algunas personas o algunas compañías perdiesen interés”, comentó. Kaplan-Moss señala que el proyecto acepta ahora donaciones para mejorar Django y, en un futuro próximo, la fundación soportará Django mediante reuniones de desarrolladores, mítines y otras actividades comunitarias. Muchas de estas reuniones de desarrolladores han tenido lugar antes de la publicación de Django 1.0 -- y Kaplan-Moss comenta que la fundación ayudará a que las personas más indispensables puedan colaborar al tiempo que asisten a las reuniones. “Si la fundación ayuda a Django a avanzar, aunque sólo sea un poco más rápido, con eso me bastará”, dijo Kaplan-Moss.
Comencemos La publicación de la versión 1.0 oficial de Django se produjo el día 2 de Septiembre de 2008, tal y como estaba planeado en su hoja de ruta. Siempre podemos obtener, usando Subversion, el código más reciente: svn checkout U http://code.djangoproject.com/U svn/django/trunk/
Independientemente de la versión que usemos, la instalación de Django es muy sencilla. Estando conectados a Internet, ejecutamos como root : python setup.py install
para instalar Django en el directorio site packages o donde sea que tengamos la instalación de Python. En nuestro ejemplo usaremos SQLite como base de datos. De todas formas, Django soporta perfectamente Post gresSQL y MySQL. Para usar SQLite, instalamos el paquete pysqlite2 [5] y seguimos las instrucciones de la instalación. Django distingue entre proyectos y aplicaciones. Por ejemplo, si hiciésemos un sitio web de gran tamaño, con una sección formada por un blog, un foro o comercio online, entonces el sitio en sí sería el proyecto, mientras que el blog, el foro y el e-
W W W . L I N U X M A G A Z I N E . E S
-
Django
Figura 1: La interfaz de administración de Django.
comercio serían las aplicaciones . En realidad sólo es una forma de organizar los subproyectos dentro del proyecto general. Para iniciar un nuevo proyecto ejecutamos django-admin.py startproject miprueba
U
con lo que se crea el directorio miejemplo con unas pocas herramientas y archivos de configuración predeterminados. Luego necesitamos que Django genere los de la aplicación, que llamaremos Prueba. Para ello, ejecutamos desde el directorio miprueba: python manage.py startapp Prueba
En miprueba/settings.py, colocamos DATA BASE_ENGINE = ‘sqlite3’ y a DATABASE_NAME le ponemos la ruta com-
Figura 2: Para añadir información a nuestra aplicación personal.
pleta a miprueba/ prueba.db, el archivo de SQLite en el que vamos a guardar nuestra base de datos. La ruta completa depende del directorio en el que hemos ejecutado el startproject inicial. Añadimos dos elementos a la lista INSTALLED_APPS: django.contrib.admin para la interfaz de administración y la aplicación miprpueba.Prueba, asegurándonos de que añadimos las comas. Después de definir qué base de datos vamos a usar, tenemos que construir nuestro modelo ( Model), que es un objeto de Python que define las tablas y columnas de SQL y su relación. Puesto que la aplicación sólo va a tener una tabla, sólo definimos una clase. El archivo miprueba/ Prueba/ models.py debería parecerse al que se muestra en el Listado 1. Primero importamos los asistentes de modelo de Django y definimos la clase Prueba, que contiene una columna de fecha y otra de texto para la entrada real. Luego
definimos el método especial __unicode__ , que le dice a Model cómo mostrar una instancia del objeto en formato de cadenas (en este caso, sólo imprime la fecha y la entrada completa). Esta será la información que usará el admin en el momento de mostrar los listados con las entradas de la base de datos. La clase vacía Admin indica a Django que queremos hacer uso de la interfaz de administración. Para comprobar lo que llevamos hecho, validamos los modelos mediante: python manage.py validate
Si todo está bien, debería devolvernos 0 errors found. Django ya puede montar las tablas de la base de datos. Para ello, introducimos python manage.py syncdb
Vemos varias líneas con Creating table, algunas de las cuales pertenecen a permisos de usuario/ grupo, otras a admin y la última para la tabla Prueba. Es ahora cuando Django nos insta a crear el superusuario para la interfaz de administración. Debemos recordar el nombre de usuario y la contraseña, ya que las vamos a necesitar luego. Después de crear las tablas para el modelo y la base de datos, habilitamos la interfaz de administración. Lo hacemos descomentando las tres líneas del archivo miprueba/urls.py que se creó al ejecutar startproject . Las tres líneas están etiquetadas, indicándonos que hay que descomentarlas para que se habilite la administración. El archivo urls.py es con el que Django, mediante expresiones regulares, enlaza las diferentes URLs con las distintas partes de nuestra aplicación.
PYTHON
53
INFRAESTRUCTURAS Django
Listado 3: Hacemos la Plantilla 01 02
03 04
05
diferentes, podemos especificarlo en el comando: python manage.py U runserver 127.0.0.1:5555
Suponiendo que lo hayamos ejecutado sin 06 dicha opción, nos dirigimos a http://127.0.0. 07 1:8000/admin, donde se nos instará a iden08 {% for t in entradas %} tificarnos para acceder a la interfaz de admi09 nistración. Después de identificarnos, vere10 1. 11 cación personal, podemos ignorar por ahora 12 las secciones Sites y admin y pulsar sobre el 13 {% endfor %} icono Add del cuadro Prueba. Veremos 14
Fecha
Entrada
{{ t.fecha mos la pantalla que se muestra en la Figura }}
{{ Debido a que estamos haciendo una aplit.entrada}}
entonces algo como lo que se muestra en la 15 Figura 2. 16 Ya podemos introducir datos de entrada. Al pulsar sobre Today se rellena automáticaAdemás, debemos crear un archivo mente la fecha actual, aunque podemos admin.py. En este ejemplo sólo usaremos la usar el calendario para escoger otra. Lo configuración predeterminada, pero éste es siguiente es introducir texto en Entrada y el lugar en el que se pueden personalizar pulsar sobre Save, que nos lleva a una varios de los aspectos de la interfaz de admipágina que nos muestra todas las Pruebas de nistración. miprueba/ Prueba/admin.py nuestra base de datos. Al pulsar sobre la necesitará contener: entrada que acabamos de hacer, llegamos a una interfaz de edición, con la que podrefrom django.contrib import admin mos realizar cambios sobre ella o eliminarla. from miprueba.Prueba.models U Es posible compartir las entradas de la import Prueba web con otras personas. Para poder hacerlo class PruebaAdminU debemos añadir una vista (o módulo encar(admin.ModelAdmin): gado de la lógica) y una plantilla (la forma pass en que se presentan los datos al usuario). admin.site.registerU Aquellos que estén acostumbrados a otros (Prueba, PruebaAdmin) frameworks de tipo MVC , en los que la vista suele ser la plantilla en sí misma, pueden Para verlo en acción, ejecutamos tener un poco más de dificultades a la hora de acostumbrarse a las vistas de Django. python manage.py runserver Para comenzar, editamos miprueba/ Prueba/views.py, de forma que contenga un que arranca un servidor de pruebas en la simple método para devolver todas las dirección http://127.0.0.1:8000. Para inientradas en orden cronológico inverso (Lisciarlo en una dirección IP o en un puerto tado 2). Así definimos el método TodasLas Pruebas, que recoge todos los objetos Prueba, ordenados por el Listado 4: Mapear a URL campo de fecha, y los invierte. 01 from django.conf.urls.defaults import * Luego llama a render_to_res02 from django.contrib import admin ponse(), con el nombre de la plan03 from mytwit import views tilla para la vista y un diccionario 04 con los datos que le queremos 05 admin.autodiscover() pasar. 06 Cuando hayamos acabado con 07 urlpatterns = Patterns(‘’, la vista, tendremos que hacer la 08 (r’^twits/’. plantilla. El Listado 3 muestra un ’mytwit.Twit.views.alltwits’). ejemplo de marcado simple con el 09 (r’admin/(.*)’, admin.site.root), que captar la idea general. Con el 10 ) fin de mantener las plantillas sepa-
54
PYTHON
radas de todo lo demás, guardamos el archivo en miprueba/ plantillas/ todas_las_pruebas.html. Como puede apreciarse, el lenguaje de plantillas de Django es fácil de usar, aunque tiene funcionalidades avanzadas. En ésta usamos un bucle for simple, con el que iteramos sobre los objetos Prueba que vamos a pasar al método TodasLasPruebas() y mostrar los datos de cada objeto Prueba mediante sus métodos fecha y entrada. Luego configuramos Django para que encuentre nuestra plantilla en el sistema de archivos, e instalamos una URL que enlace con la vista. Para instalar los directorios de plantillas en miprueba/settings.py hemos de añadir la ruta completa a la lista TEM PLATE_DIRS, que dependerá del directorio desde el cual se ejecutó startproject (debemos asegurarnos de utilizar la ruta completa). Después editamos miprueba/urls.py para mapear la URL (Listado 4). Así hemos importado las vistas específicas de la aplicación, hemos añadido la URL /pruebas/ y hemos dejado como estaba el mapeo de la interfaz de administración. Si nos dirigimos a http://127.0.0.1:8000/ pruebas, veremos todas las Pruebas que hemos añadido desde la interfaz de administración. El binomio formado por el servidor independiente y SQLite es genial para el desarrollo rápido, pero si lo que queremos es montar una aplicación en producción es mejor usar Apache con mod_python, junto con una base de datos más robusta, como PostgreSQL (ver el sitio web de Django). Nuestro agradecimiento a Jacob KaplanMoss y a Adrian Holovaty por su contribución a este artículo. Los listados de código se ■ pueden descargar de [7].
Recursos [1] Sitio Web del proyecto Django: http://www.djangoproject.com [2] Django Software Foundation: http:// www.djangoproject.com/foundation [3] Sitios desarrollados con Django: http://www.djangosites.org [4] Descarga de Django: http://www. djangoproject.com/download/ [5] Pysqlite2: http://initd.org/pub/ software/pysqlite/ [6] Django Book: http://www.djangobook.com [7] Código del Artículo: http://www.linux-magazine.es/ resources/article_code
W W W . L I N U X M A G A Z I N E . E S
-
Thrift
Serialización estilo Web 2.0
B e n i s A r a p o v i c 1 2 3 r f . c o m
Hacer que distintos servicios se comuniquen entre ellos es todo un problema que Facebook ha tratado de solucionar con Thrift. Por José María Ruíz “La información quiere ser libre” es uno de los lemas hacker, pero habría que preguntarse cómo se moverá una vez que lo sea. En un mundo como el actual, donde la información y su procesado pueden encontrarse distribuidos en decenas (¡o miles!) de servidores, es preciso contar con algún mecanismo que permita comunicar sistemas informáticos de todo tipo sin tener que recurrir a tecnologías de bajo nivel. Este problema ha sido resuelto por muchos mediante el empleo del protocolo HTTP, pero cuando lo que buscamos es rendimiento, HTTP puede no ser una opción. No es de extrañar que dos de las empresas de referencia de Internet, Facebook y Google, se hayan enfrentado a este mismo problema y hayan creado, de forma totalmente independiente, dos tecnologías que buscan solucionarlo: Thrift [1] y Protocol Buffers [2]. Tanto Facebook como Google necesitaban una forma de poder comunicar sistemas informáticos desarrollados en diferentes lenguajes de programación para que pudiesen intercambiar datos entre ellos. Por más que queramos a nuestro querido Python, cuando el rendimiento es una prioridad, no es nuestra mejor opción. Y puede ocurrir también lo contrario: por mucho que nos guste Java, en numerosas ocasiones la velocidad de desarrollo con Python ¡no tiene rival! En este artículo echaremos un vistazo a la tecnología Thrift de Facebook y vere-
WWW.LINUX- MAGAZINE.ES
mos cómo Python puede usarla para comunicarse con un sistema Java que está ganando gran popularidad: ElasticSearch.
Serializando Al acto de transformar un formato interno de datos en algo que podamos transmitir o almacenar de forma externa se le suele denominar serializar . Existe una cantidad inimaginable de formatos que podemos usar para serializar datos, y Python viene de serie con varias opciones: • XML • JSON • Pickle • Sqlite Todos ellos cuentan con ventajas e inconvenientes. XML es uno de los formatos más extendidos del mundo. Al ser un formato de texto es fácilmente manipulable, y es posible editarlo a mano. Su nivel de complejidad es seleccionable, podemos hacer que sea tan complejo y almacene tanta información como deseemos. JSON fue la respuesta de la Web a la complejidad de XML. Al igual que él, es un formato de texto, pero su estructura está cerrada. Es sorprendentemente simple y sencillo de manejar, lo que no ayuda demasiado en situaciones complejas. Pickle es en realidad un mecanismo propio de Python para la superlación de objetos. Ningún otro lenguaje parece dis-
INFRAESTRUCTURAS
poner de soporte para él, y cuenta con al menos dos versiones. Cualquier objeto serializable en Python puede serializarse con Pickle y recuperarse de nuevo intacto. Aunque parezca una burrada, Sqlite puede considerarse un formato de serialización. En principio no existe nada que nos impida usar bases de datos Sqlite como formato para transportar nuestros datos entre aplicaciones. Será lento, pero funcionará. Todos estos formatos tienen algún tipo de problema, ya sea la complejidad de XML, la extrema simplicidad de JSON, la falta de interoperabilidad de Pickle o la lentitud de usar Sqlite. Cuando la serialización es vital para el funcionamiento de nuestros sistemas, necesitamos algo más potente.
Instalación de Apache Thrift Thrift es un protocolo de serialización binario y tipado que define tanto datos como servicios (ver Figura 1). Al ser binario es mucho más eficiente que los formatos de texto, y puede enviar la misma cantidad de información de forma más compacta, ahorrando ancho de banda. Además está tipado, lo que significa que toda información que se transmita será de un tipo de dato determinado. Esto es imprescindible si queremos ser capaces de intercambiar datos con lenguajes tipados como C#, Java o C++. Podemos descargar el código fuente de Thrift desde el enlace que aparece en el Recurso 1. Para poder compilar Thrift necesitaremos disponer de flex, así como de la librería de desarrollo Boost en nuestro sistema (en Ubuntu necesitaremos el paquete libboost-dev, por ejemplo). Una vez la tengamos instalada deberemos descomprimir el fichero, compilarlo e instalarlo. Es recomendable ejecutar el configure indicando los lenguajes para los que no queremos generar un compilador, puesto que tratará de generar los compiladores de todos los lenguajes: shell$ ./configure U -without-javaU --without--csharp ... shell$ make shell$ sudo make install
Podemos comprobar que se ha instalado correctamente ejecutando el compilador de Thrift:
PYTHON
55
INFRAESTRUCTURAS
Thrift
Ya tenemos todo lo necesario para usar Thrift, pasemos a usarlo.
Necesitamos un componente más para poder hacer uso de Thrift: la librería python thrift . Instalarla es mucho más sencillo: shell$ pip install thrift
Thrift funciona como un compilador (Figura 2) que acepta una descripción de los datos y servicios, la interfaz, que vamos a utilizar, y genera a partir de ella una librería en el lenguaje de destino que codificará y decodificará ese formato en el lenguaje de programación que le indiquemos. Es más sencillo verlo con un ejemplo. Digamos que queremos disponer de un servicio llamado hola que acepta una cadena de texto y devuelve otra cadena de texto. Lo primero que necesitaremos es crear un fichero de descripción en el formato de Thrift como el que aparece en el Listado 1. Una vez tengamos el fichero listo, podemos generar el código Python con el siguiente comando: shell$ thrift -gen pyU hola.thrift
El comando generará un directorio llamado gen-py que contendrá el módulo que vamos a usar. Debemos copiar el módulo hola al directorio en el que vayamos a ejecutar tanto el script del Listado 2 como el del Listado 3. El código del Lis-
tado 2 genera un servidor de red que responderá a la interfaz declarada en el fichero hola.thrift , mientras que en Listado 3 se encuentra el código que usará este servicio. Para verlos en funcionamiento tendremos que arrancar primero el servidor en un terminal: shell$ python servidor.py Arrancando el servidor...
Y el cliente en otro terminal: shell$ python cliente.py Hola mundo shell$
¡Ha funcionado! Thrift nos permite arrancar un servidor de red con el servicio que hemos definido. La librería se encarga de prácticamente todo, lo que nos permite concentrarnos en crear el código fuente de nuestro servicio. Pero… ¿es Thrift rápido? Hagamos una prueba. Con el servidor aún arrancado, vamos a mandar
Listado 2: Fichero servidor.py 01 #!/usr/bin/env python 02 03 import sys 04 05 from hola import Saludos 06 from hola.ttypes import * 07 08 from thrift.transport import TSocket 09 from thrift.server import TServer 10 11 ## Servicio 12 class SaludosHandler:
Listado 3: Fichero cliente.py 01 import sys 02 from hola import Saludos 03 from hola.ttypes import * 04 from hola.constants import * 05 06 from thrift import Thrift 07 from thrift.transport import TSocket 08 from thrift.transport import TTransport 09 from thrift.protocol import TBinaryProtocol
56
PYTHON
WWW.LINUX- MAGAZINE.ES
Thrift
10000 mensajes mediante el código del Listado 4: shell$ time python U test_velocidad.py real 0m1.715s user 0m0.820s sys 0m0.156s
No está nada mal, siendo Python, y sin usar ninguna optimización. Podemos parar el servidor pulsando la combinación de teclas Control+C.
Cómo Funciona el Código Fuente Analicemos el código del Listado 2. Cargamos el módulo hola resultado de nuestra definición en el fichero hola.thrift , y que se encontraba dentro del directorio gen-py. Este módulo es en realidad el nombre del propio fichero, que Thrift ha convertido en módulo, por lo que hay que tener cuidado con el nombre que demos al fichero .thrift . Dentro del fichero hemos definido un servicio llamado Saludos. Thrift nos permite reunir grupos de funciones y variables bajo servicios. Así es muy sencillo organizar nuestro código. Pasamos a cargar el fichero ttypes que contiene todas las funciones, objetos y variables que necesitaremos para usar Thrift. Nuestro servicio será un objeto Python con métodos que tengan los mismos nombres y parámetros que definimos en el fichero hola.thrift . Por convención se añade la palabra Handler al nombre del servicio que vamos a implementar, en nuestro caso SaludosHandler . Mediante el método Saludos.Procesor(), indicamos qué objeto implementará la interfaz definida. Al objeto resultante se le suele llamar processor , puesto que su función será procesar peticiones. En este punto podemos elegir cómo vamos a usar nuestro procesador. Thrift debe trabajar sobre algún protocolo deco-
municaciones, ofreciendo varias posibilidades dependiendo del lenguaje de programación que usemos. En Python es posible usar un socket, el protocolo http o Twisted. Por simplicidad vamos a usar un socket, que es el protocolo de más bajo nivel, mediante la clase TSocket . Sobre el protocolo de comunicaciones debemos montar un servidor, TServer , que atienda los mensajes que lleguen y se los pase al procesador. Como puedes ver, los nombres son bastante descriptivos. Thrift nos obliga aún a hacer algunas elecciones. Debemos indicar al servidor qué clase de protocolo vamos a usar – en nuestro caso TBinaryProtocol – y cómo queremos que se comporte el servidor, usando un búfer con TBufferedTransport . Thrift es configurable y nos ofrece diferentes opciones para casi todo. Podríamos haber seleccionado un protocolo basado en JSON mediante TJSONProtocol, por ejemplo. Ya sólo nos falta arrancar el servidor, instanciando por ejemplo TSimpleServer y llamando al método server() que se bloqueará mientras no lleguen mensajes.
ElasticSearch Como ejemplo del uso de Thrift vamos a crear un pequeño programa Python que emplee esta tecnología para interactuar con el motor de búsqueda de moda: ElasticSearch [3]. ElasticSearch está revolucionando el mundo de los motores de búsqueda. Ofreciendo el rendimiento de Solr/Lucene, pero añadiendo la capacidad de trabajar de forma distribuida, reparte el índice de búsqueda entre varias máquinas de forma automática. Está programado en Java y ofrece varios protocolos de trabajo, siendo posible comunicarse con el servidor ElasticSearch mediante Rest sobre http o Thrift (Figura 3). Para instalar ElasticSearch sólo tenemos que descargarlo desde la dirección del Recurso 3 :
INFRAESTRUCTURAS
Figura 2: Http vs Thrift.
shell$ wget -c U https://github.com/downloads/U elasticsearch/elasticsearch/U elasticsearch-0.16.2.tar.gz shell$ tar zxpf U elasticsearch-0.16.2.tar.gz shell$ cd elasticsearch-0.16.2 shell$ cd bin shell$ ./plugin -install U transport-thrift shell$ ./elasticsearch -f
¡Listo! Ya tenemos funcionando un motor de búsqueda con índice distribuido y que se comunica usando Thrift. Es normal que ElasticSearch se esté ganando el corazón de muchos desarrolladores. Debemos generar el módulo de la interfaz de Thrift para Python. Para ello debemos descargar el fichero elasticsearch.thrift de la dirección que aparece en el Recurso 4. Y compilarlo: shell$ thirft --gen U py elasticsearch.thrift
Cuando tengamos el directorio gen-py, extraemos de su interior el módulo elas-
Listado 4: Test de Velocidad 01 import sys 02 sys.path.append(‘./gen-py’) 03 04 from hola import Saludos 05 from hola.ttypes import * 06 from hola.constants import * 07 08 from thrift import Thrift 09 from thrift.transport import TSocket 10 from thrift.transport import
WWW.LINUX- MAGAZINE.ES
TTransport 11 from thrift.protocol import TBinaryProtocol 12 13 transport = TSocket.TSocket(‘localhost’, 9090) 14 transport = TTransport.TBufferedTransport(t ransport) 15 protocol = TBinaryProtocol.TBi-
naryProtocol(transport) 16 17 cliente = Saludos.Client(protocol) 18 19 transport.open() 20 21 for i in range(0,10000): 22 cadena = cliente.hola(“mundo”) 23 24 transport.close()
PYTHON
57
INFRAESTRUCTURAS
Thrift
ticsearch y lo ubicamos en el mismo directorio en el que pongamos el script del Listado 5. Cuando lo ejecutemos, éste será el resultado:
shell$ time python busqueda.py [{u’_score’: 0.38431653, U u’_type’: u’articulo’, U u’_id’: u’1’, u’_source’: {u’titulo’: U u’Thrift, Python y U ElasticSearch’}, u’_index’: u’linuxmagazine’}] real 0m0.353s user 0m0.040s sys 0m0.016s
Hemos creado un índice, añadido un modelo de documento, insertado un documento y realizado 100 búsquedas en 300 milisegundos. ElasticSearch trabaja usando una API Rest que acepta comandos codificados en URIs (rutas) mediante los métodos típicos de HTTP. Tanto los datos enviados como los recibidos se codifican en JSON, que podemos codificar y decodificar empleando la librería json de Python. El esquema de trabajo es parecido al que hemos visto con anterioridad. Creamos una conexión usando TSocket , especificamos el tipo de transporte y el protocolo (en este caso una variante del binario) y generamos un cliente. La clase RestRequest ha sido generada por Thrift y tiene cuatro parámetros:
• Método (POST, GET, PUT…) • URI(//….) • Cabeceras (Headers) • Cuerpo del mensaje (Body) Algunos métodos exigen el uso del body (por ejemplo los que requieren el método POST ), mientras que otros sólo requieren el URI (GET ) ¿Y por qué usamos números para el tipo de método usado? Si echamos un vistazo al fichero elasticsearch.thrift veremos que ahí se declaran los números que usaremos para los métodos. En nuestro ejemplo podemos ver diferentes métodos en uso. Crear un índice exige un POST , añadir un modelo, un PUT y hacer una consulta, un GET . Cada llamada de ejecución de un request devuelve un objeto RestResponse con un campo body, en el que encontraremos el resultado codificado en JSON .
Conclusión Thrift puede parecer algo complejo ahora que todos nos hemos acostumbrado a emplear HTTP como protocolo para las peticiones remotas. Pero existen muchas situaciones en las que necesitaremos utilizar un protocolo que consuma menos ancho de banda y ofrezca más rendimiento. Tanto Facebook como Google han tenido que desarrollar su propia tecnología para solventar este problema, y ambos han tenido la gentileza de liberarla como software libre. Y por si fuese poco, ambos sistemas generan código Python, todo un regalo para nuestra ■ comunidad.
Figura 3: Funcionamiento de ElasticSearch.
Recursos [1] Tecnologías Thrift de Facebook: http://thrift.apache.org/ [2] Tecnología Protocol Buffers de Google: http://code.google.com/p/protobuf/ [3] Motor de búsqueda ElasticSearch: http://www.elasticsearch.org/ [4] Fichero thrift para ElasticSearch: https://github.com/elasticsearch/ elas- ticsearch/blob/master/plugins/ trans- port/thrift/elasticsearch.thrift
Listado 5: Interactuando con ElasticSearch 01 from thrift import Thrift 02 from thrift.transport import TTransport 03 from thrift.transport import TSocket 04 from thrift.protocol.TBinaryProtocol import TBinaryProtocolAccelerated 05 06 from elasticsearch import Rest 07 from elasticsearch.ttypes import * 08 09 import json 10 11 socket = TSocket.TSocket(“localhost”, 9500) 12 transport = TTransport.TBufferedTransport(s ocket) 13 protocol = TBinaryProtocolAccelerated(transport) 14 client = Rest.Client(protocol) 15
¿Te acuerdas de cuando cambiaste la versión de Firefox por última vez? ¿Y de por qué instalaste ese programa tan raro que parece no servir para nada ? Yo tengo mala memoria, así que uso un cuaderno de bitácora. Por José María Ruíz y Pedro Orantes Cuaderno de bitácora, fecha estelar
2123…. En todos los libros sobre administración de sistemas se nos recomienda llevar un pequeño cuaderno de bitácora donde ir reflejando las acciones peligrosas que realicemos. De esta manera, se supone, podremos recrear paso a paso los eventos que nos llevaron a un desastre y por tanto ir deshaciéndolos en orden inverso. La cruda realidad es que no todo el mundo usa dichos cuadernos. Es pesado tener que dejar el teclado y coger el bolígrafo para escribir… ¡a mano! ¿no estábamos en la era de los ordenadores? ¿No íbamos a desterrar el papel? Muchas personas usan un weblog en su propia máquina o en Internet para ir apuntando detalles o noticias que le resul-
W W W . L I N U X- M A G A Z I N E . E S
tan de interés. Mucha gente incluso publica sus ficheros de configuración, de manera que siempre pueda acceder a ellos. ¿Y que ocurre si solo lo queremos para nosotros? ¿Y si la máquina a la que estamos accediendo no tiene un servidor web con el software adecuado configurado para tener un weblog? ¿y si no queremos montar tanta parafernalia? Algunas aplicaciones, como KPIM, incorporan ya la opción de llevar un diario personal, pero no funcionan de forma remota a no ser que tengamos una conexión de red con mucho ancho de banda. ¿Qué opciones nos quedan? Podemos volver nuestra mirada a la era antigua de los ordenadores, cuando los interfaces funcionaban exclusivamente desde una
consola de texto. Dichos interfaces aún se utilizan en numerosas aplicaciones, la razón es que son mucho más simples de usar. Es más fácil automatizar el pulsar tres veces TAB que mover el ratón y funcionan mejor remotamente, aún con conexiones lentas. Vamos a diseñar y programar un cuaderno de bitácora en Python, que utilizará ncurses para el interfaz texto y dbm para almacenar las entradas por fecha.
Diseño del Cuaderno Comencemos nuestro diseño echando un vistazo a las librerías en que nos vamos a basar. ncurses fue desarrollada para abstraer, ocultar y simplificar la gestión de terminales texto. Cada fabricante dotaba a su terminal de texto de características
PYTHON
59
LIBRERÍAS
Curses
Figura 1: Hola Mundo en nuestro primer programa curses.
distintas a las del resto, forzadas la mayoría de las veces por una feroz competencia. Esto convertía en una tortura el simple hecho de cambiar un terminal por otro, requiriendo la mayoría de las veces la modificación del programa de turno. ncurses permitía realizar programas sin tener en cuenta las diferencias entre los terminales. No solo eso, sino que además simplificó enormemente la gestión de interfaces de texto como veremos más adelante. dbm es una “base de datos”. Lo pongo entre comillas porque en realidad sólo nos permite almacenar datos, recuperarlos y realizar búsquedas, pero no usando SQL sino llamadas a librerías. es una familia de librerías que nos permiten almacenar datos en un fichero y gestionarlos como si fuesen un diccionario o hash en Python. Cada entrada se compone de una clave y un valor asociado. Si no tenemos que realizar búsquedas complejas, dbm se convertirá en nuestro mejor opción.
Básicamente tenemos que mostrar un interfaz que divida la pantalla en dos partes. En una deberá mostrar las fechas almacenadas, y debe permitir recorrerlas. En la otra debe mostrar el texto relacionado con la fecha indicada. Las acciones serán: • Navegar entradas. • Crear entrada. • Editar entrada. • Borrar entrada. • Salir. Cada una de las acciones se corresponderá con una combinación de teclas. Comenzaremos creando los objetos que gestionen los datos y posteriormente el interfaz con el usuario.
Almacenamiento de datos Debemos conservar el texto asociado a una fecha y hora en algún sitio. Con la fiebre actual por las bases de datos relacionales pocas veces se menciona la existencia otras bases de datos que no cumplen el estándar relacional ni SQL. ¿Realmente se necesita un motor relacional y SQL para cualquier cosa que necesitemos almacenar? Por supuesto que no. Desgraciadamente, cuando sólo tienes un martillo, todo te parece clavos. El problema está en la definición de “base de datos”, dbm lo es pero sin mucha sofisticación. Básicamente nos
Figura 2: Un cuadro de texto curses.
permite almacenar claves y valores asociados a las mismas, así como recuperar el valor o borrar las claves. Ni más, ni menos. La librería dbm necesita un fichero donde depositar los datos que se almacenan. Así, tendremos que darle el nombre de un fichero e indicarle como queremos que lo trate. Puede abrir el fichero para introducir nuevos datos o crearlo de nuevo, aunque ya exista uno con el mismo nombre. Una vez abierto el fichero, un objeto dbm se comporta como un contenedor cualquiera. Podremos hacer uso de la sintaxis “[]” a la que nos tienen acostumbrados la mayor parte de los lenguajes de programación. Como podemos observar en el Listado 1, el uso de la librería dbm es realmente simple. Se comporta como una lista, con todas sus operaciones. El lector se habrá preguntado al ver el código: “¿Dónde está el truco? si dbm represen-
Listado 1: Ejemplo de uso de DBM 01 >>> import dbm 02 >>> datos = dbm.open(‘visitantes’,’c’) # crea el fichero 03 >>> datos[“Juan Jose”] = “vendra el martes” 04 >>> datos[“Juan Jose”] 05 ‘vendra el martes’
Figura 3: Inserción de una nueva entrada en la bitácora.
ta una base de datos ¿por qué puede hacer uso de la sintaxis []?”. La respuesta es que en Python la sintaxis “[]” es lo que en inglés se llama “syntactic sugar”. Por traducirlo de alguna manera, viene a decir que es una manera de hacer agradable visualmente (y a nuestro pobres dedos) la llamada a ciertas funciones del lenguaje. ¿Podemos incorporar “[]” a uno de nuestro objetos y hacer que se comporte como una lista? La respuesta es: ¡Sí! y no tiene nada de complicado. Python reserva unas serie de métodos debido a su uso especial, entre ellos están: • def __len__(self) • def __setitem__(self, clave, valor) • def __getitem__(self, clave) • def __delitem__(self, clave) Estos cuatro métodos los enmascara python posteriormente de la manera mos-
trada en la Tabla 1. Por tanto podemos enmascarar las acciones de un objeto de manera que se use como si fuese un diccionario. Y precisamente eso es lo que hacemos con nuestro objeto Almacen que encubre un diccionario, añadiendo nuevas acciones. El lector puede comprobar el código en el Listado 2 (disponible en [1]).
Curses Curses son unas librerías de bajo nivel. Las abstracciones que crean son muy básicas: preparar consola, crear “ventanas” (nada que ver con las gráficas), escribir en esas ventanas, recoger caracteres y poco más. Debido a ello son bastante complicadas de manejar. Hacer cosas vistosas suele llevar mucho código. Por ello nos vamos a centrar en un interfaz sencillo. Nuestro programa será modal, tendrá un modo de “navegación” y uno de “edición”, al igual que el editor “Vi”. Precisamente “Vi” fue uno de sus primeros usuarios.
Diseño Principal Comenzaremos por inicializar curses. Por desgracia, esto también nos hace perder el control de nuestra consola Python, puesto que anula su funcionamiento. Por ello se pide al lector que ejecute todas las acciones relacionadas con curses desde
LIBRERÍAS
Figura 4: Vista de la bitácora con varias entradas.
un programa Python ejecutable (recuerda hacer el chmod +x ). Podemos ver un programa que inicializa la consola con curses en el Listado 3. Posteriormente escribimos un “Hola mundo” y refrescamos la pantalla, podemos ver el resultado en la Figura 1. Esta parte es vital, si no refrescamos la pantalla curses no mostrará nada. En el Listado 3 stdscr representa toda la pantalla. Es posible crear subventanas y hacer actualizaciones selectivas como podremos comprobar en el código del programa. Una vez realizadas las operaciones, pasamos a dejar la pantalla en una configuración correcta, acción que realizan las cuatro últimas llamadas a funciones. El objeto diario creará a su vez un objeto GUI , que gestiona el interfaz, y el objeto Almacen que se encarga de gestionar la base de datos.
065 066 def long_fecha(self): 067 caja_texto = 2 # el | izquierdo y el | derecho 068 return len(self.fecha()) + caja_texto 069 070 def long_linea_texto(self): 071 return (80 - self.long_fecha()) 072 073 def banner(self, texto): 074 “Muestra el texto en la zona de banner” 075 self.scr_info.clear() 076 self.scr_info.addstr(texto, curses.A_BOLD) 077 self.scr_info.refresh() 078 079 def dibuja_fechas(self): 080 “Genera el listado de fechas de la izquierda” 081 082 self.scr_fechas.clear() 083 pos_x = 3 084 085 # 8 elementos por arriba y abajo 086 min = self.pos_fechas - 8 087 max = self.pos_fechas + 8 088 089 if max > len(self.datos): 090 max = len(self.datos) 091 min = min + (max len(self.datos)) 092 if min < 0: 093 max = max + ( -min) 094 min = 0 095 096 if len(self.datos) > 0: 097 # Marcamos con negrita la fecha sobre la que está el curso 098 # para ello iteramos escribiendo las fechas y cuando la 099 # encontramos le pasamos el atributo de negrita 100 fechas = self.listado_fechas() 101 for fecha in fechas[min:max]: 102 103 fecha_temp = “[“+fecha+”] “ 104 105 if fechas[self.pos_fechas] == fecha: 106 # Hemos encontrado nuestra fecha!!! 107 self.scr_fechas.addstr (pos_x,1,fecha_temp , curses.A_BOLD | curses. A_UNDERLINE)
El objeto Almacen es pasado a GUI como parámetro en su creación. Y la misión de GUI no es otra que al de responder a los eventos que el usuario envíe mediante un bucle infinito.
Dos ventanas Nuestro programa va a disponer de dos ventanas. La mayor hará las veces de “tablón” donde podemos ver las anotaciones realizadas por el momento. Podremos desplazarnos arriba y abajo por él. Para indicar qué fecha es la que tenemos seleccionada la distinguiremos iluminándola en negrita y subrayándola. La segunda venta hará las veces de barra de ayuda y estado. Cuando cambiemos el estado, por ejemplo al editar, se reflejará ahí. Es el mismo modo de trabajo del que hace gala VIM . Las ventanas deben partir la pantalla de manera que no se solapen. La pantalla de
un terminal tiene 80 columnas de ancho y 25 filas de alto. Dejaremos una fila abajo, que será la que usemos para mostrar información. La 24 filas restantes se encargarán de mostrar las entradas almacenadas.
Desplazamiento por las entradas La ventana de datos nos permitirá desplazarnos arriba y abajo por las entradas. ¿Cómo podemos conseguir recrear este movimiento? La solución es capturando las teclas de los cursores “arriba” y “abajo”. Cuando una de ellas se pulse incrementaremos o decrementaremos una variable que establece la posición la entrada seleccionada en cada momento y volveremos a dibujar, o escribir, la pantalla de datos. Pero no lo haremos de cualquier forma. Queremos que el efecto sea vistoso, así que siempre intentaremos mostrar un
LIBRERÍAS
número fijo de entradas encima y debajo de la nuestra. Como tenemos la posición de la entrada seleccionada, o resaltada, con un sencillo cálculo podemos seleccionar que entradas mostraremos. Las listas en Python tienen una funcionalidad que nos será muy útil. Usando la sintaxis lista[comienzo:fin] podemos extraer los elementos entre comienzo y fin formando una nueva lista. Simplemente tenemos que seleccionar aquellos que estén a una distancia fija del seleccionado y usarlos como comienzo y fin. Podemos ver el código que realiza esta acción en el método dibuja_fechas(self) del GUI en el Listado 6.
Textbox Python provee de una herramienta muy útil para la edición de textos dentro de curses. Desgraciadamente, a pesar de su
potencia posee algunos inconvenientes de los que hablaremos más tarde. Esta herramienta es el objeto Textbox que se encuentra en la librería curses.text pad. Textbox nos permite editar un texto dentro de una ventana y poder utilizar muchas de las combinaciones de teclas que soporta EMACS. Así por ejemplo con “control+e” iremos al final de la linea que estemos editando y con “control+d” borraremos el carácter sobre el que nos encontremos. Utilizaremos un Textbox para recoger el texto que el usuario quiera introducir. Desgraciadamente posee una limitación debido su diseño: Si cuando estamos editando el texto, pulsamos repetidas veces el cursor izquierdo desplazándonos hasta dar con el borde de la ventana, el programa fallará. El soporte de curses de Python se basa en las librerías originales escritas en C , y como ya hemos dicho son de muy bajo nivel. La implementación de Textbox es realmente básica y no controla todas las circunstancias. Aún así servirá. Un ejemplo de utilización de Textbox aparece en su propio código fuente, ver Listado 4 y Figura 2. Este código genera un rectángulo con bordes (usando la función rectangle de curses.textpad) y nos solicita que escribamos algo en el mismo. Para acabar debemos pulsar control+g , mostrándonos lo escrito más abajo. Si lo probamos comprobaremos que no podemos salir del rectángulo al editar. En la Figura 3 vemos como hemos integrado el Textbox en nuestro programa. Hemos aumentado el número de columnas para permitir introducir mensajes más largos.
El Gestor de Comandos Existen muchas maneras de hacer un gestor de comandos. La más típica consiste en hacer una sentencia switch o gran can-
tidad de if s anidados, cada uno de los cuales responde ante una tecla o combinación distinta. El código generado llegar a convertirse en ilegible en cuanto el número de comandos sobrepasa los diez. Hay una manera mucho más elegante de atacar este problema, pero no es tan fácil hacer uso de ella en todos los lenguajes. Afortunadamente Python nos permite una implementación muy sencilla. La idea es la siguiente: Cada comando estará asociado a una serie de acciones a realizar. Englobaremos las acciones vinculadas con cada comando a un método de nuestro objeto “GUI”. Hasta aquí todo es bastante normal. Ahora viene la magia. Python nos permite invocar métodos de objetos usando su nombre. Si declaramos el objeto persona:
>>> class Persona: ... def habla(self): ... print "hola mundo" ... >>> Podemos invocar el método habla usando una cadena con su nombre mediante el método getattr(), que precisa de la instancia del objeto y el método a invocar. Devuelve, por así decirlo, una referencia al método en cuestión que funciona de la misma manera. Como dicen por ahí, “una imagen vale más que mil palabras”:
>>> pepe = Persona() >>> pepe.habla() hola mundo >>> (getattr(pepe, "habla"))() hola mundo >>> Lo que haremos será crear una lista de listas, cada una de las cuales contendrá dos elementos. El primero será un carácter y el segundo el nombre del método a invo-
Tabla 1: Algunos métodos especiales de Python Método
Descripción
__len__(self)
devuelve la longitud de nuestro objeto. Se invoca cuando se ejecuta len(miObjeto)
__setitem(self, clave,valor)
se corresponde con la asignación miObjeto[“Algo”] = “otra cosa”
en
un
es el equivalente miObjeto[“Algo”] y devuelve la información almacenada en “Algo”.
__delitem(self, clave)
es del miObjeto[“Algo”] y se corresponde con la eliminación de esa entrada.
PYTHON
Uso del Programa El uso del programa se ha hecho lo más simple posible, el aspecto del mismo se puede ver en la Figura 4. Cuando se pulsa “n” se crea una nueva entrada con la fecha y la hora, si existe ya una entrada con la fecha y la hora no se hace nada. Con “d” se elimina una entrada y con “e” se edita. Cuando se está introduciendo un texto, al pulsar “control+g” se guarda. Para salir se pulsa “q” y con los cursores “arriba” y “abajo” nos desplazamos por la lista. Al fichero de almacenado se le ha dado el nombre “diario.db”. Si no existe se crea, y si existe se emplea el existente.
Conclusión Aunque el uso de Curses puede resultar engorroso, Python nos provee de una librería que las manipula dentro su instalación base. Una vez realizado el programa sabremos que cualquiera que instale Python podrá hacer uso de él. Siempre es posible realizar una serie de objetos que realicen tareas de más alto nivel. Existen librerías que nos proporcionan barras de menús y widgets más avanzados. Aún así, siempre es bueno estar lo más cerca posible del estándar. La próxima vez que tengas que hacer un interfaz en modo texto puede que sea una buena idea darle una oportunidad a ■ curses.
diccionario:
__getitem(self, clave)
64
car. De esta manera, nuestro gestor de comandos se reduce a un código que recibe un carácter, lo compara con el primero elemento de cada entrada en su lista de comandos y si encuentra una coincidencia ejecuta el comando asociado. Ver Listado 5. Como podemos ver en el código, se comprueba si el carácter recibido es “imprimible” y posteriormente se busca en la lista de comandos. En caso de coincidencia se ejecuta usando como instancia self . De esta manera, es posible manipular el funcionamiento ante qué caracteres responde el programa sin tener que modificar el código fuente. Esto nos da mucha flexibilidad y es menos propenso a errores.
Recursos [1] Descargas de los listados de este artículo: http://www.linux-magazine.es /Magazine/Downloads/Especiales/06_ Python
W W W . L I N U X- M A G A Z I N E . E S
3D con VTK
Visualización 3D con VTK (Visualization Toolkit)
Gráficas 3D Hoy por hoy, la representación gráfica 3D y su visualización forman parte de nuestra vida cotidiana; basta fijarse en el mundo del entretenimiento, en la industria del juego y en el soporte de hardware y software para tales fines. ¿Quién en su ordenador personal no ha instalado un juego o visto una película renderizada en 3D? Por Ana M. Ferreiro Ferreiro y José A. García Rodríguez
La representación gráfica en 3D ofrece la posibilidad de crear mundos virtuales en un ordenador, lo cual, unido a la visualización permite al usuario explorar y entender, rápidamente, sistemas complicados. Esto es posible gracias al avance de lenguajes orientados a objetos, que ofrecen la posibilidad de crear software de mejor calidad y más fácil de mantener. Entre las diferentes herramientas de visualización, representación 3D y procesamiento de imágenes, cabe destacar VTK (Visualization Toolkit), código abierto cuyo núcleo está implementado en C++ y que soporta envolturas (“wrappers”) para TCL, Python y Java, permitiendo el desarrollo de aplicaciones complejas de un modo eficiente y mediante scripts sencillos. Por todo ello, VTK se emplea en la visualización médica, la visualización indus-
trial, reconstrucción de superficies a partir de digitalización láser o nubes de puntos desorganizados, etc. En lo que sigue veremos los conceptos básicos en los que se basa VTK para poder generar una escena y, mediante una serie de ejemplos desarrollados en Python, llegaremos a crear nuestras propias escenas de visualización.
Instalación Para poder realizar todas las pruebas que se van sugiriendo y las que se os ocurran, es necesario tener instalado Python y VTK con soporte para Python. Además, la tarjeta gráfica de nuestro ordenador debe tener OpenGL funcionando. La instalación de las librerías VTK (que no suelen estar instaladas de manera predeterminada) es muy sencilla. Todas las distros mayoritarias cuentan con los paquetes necesarios en sus repositorios. En Debian o Ubuntu, por ejemplo, bastará con ejecutar
LIBRERÍAS
realizando. Por un momento, imaginad que estáis en la butaca del cine, viendo una película de animación, como por ejemplo “La Edad de Hielo”. Si nos centramos en una única escena y la describimos, vemos personajes animados (actores), luces de diferentes tonalidades, cámaras que modifican el punto de vista, propiedades de los personajes (color, forma, etc.). Aunque no lo creáis, todos estos conceptos son la base de la visualización gráfica. Veamos dicha estructura. El toolkit de visualización VTK está diseñado a partir de dos modelos claramente diferenciables: el modelo gráfico y el modelo de visualización. • Modelo gráfico. El modelo gráfico captura las principales características de un sistema gráfico 3D, de un modo fácil de entender y usar (ver Figura 1). La abstracción se basa en la industria del cine. Los objetos básicos que constituyen este modelo son: vtkRenderer , vtkRenderWindow , vtkLight , vtkCamera , vtkProp , vtkProperty , vtkMapper , vtkTransform. En la Tabla 1 se describen cada uno de estos objetos. • Modelo de visualización. El papel del modelo gráfico es transformar datos gráficos en imágenes, mientras que el del modelo de visualización transforma información en datos gráficos; esto significa que el modelo de visualización es el responsable de construir la representación geométrica que se renderiza mediante el modelo gráfico. VTK se basa en la aproximación de los datos para transformar la información en datos gráficos. Hay dos tipos básicos de objetos, descritos en la Tabla 2, involucrados en dicha aproximación: vtkDataObject y vtkProcessObject .
apt-cache search vtk
para ver las que necesitamos.
Modelos de Objetos VTK
Figura 1: Estructura del modelo gráfico.
WWW.LINUX MAGAZINE.ES
-
Para los inexpertos en el mundo de la visualización, vamos a explicar de un modo sencillo la estructura de VTK, ya que esto permite que comprendamos mejor cada uno de los pasos que iremos
Figura 2: Tipos de datos: a) datos poligonales, b) puntos estructurados c) malla no estructurada d) malla estructurada.
PYTHON
65
LIBRERÍAS
3D con VTK
Los diferentes tipos de datos que pueden constituir un objetos son, entre otros, puntos, rectas, polígonos, puntos estructurados, mallas estructuradas y no estructuradas, etc. (ver Figura 2).
Mi Primera Escena Ya estamos preparados para construir nuestra primera escena. Situaros en el papel de director de cine. En los siguientes ejemplos veremos el modo de emplear las clases que acabamos de describir. Para ello, tal como se menciona al comienzo, instanciaremos VTK desde Python. Con cualquier editor de textos, creamos el fichero cone.py . Lo primero es importar desde Python el paquete VTK; esto es tan sencillo como escribir la siguiente línea: import vtk
Ahora que ya podemos instanciar cualquier objeto de VTK, sin más que escribir vtk.nombre_clase, necesitamos crear nuestra ventana de renderizado vtk.vtkRenderWindow , a la que llamaremos renWin y a la que asociamos un área de renderizado vtk.vtkRenderer (que denominamos ren), mediante el método AddRenderer(). Escribamos las siguientes líneas de código:
Para poder manipular la cámara mediante el ratón se ha instanciado el objeto vtkRenderWindowInteractor (denominado en el código como iren). Nótese que la ventana de renderizado renWin se asocia al objeto de interacción iren mediante el método SetRenderWindow. En este momento no se aprecia la utilidad del mismo, paciencia… ya comprenderéis su importancia cuando tengamos un actor en nuestra escena. Guardamos el fichero y en la línea de comandos ejecutamos el programa tecleando python cone.py… ¡No ocurre nada! Esto es porque debemos inicializar la interacción del usuario e indicar que la ventana de renderizado permanezca visible hasta que el usuario finalice la ejecución de la misma cerrándola. Para ello basta escribir iren.Initialize() iren.Start()
sus botones de minimizar, maximizar y cerrar; y que sólo se cierra cuando el usuario lo estima oportuno (Figura 3). Esta ventana va a ser “el contenedor” de nuestra pequeña escena. Nótese que las dos líneas de código que acabamos de escribir deben de estar al final del fichero. Las demás líneas que escribamos a partir de este momento debemos situarlas justo antes. Para crear nuestro primer actor no nos vamos a complicar demasiado, porque ya queremos ver algo. VTK contiene una serie de clases que nos permiten crear objetos tridimensionales sencillos, como son: esfera (vtkSphereSource), cono ( vtkConeSource), cilindro ( vtkCilinderSource), etc. Para nuestro ejemplo hemos escogido un cono, sin embargo, puedes optar por cualquiera de los otros objetos. El siguiente código nos permite crear nuestro primer “actor”, cone=vtk.vtkConeSource() coneMapper=vtk.U vktPolyDataMapper() coneMapper.SetInput(cone.U GetOutput()) coneActor=vtk.vtkActor() coneActor.SetMapper(coneMapper)
Si ejecutamos nuevamente el programa, se abre una ventana de color negro con
Mediante el objeto vtk.vtkConeSource creamos una representación poligonal
18 esferaActor.SetMapper (esferaMapper) 19 esferaActor.GetProperty().SetColor(0.7,0.0,0.25) 20 esferaActor.GetProperty(). SetOpacity(0.75) 21 esferaActor.GetProperty(). SetLineWidth(1) 22 23 # Creamos: Renderer, Render Window, RenderWindowInteractor 24 ren = vtk.vtkRenderer() 25 renWin = vtk.vtkRenderWindow() 26 renWin.AddRenderer(ren) 27 iren = vtk.vtk RenderWindow Interactor() 28 iren.SetRenderWindow(renWin) 29 30 # Añadimos el actor en el área de renderizado (Renderer) 31 ren.AddActor(coneActor) 32 ren.AddActor(esferaActor) 33
34 #Fijamos el color de fondo, el tamaño y hacemos zoom sobre 35 #el area de Renderizado 36 ren.SetBackground(1, 1, 1) 37 renWin.SetSize(450, 425) 38 camera=ren.GetActiveCamera() 39 ##camera.Zoom(1.5) 40 41 coneActor.RotateX(30) 42 coneActor.RotateY(45) 43 conepro=coneActor.GetProperty() 44 conepro.SetColor(0,0.6,1) 45 ##conepro.SetOpacity(0.5) 46 conepro.SetLineWidth(2) 47 ren.ResetCamera() 48 ##camera=ren.GetActiveCamera() 49 camera.Zoom(1.5) 50 51 cone.SetResolution(40) 52 53 iren.Initialize() 54 renWin.Render() 55 iren.Start():
Listado 1: cono_esfera.py 01 import vtk 02 03 # Generamos la estructura para ver un cono 04 cone = vtk.vtkConeSource() 05 coneMapper = vtk.vtk PolyDataMapper() 06 coneMapper.SetInput(cone. GetOutput()) 07 coneActor = vtk.vtkActor() 08 coneActor.SetMapper(coneMapper) 09 10 # C r e a r f u e n t e d e e s f e r a , mapeador y actor 11 esfera = vtk.vtkSphereSource() 12 esferaMapper = vtk. vtkPolyDataMapper() 13 esfera.SetPhiResolution(10) 14 esfera.SetThetaResolution(20) 15 esfera.SetCenter(0.3,0.0,0.0) 16 esferaMapper.SetInput(esfera. GetOutput()) 17 esferaActor = vtk.vtkActor()
66
PYTHON
WWW.LINUX MAGAZINE.ES
-
LIBRERÍAS
3D con VTK
Tabla 1: Modelo Gráfico
Figura 3: Pasos que en general hay que
Objeto
Descripción
vtkRenderer
crea un área de renderizado que coordina: luces, cámaras y actores.
vtkRenderWindow
clase que representa el objeto dentro del cual se colocan una o más áreas de renderizado (vtkRenderer).
vtkLight
objeto que permite manipular las luces de la escena. Cuando se crea una escena, por defecto se incluyen luces.
vtkCamera
objeto que controla como una geometría 3D es proyectada dentro de la imagen 2D durante el proceso de renderizado. La cámara tiene diferentes métodos que permiten definir el punto de vista, el foco y la orientación.
vtkProp
objeto que representa los diferentes elementos (actores) que se sitúan dentro de la escena. Caben destacar las siguientes subclases: vtkActor, vtkVolume, vtkActor2D.
vtkProperty
representa los atributos de renderizado de un actor, incluyento color, iluminación, mapeado de la estructura, estilo de dibujo y estilo de la sombra.
vtkMapper
representa la definición de la geometría de un actor y mapea los objetos mediante una tabla de colores (vtkLookupTable). El “mapper” proporciona la frontera entre el modelo de visualizión y el modelo gráfico.
vtkTransform
objeto consistente en una matriz de transformación 4x4 y métodos para modificar dicha matriz. Especifica la posición y orientación de actores, cámaras y luces
seguir para crear un actor.
de un cono, que hemos llamado cone. La salida del cono (cone.GetOutput()) es un conjunto que se asocia al “mapper” (coneMapper ) (vtk.vtkPoly DataMapper ) vía el método SetInput() . Creamos el actor (objeto que se va renderizar) al que se le asocia la representación geométrica que aporta coneMapper . Nótese que los pasos aquí indicados son los que, en general, necesitamos seguir para poder construir un actor (Figura 4). Cuando creamos un actor, no se incluye por defecto en la escena. Es necesario añadirlo al Renderer mediante AddActor , y posteriormente renderizar la escena. Esto se logra escribiendo, ren.AddActor(conoActor) renWin.Render()
Si volvemos a ejecutar, visualizamos un cono de color gris (color que se muestra por defecto) dentro de nuestra ventana (Figura 5). Además, es en este instante cuando se aprecia la interacción con el ratón; con el botón izquierdo puedes rotar la cámara, el botón central permite trasladarla, y con el botón derecho nos acercamos o alejamos del objeto. Además, habrás observado que en la escena, por defecto se incluye una luz para poder visualizar los objetos iluminados.
Figura 4: Ventana de renderizado por defecto.
WWW.LINUX MAGAZINE.ES
-
Tabla2: Modelo de Visualización Objeto
Descripción
vtkDataObject
clase genérica que permite representar diferentes tipos de datos. Los objetos de datos consisten en estructuras geométricas y topológicas (puntos y celdas), y también en atributos asociados, tales como escalares o vectores.
vtkProcessObject
objeto que hace referencia a filtros, que actúan sobre los actores modificándolos.
Prueba a comentar la línea renWin.Render() . ¿Qué ocurre? Como habrás podido observar el cono ya no aparece, esto es porque cada vez que añadimos un actor es necesario renderizar la escena, ya que de lo contrario no se realiza un refresco de la misma y es como si no hubiésemos añadido un nuevo actor.
Habrás observado que la ventana de renderizado se abre con un tamaño predeterminado. Para fijar el tamaño de dicha ventana es necesario emplear el método SetSize, donde indicamos el alto y el ancho en pixels, renWin.SetSize(450,325)
Propiedades de Objetos
Si has seguido el tutorial hasta este punto, habrás creado tu cono de color gris. Pero probablemente no estés demasiado satisfecho, porque todos tenemos el mismo cono gris y tú lo querías blanco y el fondo azul, por ejemplo. A lo largo de este apartado veremos cómo modificar la ventana de renderizado, la cámara, propiedades del actor, etc. Al final, podrás realizar todos Figura 5: Cono dentro de aquellos cambios que te la escena. apetezcan.
Figura 6: Comportamiento de los métodos de la cámara. a) Pitch -
Azimuth
- flechas rojas; b)
flechas azul celeste; c) Yaw - flechas
azul oscuro; d) Elevation - flechas verdes; e) Roll -
flecha amarilla. La esfera blanca repre-
senta el foco.
PYTHON
67
LIBRERÍAS
3D con VTK
Si lo que pretendemos es cambiar el color de fondo de la escena ( vtkRenderer ) empleamos el método SetBack ground (RGB), donde le pasamos el color deseado en formato RGB. Si queremos un fondo azul bastaría escribir ren.SetBackground(0.0, 0.0, 1)
Como dijimos, el área de renderizado (vtkRenderer ) coordina la cámara y las luces. Mediante el método GetActiveCamera() se accede a la cámara creada en la escena, así podemos aplicarle todos los métodos del objeto vtkCamera para poder modificar la visualización según queramos. Si lo que pretendemos es que todos nuestros actores se vean en su totalidad dentro del área de renderizado, es necesario llamar al método ResetCamera(). En las siguientes líneas se recogen algunos de los métodos relativos a la cámara ren.ResetCamera() camera=ren.GetActiveCamera() camera.Azimuth(60) camera.Pitch(5) camera.Yaw(5) camera.Roll(50) camera.Elevation(20) camera.Zoom(1.5)
Los métodos Azimuth , Pitch , Yaw, Roll, Elevation se ocupan de rotar la cámara o el punto de foco en diferentes direcciones y, como argumento, se pasa un ángulo de rotación. Lo mejor es que juegues un poco con la cámara y veas lo que ocurre probando cada uno de estos métodos por separado. Por ejemplo, para ver cómo afecta el método Azimuth aplicado a la cámara, comenta las restantes lineas de código, por que si no estarías
Figura 8: Vista de la malla del cono.
68
PYTHON
mezclando distintos métodos de rotación y uno así no sabe realmente lo que ocurre. Si en algún momento el actor desaparece de la escena no te preocupes, lo que Figure 7: Vista de la superficie Figura 9: Escena con dos actores está sucediendo del cono. que se intersecan. es que el ángulo de rotación ha colocado la cámara justo en un punto La línea conepro.SetResolution(40) que evita que visualicemos el objeto modifica la resolución con la que se rendentro de la escena. En la Figura 6 se deriza el cono. Este método no es general explica de un modo sencillo el modo en para todos los actores, sino para ciertos que actúan cada uno de estos métodos objetos que VTK ya incluye, como son: respecto del foco (representado por una esfera (vtkSphereSource), cono (vtkConeSource), cilindro ( vtkCilinderSource ), etc. esfera blanca). A partir de este punto comentad las Cualquier objeto puede rotarse, líneas de código correspondientes a los escalarse, obtener su dimensiones, etc., métodos que actúan sobre la cámara, utilizando las propiedades de un vtkActor dejando únicamente la línea cameen particular(si queréis más información, ra.Zoom(1.5). Así vamos viendo cada basta consultar las ayuda de VTK sobre cosa por separado, después ya tendréis vtkProp3D, que es la clase padre). Para tiempo de mezclar código. rotar nuestro cono y escalarlo basta Ahora que sabemos modificar la escribir escena, debemos recordar que el cono coneActor.RotateX(30) continúa viéndose en un color gris un coneActor.RotateY(45) poco apagado. Para acceder a las coneActor.SetScale([1,3,2]) propiedades de cualquier actor vtkActor se emplea el método GetProperty(), que devuelve una instancia del objeto Ahora ya sabéis crear vuestra propia vtkProp asociado a dicho actor. Las escena, modificar sus propiedades, siguientes líneas permiten modificar el añadir un actor con las opciones que color, la transparencia y grosor de las queráis y modificar la cámara. En caso líneas: de que quisierais añadir más actores a vuestra ventana de renderizado, basta conepro=coneActor.GetProperty() seguir el mismo procedimiento que conepro.SetColor(1,0.2,0) hemos empleado para crear nuestro conepro.SetOpacity(0.5) cono. En el Listado 1 se añade a la conepro.SetLineWidth(3) escena un cono y una esfera que se interconepro.SetResolution(40) ■ secan (Figura 9). conepro.U SetRepresentationToWireframe() Recursos La última línea de este código se indica que queremos ver la estructura básica que constituye el actor, es decir, el mallado. Por defecto, VTK tiene asociadas teclas rápidas a la escena: si tecleas la letra “s” se ven todos los objetos renderizados (ver Figura 7), mientras que si tecleas la letra “w”, se visualiza sólo la malla (ver Figura 8). Ahora apreciarás mejor la diferencia entre mallado y estructura renderizada, no hay nada mejor que poder ver las cosas.
[1] RPMs VTK de Mandrake: ftp://ftp.rediris.es/sites3/carroll.cac. psu.edu/mandrakelinux/official/10.1/ i586/media/contrib/ [2] Kitware. VTK: http://www.kitware.org [3] Enthought. Scientific python: http://www.scipy.org [4] MayaVi: http://mayavi.sourceforge.net [5] Código de este artículo: http://www. linux-magazine.es/Magazine/Down- loads/Especiales/06_Python
WWW.LINUX MAGAZINE.ES
-
PI L
LIBRERÍAS
Imágenes satélite en Python
Vigilantes del Planeta ¿Quién no ha querido alguna vez sentirse como esos informáticos de la NASA en su centro de control? Hoy nos construiremos el nuestro y controlaremos el p laneta y sus alrededores. Por José María Ruíz y Pedro Orantes
Cada vez que vemos el lanzamiento de
un cohete, todos quedamos asombrados ante la explosión del despegue, la atenta mirada de todos esos científicos a los paneles de control, y la monstruosa cifra que nos dicen que se han gastado en el proyecto.
¿ Donde Van los Impuestos? Es entonces cuando surge la pregunta ¿y eso a mí en qué me repercute? Un día, estando en el despacho de la Rama del IEEE de Málaga tuve una conversación en la que me contaron que la mayor parte de los satélites emiten “al mundo” las imágenes y los datos que recogen. Es decir, si se posee el equipo necesario es
W W W . L I N U X - M A G A Z I N E . E S
posible recibir en tu propia casa imágenes fascinantes del universo, de Marte o de la Tierra. La temperatura del océano, imágenes meteorológicas, imágenes del campo magnético del sol o de las misiones a Marte son enviadas constantemente a la Tierra desde estos engendros espaciales. Y el efecto es siempre el mismo, el espectador es deslumbrado por el presentador de televisión con unas imágenes increíbles mientras se escuchan acordes de sintetizador. ¿Acaso no son esas imágenes de dominio público? ¿Dónde puedo conseguirlas? En el presente artículo utilizaremos Python para crear un script CGI que nos
permita recoger y mantener actualizadas las imágenes que queremos en una especie de “collage” o mural. Construiremos nuestro propio centro de control espacial.
Recoger las Imágenes Lo primero será encontrar las imágenes y reunirlas. Vamos a usar como ejemplo cuatro imágenes de carácter científico. Se actualizan a distintos intervalos, de manera que podremos ver cómo evolucionan las eventos que se registran. Puedes encontrar las URLs en Recursos [1]. Debemos descargar las imágenes y almacenarlas dentro de nuestro progra-
PYTHON
69
LIBRERÍAS
PI L
La librería httplib de Python establece en un primer paso una conexión con el servidor remoto mediante el método HTTPConnection >>> c = httplib.HTTPConnectionU ("www.linux-magazine.es") >>>
En la variable c almacenamos el objeto que representa la conexión realizada y podemos enviar peticiones. Figura 1: La imagen original que vamos a modificar con PIL.
ma; haremos uso de la librería httplib, que es parte de la distribución estándar de Python. Esta librería nos permitirá hablar de tú a tú con un servidor web remoto sin tener que preocuparnos de los detalles de más bajo nivel. Esta conversación la realizaremos usando el protocolo HTTP . Este protocolo es bastante simple, y de él solo necesitaremos una parte mínima. Cuando Tim Berners Lee realizó el diseño original de la Web, quiso que el protocolo para pedir los documentos fuese lo más simple posible. HTTP se reduce a la recepción y el envío de información al servidor, eso y sólo eso. Se compone de varios comandos, pero los más conocidos son GET , que podemos traducir como “tomar”, y POST , que podemos traducir en este contexto como “enviar” o “mandar”. Así que tomamos documentos y enviamos información. Una parte importante de HTTP es URL, que nos sirve para darle nombre a esos documentos. Todos estamos acostumbrados a tratar con urls, generalmente del http://www.linux-magazine. es/ tipo issue/08. La url se compone de: [protocolo]://[maquina]/[ruta]/[objeto]. Vamos la ver ahora porqué es tan importante que sepamos esto.
Figura 2: La imagen del pequeño demonio de
>>> c.request("GET","/issue/08") >>>
Usamos el comando GET, con lo que estamos solicitando un objeto. El segundo parámetro del método es la “ruta” hasta el objeto. Así que la URL que estahttp://www. mos solicitando es linux-magazine.es/index.html. Es importante que la ruta comience con una barra “/”, como si fuese la ruta de un fichero de una máquina. ¿Cómo sabemos si todo ha ido bien? >>> r = c.getresponse() >>> print r.status,r.reason 200 OK >>>
Con getresponse podemos conseguir un objeto que representa los datos devueltos por la conexión. Este objeto tiene, entre otros, los atributos status y reason que nos indican el estado, un número con un significado especial, y la explicación del mismo. En este caso todo ha ido bien, y por eso recibimos un “OK”. En caso contrario, si no existiese la ruta que pedimos habríamos obtenido: >>> r = c.getresponse() >>> print r.status, r.reason 400 Bad Request >>>
Cuando hayamos finalizado debemos cerrar la conexión invocando el método close() del objeto que representa la conexión, en este caso sería: >>> c.close() >>>
Para obtener las imágenes vamos a hacer exactamente lo mismo, abriremos una conexión, pediremos la imagen, la almacenaremos en un diccionario y cerraremos la conexión.
Python Imaging Library Nuestra idea original era realizar un mural o collage con las imágenes recuperadas. Python no nos provee de una librería de tratamiento gráfico en su distribución estándar. Eso no quiere decir que no exista tal librería, ya que no sólo existe, sino que además es muy potente y útil. Nos referimos a Python Imaging Library (ver URL [2] en el Listado de Recursos al final del artículo). La librería PIL (Python Imaging Library) nos va a permitir tratar imáge-
Listado 1: Ejemplo Uso de PIL
Curiosidad Poco tiempo después de finalizar este artículo apareció una noticia en Slashdot (ver Recursos [4]) hablando de una llamarada solar de tal tamaño que iba a alterar las comunicaciones. Cuando se dan este tipo de eventos en muchos centros de control de satélites, los ingenieros cruzan los dedos para que sus satélites no caigan ante la ola de viento solar que se origina. El lector puede apreciar la llamarada en la Figura 4.
