El Firefox 26 me dejó de mostrar los íconos de las carpetas en los bookmarks.
A esto lo podemos ver en la siguiente imagen (click para ampliar):
La solución es muy sencilla y la encontré acá. Se trata de agregar el siguiente código:
@namespace url("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul");
menu.bookmark-item > .menu-iconic-left {
visibility: visible;
}
en el siguiente archivo:
~/.mozilla/firefox/<profile_name>/chrome/userChrome.css
Yo lo hice de esta forma (ejecutar la línea completa como usuario normal, sin el $
), donde <profile_name>
es el nombre del perfil de Firefox que se quiera modificar:
1
|
|
Espero que le sirva a alguien. Saludos!
]]>En un post anterior comenté que había comenzado a leer un libro sobre SciPy y NumPy. En los primeros capítulos encontré ejemplos simples de la utilización de SciPy. Hoy voy a mostrar el código de dos de ellos, para los cuales implementé sus respectivos gráficos. El primero es sobre ajustar una distribución de puntos con dos Gaussianas, y el segundo es sobre encontrar los puntos de intersección de dos curvas.
Como cada paso está comentado en el código, entonces no me voy a detener en las explicaciones. Es más para tener estos ejemplos como anotaciones cuando necesite hacer un cálculo simple y un gráfico modesto, nada más que eso :-)
Si no tenemos los paquetes necesarios, en Fedora los instalamos así:
# yum install numpy scipy python-matplotlib
Si usamos Vim, podemos usar el plugin para templates del cual hablábamos ayer. Entonces creamos el archivo:
$ vim fitting-two-gaussians.py
y copiamos el siguiente código:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
|
Luego lo ejecutamos, pero antes le damos los permisos necesarios para ello:
$ chmod +x fitting-two-gaussians.py
$ ./fitting-two-gaussians.py
( 1.01566899098 +/- 0.00385041607346 )
( 3.01416857209 +/- 0.00491510905728 )
( 0.99386852028 +/- 0.00492078923246 )
( -1.91566245187 +/- 0.00722572741217 )
( 15.0208881795 +/- 0.000735898852204 )
( 0.529428527565 +/- 0.000735896650911 )
Como resultado, obtenemos los seis parámetros de las dos Gaussianas y sus respectivas incertezas. El gráfico es el siguiente (click para ampliar):
Siguiendo los pasos anteriores, creamos el archivo:
$ vim intersection-points.py
y copiamos el siguiente código:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
|
Luego lo ejecutamos, dándole sus permisos antes:
$ chmod +x intersection-points.py
$ ./intersection-points.py
( 13.4077307829 , -0.365922692171 )
( 18.1136612829 , -0.318863387171 )
( 31.7833086315 , -0.182166913685 )
( 37.0799991955 , -0.129200008045 )
( 39.8483778612 , -0.101516221388 )
( 43.8258775032 , -0.0617412249676 )
En este caso, el resultado son los seis puntos de intersección entre las dos curvas. El gráfico es este (click para ampliar):
]]>Uno de mis editores de texto preferidos es Vim, sobre todo cuando se trata de editar archivos en consola o bien para escribir código. Y es acá donde entra en juego este plugin para Vim llamado vim-template, el cual nos proporciona un conjunto de plantillas para diferentes tipos de archivos.
Primero que nada necesitamos tener Vim, al cual lo instalamos de la siguiente manera en Fedora:
$ sudo yum install vim-enhanced
Luego descargamos el plugin:
$ wget https://github.com/aperezdc/vim-template/archive/master.zip
y lo instalamos al mismo tiempo que lo extraemos:
$ unzip -j master.zip 'vim-template-master/plugin/*' -d ~/.vim/plugin
$ unzip -j master.zip 'vim-template-master/templates/*' -d ~/.vim/templates
De esta manera, ya tenemos instalado el plugin vim-template en ~/.vim/
.
Dentro de las plantillas, se utilizan variables que van a ser expandidas según su valor. Estas variables también pueden ser sobreescritas, y es lo que voy a hacer ya que las que me interesan no toman un valor muy representativo.
Dentro del archivo ~/.vimrc
(lo creamos si no existe) voy a colocar las sigientes líneas que tomarán un valor diferente según cada usuario:
1 2 3 |
|
las cuales representan la licencia del código, el email del usuario y su nombre, respectivamente.
También voy a configurar el template que más uso (~/.vim/templates/template.py
), y para ello voy a sustituir todo su contenido por lo siguiente:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
|
De esta forma queda configurado el plugin a mi gusto. Hay plantillas para otros lenguajes de programación también, y no necesariamente tienen que ser modificados. Uno también puede crear su propio template para el lenguaje que más utilice y que no esté por default en el plugin.
Podemos usar este plugin de dos maneras diferentes. Una es creando un nuevo archivo, dándole un nombre y el sufijo de interés. En este caso, para poner en práctica las configuraciones hechas anteriormente, vamos a crear un archivo Python:
$ vim foo.py
y cuando presionemos enter obtendremos lo siguiente:
Otra forma es abriendo Vim sin crear ningún archivo:
$ vim
y seleccionando luego el template desde dentro, para C en este caso:
:Template c
con lo cual obtendremos:
Podemos ver más información y definición de variables en la página de vim-template.
]]>Este fin de semana comencé a leer un libro introductorio sobre SciPy y NumPy, al cual pueden verlo acá:
SciPy and NumPy (Optimizing & Boosting Your Python Programming)
Voy a comentar sobre un cálculo interesante que se habla en el segundo capítulo sobre la diferencia en la eficiencia computacional entre el objeto list
y el objeto ndarray
.
Las operaciones sobre los elementos de una lista sólo pueden ser hechas a través de bucles iterativos, lo cual es computacionalmente ineficiente en Python. El paquete NumPy permite superar las deficiencias de las listas de Python mediante un objeto para almacenamiento de datos llamado ndarray
.
Utilizando el comando mágico %timeit
de IPython, comparamos las diferencias en velocidad de ndarray
de NumPy versus las listas de Python al ser multiplicados por un escalar. Primero creamos un array que contenga 1×107 elementos:
In [1]: import numpy as np
In [2]: arr = np.arange(1e7)
y luego convertimos el array en una lista:
In [3]: larr = arr.tolist()
En el caso de las listas, tenemos que crear una función para emular lo que ndarray
puede hacer:
In [4]: def list_times(alist, scalar):
....: for i, val in enumerate(alist):
....: alist[i] = val * scalar
....: return alist
Ahora hacemos el cálculo en IPython con %timeit
, primero multiplicando el array por 1.1:
In [5]: %timeit arr * 1.1
10 loops, best of 3: 58.9 ms per loop
y luego haciendo lo mismo con la lista, usando la función creada para ello:
In [6]: %timeit list_times(larr, 1.1)
1 loops, best of 3: 1.44 s per loop
Esto nos muestra que la operación con el objeto ndarray
es ~ 25 veces más rápida que el bucle con la lista. Por lo tanto, cuando sea posible, deberemos trabajar con objetos array en lugar de listas.
Interesante resultado para mí que soy un aprendiz de Python! :-)
]]>Esta especie de tutorial de PyGObject (Python y GTK+ 3) es casi una traducción literal de su documentación. Más que un tutorial, es el ejemplo más simple de como crear una ventana vacía. Seguidamente, extenderemos el script para agregarle un botón que realiza una determinada acción. Se necesita un conocimiento razonable del lenguaje Python, el cual dudo en tener :-)
Antes de comenzar, recomiendo los siguientes documentos para que podamos aprender un poco más sobre PyGObject:
https://developer.gnome.org/gnome-devel-demos/stable/tutorial.py.html.en
http://pfrields.fedorapeople.org/presentations/OhioLF2011/PyGObject.pdf
Para comenzar, crearemos el ejemplo más simple posible, el cual consiste de una ventana vacía.
1 2 3 4 5 6 7 8 9 10 |
|
Explicaremos ahora cada línea del ejemplo.
#!/usr/bin/python
La primera línea de todos los programas en Python debe empezar con #!
seguido del camino al intérprete Python que queremos invocar.
from gi.repository import Gtk
Para poder acceder a las clases y funciones de GTK+, primero debemos importar el módulo Gtk. La próxima línea crea una ventana vacía.
win = Gtk.Window()
Seguidamente, conectamos la ventana a su evento delete para asegurarnos de que la aplicación termine al cliquear en la x de la ventana.
win.connect("delete-event", Gtk.main_quit)
En el próximo paso mostramos la ventana.
win.show_all()
Finalmente, iniciamos el loop de procesamiento de GTK+, del cual saldremos cuando la ventana sea cerrada (ver línea 5).
Gtk.main()
Para ejecutar el programa, abrimos una terminal, cambiamos el directorio hasta donde está el archivo (al cual le llamé ejemplo_simple.py), y ponemos:
$ python ejemplo_simple.py
Alternativamente, podemos darle permisos de ejecución y luego ejecutarlo:
$ chmod +x ejemplo_simple.py
$ ./ejemplo_simple.py
Para algo un poco más útil, aquí está la vesión en PyGObject del clásico programa Hello World.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
|
A diferencia del ejemplo simple, aquí creamos una sub-clase de Gtk.Window
para definir nuestra propia clase MyWindow
.
class MyWindow(Gtk.Window):
En el constructor de la clase, tenemos que llamar al constructor de la super-clase. Además, le diremos que dé el valor de Hello World
a la propiedad title
.
Gtk.Window.__init__(self, title="Hello World")
Las próximas tres líneas son usadas para crear un botón (widget), conectarlo a su señal clicked
, y adicionarlo como hijo a la ventana.
self.button = Gtk.Button(label="Click Here")
self.button.connect("clicked", self.on_button_clicked)
self.add(self.button)
En consecuencia, el método on_button_clicked()
será llamado si cliqueamos en el botón.
def on_button_clicked(self, widget):
print "Hello World"
El último bloque, fuera de la clase, es muy similar al del ejemplo simple de más arriba, pero en lugar de crear una instancia de la cláse genérica Gtk.Window
, creamos una instancia de MyWindow
.