Tiempo de Tux

lunes, 23 de diciembre de 2013

Aplicacion de Tiempo de Tux para Android

Una sencilla aplicación de Tiempo de Tux:

Descarga

Enlace

Decoradores en python

Es hora de continuar con los tutoriales de python.

Un decorador en python es esta cosa por si la han visto:

@decorador

En el código python,un decorador se usa para "modificar" una función anidandola dentro de otra,veamos un código y a continuación lo explico:

Primero que nada ya deben conocer y saber usar args y kwargs:

Enlace

Bien vamos a crear un modificador que saluda a la funcion recibida :

def ver(fun):
   def _ver(*args,**kwargs):
      print "Bienvenido ",fun.__name__
      fun(*args,**kwargs)
      print "Adios ",fun.__name__
   return _ver

@ver
def sumar(x,y):
   print x+y
   
sumar(1,4)

Bien al ejecutar podrán ver algo como lo siguiente:

Bienvenido sumar
5
Adios sumar

Aquí lo que estamos haciendo es muy raro en la sintaxis común de python,porque de donde salio ese arroba no es perl o ruby para usar arrobas ,en python a eso se le llama decoradores,un decorador es una función anidada que ejecuta la función recibida y la decora adentro de otra función que retorna:

Veamos:

def ver(fun) # Esta es la función decoradora,el parámetro que recibe es la misma a decorar(la que esta abajo del arroba)

def _ver(*args,**kwargs) # Esta es la función modificada,adentro ejecutamos la función recibida y la decoramos

print "Bienvenido ",fun.__name__ # Ejecutamos esto como ejemplo de decoración(le damos la bienvenida a la funcion)

fun(*args,**kwargs) # Ejecutamos la función recibida(como si fuera la ejecución real),los parámetros los "hereda"(son los mismos)

print "Adios ",fun.__name__ # Nos despedimos de la función(podríamos decir que termina)

return _ver # Retornamos la función modificada o que modifico la función principal(la que ejecuto)

Bien,como vemos es sencillo solo que un poco raro ver esto en python,vamos a ver que contienen los args y kwargs:

#!/usr/bin/nev python

def ver(fun):
    def _ver(*args,**kwargs):
        print "Bienvenido ",fun.__name__
        for i in args:
            print i,"<- adentro="" del="" font="" modificador="">
        for k,v in kwargs.iteritems():
            print "Key : %s  Value : %s <- adentro="" del="" font="" modificador=""> %(k,v)
        fun(*args,**kwargs)
        print "Adios ",fun.__name__
    return _ver

@ver
def sumar(x,y,**k):
    print x+y,"<- en="" font="" funcion="" la="" real="">

sumar(1,4,uno=1)

En este caso los args y kwargs son los que le pasamos a la hora de llamarlo,por ejemplo toma de args todos los argumentos en una tupla y los kwargs todos los argumentos de clave valor,para así poder trabajar con ellos dentro del decorador por si los necesitamos,veamos un ejemplo:

Supongamos que queremos multiplicar todos los números recibidos de una funcion principal pero vamos a sumarlos también en otra función solo vamos a mostrarlos,lo cual es dos funciones una que suma y multiplica y otra que no suma solo muestra los números,podemos hacerlo 10 veces por ejemplo 7 que hagan algo con los números y 3 que solo hagan su función:

#!/usr/bin/nev python

def sumar(fun):
    def _sumar(*args,**kwargs):
        iterador = 0
        for i in args:
            iterador += i
        fun(*args,**kwargs)
        print "Suma de todos los numeros ",iterador
    return _sumar

@sumar
def multiplica(x,y,z,n): # Esta funcion multiplica todos los numeros
    print x*y*z*n

#@sumar # Si quitamos el gato tambien tendra el decorador sumar
def muestra(x,y,z,i): # Esta solo los muestra
    print "Numeros %d %d %d %d" %(x,y,z,i)


multiplica(1,2,3,4)

muestra(2321,321,545,565)

Bien como vemos es un uso muy raro el ejemplo pero es un ejemplo del uso de los decoradores,los ejemplos no son practica son aprendizaje así que esta bien.

Podemos usar decoradores con parámetros,por ejemplo vamos a ejecutar una función cierto numero de veces basado en el decorador:

#!/usr/bin/nev python

def rep(n):
    def iterador(fun):
        def _rep(*args,**kwargs):
            for i in range(0,n):
               fun(*args,**kwargs)
        return _rep
    return iterador
             
@rep(10)
def multiplica(x,y,z,n): # Esta funcion multiplica todos los numeros
    print x*y*z*n

multiplica(1,2,3,4)

Ahora lo explico:

Lo primero que hicimos fue bajar otro nivel en las funciones anidadas del decorador,el primer nivel a hora no es el que recibe la función si no el que recibe el argumento pasado al decorador:

def rep(n) # n = 10 porque @rep(10)

En la función iterador el segundo nivel de función es donde ahora recibimos la función (el decorador):

def iterador(fun) # fun = multiplica

El ultimo nivel de función es (el modificador):

def _rep(*args,**kwargs) # Modificador

En cada función en un nivel mas alto debemos retornar una función,ya que detiene la función y continua con el iterador.

return _rep termina con _rep,return iterador termina con iterador.

Como vemos los modificadores son buenos para ciertas practicas pero no son indispensables,podemos remplazarlos con funciones comunes u otras practicas,pero es bueno usarlos en ocasiones especiales.

domingo, 22 de diciembre de 2013

Terminar procesos visualmente Xkill Linux

Hace un tiempo comente como matar procesos desde la terminal,ahora un pequeño consejo mas que un tutorial,matar procesos visualmente con Xkill,mas que nada es cuando nuestro sistema se cae,por ejemplo en windows siempre iniciamos el administrador de tareas y matamos el proceso para recuperar memoria y poder usar el sistema sin que se caiga,en Linux ya hablamos de varias manera ahora la mas sencilla xkill.

X kill es X de X Server así que tiene mucho sentido,para usarlo solo tenemos que instalarlo:

Por ejemplo en Ubuntu:

sudo apt-get install xkill

Luego solo abrimos una terminal y escribimos xkill,luego nuestro cursor se convertirá en una x(depende del tema que usemos) y le damos clic a la ventana que queramos matar su proceso(mata todos los procesos relacionados a ese nombre):

Algo que recomiendo es añadirlo a un acceso directo basado en su entorno de escritorio,por ejemplo yo uso Unity pero con Compiz uso los atajos:

Por ejemplo Ctrl+Alt+K:

Les dejo un vídeo de muestra :D

Eso es todo :D

viernes, 20 de diciembre de 2013

Tutorial SQlite3 Tipos DML DDL

Este es el primer tutorial para usar Sqlite en su versión 3 que es la versión que uso,yo tengo instalada la versión 3.7.17 , no la instale directamente pero se debe haber instalado como dependencia con algún conjunto de herramientas que instale en sistema,por lo que lo mas seguro es que no necesiten instalar en su sistema o lo que es lo mismo ya la deben tener instalada.

Antes que nada este tutorial o serie de tutoriales va dedicado solamente a sistemas Linux de escritorio,no BSD,no Windows,no iOS, no Android,etc.Ya que estos tutoriales los vamos a realizar desde la misma shell de SQlite o sea desde la interfaz que nos ofrece la terminal de nuestro sistema Linux.

Bien el titulo de la entrada parece un poco raro ya que no acostumbro a hacer referencia a las introducciones de temas que hago,pero vamos a explicarlo un poco.porque en este caso es necesario:

SQL es un lenguaje de consulta mas en especifico un lenguaje de consulta estructurados ahora en ingles :

Structured Query Language

Los SQL se usan para hacer consultas a bases de datos,en este caso SQlite3 es nuestro consultor y aunque vamos a usar un nivel intermedio para comunicarnos con las bases de datos y no me refiero al nivel de dificultad,bueno un poco ya que por ejemplo hasta un usuario de una Pc que no sepa nada de programación o de nada,solo que entre a un navegador web y busque algo en google,por ejemplo ya esta manipulando una base de datos,pero a un nivel muy alto,de usuario final,en este caso nosotros usaremos un nivel intermedio gracias a SQL,en este caso SQLite.

El DML es llamado así por la abreviación de Lenguaje de Manipulación de Datos,ahora en ingles:

Data Manipulation Language

Los comandos(en rojo) se usan para lo siguiente(morado):

SELECT Consulta registros

INSERT Inserta datos en una sola operación.

DELETE Borra(modifica) los datos especificados de un registro.

UPDATE Actualiza(modifica) los datos especificados de un registro.

Esto se usa para manipular datos en una base de datos de modelo relacional ,lo que es SQLite.

DML es llamado así por la abreviación de Lenguaje de Definicion de Datos,en ingles:

Data definition language

Los comandos(en rojo) se usan para lo siguiente(morado):

CREATE Crea nuevas tablas e índices
DROP Elimina tablas e índices
ALTER Modifica las tablas agregando columnas o modificando su valor.

Bien no me gusta mucho meterme en esa parte pero bueno,primero que nada vamos a abrir una terminal y vamos a crear un archivo db llamado hola.db:

sqlite3 hola.db

Si no encuentras sqlite3 deben instalarlo según su distribución,pero lo mas seguro es que ya lo tengan.

En este caso crea un base de datos hola.db si ya existe la abre si no existe la crea.

Los comentarios en SQLite son similares a los de Lua para una sola linea,deben comenzar con dos guion medio:

-- Un comentario

Y para los de varias lineas se parecen a los de PHP:

/*
 Un comentario de varias lineas
 De varias lineas :D
*/;

Los comandos básicos que podemos usar son:

.help -- Muestra ayuda

.version -- Muestra la versión

.databases -- Muestra las bases de datos

..exit -- Sale

.quit -- Sale

.tables -- Muestra las tablas

.read script(lineas de ordenes SQL) -- Ejecuta scripts en .sqlite

.prompt estilo->PS1 estilo->PS2 -- Cambia el estilo de la prompt

Estos son los tipos de datos que podemos implementar en SQLite3:

NULL Valor nulo.

INTEGER Numero entero almacenado en 1, 2, 3, 4, 6 bytes.

REAL Valor de punto flotante, guardado en 8-byte como numero de coma flotante.

TEXT Texto.

BLOB Dato no especificado(Binario) que se guarda como entra.

De momento eso es todo en las siguientes partes veremos ejemplos del uso de DLL y DML.

jueves, 24 de octubre de 2013

Tutorial PHP-CLI introduccion

Bien,PHP es otro lenguaje de los que se podrian quedar en sitio,el cual seria el ultimo,asi que ya vere en unos dias que haga cuentas cual lenguaje le favorece mas al sitio:

Java Ruby o PHP-CLI

Bien en el tutorial de Ruby dije que no me interesaba en lo absoluto el desarrollo web y tal vez sea algo evidente como lo mencione,bien PHP no solo es para programación web sino que es de uso general,yo he visto programas en PHP+Gtk lo cual es raro ya que php es para lenguaje del servidor,pero también se puede usar para scripting,osea lineas de ordenes que nos faciliten la administración del sistema,sistemas de la familia Unix,es raro pero si.

Lo he visto en programación web y es bueno aunque un tanto sucio,por ejemplo la forma en la que wordpress lo usa embebido es sorprendente,pero sucio,pero muy útil,también otra cosa es que para aprender programación PHP como se debe se necesita saber Apache(o saber manipular alguna interfaz web),saber alguna base de datos,como MySQL,saber HTML y CSS para la vista,ademas de javascript si queremos usar también lenguaje de lado del cliente.

Por ejemplo necesitamos lenguaje de programación del lado del cliente y del lado del servidor,lenguaje de marcado,lenguaje de consulta,scripting para administrar el servidor,osea una vida :P.

O también podríamos usar DOM+PHP.

Bueno en esta introducción empezamos desde cero,osea desde lo que seria el principio básico,variables,archivos,etc.

Primero que nada PHP quiere decir Hypertext Pre-processor.lo que seria algo como Procesador de Hipertexto,o manipulador de Hipertexto,esta bajo su propia licencia la cual se considera software libre,aunque no es compatible con GPL, :O(así son las leyes).

Bueno y que es PHP-CLI,PHP-CLI es la forma de usar PHP en linea de comandos CLI(Interfaz de linea de comandos,osea comunicación por Shell),esto es bueno para las personas como yo que hacen todo desde la terminal,así que bueno vamos a comenzar con PHP-CLI.

Primero que nada instalar,en ubuntu es fácil con:

sudo apt-get install php5-cli

Para otros sistemas no se cual sea el nombre del paquete,pero lo pueden buscar como,php5-cli:

Por ejemplo en Gentoo:

eix php5-cli

Luego instalan el paquete señalado y les instala las dependencias y el paquete.

Ahora vamos a crear un archivo PHP,el cual seria como un script,el archivo le damos extensión .php, se pueden usar mas extensiones,pero el comun es .php,por ejemplo,desde la misma terminal abrimos nuestro editor de texto(en mi caso vim) y escribimos:

Abrimos:

vim holamundo.php

Luego añadimos el hashbang,con la ruta del ejecutable de php,por ejemplo:

#!/usr/bin/php

Pueden ver la ruta del ejecutable desde la linea de comandos con:

which php

O crear directamente un archivo con el hashbang desde la linea de comandos,así:

echo -e "#\x21`which php`" > holamundo.php

Bien ahora también van las llaves de PHP,estas llaves son necesarias tambien en PHP-CLI,las cuales son:

<?php //codigo ?>

Antes que otra cosa debemos crear ese código,un estilo así:

Bien ahora el primer hola mundo,como PHP ya es conocido vamos a hacer algo mas avanzado que un simple echo:

#!/usr/bin/php

<?php

if ($argc == 3) // Vemos el numero de argumentos
{
    hola($argv[1],$argv[2]); // Si son tres ejecutamos esto
} 
else 
{
    echo "Uso ".$argv[0]." texto1 texto2"; // Si no ejecutamos esto
}

?>

<?php
function hola($x,$y) // Función a ejecutar
{
    echo $x." ".$y; // Mostramos en pantalla
}
?>

Para ejecutar podemos hacerlo de varias formas,la primera es dándole permisos de ejecución y que haga su trabajo el hashbang:

chmod +x holamundo.php

Y ejecutamos:

./holamundo.php

Otra forma también es ejecutar el archivo con el programa php,usando de argumento -f(file),así:

php -f holamundo.php

O así directamente:

php holamundo.php

Bien,ahora vamos a ver entrada por teclado,para que se vea la diferencia entre Linea de comandos y Programación Web,ya que normalmente toma los parámetros PHP desde el HTML o desde la barra del navegador,asi que bueno vamos a hacer un simple código que pregunta el nombre y saluda:

Usamos la función trim para almacenar en una variable lo que devuelva fgets escaneando el STDIN(Entrada estándar(teclado)) quitando los espacios del principio y el final:

#!/usr/bin/php

<?php

echo "Como te llamas : ";

$nom = trim(fgets(STDIN)); 
if ($nom != "")
{
    echo "Hola ".$nom."\n";
}
else 
{
    echo "Tal vez luego\n";
}

?>

Bien de momento es todo,veremos si se queda PHP-CLI para introducirnos mas a fondo en este mundo.

miércoles, 23 de octubre de 2013

Tutorial python Gtk3 botones y layouts

Si vieron el script que programe hace unos días se habrán dado cuenta que use un programa muy útil que se llama zenity,este programa nos crea ventanas fácilmente para usarlas en script's de shell,eso lo menciono porque existen niveles de programación y lo que seria zenity seria muy alto,no muy alto de que es muy buen coder el que lo usa si no de que esta muy preparado para usarse lo cual nos quita la capacidad de personalización por asi decirlo ya que trae hechas las GUI que podemos usar,las cuales nos devuelven un valor,si nos damos cuenta cuando ya lleven por lo menos otro tutorial ademas de este sera muy facil programar un zenity propio para usarlo en scripts en bash,ya que la programación de Gtk desde python es mas bajo nivel que la de zenity,ya que nos permite armar todo un front end,con botones,menus,notebooks,texviews,etc.

En este caso veremos lo que es botones y layouts,para poder armar una pequeña GUI,lo mas importante serian los layouts o contenedores ya que es lo que le da forma al programa,primero vamos a ver lo mas básico para ir fusionandolo entre si:

VBOX

Una vbox(Caja vertical) es un widget que almacena otros widgets adentro de ella de manera vertical,por defecto los widgets que se añaden a la ventana son solo uno,si añadimos mas colapsamos el programa.

Una pequeña pausa:

El esqueleto de los programas de python+Gtk3 debe ser siempre este(por lo menos en estos tutoriales):

#!/usr/bin/env python3

# -*- coding: utf-8 -*- # Codificacion
from gi.repository import Gtk # Importacion de Gtk

class CLase(Gtk.Window): # Una Clase principal que herede Window
    def __init__(self): # Constructor de la clase
        Gtk.Window.__init__(self,title="Titulo de la ventana") # Constructor de la clase padre

obje = EjemploRadioB() # Objeto creado de clase principal

obje.connect("delete-event",Gtk.main_quit) # Metodo de cerrar ventana

obje.show_all() # Mostramos todo

Gtk.main() # Bucle que mantiene abierta la ventana

Bien veamos un ejemplo de como añadiríamos un botón:

#!/usr/bin/env python3

# -*- coding: utf-8 -*-
from gi.repository import Gtk

class Ejemplo(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self,title="Ejemplo de un boton")
        button = Gtk.Button("Un boton")
        self.add(button)
     
ejem = Ejemplo()

ejem.connect("delete-event",Gtk.main_quit)

ejem.show_all()

Gtk.main()

Ahora veamos como usarlos VBOX para añadir mas botones de forma vertical:

Para empezar un objeto tipo caja se define de esta manera (objeto = Gtk.Box()) no importa si es en forma vertical o horizontal,a ese objeto le podemos pasar unos parametros,definiendolos por nombre para no cometer errores de posicion de parametros,por ejemplo podemos poner el espacio entre cada widget que almacenaremos,(pixeles) y entre ello tambien tenemos el parametro orientacion que es el que nos interesa,como python es orientado a objetos la orientacion de la caja no es una excepción debemos definir primero una lista para que no se vea tan largo el codigo(esto es opcional ya que asi lo hago yo):

pos = [Gtk.Orientation.HORIZONTAL,Gtk.Orientation.VERTICAL]

Ahi tenemos una lista con los valores de horizontal y vertical,esto es un poco raro pero asi me gusta hacerlo por si debemos intercambiar el valor solo cambiamos la forma de las constantes,por ejemplo:

pos = [Gtk.Orientation.VERTICAL,Gtk.Orientation.VERTICAL]

Para no andar cambiando una por una.

Ahora vamos a pasarle el parametro a la caja para que sea vertical(por defecto es horizontal):

vbox = Gtk.Box(spacing=5,orientation=pos[0])

Con eso tenemos un objeto vbox y podemos usar todos sus atributos,otra cosa es que esto ya se supone que se debe saber para el nivel de estos tutoriales,pero no lo he comentado es que en python usamos funciones de objetos similares a beans ,lo cual hace que algunos atributos que le podamos pasar como parámetros también tengan funciones que simplemente sirven para cambiarlos,por ejemplo es lo mismo esto:

vbox = Gtk.Box(spacing=5,orientation=pos[0])

Que esto:

vbox = Gtk.Box()

vbox.set_spacing(5)

vbox.set_orientation(pos[0])

Bien,eso se debe estudiar mas a fondo pero por el momento creo que se entiende,ahora vamos a ver las funciones que añaden los widgets,el cual son dos:

pack_start(widget,expand,fill,padding)

Esta funcion sirve para añadir widgets de principio a fin,osea desde el primero o el que sigue del ultimo que añadimos,le tenemos que pasar algunos parametros los cuales son:

widget # Un widget

expand # Un booleano para decir si se va a expandir basado en el widget que lo acompaña

fill # Un booleano para decir si se va a rellenar basado en la ventana

padding # Un numero entero,es contrario a spacing,añade espacio del otro lado.

También contamos con pack_end():

pack_start(widget,expand,fill,padding)

Tiene los mimos parametros,solo que se añade del final,osea al final de derecha a izquierda.

Bien como nos queda el codigo?

Primero vamos a ver como crear un botón normal para que podamos meterlo en :

Un objeto boton se define de la siguiente manera:

boton = Gtk.Button()

Le podemos pasar varios parámetros desde la creación o con funciones,por ejemplo el texto que mostrara(label) un stock(icono) y otros mas complejos como toltips(texto que se muestra cuando pasamos el cursor por arriba de un widget).

Un boton normal seria asi:

boton = Gtk.Button("Un boton")

De esa manera le estamos pasando un parámetro el cual es la label Un botón,no hay problema de hacerlo así ya que es el primer parámetro,pero también lo podríamos hacer así:

boton = Gtk.Button(label="Un boton")

O así:

boton = Gtk.Button()

boton.set_label("Un boton")

Un simple boton tiene muchas funciones,yo del metodo autodidacta que uso les recomiendo que vean las funciones que tiene usando dir:

Por ejemplo:

class Ejemplo(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self,title="Funciones de boton")
        self.button = Gtk.Button(label="Un boton",use_underline=False)
        for i in dir(self.button):
            print i
        self.add(self.button)

ejem =  Ejemplo()

ejem.connect("delete-event",Gtk.main_quit)

ejem.show_all()

Gtk.main()

Lo ejecutan y en la terminal les salen todas las funciones asociadas a esa clase,luego ya solo vemos que parametros usan o googleamos por informacion.

Antes de ver el codigo final queda repasar lo que vimos en la entrada pasada,un widget envia señales las cuales manipulamos con funciones,asi que una buena forma de programacion seria definir el objeto,luego definir sus funciones(si las usamos),luego definir las funciones de sus señales y luego añadirlas a una caja,por ejemplo:

boton = Gtk.Button() # Definicion 
boton.set_label("Boton 1") # Una que otra funcion del objeto
boton.connect("clicked", self.clic, "1") # Señales
vbox.pack_start(boton, False, False, 0) # Añadimos

Bien vamos a ver nuestro ejemplo de una ventana con dos botones:

Enlace

Como vemos se crea una ventana con dos botones en forma vertical,sobre su contrario,que seria hbox(caja horizontal),no hay mucho que explicar solo se tiene que definir que es horizontal o no pasarle el parámetro de orientation,también podemos anidar cajas dentro de cajas,por ejemplo dos cajas verticales dentro de una horizontal:

Enlace

Ahora vamos a ver otros tipos de botones:

RadioButton,el botón radio o botones redondos son muy vistos en algunos programas para elegir una opción,yo mismo los he usado en algunas ocasiones,pero si no los conocen son aquellos que tienen varias opciones pero cuando elegimos opción, cambia a esta y las otras quedan libres,para crear uno de estos botones primero necesitamos saber usar cajas como las de arriba lo cual ya vimos asi que vamos a comenzar creado una caja horizontal para añadir nuestros botones:

hbox = Gtk.Box(spacing=10)

Para definir el primer boton lo hacemos así:

rb = Gtk.RadioButton() # rb es radio button

Le tenemos que pasar algunos parámetros como la label y el grupo al que va a pertenecer,la label sera la opción que veremos,así que ponemos la que queramos y en grupo ponemos None ya que no hay grupo aun:

rb = Gtk.RadioButton(label="Ubuntu",group=None)

El segundo botón podemos añadirlo con la función new_from_widget,el cual le pasamos un parámetro que es el primer botón y así reconoce el grupo al que pertenece:

rb2 = Gtk.RadioButton.new_from_widget(rb1)

Luego podemos ponerle una label con la función set_label(muchos widgets tienen esta función):

rb2.set_label("Windows")

También podemos poner su señal que en este caso no es clicked si no que es toggled:

rb1.connect("toggled", self.clic, "Ubuntu")

Vamos a ver un ejemplo:

Enlace

Vamos a ver ahora el CheckButton,este botón también es muy conocido,ya que para configurar opciones,el cual es un botón con una paloma,si esta palomeado esta activa esa opción,si no no esta activa,es para definir solo dos opciones,ya que el radio button es para definir infinidad de opciones,para crearlo lo hacemos así:

Gtk.CheckButton(label="Hola mundo")

Luego también tenemos su señal que es toggled,y tenemos algunos beans para ver si esta activo:

set_active(boleano)

get_active() # Retorna boleano

Veamos un ejemplo:

Enlace

Hay otro botón que se parece mucho a este, el cual lo he visto en rhythmbox,el boton es el boton Toggled,el cual tiene las mismas funciones que el CheckButton pero con otro aspecto,para definirlo los hacemos así:

tb = Gtk.ToggleButton(label="Hola mundo",stock=Gtk.STOCK_ADD)

Veamos el mismo ejemplo:

Enlace

Otro botón con el que contamos y sirve para darle un poco de fama a nuestros programas es el link button el cual abre una uri,con el navegador que tengamos configurado por defecto en el sistema,(lo que seria xdg-open en linux),para definirlo solo le pasamos la label y la uri que mostrara,podemos hacerlo sin etiquetar los argumentos ya que el primero es la uri y el segundo es la label:

lb = Gtk.LinkButton("http://www.itimetux.com", "Ejemplo por Tiempo de Tux")

Por ejemplo:

Enlace

Por ultimo tenemos el boton spin,que es un tanto raro,ya que no lo he visto mucho,por ejemplo se podría usar para ajustar el tamaño de una fuente,el volumen de una aplicación,etc,pero no lo he visto mucho ya que para eso que mencione hay otros widgets dedicados,pero bueno,para definir un boton spin lo hacemos de la siguiente manera:

sb = Gtk.SpinButton()

Antes de usarlo tenemos que añadir un ajuste con otro widget,el cual se llama Adjustment,a este widget le pasamos algunos parámetros,el primero es el valor inicial(al abrir la ventana),el segundo es el valor mínimo(cuando le demos hacia atrás),el tercero es el valor máximo(hasta donde puede contar),el cuarto es de cuanto en cuanto va a contar,el quinto y sexto son argumentos mas avanzados los cuales no son muy necesarios,ya que con los primeros parámetros podemos hacer una cuenta normal,este widget lo usan otros ademas del spinbutton así que lo veremos de nuevo despumes,de momento vamos a definirlo así:

adjustment = Gtk.Adjustment(0, 0, 10, 2, 0, 0) # Comienza en 0,el mínimo es 0 y el máximo es 10,cuenta de 2 en 2

Las señales que otros widgets envía señales solo que son varias,la que podemos usar de ejemplo es value-changed,en la documentación oficial hay la información necesaria sobre señales,así que al final pondré el enlace,de momento podemos ver este ejemplo:

spinbutton = Gtk.SpinButton() # Definimos
spinbutton.set_adjustment(adjustment) # Añadimos el ajuste
spinbutton.connect("value-changed", self.clic,None) # Desviamos la señal a una funcion

Un ejemplo completo podría ser así:

Enlace

Ahora que ya conocemos los botones podemos pasar a ver las otras dos maneras de crear layouts,una de ellas es Grid,con la cual nos da una forma mas potente de añadir widgets que un box,primero definimos nuestro grid asi:

grid = Gtk.Grid()

Luego tenemos que añadir un widget(con la función add) para empezar,supongamos que tenemos un botón:

grid.add(boton)

Luego añadimos los otros con la función attach_next_to,a la cual le pasamos algunos parámetros:

attach_next_to(widget,despues,posicion,alto,ancho)

En widget ponemos el widget que vamos a añadir.

En después ponemos el widget del que queremos poner despues el widget del parametro 1.

En posición vamos a definir si va a estar arriba,abajo,izquierda o derecha,solo que vamos a usuar objetos especiales:

Gtk.PositionType.LEFT # Izquierda
Gtk.PositionType.RIGHT # Derecha
Gtk.PositionType.TOP # Arriba
Gtk.PositionType.BOTTOM # Abajo

En alto va a ser un dato int,el cual es el numero de widgets que estén disponibles,lo que seria las celdas a ocupar.

En ancho es igual que alto,solo que horizontal.

Veamos un ejemplo:

Enlace

Por ultimo tenemos el modo tabla,este es el mas avanzado de los tres,ya que manejamos celdas basadas en números,es como un tipo exel,o como un array de dos dimensiones,digamos que tenemos cuatro botones y queremos uno en cada esquina de la ventana,usando el método tabla tenemos que definir sus espacios basados en las celdas que ocupara cada widget:

Usamos la función attach y le pasamos algunos parámetros,el primero es el widget,pero los segundos son la celda que ocupara,basado en números:

izquierda, derecha, arriba, abajo

Primero creamos un objeto tabla con los parametros que serán el numero de filas y columnas para crear las celdas,supongamos 2x2:

table = Gtk.Table(2, 2, True) # El tercer parámetro es un bool

Luego nos quedaría una ventana así:

Rojo es vertical y negro es horizontal.

Este es un ejemplo para que vean el modo de adición que vamos a usar.

Como vemos tenemos asignaciones numéricas,si quiero poner cuatro botones para que dibujen esa forma lo haría así:

Que el primer botón a la izquierda tenga cero para que este pegado a la izquierda,a la derecha tenga uno para que ocupe solo un espacio,que arriba comience en 0 para que este pegado a arriba,y abajo tenga 1 para que ocupe solo un espacio:

table.attach(boton1, 0, 1, 0, 1)

Ahora el segundo,que empiece en 1 a la izquierda,para que continue el espacio donde termina el primero,que a la derecha termine en 2,pegado a la otra orilla de la ventana,arriba y abajo es igual ya que usan la misma linea 0 y 1:

table.attach(boton2, 1, 2, 0, 1)

El tercer botón que empiece en 0 ya que estará pegado a la izquierda,a la derecha termine en 1,ya que es igual que el de arriba,arriba que comience en 1 para que este abajo del primero,y abajo termine en 2,pegado a la parte de abajo:

table.attach(boton3, 0, 1, 1, 2)

Por ultimo el cuarto que comience en 1,pegado al tercero,que termine en 2 a la derecha,pegado a la derecha,arriba y abajo es igual que el tercero 1 y 2:

table.attach(boton3, 1, 2, 1, 2)

Veamos el código entero:

Enlace

Es un poco raro,pero solo es cuestión de que se entienda como elegir las celdas de hecho Grid tambien cuenta con este modo de adición de widgets,con su función attach,pero quería mostrar el modo sencillo,también tenemos unas funciones para Table:

Estas son las que me gustan mas:

espacio = 10

table.set_row_spacings(espacio) # El espacio de serparacion de cada fila(pixeles)

table.set_col_spacings(espacio) # Eñ espacio de separacion de cada columna(pixeles)

Mas información el pagina oficial:

Enlace

developer.gnome.org/gtk3/stable/ch03.html

viernes, 18 de octubre de 2013

Tutorial Ruby en Linux introduccion

Otro lenguaje de programación que posiblemente deje en el sitio,de hecho este lenguaje tenia un blog especial para el como Lua pero no escribía mucho, ademas de que lo mas común seria tener un sitio de un lenguaje corriendo sobre el mismo,por el ejemplo con RoR,pero no me gusta mucho la programación web así que por eso no le hecho muchas ganas a crear un sitio desde cero,de hecho se podrán haber dado cuenta con el simple hecho de que yo uso blogger en vez de wordpress o movabletype o crear un sitio con Django o RoR de hecho si se dan cuenta de los mismos tutoriales de los lenguajes que hay no hay ninguno sobre desarrollo web,de hecho podrán ver mi poco interés por el desarrollo web al ver los mas de 300 errores que tiene esta plantilla :P.

Bien este no es un tutorial en si ya que solo es para probar las estadisticas,pero vamos a comenzar.

Ruby es un lenguaje de script un tanto influido por Perl,es creado por Yukihiro Matsumoto(Matz) el cual hizo publica la primera version en 1995,la cual comenzó a trabajar desde 1993, lenguaje de programación interpretado, reflexivo y orientado a objetos.

Ruby en lo personal me gusta ya que es muy facil hacer cosas con el al igual que con Python,si conocen la sintaxis de Perl y de Python veran que Ruby es como si fuera una mezcla de ambos,vean:

Por ejemplo la forma de definir clases de python:

class hola():
def __init__(self,hola,mundo):
self.hola = hola
self.mundo = mundo
def ver(self):
print self.hola+" "+self.mundo

ob = hola("Hola","Mundo")

ob.ver()

En ruby :

class Hola
def initialize(hola,mundo)
@hola = hola
@mundo = mundo
end
def ver()
print @hola+" "+@mundo+"\n"
end
end

ob = Hola.new("Hola","Mundo")

ob.ver()

En Perl:

package Hola;

sub new
{
my $this = shift;
my $class = ref($this) || $this;
my $self = {hola => shift,mundo => shift};
bless $self,$class;
return $self;
}

sub ver
{
my $self = shift;
print $self->{hola}." ".$self->{mundo}."\n";
}

my $ob = Hola->new("Hola","Mundo");

$ob->ver();

Bien,vamos a comezar primero que nada necesitamos instalar ruby,la version estable es la 2.0.0 pero en muchas distribuciones de Linux tenemos la version 1.8 y nos servira para este tutorial así que instalamos:

Enterminal:

sudo apt-get install ruby

Los archivos de ruby son de extensión .rb o .rbw podemos ejecutarlos con ruby directamente asi:

ruby archivo.rb

O con hashbang en modo de ejecucion,primero añadimos un bang:

#!

Luego añadimos la ruta de ruby pero como varia dependiendo los sistemas haremos que env lo encuentre,así que mejor ponemos la ruta de env y le pasamos como parámetro el nombre de ruby,asi queda el hashbang:

#!/usr/bin/env ruby

Si no queremos usar un archivo,podemos usar la shell interactiva de ruby ibr,es similar a la de python solo que esta se abre tecleando:

irb

El programa hola mundo es muy sencillo a diferencia de lo que veimos en Java en el tutorial pasado,para imprimir texto desde la STDOUT(salida estándar),solo debemos escribir:

puts "Hola Mundo"

Y listo nuestro primer programa :D,puts es como print solo que añade un (\n) al final para nueva linea.

Vamos a ver los tipos básicos:

my_num = 25 # numero entero

my_num_r = 10.7 # numero real

my_boolean = true # Boleano verdadero = true falso = false

my_string = "Ruby" # Cadena

Ejemplo:

#!/usr/bin/ruby

my_num = 25 # numero

my_num_r = 10.7 # numero real

my_boolean = true # Boleano

my_string = "Ruby" # Cadena

puts "Tipos de datos :"

print "Numero entero : ", my_num, "\n"

print "Numero real : ", my_num_r, "\n"

print "Boolean: ", my_boolean, "\n"

print "Cadena: ", my_string

En ruby podemos añadir comentarios a nuestro codigo de dos maneras,la primera es en una sola linea con el hash o gato:

# Un comentario

De esta manera no hará caso a lo que escribamos a menos que sea un bang.

La otra forma es multilinea con las palabras especiales begin/end:

=begin

Un comentario

Otra linea

=end

Esto es lo mismo que vimos en Java,no es tutorial en si solo es un prueba,pero si dejo ruby lo veremos mas a fondo.

miércoles, 16 de octubre de 2013

Enviar a disco extraible en ubuntu [Script]

En Linux ubuntu hay algo que no encontré desde el principio y es que por ejemplo en Windows cuando tenemos conectada una memoria usb nos da la opción de mandar los archivos seleccionados a esa memoria,en todo el universo de Linux no se si haya algo similar a esto,pero en el sistema que uso yo que es Ubuntu con Nautilus 3.4.x no,asi que programe algo en bash con un poco de Perl embebido para manejar esto,es facil emularlo con bash aunque en mi caso lo he usado y no me ha dado problemas si les da algún tipo de problemas comenten para arreglarlo o manden un aviso en la zona de contacto del sitio.

El script es el siguiente:

Enlace

El nivel de programación que use es un poco mas avanzado(en sintaxis de lo que hemos visto en este sitio) sin embargo los algoritmos son algo vulnerables, ya que solicitan texto de un archivo externo,pero no es un gran problema a menos que tengamos un espía en nuestro sistema que pueda agregar archivos mas rápido de lo que se ejecuta un script.

Bien para usar solo hay que hacer lo siguiente:

Abren una terminal(Ctrl+Alt+T) y escriben esto:

gedit ~/.gnome2/nautilus-scripts/enviar\ a... && chmod +x ~/.gnome2/nautilus-scripts/enviar\ a...

Se les va abrir gedit,copian de la web el codigo en bash y lo pegan en Gedit:

luego cierran Gedit y listo :D.

Seleccionan sus archivos luego le dan clic derecho:

Y elegimos nuestro disco:

Pequeña actualización:

Luego esperamos basado en el peso de nuestro archivo.

Eso es todo :D.

martes, 15 de octubre de 2013

Tutorial Java en Linux Introduccion

Tengo pensado traer un nuevo lenguaje de programación al sitio y uno de ellos es Java,en las siguientes entradas haré algunos tutoriales de lenguajes de programación que no he traído al sitio y tenia pensado preguntar que lenguaje les gustaría que hiciera tutoriales,pero como no hay mucha respuesta me basare en las estadísticas aunque se caiga el poco SEO que queda,asi que en los próximos días veremos nuevos lenguajes en el sitio y basado en la respuesta que vea dejare alguno.

Como no es un tutorial muy propio del mismo lenguaje no voy a entrar en detalles muy técnicos,Java es un lenguaje diseñado por Sun Microsystems cuenta con una implementacion un tanto libre llamada OpenJDK que tiene una licencia GPL con linking exception,así que para los amantes de lo libre pueden usar OpenJDK para programar.

OpenJDK es la versión libre de JDK(Java Development Kit) es el kit de desarrollo para Java,el cual se debe instalar para poder usarlo.

Otra ventaja que tiene Java es que es multiplataforma por lo cual si hacemos algo en Windows lo podemos traer a Linux(usando las librerías especificas) por ejemplo,solo que el otro lado de la modena de esto es que Java tiene su propia maquina virtual JVM(Java Virtual Machine) la cual hace una doble ejecución,primero la maquina y luego la ejecución del código en la maquina,ademas esto se traduce en bytecode para que lo lea la JVM y luego la ejecución en el sistema,es algo así como en Lua.

Otra cosa que hay que tener en cuenta es que Java es puro OPP,Programación Orientada a Objetos,la cual en mi punto de vista es muy lenta en java ya que son variables de objetos de variables de variables de variables de variables,por lo cual veremos mucho algo como:

var.var.var.var.var();

Es una opinión muy propia,pero la pueden tomar en cuenta.

Java es muy bueno para aprender ya que es un lenguaje de programación total muy popular por lo cual podremos crear programas y aplicaciones profesionales.

Bien vamos a comenzar:

Primero instalamos Java,en Ubuntu podemos instalar Java 7 con este comando:

sudo add-apt-repository ppa:webupd8team/java

sudo apt-get update

sudo apt-get install oracle-java7-installer

O OpenJDK con:

sudo apt-get install openjdk-7-jdk

Para otros sistemas googlen.

Hola Mundo,este programa es muy básico el cual consta en mostrar en la salida estándar(consola) el mensaje Hola Mundo,vamos a verlo y en seguida lo explico:

Primero que nada abrimos nuestro editor de texto,yo uso vim pero si necesitamos hacer algo mas rápido o con ayuda les recomiendo instalar eclipse.

Pero en este tutorial vamos a usar un editor de texto común,primero que nada abrimos nuestro archivo,en mi caso:

Desde terminal.

vim hola.java

O por ejemplo con gedit(un editor grafico):

gedit hola.java &

El nombre del archivo es el nombre de la clase,el nombre principal,así que vamos a definir nuestra clase y adentro nuestro constructor:

public class hola {
    public static void main(String[] args) {
        System.out.println("Hola Mundo");
    }
}

Ahora necesitamos compilar a bytecode:

javac hola.java

Y por ultimo ejecutamos:

java hola

Y listo Hola Mundo,como ven al ejecutar java no necesitamos usar el nombre completo del archivo creado que seria hola.class,vamos a explicar linea a linea ya que es un poco diferente a los programas de script que hemos visto:

public class hola { // Crea una clase llamada hola de instancia publica

public static void main(String[] args) { // Iniciamos la clase con el metodo(funcion) main

public // Instancia publica

static // Modificador static,se usa para poder usar metodos de un objeto sin definirlo

void // Tipo de retorno de la funcion en este caso ninguna(vacia->[void])

main // Metodo principal que inicia el programa principal y en este caso la clase hola

(String[] args) // Es el parámetro que le pasamos a la función main o en este caso que nos pasa el sistema,lo que esta adentro es un vector compuesto de variables tipo string,en otras palabras es un array de strings,el cual contiene los parámetros pasados desde la terminal o desde el Path del ejecutable.

System.out.println("Hola Mundo"); // Esta es una función de System que a la vez entra a out que a la vez llama a println al cual le pasamos un parámetro que en esta ocasión es el texto Hola Mundo:

Vamos a comenzar con las variables,esta estructura siempre la vamos a ver:

public class clase {
    public static void main(String[] args) {
        // Codigo
    }
}

En java podemos escribir comentarios con // o podemos escribir comentarios en varias lineas con (/**/):

// Comentario

/* comentarios */

/************
  
 Comentario  
    
*************/

En java debes escribir el tipo de variable antes de iniciarla,los tipos mas comunes con:

boolean => true o false

int => Numero entero

long => Numero entero largo

short => Numero entero corto

float => Numero de coma flotante de precicion simple

double => Numero de coma flotante de doble precision

char => Carácter

String => Cadena

void => Nada

Por ejemplo:

boolean no = false;

int x = 100;

long y = 143435435675;

short z = 1;

float xy = 10.1;

double yx = 123213.2421421421;

char a = '\u0061';

String cadena = "Hola Mundo";

En el caso de los caracteres son caracteres Unicode,los primeros son de ASCII pero también podemos poner directamente un carácter.

char a = 'a';

También hay que recordar que en Java debemos terminar cada linea con punto y coma.

O un numero que se pasara a carácter:

for (int i = 48;i < 91;++i)
{
    System.out.printf("%c\n",i);
}

En el caso de los argumentos usamos un vector de strings,es algo que veremos si se queda java,pero podemos ver un array de una dimensión (vector o arreglo unidimensional
) de strings fácilmente:

public class hola {
    public static void main(String[] args) {
        String[] abs = new String[2]; // Creamos un vector de strings
        abs[0] = "Hola"; // <- Comenzamos el valor desde cero
        abs[1] = " Mundo";
        String[] abc = {"Hola"," Mundo"}; // <- Esto equivale lo mismo
        System.out.println(abs[0]+abs[1]);
        System.out.println(abc[0]+abc[1]);
    }
}

Vamos a emular lo que nos pasa la linea de comandos:

public class hola {
    public static void main(String[] args) {
        String[] abs = new String[2]; // Creamos un vector de strings
        abs[0] = "Hola";
        abs[1] = " Mundo";
        String[] abc = {"Hola"," Mundo"}; // <- Esto equivale lo mismo
        ver(abc); // Pasamos el vector
    }
    static void ver(String[] args) { // El parametro es el mismo tipo que le pasamos arriba
        for (int i = 0;i < args.length;i++) // Lo recorremos
        {
            System.out.println(args[i]);
        }
   }
}

Vamos a verlo en uso:

public class hola {
    public static void main(String[] args) {
        for (int i = 0;i < args.length;i++)
        {
            String ar = String.format("Argumento %d : %s\n",i,args[i]);
            System.out.print(ar);
        }
    }
}