17 jun. 2009

Desarrollo de aplicaciones gráficas con python+gtk+glade. Parte 4

El siguiente ejemplo explicará como manejar 2 ventanas en una aplicación.
La primera venta muestra 2 etiquetas una con un texto y la otra en blanco, luego una entrada de datos solicitando el nombre, 2 botones uno de capturar texto y otra de salir. Al darle al botón de capturar texto se abre otra ventana preguntando si está seguro de lo que desea hacer, si se le da aceptar presenta el texto en la etiqueta.

La siguiente figura muestra la interfaz desarrollado con glade.



El código del programa es el siguiente:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import pygtk
pygtk.require('2.0')
import gtk, gtk.glade, inspect, sys

class ej5:
def __init__(self):
#Se captura el archivo de la interfaz glade
self.w_tree = gtk.glade.XML('ej5.glade')
#Se asocian los widgets ventana1, etiqueta2, entrada, boton1, boton2
#ventana1, boton3 y boton4
self.ventana1 = self.w_tree.get_widget('ventana1')
self.etiqueta2 = self.w_tree.get_widget('etiqueta2')
self.entrada = self.w_tree.get_widget("entrada")
self.b_capturar = self.w_tree.get_widget('boton1')
self.b_salir = self.w_tree.get_widget('boton2')
self.ventana2 =self.w_tree.get_widget("ventana2")
self.baceptar = self.w_tree.get_widget("boton3")
self.bsalir = self.w_tree.get_widget("boton4")
#Se asocian las señales con los métodos
self.w_tree.signal_autoconnect(dict(inspect.getmembers(self)))
#Se define la variable texto en blanco.
self.texto = ""
#El método del boton2 salir, al darle clip se cierra la aplicación
def on_boton2_clicked(self,*args):
gtk.main_quit()
#El boton1 es para capturar el texto y luego se muestra la ventana2
def on_boton1_clicked(self,*args):
self.texto = self.entrada.get_text()
self.ventana2.show()

#El boton3 es el boton que acepta la captura de texto, se hace esto y se le
#pasa el texto a la etiqueta2, se cierra la ventan2.
def on_boton3_clicked(self,*args):
self.etiqueta2.set_text(self.texto)
self.ventana2.hide()
#Se cierra la ventana2
def on_boton4_clicked(self,*args):
self.ventana2.hide()
#Al presionar cerrar la ventana1 se cierra la aplicación
def on_ventana1_destroy(self,*args):
gtk.main_quit()
#Al presionar cerrar la ventana2 se oculta la misma
def on_ventana2_destroy(self,*args):
self.ventana2.hide()
#Se muestra la ventana1 y se oculta la ventana 2 al iniciar el programa.
def main(self,*args):
self.ventana2.hide()
self.ventana1.show()
gtk.main()

if __name__ == "__main__":
app = ej5()
app.main()


Al ejecutar el programa se muestra la siguiente figura:


Se escribe el nombre y se presiona capturar texto:


Al presiona capturar texto y se abre una ventana con la pregunta si se desea aceptar o salir de la aplicación.


Para finalizar se muestra la captura de texto en la etiqueta.

Desarrollo de aplicaciones gráficas con python+gtk+glade. Parte 3

Ahora se mostrará como usar el widget combobox. La idea es mostrar una lista de países en el primer combo y cuando este cambie, se cambie la lista de ciudades con respecto a los países.
La interfaz desarrollada con glade se colocan 2 combobox, 1 etiqueta y 2 botones. El primer combobox contiene los países y se agrega desde el glade, el 2do combobox se deja en blanco manejandose vía python. En la siguiente figura se muestra la interfaz en glade.


El código del programa es el siguiente:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import pygtk
pygtk.require('2.0')
import gtk, gtk.glade, inspect, sys

class ej4:
def __init__(self):
#Se captura el archivo glade
self.w_tree = gtk.glade.XML('ej4.glade')
#Se capturan los widgets ventana, etiqueta3, combo1, combo2
#boton1 y boton2.
self.ventana = self.w_tree.get_widget('ventana')
self.etiqueta3 = self.w_tree.get_widget('etiqueta3')
self.combo1 = self.w_tree.get_widget('combo1')
self.combo2 = self.w_tree.get_widget('combo2')
self.b_capturar = self.w_tree.get_widget('boton1')
self.b_salir = self.w_tree.get_widget('boton2')
#Se asocian las señales de la interfaz con los métodos de la aplicación.
self.w_tree.signal_autoconnect(dict(inspect.getmembers(self)))
#Se crea el diccionario donde se manejan los países con sus ciudades
self.listado = {'Venezuela': ['Caracas','Valencia','Barquisimeto','Merida'],'Argentina':['Buenos Aires','Tucuman','Mar del Plata'],'Escocia':['Edimburgo','Glasgow']}
#Se crea una lista vacía donde se maneja la ciudad antigua.
self.ciudades_old = []

#Método asociado al cambio del combo1
def on_combo1_changed (self,*args):
#Se captura el país para asociarlo a la ciudad
ciudades = self.listado[self.combo1.get_active_text()]
#Si el combo2 está activo se revisa las ciudades para ver si es de la lista de
#países
if self.combo2.get_active() == -1:
self.ciudades_old = ciudades
for ciudad in ciudades:
self.combo2.append_text(ciudad)
else:
#Si no es de la lista de ciudades del país se remueve y se agrega la
# nueva lista
for i in range(1,len(self.ciudades_old)+1): self.combo2.remove_text(1)
self.ciudades_old = ciudades
for ciudad in ciudades: self.combo2.append_text(ciudad)

#Si cambia el combo2 no se hace nada
def on_combo2_changed (self, *args):
pass
#Si se le da clip al boton salir se cierra la aplicación
def on_boton2(self,*args):
gtk.main_quit()
#Si se le da clip el boton aceptar, se captura los datos de los combos
#y se presenta en la etiqueta
def on_boton1(self,*args):
self.etiqueta3.set_text("Pais : %s, Ciudad: %s" %(self.combo1.get_active_text(),self.combo2.get_active_text()))

#Si se le da clip a cerrar se sale de la aplicación
def on_ventana_destroy(self,*args):
gtk.main_quit()

#Se muestra la ventana
def main(self,*args):
self.ventana.show()
gtk.main()


if __name__ == "__main__":
app = ej4()
app.main()



Al ejecutar el programa se muestra lo siguiente:

Luego se selecciona el país que se tiene Venezuela, Argentina y Escocia. Se cambia cada vez el país y se selecciona la ciudad, luego se le da clip al boton aceptar apareciendo en la etiqueta el país y la ciudad.



Desarrollo de aplicaciones gráficas con python+gtk+glade. Parte 2

En el siguiente ejemplo de desarrollo de aplicaciones gráficas con glade se muestra como capturar texto en una entrada de texto, como modificar la información en una etiqueta usando botones.



Se muestra la interfaz creada con glade en la siguiente figura:


A continuación se muestra el código del programa:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import pygtk
pygtk.require('2.0')
import gtk, gtk.glade, inspect, sys

class ej3:
def __init__(self):
#Se captura el archivo glade
self.w_tree = gtk.glade.XML('ej3.glade')
#Se asocian los widgets ventana, etiqueta1, etiqueta2, entrada, boton1 y #boton2 a unas variables del objeto
self.ventana = self.w_tree.get_widget('ventana')
self.etiqueta1 = self.w_tree.get_widget('etiqueta1')
self.etiqueta2 = self.w_tree.get_widget('etiqueta2')
self.entrada = self.w_tree.get_widget('entrada')
self.b_capturar = self.w_tree.get_widget('boton1')
self.b_salir = self.w_tree.get_widget('boton2')
#Se asocia las señales de los widgets con funciones.
self.w_tree.signal_autoconnect(dict(inspect.getmembers(self)))
self.texto = ""

#Se define la función salir del boton2
def on_boton2(self,*args):
gtk.main_quit()
#Se define capturar el texto y presentarlo en la etiqueta2 al presionar el boton2
def on_boton1(self,*args):
print self.entrada.get_text()
self.etiqueta2.set_text("Hola Sr. %s" %self.entrada.get_text())
#Se finaliza la aplicación al darle clip en cerrar ventana.
def on_ventana_destroy(self,*args):
gtk.main_quit()

#Se muestra la ventana
def main(self,*args):
self.ventana.show()
gtk.main()


if __name__ == "__main__":
app = ej3()
app.main()





Al ejecutar el programa se muestra la figura:

Luego de colocar el dato que se pide y darle clip al boton capturar texto:

Tutoriales de matplotlib con python. Parte 6.

Continuando con los tutoriales de matplotlib, ahora se mostrará como colocar 2 gráficas separadas.


#!/usr/bin/env python
# -*- coding: utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt

def f(t): return np.exp(-t) * np.cos(2*np.pi*t)*np.sqrt(np.sin(2*np.pi*t))

t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)



plt.figure(1)
plt.subplot(211)
plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')
plt.title("Graficas")
plt.xlabel("tiempo (seg)")
plt.ylabel("funcion")
plt.subplot(212)
plt.plot(t2, np.sin(3*np.pi*t2), 'r--')
plt.xlabel("tiempo (seg)")
plt.ylabel("funcion")
plt.show()

Se importan los módulos necesarios, se define una función que devuelve el resultado de un cálculo matemático, luego se define los rangos de tiempo1 y tiempo2.
Se define la figura, luego la subgráfica, se le pasa los datos para construir la primera gráfica (tiempo1, la función, identificación de la gráfica, tiempo2, la función y la identificación de la gráfica).
Se le coloca el título a la gráfica, las identificaciones de los ejes para ambas gráficas, se construye la segunda gráfica y se muestra las mismas.

La figura muestra las 2 gráficas:

16 jun. 2009

Desarrollo de aplicaciones gráficas con python+gtk+glade. Parte 1

Tengo guardado un material que he preparado para un curso de python con gtk y glade; desde hace algún tiempo he intentado dictar ese curso pero siempre había contratiempos así que mejor publico lo que tengo en el blog.
Empezare con hacer una simple interfaz que tenga información en una etiqueta.

En la figura se muestra la ventana creada y el widget etiqueta con el mensaje. La interfaz se guarda con extensión .glade el cual contiene un archivo XML.


El código del programa es el siguiente:

1.#!/usr/bin/env python
2.# -*- coding: utf-8 -*-
3.import pygtk
4.pygtk.require('2.0')
5.import gtk, gtk.glade, inspect, sys
6.class ej1:
7. def __init__(self):
8. self.w_tree = gtk.glade.XML('ej1.glade')
9. self.ventana = self.w_tree.get_widget('ventana')
10. self.etiqueta = self.w_tree.get_widget('etiqueta1')
11. print self.etiqueta.get()
12. self.etiqueta.set_text("Hola mundo")
13. self.w_tree.signal_autoconnect(dict(inspect.getmembers(self)))
14. def on_ventana_destroy(self,*args):
15. gtk.main_quit()
16. def main(self,*args):
17. self.ventana.show()
18. gtk.main()
19.if __name__ == "__main__":
20. app = ej1()
21. app.main()

La primera línea define el interpretador de comandos a utilizar, en este caso python.
La segunda línea define que se usará UTF-8 en el formato de texto.
Las líneas 3,4 y 5 se importan módulos y se define el requerimiento de versión de gtk.
Línea 6 se define la clase ej1.
Línea 7 a la 13 se define el método init, que se ejecuta cuando el objeto se crea.
Línea 8 se captura el archivo XML de glade.
Línea 9 y 10 se capturan los widgets ventana y etiqueta1 tal como se llama en el archivo glade.
Línea 11 se imprime lo que tiene la etiqueta1, se toma el valor con get().
Línea 12 se cambia el valor de lo que contiene la etiqueta1 con set_text("hola mundo").
Línea 13. Esta línea es la que relaciona los widgets con las señales y los métodos de la clase ej1.
Línea 14. define el método on_ventana_destroy. Esté método se usa para cuando se le da clip a la ventana para cerrarla.
Línea 15. Llama a la función quit de gtk.
Línea 16. Define el método main.
Línea 17.Muestra la ventana.
Línea 18. Llama a main para la presentación de la ventana en pantalla.
Línea 19. Si se ejecuta el script se ejecutará las siguientes líneas:
Línea 20. Se crea el objeto.
Línea 21. Se ejecuta el método main del objeto.
El resultado lo muestra la figura.

Tutoriales de matplotlib con python. Parte 5

El siguiente ejemplo se muestra como colocar varias curvas en una misma gráfica.

>>> from pylab import *
>>> t=arange(0.,2.*pi,0.1)
>>> s=cos(t)
>>> x=sqrt(t)
>>> y = sin(t)
>>> p1=plot(t,s, 'g-o',linewidth=2)
>>> p2=plot(t,x, 'r--',linewidth=3)
>>> p3=plot(t,y, 'b--d')
>>> show()


Se importa el módulo pylab, luego se define el rango del eje del tiempo, se calcula el coseno, la raíz cuadrada y el seno, luego se muestra cada calculo.

Tutoriales de matplotlib con python. Parte 4.


El siguiente ejemplo se graficará una curva senosoidal definiendo un rango de tiempo.



>>> import numpy

>>> import pylab
>>> t = numpy.arange(0.0, 1.0+0.01, 0.01)
>>> s = numpy.cos(2*2*numpy.pi*t)
>>> pylab.plot(t, s)
[]
>>> pylab.xlabel('tiempo (seg)')
>>> pylab.ylabel('Tension (mV)')
>>> pylab.title('Grafica de tension versus tiempo')
>>> pylab.axis([0,1, -2,2])
>>> pylab.grid(True)
>>> pylab.annotate('tension maxima', xy=(0, 1), xytext=(0.2, 1.5),arrowprops=dict(facecolor='black', shrink=0.05),)

>>> pylab.savefig('grafica.png')
>>> pylab.show()
Se importa el módulo numpy y pylab, luego se define el rango del eje del tiempo con una función de numpy, luego se define el eje de la tensión con la función coseno, se gráfica tanto el tiempo como la tensión, se coloca etiqueta a ambos ejes, título a la gráfica, se define los ejes de la gráfica,se define cuadricula, se define una anotación, colocando el texto de la anotación, luego la posición de a flacha, la posición del texto y las características de la flecha; se guarda la gráfica y se muestra.





Tutoriales de matplotlib con python. Parte 3. Histograma

Ahora se demostrará como graficar un histograma. El ejemplo que se usará es el de graficar una gaussiana.

>>> from pylab import randn, hist
>>> import matplotlib.pyplot as plt
>>> plt.title("Ejemplo de graficar una gaussiana")
>>> x = randn(10000)
>>> plt.hist(x)
(array([ 26, 182, 846, 2061, 2876, 2449, 1194, 312, 46, 8]), array([-3.56266387, -2.79960319, -2.03654252, -1.27348184, -0.51042117,
0.25263951, 1.01570018, 1.77876086, 2.54182153, 3.30488221, 4.06794288]), )
>>> plt.axis([-5, 5, 0, 4000])
[-5, 5, 0, 4000]
>>> plt.grid(True)

Se importa random e histograma, luego matplotlib. Se define el título de la gráfica, se generan los números aleatorios entre 0 y 10000, se le pasan los datos a matplotlib, se definen los ejes de la gráfica y para finalizar se define cuadros a la gráfica
.

Tutoriales de matplotlib con python. Parte 2

Ahora se mostrará como se definen unos puntos en el gráfico, se define el rango de los ejes.

ernesto@zvezda:~/bin$ python2.5
Python 2.5.4 (r254:67916, Feb 17 2009, 20:16:45)
[GCC 4.3.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import matplotlib.pyplot as plt
>>> plt.plot([1,2,3,4], [1,4,9,16], 'ro')
[]
>>> plt.axis([0, 6, 0, 20])
[0, 6, 0, 20]
>>> plt.show()

La diferencia con el anterior es que se definen las coordenadas y se pasa el parámetro 'ro', este hace que sólo se muestre los puntos en vez de una curva en el gráfico; luego se define los ejes de 0 a 6 y de 0 a 20.


El siguiente ejemplo es uniendo los puntos, para ello se le quita el parámetro 'ro' al pasar las coordenadas.
>>> import matplotlib.pyplot as plt
>>> plt.plot([1,2,3,4], [1,4,9,16])
[]
>>> plt.axis([0, 6, 0, 20])
[0, 6, 0, 20]
>>> plt.show()


Tutoriales de matplotlib con python. Parte 1

Luego de un tiempo dedicado a otros asuntos y debido a mi reposo voy a empezar una serie de tutoriales cortos sobre matplotlib.

Lo primero que se necesita tener es matplotlib instalado:
Como root:
aptitude install python-matplotlib python-matplotlib-data python-matplotlib-doc

Luego desde la línea de comandos se ejecuta python
ernesto@zvezda:~/bin$ python2.5
Python 2.5.4 (r254:67916, Feb 17 2009, 20:16:45)
[GCC 4.3.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.

>>> import matplotlib.pyplot as plt
>>> plt.plot([1,2,3],[5,7,9])
[]
>>> plt.ylabel('Eje Y')

>>> plt.xlabel('Eje X')
>>> plt.show()

El primer comando importa la librería matplotlib, luego se le pasan los puntos a graficar, los del eje X y del eje Y; luego se colocan etiquetas a los ejes cartesianos y se presenta la gráfica.



AddThis