Puesto que estaré haciendo un proyecto en Python, iré colocando aquellos tips útiles que he aprendido usando este maravilloso lenguaje de programación. En este caso, se trata de obtener la información del sistema que ejecuta el script; cosas como el PID del script, el directorio donde se está ejecutando, el nombre y versión del sistema operativo, etc.:

#!/usr/bin/python

import os
import time

numUsuario = os.getuid()
pidProceso = os.getpid()
donde = os.getcwd()
sistemaOperativo = os.uname()
tiempos = os.times()
horaRaw = time.time()
horaFormato = time.ctime(horaRaw)

print "Numero de usuario",numUsuario
print "PID",pidProceso
print "Directorio actual",donde
print "Informacion del sistema",sistemaOperativo
print "Informacion de tiempos del sistema",tiempos

print "\nLa hora/fecha actual es",horaRaw
print "Lo cual significa",horaFormato

Información extra: http://docs.python.org/library/os.html

A falta de tiempo para cosas más profesionales, voy a ir poniendo los algoritmos bonitos que desarrolle en la Universidad. En este caso, la especificación del ejercicio sería: Dado un arreglo de números, determinar la longitud del subarreglo creciente más largo del arreglo.

Ejemplo

Si recibiéramos un arreglo de naturales con los siguientes elementos: 2, 6, 5, 1, 3, 4, 9, 8 el resultado sería 4, puesto que es el subarreglo más largo de elementos crecientes (es decir, la longitud del subarreglo 1, 3, 4, 9)

Solución en palabras

El algoritmo que resuelve este problema debería recorrer el arreglo e ir verificando si el elemento en la posición a la que apunta es menor al de la siguiente posición. Esto supone además que, puesto que evaluaremos el elemento de la siguiente posición, debemos recorrer el arreglo desde la posición 0 hasta n-1 (siendo n la longitud del arreglo), ya que no queremos sobrepasar la longitud del mismo. Por otro lado, para cada elemento del arreglo contaremos sus sucesores que sean mayores que él mismo y con dicho conteo podremos determinar cual es la longitud de los subarreglos crecientes.

Solución en Java

El algoritmo en Java sería este:

public class SubarregloCreciente{
	public static void main(String args[]){
		//arreglo a evaluar
		int[] arr = {5,6,4,1,2,6,7,78,6,2,3,4,5,6,7,3,6,1};
		//la longitud al menos sera 0;
		//k contador por cada recorrido
		int longitud = 1, k;
		//recorremos el arreglo
		for(int i=0; i<arr.length-1;i++){
			//contamos desde el indice i cuantos
			//elementos hay en orden ascendente
			for(k = i; k < arr.length-1 && arr[k] < arr[k+1]; k++);
			//si la longitud es mayor que la anterior guardarla
			if(longitud < k - i + 1)
				longitud = k - i + 1;
		}
		System.out.println("Longitud del subarreglo creciente mas grande: "+longitud);
	}
}

Descargar código fuente

Solución en Python

from array import array
#arreglo a evaluar
arr = array('d',[5,6,4,1,2,6,7,78,6,2,3,4,5,6,7,3,6,1])
#la longitud al menos sera 0;
#k contador por cada recorrido
longitud = 1
#k=0
#recorremos el arreglo
for i in range (0, len(arr)-1):
	#contamos desde el indice i cuantos
	#elementos hay en orden ascendente
	for k in range(i, len(arr)-1):
		if not arr[k] < arr[k+1]: break
	#si la longitud es mayor que la anterior guardarla
	if longitud < k - i + 1:
		longitud = k - i + 1
print "Longitud del subarreglo creciente mas grande: "+str(longitud)

Descargar código fuente

Representación formal de la solución

Por supuesto, el algoritmo planteado es solo la aproximación más sencilla, mas no la más eficiente de todas.

He leído bastante información acerca de cómo debianizar paquetes de software, pero en la mayoría de los casos se parte de el hecho de tener un programa en C/C++, en donde es necesario preocuparse por las tareas de compilación.

Y puesto que no he visto ningún tutorial en español, he decidido escribir algo al respecto de la manera más clara posible. ¡Manos a la obra!

0. Preparativos

Lo único que necesitas son dos herramientas: dpkg-dev y dh-make, las cuales puedes instalar ejecutando este comando:

Ten en cuenta que en éste ejemplo vamos a empaquetar un programa simple llamado “pngcrushgtk“, y que debes cambiar todo lo que aparece con ése nombre con el nombre de tu programa.

1. Creando un espacio de trabajo

Puesto que mientras estemos realizando el empaquetado se van a crear varios archivos, lo ideal es tener un espacio de trabajo (una carpeta) totalmente vacío al comenzar. Así que crearemos una carpeta llamada sandbox, en donde realizaremos todo cómodamente:

Dentro, debemos crear una carpeta cuyo nombre sea del tipo: nombreprograma-version:

En la cual debemos copiar una versión empaquetada de nuestro programa dentro de un .tar.gz. Si aún no lo tienes, puedes hacer lo siguiente:

2. Debianizando nuestro paquete

Para ello utilizaremos el comando dh_make de la siguiente forma:

Nos preguntará qué tipo de paquete estamos creando, y seleccionamos “s” (simple). Permíteme explicarte cada parámetro:

• -e cristian@elhacker.net, indicamos el correo electrónico del autor del programa
• -f pngcrushgtk.tar-0.2.gz, indicamos el paquete comprimido que contiene nuestro programa
• -c GPL, indicamos el tipo de licencia de nuestro programa

Luego de ejecutar el comando se habrá creado una carpeta llamada debian dentro de pngcrushgtk-0.2; y un archivo llamado pngcrushgtk_0.2.orig.tar.gz dentro de la carpeta sandbox, el cual debes eliminar.

Continúa leyendo en la siguiente página, en donde comenzamos con la configuración del paquete…

Uno de los típicos problemas que se tienen al programar en PyGtk es que si necestamos ejecutar un comando externo, nuestra aplicación se bloquea hasta que el proceso termine. La solución a esto es usar threads, pero NO “de la manera normal“.

La cosa es que, cuando estamos desarrollando software en PyGtk, usar threads de la forma convencional tiene problemas: algunas veces, los widgets como botones que ejecutan threads no trabajan adecuadamente, o simplemente la aplicación se congela como si no estuvieramos usando hilos

La solución es usar los métodos gtk.gdk.threads_init(), gtk.gdk.threads_enter() y gtk.gdk.threads_leave(). Vamos con un ejemplo, y luego de ello paso a explicar las particualiaridades del programa:

#!/usr/bin/env python
import os, threading, locale, gtk
gtk.gdk.threads_init()

codificacion = locale.getpreferredencoding()
utf8conv = lambda x : unicode(x, codificacion).encode('utf8')

def clic_boton(boton, area_texto, buffer, comando):
 hilo = threading.Thread(target=leer_salida, args=(area_texto, buffer, comando))
 hilo.start()

def leer_salida(area_texto, buffer, comando):
 stdin, stdouterr = os.popen4(comando)
 while 1:
	 linea = stdouterr.readline()
	 if not linea:
		 break
	 gtk.gdk.threads_enter()
	 iter = buffer.get_end_iter()
	 buffer.place_cursor(iter)
	 buffer.insert(iter, utf8conv(linea))
	 area_texto.scroll_to_mark(buffer.get_insert(), 0.1)
	 gtk.gdk.threads_leave()

sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
area_texto = gtk.TextView()
buffer_texto = area_texto.get_buffer()
sw.add(area_texto)
ventana = gtk.Window()
ventana.resize(300,300)
ventana.set_title("Hilos en PyGtk")
ventana.connect('delete-event', gtk.main_quit)
boton = gtk.Button("Haz clic!")
comando = 'ls -R $HOME'
boton.connect("clicked", clic_boton, area_texto, buffer_texto, comando)
vbox = gtk.VBox()
vbox.pack_start(boton, False)
vbox.pack_start(sw)
ventana.add(vbox)
ventana.show_all()

gtk.main()

1. Lo primero (línea 2) es importar el paquete threading, que nos permitirá usar threads
2. Ahora, es necesario invocar la función gtk.gdk.threads_init() al inicio del programa (línea 3), lo que le indica a la aplicación que se van a usar hilos en la interfaz gráfica
3. En tercer lugar, debemos identificar las líneas de nuestro programa que pueden congelar la aplicación, que por lo general son llamadas a comandos externos. Una vez indentificadas basta con invocar la función gtk.gdk.threads_enter() antes de dichas líneas (línea 18), y gtk.gdk.threads_leave() después de las mismas (línea 23).

El resultado del programa es el siguiente:

Descargar código fuente del ejemplo

Recientemente ando aprendiendo algo de Python, y por supuesto me he lanzado a la búsqueda de un bonito IDE para trabajar. Después de muchas vueltas probando diferentes opciones, al fin he seleccionado mis dos finalistas.

PyDev

Es sin duda el mejor de todos. Se trata de un plugin para Eclipse que tiene todo lo que pudiéramos necesitar de un IDE:

• Resaltado de código
• Sangrado automática
• Completado automático
• Ejecución de programas
• Depurador de soluciones
• Administrador de proyectos

OpenKomodo

Es muy bueno sin duda, y nace como resultado de la liberación de parte del código del editor de Komodo, pero es solo un editor, por lo que el proceso de ejecución y depuración de aplicaciones lo tenemos que hacer manualmente o usando otras herramientas. Aún así­ posee:

• Resaltado de código
• Sangrado automática
• Completado automático
• Administrador de proyectos
• Y utilidades para el código (des/comentar bloques de código, uso de bookmarks, etc.)

Otros IDEs

Existen por supuesto una gran variedad de alternativas muy buenas, cada una con sus pros y contras. Entre las que podemos encontrar (todos instalables usando apt-get en sistemas basados en Debian):

• Eric
• PIDA
• SPE
• WingIDE

Enlaces interesantes…

• Página oficial de Python
• Python para todos. Es un eBook escrito por Raúl González Duque que cubre a grandes rasgos las principales caracterí­sticas de Python, y aunque es algo básico estoy seguro que sirve de gran ayuda a los que se inician con este maravilloso lenguaje.
• Manual de referencia oficial de Python
• Página oficial del proyecto PyGtk, un conjunto de librerí­as que permiten desarrollar aplicaciones con interfaces gráficas Gtk, usando Python
• Tutorial oficial PyGtk en español, la guí­a más completa para aprender a usar PyGtk
• Página oficial del proyecto PyQt, un conjunto de librerí­as que permiten desarrollar aplicaciones con interfaces gráficas Qt (para KDE), usando Python
• Tutorial de introducción al uso de PyQt
• Listado de IDEs en Python

Hace apenas unas horas me entero en menéame del lanzamiento de KDE 4.1 (la segunda de la serie KDE4), con algunas novedades como el regreso de la suite KDE-PIM, mejoras en Plasma y muchas aplicaciones nueva. Los que desean actualizar desde la versión KDE 4.1 Beta 2, pueden seguir ésta pequeña guía que ha escrito José en UbuntuLife.

Enlaces…

• Anuncio oficial en Español
• KDE 4.1 – Are You Ready to Switch?
• KDE 4.1 rocks the desktop
• python docActivar los efectos 3D en KDE 4.1

Uno de los aspectos más descuidados por muchos usuarios de computador, es el de realizar backups periódicamente de sus archivos. Aquí vamos a ver un pequeño tip para crear backups de una manera sencilla y rápida. Lo único que necesitaremos es un programa en Shell, tan solo de dos líneas:

#!/bin/sh
tar czvf $1.$(date +%Y%m%d-%H%M%S).tgz $1
exit $?

A este script le podemos pasar como parámetro un nombre de archivo o direcotorio, y éste crea un archivo comprimido con la fecha actual embebida en el nombre. Por ejemplo, si tenemos un directorio llamado src y deseas hacerle un bakcup, puedes invocar el script de esta manera:

$ ./backup.sh src
src/
src/EjemploGUI.java
src/Suma.java
src/EjemploGUI.class
src/Hola4.java
src/Tarea.java
src/EjemploGUI2.java
src/Hola2.java
src/EjemploGUI2.class
src/Hola3.java
src/EjemploGUI2$MiPanel.class
src/Hola.java
src/Humano.java
$ ls
bin src src.20080719-181907.tgz

Tal vez ponga algo más avanzado para hacer backups, pero de momento esto resultará muy útil para muchos. Además que es bastante sencillo!

Nota: para darle permisos de ejecución a nuestro archivo es necesario ejecutar el comando: chmod a+x bakcup.sh, suponiendo que nuestro script se llama bakcup.sh.

Me entero a través de UbuntuLife de PyQt, Desarrollando Aplicaciones de Escritorio un eBook escrito por Daniel M. Maldonado El codigo K, se trata de una pequeña guía que nos va a permitir entender como integrar de manera muy simple el lenguaje de programación Python con las librerías gráficas Qt (las que usa KDE), el mismo se encuentra bajo licencia Creative Commons. El documento es bastante simple y puedes descargarlo. Además está disponible el código fuente del ejemplo.

Anuncio del libro

¿Para qué tomarnos la molestía de hacerlo desde un navegador web, si podemos hacerlos desde la comodidad de la consola? He encontrado un script bastante bonito con el que podemos buscar en google usando nuestra amada consola. El script lo programó Sebastien Bilbeau, pero yo le he hecho algunos ajustes para que los resultados sean de páginas que estén en español.

Es necesario tener instalado lynx para que funcione. He aquí un comando de instalación rápida:

Ubuntu, Debian o derivados

sudo apt-get install lynx && wget http://casidiablo.net/codigos/google.zip && unzip google.zip && chmod a+x google

openSuse, Fedora o distros con RPM

sudo yum install lynx && wget http://casidiablo.net/codigos/google.zip && unzip google.zip && chmod a+x google

Uso

cristian@alienxp:~/Escritorio$ ./google ubuntu
10 de 5.440.000 resultados en total
———————

http://en.wikipedia.org/wiki/Ubuntu_(Linux_distribution)

http://es.wikipedia.org/wiki/Ubuntu

http://es.wikipedia.org/wiki/Ubuntu_(distribuci%C3%B3n_Linux)

http://es.youtube.com/results?num=10&hl=es&safe=on&q=ubuntu&um=1&ie=UTF-8&sa=N&tab=w1

http://ubuntu.com.es/

http://ubuntuforums.org/

http://www.guia-ubuntu.org/

http://www.ubuntu-es.org/

http://www.ubuntu.com/

http://www.ubuntu.com/GetUbuntu/download

http://www.ubuntu.upc.edu/

Descargar script

Y de hace ya un tiempo En orden cronológico:

• Como cambiar la clave de root en Mysql
• Compiz-check: Comprueba si puedes ejecutar Compiz en tu PC
• Comandos utiles para Ubuntu
• Consejos para optimizar bases de datos MySQL
• Ship it de Fedora
• Corre Ubuntu mobile desde tu PC de escritorio
• La mejor PHP Cheat Sheet
• El tutorial de Python en PDF
• Como conectar a Java y MySQL (NetBeans)
• El resultado del Proyecto Indiana: Open Solaris 2008.05

Podcasts…

• Linpodcast 03 – 02
• El podcast de mrcomputer 4
• #014 – El podcast de Linux Hispano
• Java Posse #184 – Newscast for May 2nd 2008
• Season 8, Episode 7 – Slightly Delayed
• Pingüinos en el Alambre
• OPSL 30 – Seguridad, VirtualBox, Compilando Mono y otras cosas