Tiempo de Tux: octubre 2013

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);
        }
    }
}

Podemos ejecutar así:

java hola Hola Mundo

Eso es una pequeña introducción a lo que seria Java,así que veremos en unos días si lo dejo.

sábado, 12 de octubre de 2013

Tutorial SQlite3 con Python3 en Linux

SQLite es una herramienta que nos permite guardar bases de datos portables para poder usarlas en programas,scripts,etc sin tener que acceder a conexiones de Bases de Datos establecidas en un servidor especifico,en otras palabras(mis palabras) SQLite es como un MySQL portable, SQLite usa una variante no estándar del lenguaje SQL,por lo cual si conoces el lenguaje SQL como con MySQL,no sera dificil comprender el funcionamiento de SQLite.

Primero que nada debemos tener instalado el modulo para Python,en Linux no debe haber problema,he oído que en otros sistemas si,pero en GNU/Linux no,pero de todos modos comprobamos:

python -c 'import sqlite3'

Si no ven ningún error no hay problema,si ven alguno tendrán que instalar,por ejemplo con pip:

pip install sqlite3

Bueno,primero que nada vamos a abrir nuestro editor de texto favorito para comenzar con los ejemplos,pueden usar la consola de python,pero yo recomiendo un editor y la shell de bash(la termina):

O sea dos terminales:

En mi caso vim(desde aquí se puede ejecutar el código sin usar otra terminal,pero yo uso dos).

Primero que nada vamos a crear un archivo .db,si no existe lo crea si no se conecta a el.

Vamos a crear una variable objeto para conectarnos al archivo que guardara la base de datos:

db = sqlite3.connect('hola.db')

En estos momentos ya creamos un objeto para manipular la base de datos hola.db,ahora lo que tenemos que crear es un cursor para movernos(por así decirlo) dentro de la db,osea ejecutar comandos de lenguaje SQL en la DB:

cur = db.cursor()

Ahora vamos a ejecutar algunos comandos básicos de SQL con la función execute(este tutorial supone que tienes conocimientos básicos de lenguaje SQL):

cur.execute('CREATE TABLE holamundo(pal1 text,pal2 text)')

cur.execute('INSERT INTO holamundo VALUES("Hola","Mundo")')

Con eso ya tendriamos creada una DB basica,ahora vamos a guardar lo que hicimos con la funcion commit de la db:

db.commit()

Siempre debemos ejecutar commit o no guardara los cambios.

Por ultimo vamos a ejecutar la funcion close para que cierre la conexion:

db.close()

Podemos ejecutar nuestro script,asi quedaria:

 #!/usr/bin/env python3  
 import sqlite3  
 db = sqlite3.connect('hola.db')  
 cur = db.cursor()  
 cur.execute('CREATE TABLE holamundo(pal1 text,pal2 text)')  
 cur.execute('INSERT INTO holamundo VALUES("Hola","Mundo")')  
 db.commit()  
 db.close()

Y listo tenemos una base de datos portable,si no me creen pueden ejecutar la shell de sqlite3 de linux:

sqlite3 hola.db

.tables

SELECT * FROM hola

Bien funciona :D.

Las ordenes que dimos con exec,las podemos dar en una sola linea ejecutando un script interno,con la función executescript del cursor:

Primero vamos a usar comillas triples,que son para varios comentarios,como DATA<< en Perl,Ruby o como --[[ ]]-- en lua:

cur.executescript("""
CREATE TABLE holamundo(pal1 text,pal2 text);
INSERT INTO holamundo VALUES("Hola","Mundo");
INSERT INTO holamundo VALUES("Hola","desde SQLite Python");
""")

Añadí un comando mas para ver como funciona,en este caso no necesitamos hacer un commit ya que agrega y hace un commit internamente en cada orden.

Ya vimos como agregar ahora como obtener:

Para obtener los datos que necesitamos hay varias maneras,primero la mas sencilla,pero menos potente llamar un único valor:

Como se ve arriba el comando execute usa comandos SQL,si usamos comandos de creación crea,pero si usamos comandos de recuperación donde quedan?

Quedan en variables especiales que se convierten en tuplas,en este caso la función fetchone devuelve una tupla del primer valor que coincida:

cur.execute("SELECT * FROM holamundo")
print (cur.fetchone())

Eso nos devuelve una tupla desde una funcion,por lo cual es valido hacer esto:

print (cur.fetchone()[0])

Bien,pero si queremos todo?

Es fácil saberlo (sabiendo ingles básico),con el comando fetchall:

La cual nos devuelve una tupla de dos dimensiones(en este caso),ya que la primera dimensión contiene las dos tuplas que creamos,y la segunda dimensión contiene los valores de cada tupla:

print (cur.fetchall())

Por lo cual es valido hacer esto:

print (cur.fetchall()[1][1])

En este caso nos devuelve esto:

Bien,hay otra forma de recuperación de datos la cual es iterando sobre una orden de ejecución,ya que como nos devuelve una tupla podemos iterar sobre ella:

for tup in cur.execute("SELECT * FROM holamundo"): # Iteramos en la primera dimencion
for val in tup: # Iteramos en la segunda dimencion
print (val)

Bien vamos a temas mas avanzados de agregación de datos.

Supongamos que queremos poner un dato en la query que ejecuta la API de SQLite,en otras palabras queremos definir los valores que introduciremos en la tabla desde una variable,como le hacemos,¿Podemos usar formateo de cadenas?,Si,por ejemplo:

Borren la DB que creamos desde la shell:

rm hola.db

 #!/usr/bin/env python3  
 import sqlite3  
 db = sqlite3.connect('hola.db')  
 cur = db.cursor()  
 #cur.execute('CREATE TABLE holamundo(pal1 text,pal2 text)')  
 cur.execute("SELECT * FROM holamundo")  
 x,y = "Hola","Mundo" # Creamos variables  
 cur.execute('INSERT INTO holamundo VALUES ("%s","%s")' %(x,y)) # Formateamos  
 db.commit()  
 db.close()

Eso se puede hacer,pero no se debe hacer,porque?

Por la vulnerabilidad de formateo de strings,por ejemplo una Inyección SQL.

Entonces que hacemos?

Podemos hacerlo de dos maneras creamos un dato tipo diccionario para que la query parse el valor desde los valores de un diccionario que es clave/valor o usando una tupla que no se puede cambiar el valor:

Primer ejemplo, metodo qmark:

cur.execute('INSER INTO holamundo VALUES(?,?)',(x,y))

En este caso usamos un estilo de formateo,pero con el símbolo (?) y le pasamos el valor desde una tupla,la cual no se puede modificar.

Segundo ejemplo, metodo de nombre:

cur.execute('SELECT * FROM holamundo WHERE pal1=:hola',{"hola":"Hola"});

print(cur.fetchall())

Este se ve un poco mas complejo pero es fácil,solo hay que pesarle los valores de un diccionario y como es una string para que no de error de valor debemos anteponer dos puntos en la query SQL,veamos otro ejemplo:

x,y = "Hola", "Mundo" # X vale Hola,Y vale Mundo

dic = {'x':x,'y':y} # Adentro del diccionario X vale X que a la vez vale Hola,Y vale Y que a la vez vale Mundo

cur.execute("INSERT INTO holamundo VALUES(:x,:y)",dic) # Insertamos los valores del diccionario,anteponemos dos puntos para que se reconozca como string.

Ahora como podemos ver las columnas?,ya que podemos ver los valores que contienen pero las columnas?

Aquí falta ver que columnas son las que contienen Hola y Mundo que serian pal1 y pal2,para ello vamos a cambiar el atributo row_factory de la db a sqlite3.Row:

db.row_factory = sqlite3.Row

cur = db.cursor()

cur.execute("SELECT * FROM holamundo")

Ahora podemos acceder a las llaves de la tupla que se crea cuando buscamos algo,recuerdan fetchone:

for i in cur.fetchone().keys():
print(i)

También compatible con len:

print(len(cur.fetchone().keys()))

De esa manera tendremos las columnas de la tabla ya que por defecto fetch nos devuelve una tupla sqlite,y de esta manera nos devuelve una columna sqlite compatible con las funciones keys,len,entre otra.

De hecho la funcion sqlite3.Row es opcional,podemos programar nuestra propia funcion para que sea igual al parametro de row_factory de la DB,es un poco largo de explicar pero veamos un poco:

Creamos una funcion que sea igual a row:_factory,este parametro nos pasa argumentos,asi que vamos a recorrerlos con,con *args(recuerdan el tutorial):

 #!/usr/bin/env python3  
 import sqlite3  
 def datos(*args):  
   for i in args:  
     print (i)  
 db = sqlite3.connect('hola.db')  
 db.row_factory = datos  
 cur = db.cursor()
 cur.execute("select * from holamundo")
 print(cur.fetchone())
 db.close()

Eso nos dirá los argumentos que nos manda,los cuales son:

El primero es un objeto mas específicamente un cursor,el segundo es la columna que regresa la query que ejecutamos y nos manda un tercero Nulo(None):

Así que podemos hacer esto,para ver las funciones que tienen:

for i in dir(args[0]):
print i

for i in dir(args[1]):

print i

Y nos muestra las funciones de cada uno,en la pagina oficial nos muestra una manera de crear un diccionario,en este ejemplo seria así:

 import sqlite3  
   
 def dict_factory(cursor, row):  
   d = {}  
   for idx, col in enumerate(cursor.description):  
     d[col[0]] = row[idx]  
   return d  
   
 con = sqlite3.connect("hola.db")  
 con.row_factory = dict_factory  
 cur = con.cursor()  
 cur.execute("select * from holamundo")  
   
 print (type(cur.fetchone()))  
   
 for k in cur.fetchone():  
   print (k,"->",cur.fetchone()[k])

Todo lo que hicimos lo podemos hacer conectandonos directamente a la memoria ram,el cual nos dara un espacio de trabajo temporal,no lo recomiendo a menos de que sea un trabajo especial como un manejo de memoria basada en un algoritmo temporal,osea como una actualización basada en datos actuales que pueden cambiar,normalmente podemos hacer todo el trabajo en archivos,como en este tutorial en la base hola.db,de todas formas podemos conectarnos a una base de datos creada directamente en la memoria RAM la base de datos se destruirá cuando se cierre la conexión:

Para hacerlo necesitamos usar el parámetro :memory: en la conexión:

  #!/usr/bin/env python3   
  import sqlite3   
  db = sqlite3.connect(':memory:')   
  cur = db.cursor()   
  cur.execute('CREATE TABLE holamundo(pal1 text,pal2 text)')   
  cur.execute('INSERT INTO holamundo VALUES("Hola","Mundo")')  
  cur.execute('SELECT * from holamundo')  
  print(cur.fetchall())   
  db.commit()   
  db.close()

Bien con eso terminamos este tutorial,tal vez haga otra parte ya que falto lo mas avanzado que es crear funciones y clases para usarlas como extensión,pero de momento es todo.

Esto es muy útil cuando se programan juegos,por ejemplo con pygame,o para android,un ejemplo rápido es ponerle un historial de juegos ganados al juego de ahorcado que programe en perl,así es usar Python junto con Perl es sencillo usar lenguajes juntos,así que vamos a ver como quedaría el script y haber si le entienden o encuentran errores con lo que aprendimos en este tutorial:

 #!/usr/bin/ev python3  
   
 from sys import argv  
   
 import sqlite3  
   
 db = sqlite3.connect('records.db')  
 db.row_factory = sqlite3.Row  
 cur = db.cursor()  
 num = 0  
   
 query = "SELECT * FROM ahorcado order by puntuaje"  
   
 try:  
   cur.execute(query)  
 except:  
   cur.execute('CREATE TABLE ahorcado(nombre TEXT,puntuaje INTEGER)')  
   
 def mayor_pal(p):  
   global num  
   if len(p) > num:  
     num = len(p)  
   
 def agregar(x,y):  
   gamer = x  
   puntos = y  
   cur.execute("INSERT INTO ahorcado VALUES(:jugador,:puntuaje)",{"jugador":gamer,"puntuaje":puntos})  
   db.commit()  
   
 def ver(x):  
   for i in x.execute(query):  
     mayor_pal(i[0])   
   print "\tJugador",(" "*num),"Puntuaje\n"  
   for i in x.execute(query):  
     print "\t",i[0],(" "*(num+4)),i[1]  
   
 if len(argv) > 1:  
   if argv[1] == "-a" and len(argv) == 4:  
     agregar(argv[2],argv[3])  
   elif argv[1] == "-v":  
     ver(cur)  
   else:  
     exit()  
   
 db.close()

Al juego de ahorcado le hice también unas pequeñas modificaciones.

Pueden descargarlo aquí: