Tutorial python gtk3 Entry

En esta ocasión vamos a aprender a usar cajas de entrada de texto usando Python + Gtk. Los entry se usan para introducir texto,o mostrar texto en forma muy corta.

Para crear un entry se crea un objeto de la clase Gtk.Entry(),los cuales pueden tener algunos parámetros,funciones para hacer un entry mas customizado y funcional:

self.entry = Gtk.Entry()

Este es un entry muy muy básico:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# -*- coding: latin-1 -*- from gi.repository import Gtk, GObject class Ejemplo(Gtk.Window): def __init__(self): Gtk.Window.__init__(self, title="Ejemplo entry") self.set_size_request(200, 100) self.entry = Gtk.Entry() self.add(self.entry) ventana = Ejemplo() ventana.connect("delete-event", Gtk.main_quit) ventana.show_all() Gtk.main()

Ahora vamos a ver algunas funciones:

Añadir texto al crearlo:

Para añadir texto vamos a usar el argumento explicito text,al crearlo:

self.entry = Gtk.Entry(text="Hola Mundo!!")

 Si se desea colocar texto en el entry aun cuando ya esta creado el objeto,podemos usar la función set_text("texto"):

self.entry.set_text("Hola Mundo!!")

De igual manera tenemos una función opuesta que llama el texto que se haya introducido :

self.entry.get_text()

Ejemplo de intercambiar texto de un entry a otro:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# -*- coding: latin-1 -*- from gi.repository import Gtk, GObject class Ejemplo(Gtk.Window): def __init__(self): Gtk.Window.__init__(self, title="Ejemplo entry") self.set_size_request(200, 100) self.pos = [Gtk.Orientation.HORIZONTAL,Gtk.Orientation.VERTICAL] self.vbox = Gtk.Box() self.vbox.set_spacing(1) self.vbox.set_orientation(self.pos[1]) self.entry = Gtk.Entry(text="Hola Mundo!!") # Inicia con el texto "Hola Mundo!!" self.vbox.pack_start(self.entry,True,False,1) # Lo añadimos al box self.button = Gtk.Button(label="Cambiar") # Añadimos un boton self.vbox.pack_start(self.button,True,False,1) self.button.connect("clicked", self.cambiar) # Si el boton se cliquea vamos a la funcion cambiar self.entry2 = Gtk.Entry() self.vbox.pack_start(self.entry2,True,False,1) self.add(self.vbox) def cambiar(self,widget): texto = self.entry.get_text() # El texto es igual al get_text() del entry1 self.entry2.set_text(texto) # Ponemos el texto del entry1 en el entry2 ventana = Ejemplo() ventana.connect("delete-event", Gtk.main_quit) ventana.show_all() Gtk.main()

También contamos con funciones para esconder el texto ingresado:

Para ello solo usamos la función set_visibility(bool) con un valor booleano,en este caso False:

self.entry.set_visibility(False)

Ejemplo de login:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

from gi.repository import Gtk, GObject class Ejemplo(Gtk.Window): def __init__(self): Gtk.Window.__init__(self, title="Ejemplo entry") self.set_size_request(200, 100) self.pos = [Gtk.Orientation.HORIZONTAL,Gtk.Orientation.VERTICAL] self.vbox = Gtk.Box() self.vbox.set_spacing(1) self.vbox.set_orientation(self.pos[1]) self.entry = Gtk.Entry() self.vbox.pack_start(self.entry,True,False,1) self.entry2 = Gtk.Entry() self.entry2.set_visibility(False) self.vbox.pack_start(self.entry2,True,False,1) self.button = Gtk.Button(label="Login") self.button.connect("clicked", self.login) self.vbox.pack_start(self.button,True,False,1) self.add(self.vbox) def login(self,widget): user = self.entry.get_text() password = self.entry2.get_text() if (user == "Gtk" and password == "Gtk"): print "Login correcto" else: print "Login incorrecto" ventana = Ejemplo() ventana.connect("delete-event", Gtk.main_quit) ventana.show_all() Gtk.main()

En ese mismo ejemplo podemos usar algo que se usan en muchos logins,asignar un máximo de letras al usar el entry:

self.entry.set_max_length(numero_de_letras)

Tambien en el ejemplo de arriba si quisieramos indicar de que o para que sirve el entry podemos usar un placeholder,esto para que nos muestre de que sirve sin añadir un widget extra y que no estorbe en funcionalidad:

self.entry.set_placeholder_text("Texto")

Si quisiéramos hacer que el testo mostrado,por ejemplo desde el principio (como se ve arriba) fuera inmutable,podemos usar set_editable(), al cual le pasamos como argumento un bool,para ver si se podrá editar:

self.entry.set_editable(False) # Evita cambio

Si queremos que nuestro entry nos autocomplete podemos usar un EntryCompletion,esto lo veremos cuando veamos los Liststore,pero de momento pueden ver esta función que crea un EntryCompletion:

1 2 3 4 5 6 7 8 9 10 11 12 13

def set_completation(self): sistemas = [ "Ubuntu","Arch","Gentoo","Debian","Mint","openSUSE", ] liststore = Gtk.ListStore(str) for sistema in sistemas: liststore.append([sistema]) completion = Gtk.EntryCompletion() completion.set_model(liststore) completion.set_text_column(0) return completion

Esa función devuelve una EntryCompletion ahora solo tenemos que asignarla al entry,con la funcion

self.entry.set_completion(self.set_completation())

Este es un ejemplo que pregunta que distribución de Linux usas:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

from gi.repository import Gtk, GObject class Ejemplo(Gtk.Window): def __init__(self): Gtk.Window.__init__(self, title="Ejemplo entry") self.set_size_request(200, 100) self.pos = [Gtk.Orientation.HORIZONTAL,Gtk.Orientation.VERTICAL] self.vbox = Gtk.Box() self.vbox.set_spacing(1) self.vbox.set_orientation(self.pos[1]) self.entry = Gtk.Entry() self.entry.set_placeholder_text("Que sistema Linux usas?") self.entry.set_completion(self.set_completation()) self.vbox.pack_start(self.entry,True,False,1) self.button = Gtk.Button(label="Aceptar") self.button.connect("clicked", self.uso) self.vbox.pack_start(self.button,True,False,1) self.add(self.vbox) def set_completation(self): sistemas = [ "Ubuntu","Arch","Gentoo","Debian","Mint","openSUSE", ] liststore = Gtk.ListStore(str) for sistema in sistemas: liststore.append([sistema]) completion = Gtk.EntryCompletion() completion.set_model(liststore) completion.set_text_column(0) return completion def uso(self,widget): if self.entry.get_text() != "": print "Uso %s" %(self.entry.get_text()) ventana = Ejemplo() ventana.connect("delete-event", Gtk.main_quit) ventana.show_all() Gtk.main()

Si quisiéramos que hubiera un boton en el mismo entry para no usar uno ajeno haríamos esto:

Primero añadimos un icono,por ejemplo uno de los stocks :

self.entry.set_icon_from_stock(icon_pos,stock)

En stock añadimos uno de los siguientes:

Enlace 

Y en icon_pos,podemos usar:

Gtk.EntryIconPosition.SECONDARY # Derecha

Gtk.EntryIconPosition.PRIMARY # Izquierda

Ahora nos quedaría así,un boton para limpiar el texto(borrar el texto del entry):

self.entry.set_icon_from_stock(Gtk.EntryIconPosition.SECONDARY,Gtk.STOCK_CLEAR)

Con eso añadiríamos el boton,pero ahora hay que definir la función,para ellor tendriamos que añadir la señal de icono presionado:

self.entry.connect("icon-press",self.limpiar,None)

El primer argumento es el tipo de señal,el segundo la función a llamar,y el tercero es algún parámetro extra.

Por ultimo podemos añadir un tooltip al boton del entry para que nos diga por ejemplo en este ejemplo que es lo que hace,en este caso borrar el texto,par ello solo debemos llamar la función set_icon_tooltip_text, y pasarle rn el primer parametro la posision(igual que arriba) y en el segundo el tooltip:

 self.entry.set_icon_tooltip_text(Gtk.EntryIconPosition.SECONDARY, "Borrar texto")

Ejemplo completo:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

# -*- coding: latin-1  -*- from gi.repository import Gtk, GObject class Ejemplo(Gtk.Window): def __init__(self): Gtk.Window.__init__(self, title="Ejemplo entry") self.set_size_request(200, 100) self.pos = [Gtk.Orientation.HORIZONTAL,Gtk.Orientation.VERTICAL] self.vbox = Gtk.Box() self.vbox.set_spacing(1) self.vbox.set_orientation(self.pos[1]) self.entry = Gtk.Entry() self.entry.set_placeholder_text("Que sistema Linux usas?") self.entry.set_completion(self.set_completation()) self.entry.set_icon_tooltip_text(Gtk.EntryIconPosition.SECONDARY, "Borrar texto") self.entry.set_icon_from_stock(Gtk.EntryIconPosition.SECONDARY,Gtk.STOCK_CLEAR) self.entry.connect("icon-press",self.limpiar,None) self.vbox.pack_start(self.entry,True,False,1) self.button = Gtk.Button(label="Aceptar") self.button.connect("clicked", self.uso) self.vbox.pack_start(self.button,True,False,1) self.add(self.vbox) def limpiar(self,*args): self.entry.set_text("") def set_completation(self): sistemas = [ "Ubuntu","Arch","Gentoo","Debian","Mint","openSUSE", ] liststore = Gtk.ListStore(str) for sistema in sistemas: liststore.append([sistema]) completion = Gtk.EntryCompletion() completion.set_model(liststore) completion.set_text_column(0) return completion def uso(self,widget): if self.entry.get_text() != "": print "Uso %s" %(self.entry.get_text()) ventana = Ejemplo() ventana.connect("delete-event", Gtk.main_quit) ventana.show_all() Gtk.main()

Eso es todo :D

Referencia : developer.gnome.org/

Leer más...

Tutorial python gtk3 Spinner y ProgressBar

En muchas ocasiones necesitamos mostrar una pequeña señal de que algo esta pasando,cuando estamos ejecutando una tarea y necesitamos que algo este respondiendo a dicha acción,por ejemplo cuando descargamos algo,cuando movemos archivos,cuando salvamos un documento,etc.

En muchos casos de muchos sistemas vemos los spinners,loc cuales son un widget que giran o se hacen presentes hasta que son necesarios,por ejemplo en windows cuando esta una tarea ocupada vemos que el cursor se convierte en un spinner,luego en otros casos cuando necesitamos un dialogo mas preciso nos encontramos con las barras de progreso o progressbar en ingles,los barras de progreso nos muestran una información mas exacta en casos en los cuales los spinners no son suficientes,en este caso veremos como funcionan ambos widgets en Gtk3 + Python.

Spinner:

Para crear un spinner se usa el constructor Gtk.Spinner(),al cual le podemos pasar el parámetro active para que le digamos al constructor si queremos que comience en movimiento:

self.spinner = Gtk.Spinner(active=True) # Comienza en movimiento

self.spinner = Gtk.Spinner() # Comienza quieto

Las únicas dos funciones que tenemos en este widget es start y stop una para iniciar y otro para comenzar,vamos a crear una ventana de ejemplo para ver como funciona:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

# -*- coding: latin-1 -*- from gi.repository import Gtk, GObject class SpinnerEjemplo(Gtk.Window): def __init__(self): Gtk.Window.__init__(self, title="Spinner") self.set_border_width(5) self.connect("delete-event", Gtk.main_quit) self.vbox = Gtk.Box(spacing=5) self.button = Gtk.ToggleButton("Girar") self.button.connect("toggled", self.on_start) # Este boton manipula el spinner self.button.set_active(False) self.vbox.pack_start(self.button,True,False,10) self.spinner = Gtk.Spinner() # Creamos un spinner self.vbox.pack_start(self.spinner,True,False,10) self.add(self.vbox) self.show_all() def on_start(self, widget): if widget.get_active(): # widget es el boton si esta activo self.spinner.start() # Iniciamos el widget self.button.set_label("Detener") else: # Si no self.spinner.stop() # Lo detenemos self.button.set_label("Girar") myspinner = SpinnerEjemplo() Gtk.main()

Como vemos es muy simple mostrar un  spinner,en el caso del progressbar es un poco mas complicado pero a la vez esto nos da mas posibilidades de personalización y una mayor descripción de la situación:

ProgresBar:

Para crear un ProgressBar se usa el constructor Gtk.ProgressBar(),primero que nada vamos a crear un ejemplo sencillo:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

# -*- coding: latin-1 -*- from gi.repository import Gtk, GObject class SpinnerEjemplo(Gtk.Window): def __init__(self): Gtk.Window.__init__(self, title="Progressbar") self.set_border_width(5) self.connect("delete-event", Gtk.main_quit) self.vbox = Gtk.Box(spacing=5) self.button = Gtk.ToggleButton("Iniciar") self.button.connect("toggled", self.on_control) # Este boton manipula el spinner self.button.set_active(False) self.vbox.pack_start(self.button,True,False,10) self.progressbar = Gtk.ProgressBar() # Creamos un ProgressBar self.vbox.pack_start(self.progressbar,True,False,10) self.timeout_id = GObject.timeout_add(100, self.on_start, None) # Esta funcion es mantiene el ciclo de on_start # en milisegunos self.controller = False # Creamos un controlador self.add(self.vbox) self.show_all() def on_control(self,widget): self.controller = widget.get_active() # Cambiamos el valor del controlador al valor del boton if self.controller: self.button.set_label("Pausar") else: self.button.set_label("Continuar") def on_start(self, widget): # Esta funcion se ejecuta cada 100 milisegundos basado en el retorno de la misma if self.controller: # Si el controlador es True new_value = self.progressbar.get_fraction() + 0.01 # Añade una centecima if new_value > 1: # Si el valor es uno(completo) new_value = 0 # Reiniciamos a cero(vacio) self.progressbar.set_fraction(new_value) # Colocamos la fraccion return True myspinner = SpinnerEjemplo() Gtk.main()

Como vemos,he usado una función de la clase de ProgressBar,las cuales es:

set_fraction(new_value) # new_value es un entero a punto flotante 0,por ejemplo:

0.99,0.10,0.01,etc # 1 es lleno

También tenemos otras mas:

pulse() # Esta función hace que sea indefinida la barra de progreso,ya que solo va de un lado a otro.

set_inverted(bool) # Esta función invierte la forma que se llena el progressbar si el parámetro pasado es True.

set_orientation(orientacion) # Esta función cambia la forma de la orientación,por defecto es horizontal,pero podemos cambiarla a vertical pasandole como parámetro Gtk.Orientation.VERTICAL.

set_show_text("Porcentaje") # Muestra el progreso de la barra en porcentaje.

set_text("Texto") # Coloca texto a la barra.

De momento eso es todo,en otra ocasión veremos las labels,menus,etc.

Leer más...

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 :

1 2 3 4 5 6 7 8 9 10 11 12

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:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

#!/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:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

#!/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:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#!/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.

Leer más...

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 

Leer más...

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í:

Enlace

Esto lo he aprendido de la documentación oficial como siempre,así que pueden darle una leeida para que aprendan de la misma fuente que yo:

http://docs.python.org/2/library/sqlite3.html

Leer más...