Se podría decir que en PHP hay dos caminos para usar la introspección, el uso de ciertas funciones que aparecieron a partir de la versión 4 de PHP (siguiendo el paradigma de la programación estructurada) , o bien el uso de ciertas clases (y sus respectivos objetos, obviamente) que hicieron su aparición estelar con PHP 5.

Por diversos motivos, en el framework que estoy desarrollando he escogido el segundo camino (en realidad un mix, pero predomina la segunda opción), pero aquí comentaré los dos.

Introspección al estilo de PHP 4

Los primeros métodos que deberíamos conocer son los que nos permiten saber qué clases hay declaradas, o si una determinada clase está cargada ya en el contexto en el que nos encontramos, tenemos estos métodos:

• get_declared_classes () : retorna una lista que contiene los nombres de todas las clases declaradas.
• class_exists ($nombre_clase) : retorna verdadero o falso en función de si la clase pasada como parametro ha sido declarada o no. Como parámetro podemos pasar una cadena, o la propia clase si ya la conocemos. Ejemplo:

  class Prueba {
  }
  class_exists ('Prueba'); // Retorna verdadero
  class_exists (Prueba);   // También retorna verdadero

Una vez sabemos qué clases hay declaradas, también podríamos querer cómo son éstas por dentro, tenemos los siguientes métodos (creo que esta lista no es exhaustiva):

• get_class_methods ($nombre_clase) : Nos devuelve una lista con los nombres de todos los métodos de la clase
• get_class_vars ($nombre_clase) : Nos devuelve una lista asociativa con los nombres de las propiedades como claves, y los respectivos valores de las propiedades como elementos de la lista.
• property_exists ($nombre_clase, $nombre_propiedad) : Nos indica si la clase tiene la propiedad que buscamos
• get_parent_class ($nombre_clase) : Nos devuelve el nombre de la clase padre (si no hay clase padre, entonces devuelve una cadena vacía). También podemos usar objetos en este caso, no solo clases.
• is_subclass_of ($nombre_clase, $nombre_clase_padre) : Nos indica si la clase hereda de la clase padre, también podemos usar objetos en este caso, no solo clases.

Podemos hacer prácticamente lo mismo, pero con objetos:

• get_object_vars ($objeto) : Se parece mucho a get_class_vars , pero se diferencia en que los valores de las propiedades de los objetos pueden variar en tiempo de ejecución, y además se pueden añadir propiedades también en tiempo de ejecución.
• method_exists ($objeto, $nombre_metodo) : Nos indica si el objeto tiene o no un método concreto

Y aquí nos quedamos, más o menos eso es todo. Antes había ciertas funciones que completaban la parrilla y eran bastante útiles, que servían, básicamente, para hacer uso de callbacks o ejecutar métodos de forma “dinámica”, pero fueron marcadas como obsoletas a partir de la versión 4.1 de PHP, por lo que no las comentaré.  El hecho de que “falten” ciertas funciones nos podría obligar a agudizar el ingenio.. o a abusar de funciones como eval , pero por suerte, en PHP 5 se introdujo una nueva forma de trabajar.

Introspección al estilo de PHP 5 ( clase Reflection )

En PHP 5 se introdujeron diversas mejoras, entre otras el tratamiento de errores se ha orientado más hacia el manejo de excepciones con bloques try-catch , y se han creado más clases que permiten trabajar de una forma mucho más orientada al paradigma de Orientación a Objetos, aumentando en cierta medida la cohesión del código resultante.

Una de las clases que fueron introducidas en esta versión fue la clase Reflection (y algunas otras que derivan de ésta). Todas ellas, cuando se produce algún error, lo que hacen es lanzar una excepción, simplificando la gestión y evitando que tengamos que interpretar el significado de los valores de retorno. Estas son las clases de las que hablaremos (un poco por encima):

• ReflectionClass : La usaremos para analizar las clases
• ReflectionObject : La usaremos para analizar los objetos
• ReflectionProperty : La usaremos para analizar las propiedades de las clases
• ReflectionMethod : La usaremos para analizar los métodos de las clases
• ReflectionFunction : La usaremos para analizar las funciones
• ReflectionParameter : La usaremos para analizar los parámetros de los métodos y funciones

Para hacer introspección o reflexión lo que debemos es construir un objeto a partir de una de estas clases, usando como parámetro en el constructor aquello que queramos “ver por dentro”. Por ejemplo:

$metainformacion_clase = new ReflectionClass ("nombre_de_la_clase");

a partir de aquí contamos con un montón de métodos (muchos más que los que había disponibles en PHP 4) que nos servirán para conocer todo cuanto queramos sobre la susodicha clase. Podéis ver los métodos disponibles en los enlaces que he hecho para cada una de ellas. Es interesante comentar que, algunos métodos devuelven objetos que a su vez también sirven para aplicar introspección, como getMethod ($name) o getProperty ($name) , que devuelven sendos ReflectionMethod i ReflectionProperty.

Uno de los métodos más interesantes de ReflectionMethod es el método invoke ($object, $params) , al cual le podemos pasar un objeto para el que queremos que se ejecute el método reflejado con los parámetros indicados. Esto sería “equivalente” a hacer la llamada (atentos, el ==== no es código, lo uso para indicar una cierta equivalencia):

$metainformacion_metodo->invoke($object, $params); ====  $object->metodo_reflejado($params);

Con ésto no es que se pueda zanjar el asunto de la introspección o reflexión, pero hay poco más interesante por decir, casi todo lo demás es simplemente conocer los nombres de las funciones y aplicarlas, así pues, deberíamos pensar en cómo toda esta parafernalia nos puede resultar útil para crear un framework con PHP. Lo veremos en el siguiente artículo, que este ya es suficientemente largo.

http://www.scottklarr.com/topic/95/javascriptajax-cheat-sheets/

Personalmente la que más me gusta a mí es la de colorines xD, tengo muco de niño pequeño todavía. Saludos!

El caso es que cuando digo lo de poco tiempo lo digo con todas las de la ley, tan poco que no hemos podido encontrar ningún hueco para coincidir en persona, así que hemos tenido que optar por trabajar a distancia con casi todo lo que eso comporta normalmente. Y digo con casi todo porque en este caso Gobby nos ha puesto las cosas fáciles . Gracias a este programa podemos editar documentos simultániamente (viendo los cambios en tiempo real, omitiendo el pequeño retardo claro) mientras podemos charlar y comentar los cambios a través del chat integrado.

Su sistema de funcionamiento es sencillo, uno de los que participa en el proceso de edición de los documentos inicia una sesión, lo que viene a significar que crea la instancia de un servidor al que otros se pueden conectar, los demás se conectan.. y listos   (se pueden establecer claves de acceso por si se quieren grupos cerrados ). Por otro lado, por el momento solo se puede trabajar con ficheros de texto plano, así que para ciertas tareas está un poco limitadito. Habría que ver si se quiere “mejorar” ese aspecto o si ya se diseñó el programa con la idea de que funcionara tal y como funciona para no hacer nada más en un futuro. Sea como sea, ya sabéis, si os interesa podéis intentar añadir funcionalidad al programa y me haréis un favor xD… y si no, talvez un día me ponga a ver si puedo hacer algo yo con mis propias manos .

Saludos! (Voy a seguir con la práctica… )

P.D.: Para los KDE-adictos (aunque cada vez quedan menos gracias a las regresiones de KDE4) hay un programa que realiza la misma función que Gobby (y puede interactuar con éste) que se llama Kobby, aun está en fase de desarrollo, pero seguro que a los aventureros eso no os asusta. Lo podéis encontrar en http://greghaynes.github.com/kobby/ .

Aun así, puede darse el caso de que nos dé la gana de hacer una aplicación de uso común en la que sería deseable que el rendimiento fuera bueno, lo que no será posible si no conocemos algunos detalles de Python. Hoy comentaré como hacer bucles lo más rápidos posible.

En principio tenemos 2 formas de crear bucles en Python, con el bucle for y con el bucle while. El bucle for ejecuta un bloque de código por cada elemento de un objeto iterable.

L = [1 2 3 4]
for i in L:
  accion(i)

Mientras que el bucle while ejecuta un trozo de código mientras se cumpla una condición concreta:

i = 1
while i <= 4:
  accion(i)
  i += 1

Los objetos iterables pueden ser de muchos tipos, pueden ser listas (que consumen memoria por cada uno de sus elementos) o pueden ser también generadores, objetos que devuelven un elemento nuevo cada vez que se llama a su método __iter__, también se pueden crear métodos generadores que actúan como objetos iterables. Así que podemos crear un método que hará algo parecido a la función range:

def generador(n):
  i = 0
  while i < n:
    yield i
    i += 1

Que podemos usar en un bucle:

  for i in generador(5):
    print i

Nota: por si alguien no sabe lo que hace la función range, crea una lista de 0 a n y la devuelve (donde n es el parámetro que se le pasa).

¿Qué ventajas tienen los generadores sobre la función range? Pues para empezar, no consumen tanta memoria, no hace falta crear un array de n elementos para hacer un bucle con n iteraciones. Aun así, si experimentamos con nuestros generadores y comparamos tiempos de ejecución veremos que la función range funciona significativamente más rápida. La razón es que está programada internamente en C y nuestro generador está programado en Python.

Ésto nos puede hacer pensar que la mejor alternativa, entonces, es usar un bucle while (aunque sea más feo) ya que evitaremos la sobrecarga de llamar a una función, no gastaremos tanta memoria como con range y sólo haremos una comparación al principio y una suma al final de cada iteración. Pero... nos equivocaríamos otra vez. Resulta que la función range da mejores resultados que el típico bucle while en cuanto a tiempo, la razón, otra vez, es que está programada internamente en C. De hecho es esperable que si el array creado por range fuera lo suficientemente grande, los resultados cambiaran (porque se tendría que recurrir a la memoria virtual y habría fallos de página), pero para que eso se dé hacen falta muuchas iteraciones, sobretodo ahora, cuando tenemos tanta memoria RAM.

Después de todo, podemos acabar un poco desanimados, pues no hemos visto ninguna solución que nos aporte todo lo que queremos. Pero está ahí , y se llama xrange. Funciona de manera análoga a la función range, sólo que en vez de devolvernos un array lo que hace es devolvernos un generador sobre el que podrá iterar el bucle for de forma elegante y aprovechando el rendimiento de C (pues está programada internamente en C). Así pues, la manera más eficiente de hacer un bucle viene a ser algo como ésto:

for i in xrange(5):
  print i

No pongo aquí los tiempos porque haría demasiado largo el artículo y lo podéis calcular vosotros mismos de forma fácil con el comando time de UNIX. Saludos!

Como en otras versiones, los que hemos colaborado somos unos cuantos, principalmente se han añadido traducciones, se ha añadido la posibilidad de cargar más de un documento a la vez a través del diálogo de fichero y se ha mejorado levemente la usabilidad, asociando la combinación Ctrl-Shift-Z a “rehacer” y añadiendo un asterisco al nombre de fichero mostrado cada vez que tenga modificaciones no guardadas.

Podéis ver el changelog en esta dirección: http://git.gnome.org/cgit/pdfmod/plain/NEWS y el anuncio oficial de Gabriel Burt en su blog: http://gburt.blogspot.com/2009/11/pdf-mod-08.html .

Por otro lado tenemos que considerar los inconvenientes: el manejo de memoria con sus punteros, la asignación y la liberación de memoria puede resultar un engorro. Y no solo eso, la sintaxis de C++ es mucho más compleja de lo que puede ser la de Python, Ruby, C#, PHP u otros lenguajes más modernos, hay que tener verdadera paciencia con él.

Voy a ver que tal es trabajar con ella, ya os diré algo , pero parece que promete.

Referencias

• (Minitutorial) http://www.ddj.com/cpp/206401952

En Java podemos encontrar tres clases diferentes que nos permiten trabajar con cadenas, la archiconocida String, StringBuffer y StringBuilder. Debido a que los objetos String son inmutables, cada vez que se hace una concatenación con el operador + se debe crear un nuevo objeto que albergue el resultado (y en caso de que las cadenas anteriores no esten referenciadas, eliminar los objetos correspondientes). Por eso también existe la clase StringBuffer que nos permite añadir a la cadena que contiene otras cadenas con su método append sin tener que construir ni destruir ningún objeto. Con ello se consigue una mejora de rendimiento considerable cuando se hacen muchas concatenaciones, luego si se quiere trabajar con un objeto String solo tenemos que usar el método toString y listos.

La clase StringBuffer está diseñada para ser segura en un entorno concurrente, por lo que tiene código extra para gestionar los bloqueos y demás. Esta característica no siempre nos es útil y puede hacer decrecer el rendimiento en demasía, por lo que también se creó la clase StringBuilder que no es segura para operaciones concurrentes pero puede ser el doble de rápida que StringBuffer (además, casi siempre que trabajamos con cadenas es de forma no concurrente).

Tanto StringBuffer como StringBuilder escalan linealmente a medida que aumentamos el número de concatenaciones, no siendo así en el caso de la clase String que parece mostrar un incremento supralineal en el consumo de recursos. Aquí os dejo las tablas de resultados, para String no están completas porque tardaba demasiado y me he cansado.

run:
StringBuffer (100): 0
StringBuffer (1000): 3
StringBuffer (10000): 19
StringBuffer (100000): 13
StringBuffer (1000000): 75
StringBuffer (10000000): 642
StringBuffer (50000000): 2738

StringBuilder (100): 0
StringBuilder (1000): 0
StringBuilder (10000): 4
StringBuilder (100000): 70
StringBuilder (1000000): 32
StringBuilder (10000000): 342
StringBuilder (50000000): 1706

String (100): 1
String (1000): 67
String (10000): 777
String (100000): 80040

Los números indican la cantidad de milisegundos consumidos para la cantidad indicada de concatenaciones. El código que he usado es éste:

public static void main(String[] args) {
        // StringBuffer
        System.out.println("StringBuffer (100): "+cSBuffer(100));
        System.out.println("StringBuffer (1000): "+cSBuffer(1000));
        System.out.println("StringBuffer (10000): "+cSBuffer(10000));
        System.out.println("StringBuffer (100000): "+cSBuffer(100000));
        System.out.println("StringBuffer (1000000): "+cSBuffer(1000000));
        System.out.println("StringBuffer (10000000): "+cSBuffer(10000000));
        System.out.println("StringBuffer (50000000): "+cSBuffer(50000000));
        // END StringBuffer

        System.out.println();

        // StringBuilder
        System.out.println("StringBuilder (100): "+cSBuilder(100));
        System.out.println("StringBuilder (1000): "+cSBuilder(1000));
        System.out.println("StringBuilder (10000): "+cSBuilder(10000));
        System.out.println("StringBuilder (100000): "+cSBuilder(100000));
        System.out.println("StringBuilder (1000000): "+cSBuilder(1000000));
        System.out.println("StringBuilder (10000000): "+cSBuilder(10000000));
        System.out.println("StringBuilder (50000000): "+cSBuilder(50000000));
        // END StringBuilder

        System.out.println();

        // StringBuilder
        System.out.println("String (100): "+cS(100));
        System.out.println("String (1000): "+cS(1000));
        System.out.println("String (10000): "+cS(10000));
        System.out.println("String (100000): "+cS(100000));
        System.out.println("String (1000000): "+cS(1000000));
        System.out.println("String (10000000): "+cS(10000000));
        System.out.println("String (50000000): "+cS(50000000));
        // END StringBuilder
    }

    static private long cSBuffer(long num)
    {
        long ini = System.currentTimeMillis();

        StringBuffer sbuffer = new StringBuffer();

        for(int i=0; i
Por cierto, y esto tiene poco que ver con lo de las clases. Lo he probado con IKVM también... y bueno, tengo que decir que va el doble de lento que con OpenJDK (no lo he probado con la máquina Hotspot de Sun).
Referencias

http://www.dosideas.com/java/339-string-vs-stringbuffer-vs-stringbuilder.html

Python Bytecode Disassembler ( dis )

El módulo que trataremos se llama dis y su principal utilidad es convertir código objeto a una representación de bytecode que sea entendible para los seres humanos (o almenos para aquellos que hayan perdido un poco de su tiempo en intentar entender éstas cosas). Éste texto está indicado para versiones de Python iguales o superiores a la versión 1.4, por lo que no tendréis ningún problema (ahora todo el casi mundo usa versiones iguales o superiores a la 2.4).

El módulo dis incluye funciones para desensamblar bytecode de Python (que se genera durante la interpretación del código para acelerar el funcionamiento de los scripts).Observar el código bytecode ejecutado por el intérprete es una buena forma de optimizar a mano bucles y otras secuencias de código. También es útil para encontrar condiciones de carrera en aplicaciones multihilo ya que mirando el bytecode se puede ver en qué “momento” es más probable que haya un cambio de hilo.

Desensamblado básico

La función dis.dis() muestra por pantalla la representación del desensamblado de código fuente Python (módulo, clase, método, función, o código objeto). Podemos desensamblar código como el siguiente:

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

my_dict = { 'a':1 }

ejecutando dis desde la línea de comandos. La salida está organizada en columnas con el número de línea original del código fuente, la “dirección” dentro del código objeto, el nombre de opcode y los argumentos pasados al opcode.

$ python -m dis codigo.py
  4           0 BUILD_MAP                1
              3 LOAD_CONST               0 (1)
              6 LOAD_CONST               1 ('a')
              9 STORE_MAP
             10 STORE_NAME               0 (my_dict)
             13 LOAD_CONST               2 (None)
             16 RETURN_VALUE

En este caso el código se traduce a 5 operaciones para inicializar el diccionario (crearlo y llenarlo), luego guarda los resultados en una variable global. Como el intérprete de Python está basado en un esquema de pila, los primeros pasos consisten en poner las constantes en la pila siguiendo el orden correcto con la operación LOAD_CONST, y luego usar STORE_MAP para sacar la clave y el valor que se añadirán al diccionario (no nos olvidemos de que antes se ha hecho la operación BUILD_MAP, los valores añadidos entre la ejecución de BUILD_MAP y STORE_MAP serán las claves y los valores del diccionario que estamos creando). El objeto resultante se enlaza con el nombre “my_dict” con la operación STORE_NAME.

Desensamblando funciones

Desafortunadamente desensamblar el módulo entero no lo hace con las funciones que hay en él automáticamente. Por ejemplo, si desensamblamos éste módulo:

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

def f(*args):
    nargs = len(args)
    print nargs, args

if __name__ == '__main__':
    import dis
    dis.dis(f)

los resultados muestran como se carga el código objeto en la pila y luego se salta dentro de la función (LOAD_CONST, MAKE_FUNCTION), pero el cuerpo de la función no está.

$ python -m dis dis_function.py
  4           0 LOAD_CONST               0 ()
              3 MAKE_FUNCTION            0
              6 STORE_NAME               0 (f)

  8           9 LOAD_NAME                1 (__name__)
             12 LOAD_CONST               1 ('__main__')
             15 COMPARE_OP               2 (==)
             18 JUMP_IF_FALSE           29 (to 50)
             21 POP_TOP

  9          22 LOAD_CONST               2 (-1)
             25 LOAD_CONST               3 (None)
             28 IMPORT_NAME              2 (dis)
             31 STORE_NAME               2 (dis)

 10          34 LOAD_NAME                2 (dis)
             37 LOAD_ATTR                2 (dis)
             40 LOAD_NAME                0 (f)
             43 CALL_FUNCTION            1
             46 POP_TOP
             47 JUMP_FORWARD             1 (to 51)
        >>   50 POP_TOP
        >>   51 LOAD_CONST               3 (None)
             54 RETURN_VALUE

Para ver dentro de la función tenemos que pasarla como argumento a dis.dis().

$ python dis_function.py
  5           0 LOAD_GLOBAL              0 (len)
              3 LOAD_FAST                0 (args)
              6 CALL_FUNCTION            1
              9 STORE_FAST               1 (nargs)

  6          12 LOAD_FAST                1 (nargs)
             15 PRINT_ITEM
             16 LOAD_FAST                0 (args)
             19 PRINT_ITEM
             20 PRINT_NEWLINE
             21 LOAD_CONST               0 (None)
             24 RETURN_VALUE

Clases

Se pueden pasar también clases a la función dis, en este caso todos sus métodos son desensamblados a la vez.

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

import dis

class MyObject(object):
    """Example for dis."""

    CLASS_ATTRIBUTE = 'some value'

    def __init__(self, name):
        self.name = name

    def __str__(self):
        return 'MyObject(%s)' % self.name

dis.dis(MyObject)

$ python dis_class.py
Disassembly of __init__:
 12           0 LOAD_FAST                1 (name)
              3 LOAD_FAST                0 (self)
              6 STORE_ATTR               0 (name)
              9 LOAD_CONST               0 (None)
             12 RETURN_VALUE

Disassembly of __str__:
 15           0 LOAD_CONST               1 ('MyObject(%s)')
              3 LOAD_FAST                0 (self)
              6 LOAD_ATTR                0 (name)
              9 BINARY_MODULO
             10 RETURN_VALUE

Desensamblando para debuggear

A veces puede ser útil ver qué bytecode causó el problema cuando se está debuggeando una excepción.  Hay un par de formas de desensamblar el código que encierra el error.

La primera forma consiste en usar dis.dis() dentro del intérprete interactivo para que analize la última excepción ocurrida. Si no se le pasa ningún argumento a dis, ésta busca la última excepción ocurrida y muestra el desensamblado de la parte “más alta” de la pila que la causó.

$ python
Python 2.6.2 (r262:71600, Apr 16 2009, 09:17:39)
[GCC 4.0.1 (Apple Computer, Inc. build 5250)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import dis
>>> j = 4
>>> i = i + 4
Traceback (most recent call last):
  File "", line 1, in
NameError: name 'i' is not defined
>>> dis.distb()
  1 -->       0 LOAD_NAME                0 (i)
              3 LOAD_CONST               0 (4)
              6 BINARY_ADD
              7 STORE_NAME               0 (i)
             10 LOAD_CONST               1 (None)
             13 RETURN_VALUE
>>>

Notad la flecha --> indicando el opcode que causó el error. La variable “i” no está definida, por lo que el valor asociado con el nombre no puede ser cargado en la pila.

Desde tu propio código puedes mostrar por pantalla información sobre el traceback pasándolodirectamente como argumento a dis.distb(). En este ejemplo hay una excepción DivideByZero, pero como la fórmula tiene dos partes, no está claro cual de los elementos es el cero.

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

i = 1
j = 0
k = 3

# ... many lines removed ...

try:
    result = k * (i / j) + (i / k)
except:
    import dis
    import sys
    exc_type, exc_value, exc_tb = sys.exc_info()
    dis.distb(exc_tb)

El valor incorrecto es fácil de detectar cuando está cargado en la pila dentro del desensamblado. La operación incorrecta está remarcada con la flecha -->, y sólo tenemos que mirar unas cuantas líneas hacia arriba para encontrar dónde se ha cargado el valor 0 en la pila.

$ python dis_traceback.py
  4           0 LOAD_CONST               0 (1)
              3 STORE_NAME               0 (i)

  5           6 LOAD_CONST               1 (0)
              9 STORE_NAME               1 (j)

  6          12 LOAD_CONST               2 (3)
             15 STORE_NAME               2 (k)

 10          18 SETUP_EXCEPT            26 (to 47)

 11          21 LOAD_NAME                2 (k)
             24 LOAD_NAME                0 (i)
             27 LOAD_NAME                1 (j)
    -->      30 BINARY_DIVIDE
             31 BINARY_MULTIPLY
             32 LOAD_NAME                0 (i)
             35 LOAD_NAME                2 (k)
             38 BINARY_DIVIDE
             39 BINARY_ADD
             40 STORE_NAME               3 (result)
             43 POP_BLOCK
             44 JUMP_FORWARD            65 (to 112)

 12     >>   47 POP_TOP
             48 POP_TOP
             49 POP_TOP

 13          50 LOAD_CONST               3 (-1)
             53 LOAD_CONST               4 (None)
             56 IMPORT_NAME              4 (dis)
             59 STORE_NAME               4 (dis)

 14          62 LOAD_CONST               3 (-1)
             65 LOAD_CONST               4 (None)
             68 IMPORT_NAME              5 (sys)
             71 STORE_NAME               5 (sys)

 15          74 LOAD_NAME                5 (sys)
             77 LOAD_ATTR                6 (exc_info)
             80 CALL_FUNCTION            0
             83 UNPACK_SEQUENCE          3
             86 STORE_NAME               7 (exc_type)
             89 STORE_NAME               8 (exc_value)
             92 STORE_NAME               9 (exc_tb)

 16          95 LOAD_NAME                4 (dis)
             98 LOAD_ATTR               10 (distb)
            101 LOAD_NAME                9 (exc_tb)
            104 CALL_FUNCTION            1
            107 POP_TOP
            108 JUMP_FORWARD             1 (to 112)
            111 END_FINALLY
        >>  112 LOAD_CONST               4 (None)
            115 RETURN_VALUE

Análisis de rendimiento en bucles

Además de para localizar errores, dis también puede ayudar a encontrar problemas de rendimiento en nuestro código. Examinar el código desensamblado es especialmente útil con pequeños bucles en los que el número de líneas de código Python es pequeño pero éstas se  ejecutan lentamente ya que se traducen a un conjunto ineficiente de bytecodes. Veremos como el desensamblado nos ayuda a examinar unas pocas implementaciones de una clase, Dictionary, que lee un conjunto de palabras y las agrupa por su primera letra.

Antes de nada, la aplicación que usaremos para hacer los tests:

import dis
import sys
import timeit

module_name = sys.argv[1]
module = __import__(module_name)
Dictionary = module.Dictionary

dis.dis(Dictionary.load_data)
print
t = timeit.Timer(
    'd = Dictionary(words)',
    """from %(module_name)s import Dictionary
words = [l.strip() for l in open('/usr/share/dict/words', 'rt')]
    """ % locals()
    )
iterations = 10
print 'TIME: %0.4f' % (t.timeit(iterations)/iterations)

Podemos usar dis_test_loop.py para ejecutar cada versión de la clase Dictionary que hagamos.

Una implementación sencilla de la classe Dictionary puede ser algo así:

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

class Dictionary(object):

    def __init__(self, words):
        self.by_letter = {}
        self.load_data(words)

    def load_data(self, words):
        for word in words:
            try:
                self.by_letter[word[0]].append(word)
            except KeyError:
                self.by_letter[word[0]] = [word]

La salida muestra que esta versión ha tomado 0.1074 segundos para cargar las 234936 palabras en mi copia de  /usr/share/dict/words en OS X [Recordad que es una traducción y no lo hice directamente yo ésto]. No está demasiado mal, pero como podemos ver en el desensamblado de abajo, el bucle. está haciendo más trabajo del necesario. Tal como entra en el bucle en el opcode 13, se instala el contexto de una excepción (SETUP_EXCEPT). Entonces usa 6 opcodes para encontrar self.by_letter[word[0]] antes de añadir la palabra a la lista. Si se lanza una excepción porque word[0] todavía no está en el diccionario, el manejador de excepciones hace otra vez el mismo trabajo para  determinar word[0] (3 opcodes) y inicializa self.by_letter[word[0]] como una nueva lista que contiene la palabra.

$ python dis_test_loop.py dis_slow_loop
 11           0 SETUP_LOOP              84 (to 87)
              3 LOAD_FAST                1 (words)
              6 GET_ITER
        >>    7 FOR_ITER                76 (to 86)
             10 STORE_FAST               2 (word)

 12          13 SETUP_EXCEPT            28 (to 44)

 13          16 LOAD_FAST                0 (self)
             19 LOAD_ATTR                0 (by_letter)
             22 LOAD_FAST                2 (word)
             25 LOAD_CONST               1 (0)
             28 BINARY_SUBSCR
             29 BINARY_SUBSCR
             30 LOAD_ATTR                1 (append)
             33 LOAD_FAST                2 (word)
             36 CALL_FUNCTION            1
             39 POP_TOP
             40 POP_BLOCK
             41 JUMP_ABSOLUTE            7

 14     >>   44 DUP_TOP
             45 LOAD_GLOBAL              2 (KeyError)
             48 COMPARE_OP              10 (exception match)
             51 JUMP_IF_FALSE           27 (to 81)
             54 POP_TOP
             55 POP_TOP
             56 POP_TOP
             57 POP_TOP

 15          58 LOAD_FAST                2 (word)
             61 BUILD_LIST               1
             64 LOAD_FAST                0 (self)
             67 LOAD_ATTR                0 (by_letter)
             70 LOAD_FAST                2 (word)
             73 LOAD_CONST               1 (0)
             76 BINARY_SUBSCR
             77 STORE_SUBSCR
             78 JUMP_ABSOLUTE            7
        >>   81 POP_TOP
             82 END_FINALLY
             83 JUMP_ABSOLUTE            7
        >>   86 POP_BLOCK
        >>   87 LOAD_CONST               0 (None)
             90 RETURN_VALUE

TIME: 0.1074

Una técnica para elimnar la excepción es rellenar self.by_letter con una lista para cada letra del alfabeto antes de empezar a llenar el diccionario. Esto significa que siempre podremos hacer la operación append satisfactoriamente sin necesidad de manejar ninguna excepción.

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

import string

class Dictionary(object):

    def __init__(self, words):
        self.by_letter = dict( (letter, [])
                                for letter in string.letters)
        self.load_data(words)

    def load_data(self, words):
        for word in words:
            self.by_letter[word[0]].append(word)

El cambio reduce el número de opcodes aproximadamente a la mitad, pero solo se reduce el tiempo a 0.0984 segundos. Obviamente el manejo de la excepción añadía un cierto overhead pero tampoco demasiado.

$ python dis_test_loop.py dis_faster_loop
 14           0 SETUP_LOOP              38 (to 41)
              3 LOAD_FAST                1 (words)
              6 GET_ITER
        >>    7 FOR_ITER                30 (to 40)
             10 STORE_FAST               2 (word)

 15          13 LOAD_FAST                0 (self)
             16 LOAD_ATTR                0 (by_letter)
             19 LOAD_FAST                2 (word)
             22 LOAD_CONST               1 (0)
             25 BINARY_SUBSCR
             26 BINARY_SUBSCR
             27 LOAD_ATTR                1 (append)
             30 LOAD_FAST                2 (word)
             33 CALL_FUNCTION            1
             36 POP_TOP
             37 JUMP_ABSOLUTE            7
        >>   40 POP_BLOCK
        >>   41 LOAD_CONST               0 (None)
             44 RETURN_VALUE

TIME: 0.0984

Podemos optimizar aún más el rendimiento moviendo el acceso a self.by_letter fuera del bucle (dado que el valor no cambia en ningún momento).

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

import collections

class Dictionary(object):

    def __init__(self, words):
        self.by_letter = collections.defaultdict(list)
        self.load_data(words)

    def load_data(self, words):
        by_letter = self.by_letter
        for word in words:
            by_letter[word[0]].append(word)

Los opcodes 0-6 ahora encuentran el valor de self.by_letter y lo guardan como la variable local by_letter. Usar variables locales solo requiere un opcode en vez de 2 (en la posición 22 se usa LOAD_FAST para almacenar dictionary en la pila). Después de este cambio el tiempo de ejecución se reduce a 0.0842 segundos.

$ python dis_test_loop.py dis_fastest_loop
 13           0 LOAD_FAST                0 (self)
              3 LOAD_ATTR                0 (by_letter)
              6 STORE_FAST               2 (by_letter)

 14           9 SETUP_LOOP              35 (to 47)
             12 LOAD_FAST                1 (words)
             15 GET_ITER
        >>   16 FOR_ITER                27 (to 46)
             19 STORE_FAST               3 (word)

 15          22 LOAD_FAST                2 (by_letter)
             25 LOAD_FAST                3 (word)
             28 LOAD_CONST               1 (0)
             31 BINARY_SUBSCR
             32 BINARY_SUBSCR
             33 LOAD_ATTR                1 (append)
             36 LOAD_FAST                3 (word)
             39 CALL_FUNCTION            1
             42 POP_TOP
             43 JUMP_ABSOLUTE           16
        >>   46 POP_BLOCK
        >>   47 LOAD_CONST               0 (None)
             50 RETURN_VALUE

TIME: 0.0842

Una mayor optimización sugerida por Brandon Rhodes es eliminar la versión Python del bucle por completo. Si usamos groupby() del módulo itertools para agrupar la entrada, la iteración es movida a código C. Podemos hacer ésto porque sabemos que la entrada está ordenada. En caso de no saber si está ordenada o no, deberíamos ordenarla por si acaso.

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

import operator
import itertools

class Dictionary(object):

    def __init__(self, words):
        self.by_letter = {}
        self.load_data(words)

    def load_data(self, words):
        # Arrange by letter
        grouped = itertools.groupby(words, key=operator.itemgetter(0))
        # Save arranged sets of words
        self.by_letter = dict((group[0][0], group) for group in grouped)

La versión con itertools solo tarda 0.0543 segundos en ejecutarse, más o menos la mitad del tiempo original.

$ python dis_test_loop.py dis_eliminate_loop
 15           0 LOAD_GLOBAL              0 (itertools)
              3 LOAD_ATTR                1 (groupby)
              6 LOAD_FAST                1 (words)
              9 LOAD_CONST               1 ('key')
             12 LOAD_GLOBAL              2 (operator)
             15 LOAD_ATTR                3 (itemgetter)
             18 LOAD_CONST               2 (0)
             21 CALL_FUNCTION            1
             24 CALL_FUNCTION          257
             27 STORE_FAST               2 (grouped)

 17          30 LOAD_GLOBAL              4 (dict)
             33 LOAD_CONST               3 ( at 0x7e7b8, file "/Users/dhellmann/Documents/PyMOTW/dis/PyMOTW/dis/dis_eliminate_loop.py", line 17>)
             36 MAKE_FUNCTION            0
             39 LOAD_FAST                2 (grouped)
             42 GET_ITER
             43 CALL_FUNCTION            1
             46 CALL_FUNCTION            1
             49 LOAD_FAST                0 (self)
             52 STORE_ATTR               5 (by_letter)
             55 LOAD_CONST               0 (None)
             58 RETURN_VALUE

TIME: 0.0543

Referencias:

• Artículo original: http://www.doughellmann.com/PyMOTW/dis/
• Módulo dis: http://docs.python.org/library/dis.html
• Módulo itertools: http://docs.python.org/library/itertools.html

$ python dis_test_loop.py dis_eliminate_loop
 15           0 LOAD_GLOBAL              0 (itertools)
              3 LOAD_ATTR                1 (groupby)
              6 LOAD_FAST                1 (words)
              9 LOAD_CONST               1 ('key')
             12 LOAD_GLOBAL              2 (operator)
             15 LOAD_ATTR                3 (itemgetter)
             18 LOAD_CONST               2 (0)
             21 CALL_FUNCTION            1
             24 CALL_FUNCTION          257
             27 STORE_FAST               2 (grouped)

 17          30 LOAD_GLOBAL              4 (dict)
             33 LOAD_CONST               3 (<code object <genexpr> at 0x7e7b8, file "/Users/dhellmann/Documents/PyMOTW/dis/PyMOTW/dis/dis_eliminate_loop.py", line 17>)
             36 MAKE_FUNCTION            0
             39 LOAD_FAST                2 (grouped)
             42 GET_ITER
             43 CALL_FUNCTION            1
             46 CALL_FUNCTION            1
             49 LOAD_FAST                0 (self)
             52 STORE_ATTR               5 (by_letter)
             55 LOAD_CONST               0 (None)
             58 RETURN_VALUE

TIME: 0.0543

El meu nom es Andreu i us explicaré una de les histories més extrañes del món. Un dia vaig començar a escriure un programet que… bé, realment no li veia cap futur. Però vanar creixent i creixent.. ¿Qui ho hagués dit? Doncs sí, va arribar a ser el programa més conegut del món, ningú utilitzaba la linia de comandes fins llavors… però el fet que el meu programa esdevingués tan popular va promoure l’adopció de la linia de comandes com la interficie per defecte per interactuar amb els ordinadors… doncs.. si tots els programes per linia de comandes havien de ser tan genials com el que havia fet jo.. era clar que les interficies gràfiques caurien en desús, no valien res comparades amb el munt de lletres que ara m’està mostrant l’editor de linia de comandes que estic fent servir per explicar-vos aquesta historia.. i la veritat, ja m’agradaria que alguna cosa del que estic dient fos certa. El meu programa es una cagada impresionant.. i dificilment conseguiré més de 10 usuaris a tot el món, però necessito escriure la major quantitat de text possible per comprovar certes característiques d’una llibreria que es diu urwid i està basada en lesllibreries nCurses. Vull veure si apareix una barra de desplaçament o quelcom semblant per poder veure el text que he escrit i que no es visible a la pantalla… Però sembla ser que he d’escriure molt més del que m’agradaria i ja n’estic fart. Podria tirarme del balcó, fotrem un tret al cap o pendrem una pastilleta de cianur.. i tot això seria sens cap mena de dubte millor que el fet d’haver d’estar perdent el temps escrivint tonteries com aquestes… ara fa un moment m’ho he rellegit i la veritat es que passo de semblar un narcisista acabat a semblar un desequilibrat mental que necessita ser internat el mes aviat possible per assegurar que no s’autolesioni i prengui mal… em sembla que ja he aconseguit el que volia, ara no caldrà que patiu per la meva integritat física.. tot i així podeu seguir patint per la meva integritat mental, no n’estic segur.. de mantenirla intacta.

Lo que me queda por hacer:

1. Añadir un modo interactivo, lo programaré con la librería curses
2. Aprovechar la capacidad de internacionalización del programa y traducirlo al castellano y al catalán
3. Empaquetarlo para Debian
4. Si a alguien se le ocurre algo más, tiene todo el derecho del mundo a decirlo .

Algunas cosillas más :

Añadí el proyecto a Launchpad ( CMD Twitt ) ya que gracias a ésto ahora tengo un bug tracker donde todo el mundo puede indicar los bugs que encuentre en el programa y también dejar sugerencias de mejora en los Blue Prints.

Saludos!