Mensajes

Pues no sé si necesiten Python para esto, quizás para integrar aplicaciones a la distro o algo...



Saludos !

[for s in string:]

Hola, buen día.

Una manera de resolverlo sería:

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
def contar(string):
  i = 0
  for s in string:
    if s=='a':
      i+=1
  return i

print contar("Jaavier")
Salida:

Código [Seleccionar] Expandir

2
con for s in string: recorremos el string "Jaavier" letra por letra
Si la letra es igual a 'a' entonces a i le sumo 1
Una vez fuera del bucle, retornamos cuantas 'a' habían.


Con respecto a lo de cuanto tiempo tarda en aprender y esas cosas...
No te apresures con saberlo todo rapidamente, hay a quienes se les da más fácil
pues tienen bases de otros lenguajes...

Saludos.

["binascii"]

Hola, buen día !

Efectivamente, puedes crear tu editor hexadecimal con Python. Para ello te recomiendo usar el módulo "binascii":

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
import binascii
archivo = open(raw_input("Archivo >>"),"r").read()
for d in archivo:
  print binascii.b2a_hex(d),

Con eso ya pasas cualquier archivo a hexadecimal


Saludos !

En realidad es muy sencillo:

Código [Seleccionar] Expandir

contador = 1
total = 0
while contador <= num
{
    total = total + contador
    contador = contador + 1
}

OFF: Tiempo sin saber de ti !

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
addNumbers = lambda start, end: sum(range(start,end+1))
print addNumbers(input("Inicio >>"),input("Fin >>"))
Eso con lambda() y con sum():

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
def addNumbers(start, end):
  return sum(range(start,end+1))
 
print addNumbers(input("Inicio >>"),input("Fin >>"))

Saludos

[start]

Código (python) [Seleccionar] Expandir

def addNumbers(start, end):
total = 0
while start <= end:
total += start
start += 1
return total

Usas la misma variable start como contador.

Un saludo.

O podrías utilizar la función "sum()" :

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
def addNumbers(start, end):
  return sum(range(start,end+1))
 
print addNumbers(2,5)

Y con una función lambda():

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
addNumbers = lambda start, end: sum(range(start,end+1))
print addNumbers(2,5)


Saludos !

[QLineEdit()]

Hola nuevamente !

En la [Parte3] dejé pendiente hablar sobre como obtener los datos de un QLineEdit(), voy a ir directo al grano .

Pondré un ejemplo sencillo, tenemos el QLineEdit():

Código (python) [Seleccionar] Expandir

self.input_datos = QtGui.QLineEdit(self)
Entonces para obtener lo que ingresamos, usamos la propiedad .text() acompañada de un str() para que no devuelva el objeto y si el valor:

Código (python) [Seleccionar] Expandir

variable = str(self.input_datos.text())

  Entonces solo bastaría poner dicha línea en la función del botón(self.connect):

Código (python) [Seleccionar] Expandir


def funcion(self):
  recibo_datos = str(self.input_datos.text())

Y con ello ya tendremos en nuestras manos el valor del QLineEdit() en la variable. Ahora con ella podemos hacer lo mismo que hacemos en nuestros códigos Python normales, a nuestro antojo.

Pero como quedó pendiente en la pasada parte sobre utilizar el valor del QLineEdit() en el QLabel(), con lo que hemos visto ya deberíamos saber hacerlo , de todas formas dejaré el código con comentarios :

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
import sys

class Mi_Programa(QtGui.QWidget):
 
  def __init__(self, parent=None):
   
    QtGui.QWidget.__init__(self, parent)
    self.resize(200,134)
    #Creamos los Labels,label_mensaje "Mensaje:", label_resultado el mensaje de "Resultado:"
    #Y el tercero mostrará el texto ingresado.
    self.label_mensaje = QtGui.QLabel("Mensaje:", self)
    self.label_mensaje.setGeometry(3,14,59,17)
    self.label_resultado = QtGui.QLabel("Resultado:", self)
    self.label_resultado.setGeometry(5,80,71,17)
    self.label_show = QtGui.QLabel("",self)
    self.label_show.setGeometry(80,80,111,17)
    #Creamos el QLineEdit para pedir datos
    self.input_datos = QtGui.QLineEdit(self)
    self.input_datos.setGeometry(60,10,113,27)
    #Creamos el Boton
    self.mi_boton = QtGui.QPushButton("Dame Clic", self)
    self.mi_boton.setGeometry(60,40,92,27)
    #Le damos función al botón
    self.connect(self.mi_boton, QtCore.SIGNAL('clicked()'), self.show_message)
   
  def show_message(self):
    mensaje = str(self.input_datos.text())
    self.label_show.setText(mensaje)
aplicacion = QtGui.QApplication(sys.argv)
formulario = Mi_Programa()
formulario.show()
aplicacion.exec_()

Explico un poco:
Al dar clic en el botón, llamamos a la función show_message() en la cual obtendremos el dato de self.input_datos, posteriormente guardamos el valor en la variable mensaje y como ya vimos, usamos setText(mensaje) para darle el nuevo valor al QLabel().

  Supongo que ya no hay temas pendientes con QLineEdit, QLabel, QPushButton , veamos el uso de otros Widgets, el siguiente es QPlainTextEdit().

  Como dice su nombre, es para insertar un texto plano, a diferencia del QLineEdit, este es multilíneas.

La manera de utilización es la siguiente :

Código (python) [Seleccionar] Expandir

self.texto_plano = QtGui.QPlainTextEdit("", self)
Como ya sabemos, usamos la propiedad setGeometry() para dar posición, ancho y altura.
 
  Para obtener los datos que se insertan en dicho widget, usaremos la propiedad toPlainText(), que es el equivalente al .text() del QLineEdit.

  Para insertar datos en un QPlainTextEdit(), debemos usar setPlainText('Msj').

Un pequeño ejemplo de lo que he escrito en código :

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
import sys

class Mi_Programa(QtGui.QWidget):
 
  def __init__(self, parent=None):
   
    QtGui.QWidget.__init__(self, parent)
    self.resize(400,319) # Tamaño
    #Creamos el primer PlainTextEdit que luego envía los datos al segundo
    self.texto_plano = QtGui.QPlainTextEdit("", self)
    self.texto_plano.setGeometry(10,10,191,271)
    #Creamos el botón
    self.transcribir = QtGui.QPushButton("Transcribir", self)
    self.transcribir.setGeometry(10,285,95,27)
    #Creamos el segundo PlainTextEdit que recibirá el primer contenido
    self.nuevo_txt = QtGui.QPlainTextEdit("", self)
    self.nuevo_txt.setGeometry(206,10,191,271)
    #Le damos la función al botón y llamamos al def transcribe
    self.connect(self.transcribir, QtCore.SIGNAL('clicked()'), self.transcribe)

  def transcribe(self):
    #Obtenemos el contenido del primer QPlainTextEdit
    contenido = self.texto_plano.toPlainText()
    #Escribimos el contenido del primer QPlainTextEdit en el segundo
    #Usando setPlainText
    self.nuevo_txt.setPlainText(contenido)
   
aplicacion = QtGui.QApplication(sys.argv)
formulario = Mi_Programa()
formulario.show()
aplicacion.exec_()


Luego seguiré con el QTextBrowser(), que nos permite ingresar código HTML en el campo de escritura...

Fuente : http://rootcodes.com/tutorialaprendiendo-pyqt4-con-rootcodes-parte4/

Saludos, Javier.

[Nuestro primer Hola mundo en PyQT4]

Hola ! , en la pasa ocasión quedaron pendientes un par de puntos :

   
• Dar función a un botón
• Crear un QLabel()
• Nuestro primer Hola mundo en PyQT4

Bien, manos a la obra, para quienes no sepan que es un Label, dejaré un Screenshot , es algo bien sencillo:


Sencillo no ? , nos servirá para imprimir resultados por pantalla, como dije en la primera parte, como un reemplazo al print de la versión Python en Consola.

Bueno... ¿ Y cómo uso el QLabel ?

Nada más que esto:

Código (python) [Seleccionar] Expandir


self.mi_label = QtGui.QLabel("Mi texto", self)

Luego pueden cambiar las coordenadas con el ya mencionado self.objeto.setGeometry() (donde objeto puede ser un QLabel, QLineEdit, etc)

  Siguiendo con algo más "útil", pasaré a explicar como dar vida a los famosos Botones.

  Para poder crear acciones al dar clic en un botón, usaremos self.connect(), pero antes de ello, debemos tener una función creada para que al dar clic, esta se ejecute...

  La sintaxis del self.connect será esta:

Código (python) [Seleccionar] Expandir

self.connect(self.mi_boton, QtCore.SIGNAL("clicked()"), self.respuesta)
Paso a explicar:

   
• self.connect(self.mi_boton = Eso indica que la función self.respuesta solo será ejecutada al dar clic en el botón "self.mi_boton"
• QtCore.SIGNAL('clicked()'), quiere decir que será ejecutado al ser clickeado
• self.respuesta) es la función que se ejecuta al ser clickeado el botón

Osea, en nuestros programas, la única parte que debería cambiar serían self.mi_boton y self.respuesta, veamos como queda el código:

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
import sys

class Mi_Programa(QtGui.QWidget):
 
  def __init__(self, parent=None):
   
    QtGui.QWidget.__init__(self, parent)
    self.resize(200,200) #Dimensiones del formulario
    self.mi_boton = QtGui.QPushButton("Boton", self) # Creo el QPushButton()
    self.mi_boton.setGeometry(10,10,92,27) #X = 10 ; Y = 15 ; Width = 92 ; Height = 27
    self.connect(self.mi_boton, QtCore.SIGNAL('clicked()'), self.respuesta)
    self.mi_label = QtGui.QLabel('', self)#Lo definimos sin texto, luego le damos un valor
    self.mi_label.setGeometry(10,40,92,27)
   
aplicacion = QtGui.QApplication(sys.argv)
formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
formulario.show() # Mostramos el Formulario
aplicacion.exec_() # Ejecutamos

  Bien hasta ahí... Pero algo falta... La función respuesta !
Haremos algo sencillo, que al dar clic en el botón, nos cree un QLabel con una respuesta:

Código (python) [Seleccionar] Expandir


  def respuesta(self):
    self.mi_label.setText('Gracias !')

Pero que es eso ! ? , setText() ?
Sí, es la propiedad que usaremos para definir un texto en el QLabel(), siempre y cuando el QLabel() ya haya sido creado.

Entonces nuestro código será el siguiente, ya terminado:

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
import sys

class Mi_Programa(QtGui.QWidget):
 
  def __init__(self, parent=None):
   
    QtGui.QWidget.__init__(self, parent)
    self.resize(200,200) #Dimensiones del formulario
    self.mi_boton = QtGui.QPushButton("Boton", self) # Creo el QPushButton()
    self.mi_boton.setGeometry(10,10,92,27) #X = 10 ; Y = 15 ; Width = 92 ; Height = 27
    self.connect(self.mi_boton, QtCore.SIGNAL('clicked()'), self.respuesta)
    self.mi_label = QtGui.QLabel('', self)
    self.mi_label.setGeometry(10,40,92,27)
   
  def respuesta(self):
    self.mi_label.setText('Gracias !') #Defino un texto al dar clic en self.mi_boton
   
aplicacion = QtGui.QApplication(sys.argv)
formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
formulario.show() # Mostramos el Formulario
aplicacion.exec_() # Ejecutamos

Genial ! , ya tenemos nuestro primer programa en PyQT4. Nos aparecerá el formulario con el botón y al dar clic aparecerá el mensaje: "Gracias !"


Los puntos :

   
• Dar función a un botón
• Crear un QLabel()
• Nuestro primer Hola mundo en PyQT4

Ya fueron tratados en esta 3era parte... En la siguiente parte explicaré como obtener los datos ingresados en un QLineEdit(), mostrarlos en un QLabel() al dar clic en un QPushButton(). Ya con eso podrán empezar a crear vuestras aplicaciones !

Fuente : http://rootcodes.com/tutorialaprende-pyqt4-con-rootcodes-parte3

Saludos , Javier !

[QLineEdit() y un QPushButton()]

Hola nuevamente !

Siguiendo con el tutorial, pasaré a explicar como implementar un QLineEdit() y un QPushButton(), para que tengan una idea de que les hablo :

Código [Seleccionar] Expandir


<input value="Esto es un QLineEdit()">
<input value="Esto es un QPushButton()" type="submit">
(ESO EN HTML)

  Ello mismo, pero en PyQT4. Bien, para poder insertar nuestro QLineEdit, debemos añadir bajo la línea del self.resize(200,200):

Código (python) [Seleccionar] Expandir


self.mi_qlinedit = QtGui.QLineEdit(self)

Quedando así en nuestro form:

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
import sys

class Mi_Programa(QtGui.QWidget):
 
  def __init__(self, parent=None):
   
    QtGui.QWidget.__init__(self, parent)
    self.resize(200,200) #Dimensiones del formulario
    self.mi_qlinedit = QtGui.QLineEdit(self) # añadimos el QLineEdit

aplicacion = QtGui.QApplication(sys.argv)
formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
formulario.show() # Mostramos el Formulario
aplicacion.exec_() # Ejecutamos


Y Pues para añadir un botón:

Código (python) [Seleccionar] Expandir


self.mi_boton = QtGui.QPushButton("Hola, soy un boton!", self)

Nuestro formulario quedaría así:

Código (python) [Seleccionar] Expandir

# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
import sys

class Mi_Programa(QtGui.QWidget):
 
  def __init__(self, parent=None):
   
    QtGui.QWidget.__init__(self, parent)
    self.resize(200,200) #Dimensiones del formulario
    self.mi_boton = QtGui.QPushButton("Hola, soy un boton!", self)

aplicacion = QtGui.QApplication(sys.argv)
formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
formulario.show() # Mostramos el Formulario
aplicacion.exec_() # Ejecutamos


Nota: Podemos utilizar cualquier variable, siempre anteponiendo el self., solo que yo usé mi_boton para darle un nombre descriptivo.

  Bien, ya sabemos como insertar nuestros primeros Widgets en PyQT4, pero verás que al mezclar ambos, solo muestra un widget, esto sucede porque no le hemos dado una ubicación, por lo que ambos se posición en las coordenadas X = 0; Y = 0 , así uno se sobre pone del otro.

Entonces, ¿ Cómo ubico mi widget donde yo quiera ?

  Sencillo ! , debemos utilizar la propiedad setGeometry(X,Y,Width, Height) , Donde X será la ubicación hacia los costados e Y arriba y abajo. Aquí es donde yo recomiendo usar el QT Designer, pues nos ayudará a ubicar nuestro Widget de manera correcta y no dirá en que ubicación se encuentra.

  Recomiendo utilizar en el botón, el height 27, que es la altura de un botón normal. El width dependerá del ancho del texto de nuestro botón. (width = ancho ; height = altura)

  En lo que respecta el QLineEdit, recomiendo usar también el height = 27
  Así quedando la mezcla:

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
import sys

class Mi_Programa(QtGui.QWidget):
 
  def __init__(self, parent=None):
   
    QtGui.QWidget.__init__(self, parent)
    self.resize(200,200) #Dimensiones del formulario
    self.mi_boton = QtGui.QPushButton("Boton", self) # Creo el QPushButton()
    self.mi_boton.setGeometry(10,40,92,27) #X = 10 ; Y = 15 ; Width = 92 ; Height = 27
    self.mi_qlinedit = QtGui.QLineEdit(self) # Creo el QLineEdit()
    self.mi_qlinedit.setGeometry(10,10,92,27) # X = 10 ; Y = 10 ; Width = 92 ; Height = 27
   
aplicacion = QtGui.QApplication(sys.argv)
formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
formulario.show() # Mostramos el Formulario
aplicacion.exec_() # Ejecutamos
Un ScreenShot:


En la siguiente parte, explicaré como darle función a un botón e implementar un QLabel() con un resultado posterior !

Fuente : http://rootcodes.com/tutorialaprende-pyqt4-con-rootcodes-parte2

Saludos, Javier !

["enseñar"]

Hola, buen día.
 
    En esta ocasión vengo a "enseñar" un poco sobre lo que es la aplicación de QT4 en nuestro siempre querido Python.
   
    En esta guía pretendo explicar la base para crear un formulario y los distintos widgets a utilizar, como dar función a un botón, obtener datos de campos QLineEdit(), insertar datos en diferentes tipos de widgets, tales como QLineEdit, QPlainText, QTextBrowser, etc. Y pues ya lo demás es saber
lo básico de Python, pero en ves de pedir los datos vía raw_input() estos son reemplazados por los ya mencionados QLineEdit, para imprimir un dato por pantalla podemos usar QLabel. Ya lo demás es saber programar en Python nada más !


  Bien, antes que todo, veamos que es QT, según la conocida Wikipedia :

 

Qt es una biblioteca multiplataforma ampliamente usada para desarrollar aplicaciones con una interfaz gráfica
de usuario así como también para el desarrollo de programas sin interfaz gráfica como herramientas para
la línea de comandos y consolas para servidores.

  Ya, vamos al grano...
  ¿ Qué necesito para programar en PyQT4 ?

    Necesitas obviamente tener instalado Python:

Código [Seleccionar] Expandir

sudo apt-get install python

    Una vez instalado, debemos instalar las librerías QT4:

Código [Seleccionar] Expandir

sudo apt-get install python-qt4

    Esto es <em>opcional</em>, es el QT4 Designer, que nos ayuda a crear la interfaz gráfica, pero en C++

Código [Seleccionar] Expandir

sudo apt-get install qt4-designer

    Y lo siguiente, es para traducir el código C++ a PyQT4, en caso de usar el QT4 Designer:

Código [Seleccionar] Expandir

sudo apt-get install pyqt4-dev-tools

    Aclaro que yo a lo largo del tutorial solo usaré el QT4 Designer para saber las dimensiones de los
widgets, tamaños y propiedades.

   Bueno, volvamos al tema... Vamos a empezar !

  La base de todos los programas en PyQT4 debe ser:

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
#Autor: JaAViEr(0x5d)
#Website: http://www.rootcodes.com
#Twitter: @0x5d

from PyQt4 import QtCore, QtGui
import sys

class Mi_Programa(QtGui.QWidget):
 
  def __init__(self, parent=None):
   
    QtGui.QWidget.__init__(self, parent)
    self.resize(200,200) #Dimensiones del formulario
   
aplicacion = QtGui.QApplication(sys.argv)
formulario = Mi_Programa() # Instanciamos la clase de nuestro programa
formulario.show() # Mostramos el Formulario
aplicacion.exec_() # Ejecutamos
Si has copiado y pegado bien, la salida debe ser:


Genial, nuestra primera mini aplicación en PyQT4, en la segunda parte empezaremos a utilizar los widgets QLineEdit(), QLabel() y QPushButton()

Fuente : http://rootcodes.com/tutorialaprende-pyqt4-con-rootcodes-parte1

[PythonQT]

Hola, tengan muy buenos días !

 Hoy, pasando por un foro en el cual participo, tocaron un tema sobre PythonQT y me recordé que hace rato que no hacía nada en él y pues tras la perdida de mi otro HDD ni instalado lo tenía en este Debian.
 
 Así que me senté a pensar que codear y se me vino a la mente meter todas las aplicaciones QT4 que he hecho (que son bien pocas) en un solo PyQT4 para acceder a ellas por un boton nada más, así que me puse en marcha y este fue el resultado :

Código (python) [Seleccionar] Expandir


# -*- coding: utf-8 -*-
#Autor : 0x5d
#Website : http://www.rootcodes.com
#Twitter : 0x5d

import sys, urllib2, re, urllib
from PyQt4 import QtCore, QtGui, QtWebKit

class all_in_one(QtGui.QWidget):

 def __init__(self, parent=None):

   QtGui.QWidget.__init__(self,parent)
   self.resize(400, 203)
   self.setWindowTitle('Todo en uno PyQT4 - JaAViEr')
   self.boton_extractor = QtGui.QPushButton('Extractor de imagenes', self)
   self.boton_extractor.setGeometry(10, 10, 171, 51)
   self.connect(self.boton_extractor, QtCore.SIGNAL('clicked()'), self.show_extractor)
   self.boton_digitoveri = QtGui.QPushButton('Obtener digito verificador', self)
   self.boton_digitoveri.setGeometry(190, 10, 191, 51)
   self.connect(self.boton_digitoveri, QtCore.SIGNAL('clicked()'), self.show_digitoveri)
   self.boton_calculadorasecuencias = QtGui.QPushButton('Calculadora por secuencias', self)
   self.boton_calculadorasecuencias.setGeometry(10, 70, 201, 51)
   self.connect(self.boton_calculadorasecuencias, QtCore.SIGNAL('clicked()'), self.show_secuencias)
   self.boton_htmlhelper = QtGui.QPushButton('HTML Helper', self)
   self.boton_htmlhelper.setGeometry(10, 130, 101, 51)
   self.connect(self.boton_htmlhelper, QtCore.SIGNAL('clicked()'), self.show_htmlhelper)
   self.boton_twitter = QtGui.QPushButton('Menciones Twitter', self)
   self.boton_twitter.setGeometry(220, 70, 161, 51)
   self.connect(self.boton_twitter, QtCore.SIGNAL('clicked()'), self.show_twitter)
   self.boton_calculadora = QtGui.QPushButton('Calculadora', self)
   self.boton_calculadora.setGeometry(120, 130, 92, 51)
   self.connect(self.boton_calculadora, QtCore.SIGNAL('clicked()'), self.show_calculadora)
   self.boton_versource = QtGui.QPushButton('Ver codigo de fuente', self)
   self.boton_versource.setGeometry(220, 130, 171, 51)
   self.connect(self.boton_versource, QtCore.SIGNAL('clicked()'), self.show_viewsource)

 def show_extractor(self):

   extractor.show()

 def show_digitoveri(self):

   digito.show()

 def show_viewsource(self):

   source.show()

 def show_calculadora(self):

   calculadora.show()

 def show_twitter(self):

   twitter.show()

 def show_htmlhelper(self):

   html_helper.show()

 def show_secuencias(self):

   secuencia.show()

# Inicio Obtener dígito verificador
class ventana_alerta(QtGui.QWidget):

 def __init__(self, parent=None):

   QtGui.QWidget.__init__(self, parent)
   self.resize(283, 31)
   self.setWindowTitle('ALERTA!')

 def message(self, txt):

   self.txt = txt
   self.respuesta = QtGui.QLabel(self.txt, self)
   self.respuesta.setGeometry(10, 10, 260, 17)

class formulario_rut(QtGui.QWidget):

 def __init__(self, parent=None):

   QtGui.QWidget.__init__(self, parent)
   self.setWindowTitle('Digito verificador')
   self.resize(279, 36)
   self.label_rut = QtGui.QLabel('RUT', self)
   self.label_rut.setGeometry(0, 11, 59, 17)
   self.rut = QtGui.QLineEdit(self)
   self.rut.setGeometry(30, 7, 101, 23)
   self.label_verificador = QtGui.QLabel('-', self)
   self.label_verificador.setGeometry(135, 11, 16, 17)
   self.digito = QtGui.QLineEdit(self)
   self.digito.setGeometry(147, 7, 21, 23)
   self.digito.setReadOnly(True)
   self.verificar = QtGui.QPushButton('Verificar', self)
   self.verificar.setGeometry(180, 7, 92, 23)
   self.connect(self.verificar, QtCore.SIGNAL('clicked()'), self.operacion)

 def operacion(self):

   self.rut_valor = str(self.rut.text())
   if len(self.rut_valor) < 8 and len(self.rut_valor) > 9:

     creacion_alerta.message('Ingresa un rut valido por favor')
     creacion_alerta.show()

   else:

     rut = []
     ingresar = [rut.append(numeros) for numeros in self.rut_valor]
     rut.reverse()
     recorrido = 2
     multiplicar = 0

     for x in rut:
       multiplicar+=int(x)*recorrido
       if recorrido==7: recorrido = 1
       recorrido+=1

     modulo = multiplicar%11
     resultado = 11-modulo
     if resultado == 11: digito=0
     elif resultado == 10: digito="K"
     else: digito=resultado
     self.digito.setText(str(digito))
#Fin obtener dígito verificador

#Inicio extractor
class extractor(QtGui.QWidget):

   def __init__(self, parent=None):

     QtGui.QWidget.__init__(self, parent)
     self.resize(602, 514)
     self.setWindowTitle(QtGui.QApplication.translate('self', 'Extractor de imágenes :: JaAViEr (0x5d)', None, QtGui.QApplication.UnicodeUTF8))
     self.label_url = QtGui.QLabel('Url', self)
     self.label_url.setGeometry(10, 15, 21, 16)
     self.input_url = QtGui.QLineEdit(self)
     self.input_url.setGeometry(30, 13, 561, 19)
     self.label_salida = QtGui.QLabel('Salida', self)
     self.label_salida.setGeometry(12, 40, 57, 15)
     self.boton_extraer = QtGui.QPushButton(QtGui.QApplication.translate('self', 'Extraer imágenes', None, QtGui.QApplication.UnicodeUTF8), self)
     self.boton_extraer.setGeometry(469, 37, 121, 20)
     self.connect(self.boton_extraer, QtCore.SIGNAL('clicked()'), self.extraer_todo)
     self.listWidget = QtGui.QListWidget(self)
     self.listWidget.setGeometry(QtCore.QRect(5, 60, 591, 441))
   
   def extraer_todo(self):

     url_imagenes = ""
     clear = ""
     i = 0
     self.web = str(self.input_url.text())
     for imagen in re.findall('<img (.*)>',urllib.urlopen(self.web).read()):
       if "src" in imagen.lower():

         for imagenes in imagen.split():
           if re.findall('src=(.*)',imagenes):

             clear = imagenes[:-1].replace('src=\"','"')
             QtGui.QListWidgetItem(self.listWidget)
             self.listWidget.item(i).setText('%s.- %s'%(i, clear.replace(self.web,'"')))
             i+=1
class secuencia(QtGui.QWidget):

 def __init__(self, parent=None):

   QtGui.QWidget.__init__(self, parent)
   self.resize(411, 60)
   self.setWindowTitle('Calculadora de secuencias :: JaAViEr(0x5d)')
   self.input_secuencia = QtGui.QLineEdit(self)
   self.input_secuencia.setGeometry(80, 5, 321, 21)
   self.label_secuencia = QtGui.QLabel('Secuencia', self)
   self.label_secuencia.setGeometry(5, 2, 71, 31)
   self.boton_ver = QtGui.QPushButton('Ver', self)
   self.boton_ver.setGeometry(323, 30, 81, 21)
   self.input_resultado = QtGui.QLineEdit(self)
   self.input_resultado.setGeometry(80, 30, 240, 21)
   self.input_resultado.setReadOnly(True)
   self.label_resultado = QtGui.QLabel('Resultado', self)
   self.label_resultado.setGeometry(5, 31, 71, 21)
   self.connect(self.boton_ver, QtCore.SIGNAL('clicked()'), self.ejecutar)
 
 def ejecutar(self):

   try:

     self.resultado = str(self.input_secuencia.text())
     self.input_resultado.setText(str(eval(self.resultado)))

   except:

     self.input_resultado.setText(QtGui.QApplication.translate('self', 'Operación inválida', None, QtGui.QApplication.UnicodeUTF8))

class html_helper(QtGui.QMainWindow):

 def __init__(self):

   QtGui.QMainWindow.__init__(self)
#Boton Bold
   self.bold = QtGui.QPushButton('Bold',self)
   self.bold.setGeometry(172,26,41,25)
   self.connect(self.bold,QtCore.SIGNAL('clicked()'), self.make_bold)
#Boton Italic
   self.italic = QtGui.QPushButton('Italic',self)
   self.italic.setGeometry(216,26,41,25)
   self.connect(self.italic,QtCore.SIGNAL('clicked()'), self.make_italic)
#Boton Underline
   self.underline = QtGui.QPushButton('Underline',self)
   self.underline.setGeometry(261,26,63,25)
   self.connect(self.underline,QtCore.SIGNAL('clicked()'), self.make_underline)
#Nuevo menu "Archivo"
   menu_archivo = self.menuBar()
   archivo = menu_archivo.addMenu('&Archivo')
#Menu Abrir
   abrir = QtGui.QAction('&Abrir',self)
   abrir.setShortcut('Ctrl+O')
   archivo.addAction(abrir)
   self.connect(abrir, QtCore.SIGNAL('triggered()'),self.abrir)
#Menu Abrir URL
   abrir_url = QtGui.QAction('Abrir desde &URL',self)
   abrir_url.setShortcut('Ctrl+U')
   archivo.addAction(abrir_url)
   self.connect(abrir_url, QtCore.SIGNAL('triggered()'),self.get_source)
#Menu Guardar
   guardar = QtGui.QAction('&Guardar',self)
   guardar.setShortcut('Ctrl+S')
   archivo.addAction(guardar)
   self.connect(guardar, QtCore.SIGNAL('triggered()'),self.guardar)
#Menu salir
   salida = QtGui.QAction('&Exit', self)
   salida.setShortcut('Ctrl+W')
   archivo.addAction(salida)
   self.connect(salida, QtCore.SIGNAL('triggered()'), QtCore.SLOT('close()'))
#Fin del menú Archivo
#Nuevo menú Herramientas
   menu_inputs = self.menuBar()
   herramientas = menu_inputs.addMenu('&Herramientas')
#Menu textarea
   textarea = QtGui.QAction('Agregar &TextArea', self)
   herramientas.addAction(textarea)
   self.connect(textarea, QtCore.SIGNAL('triggered()'), self.add_textarea)
#Menu input
   inputx = QtGui.QAction('Agregar &Input', self)
   herramientas.addAction(inputx)
   self.connect(inputx, QtCore.SIGNAL('triggered()'), self.add_input)
#Menu Boton
   boton = QtGui.QAction('Agregar &Boton', self)
   herramientas.addAction(boton)
   self.connect(boton, QtCore.SIGNAL('triggered()'), self.add_button)
#Menu Imagen
   imagen = QtGui.QAction('Agregar I&magen', self)
   herramientas.addAction(imagen)
   self.connect(imagen, QtCore.SIGNAL('triggered()'), self.add_imagen)
#Menu Cambiar Fondo
   fondo = QtGui.QAction('Color de &Fondo', self)
   herramientas.addAction(fondo)
   self.connect(fondo, QtCore.SIGNAL('triggered()'), self.add_fondo)
#Menu Link
   link = QtGui.QAction('Agregar &Link', self)
   herramientas.addAction(link)
   self.connect(link, QtCore.SIGNAL('triggered()'), self.add_link)
#Fin menú Herramientas
   self.resize(729, 674)
   self.pest_code = QtGui.QTabWidget(self)
   self.pest_code.setGeometry(QtCore.QRect(0, 30, 711, 631))
   self.tab = QtGui.QWidget()
   self.html_plano = QtGui.QPlainTextEdit(self.tab)
   self.html_plano.setGeometry(QtCore.QRect(10, 30, 691, 571))
   self.boton_previw = QtGui.QPushButton('Preview',self.tab)
   self.boton_previw.setGeometry(QtCore.QRect(10, 4,83, 21))
   self.pest_code.addTab(self.tab, '')
   self.tab_2 = QtGui.QWidget()
#Nuevo menú Fuente / Colores
   font_color = self.menuBar()
   fuentes_colores = font_color.addMenu('&Fuente / Colores')
#Menu Buscar Color
   search_color = QtGui.QAction('Buscar Color', self)
   fuentes_colores.addAction(search_color)
   self.connect(search_color, QtCore.SIGNAL('triggered()'), self.find_color)
#Menu buscar Fuente
   search_font = QtGui.QAction('Buscar Fuente', self)
   fuentes_colores.addAction(search_font)
   self.connect(search_font, QtCore.SIGNAL('triggered()'), self.find_font)
   self.vista_web = QtWebKit.QWebView(self.tab_2)
   self.vista_web.setGeometry(QtCore.QRect(10, 10, 691, 591))
   self.pest_code.addTab(self.tab_2, '')
   self.pest_code.setCurrentIndex(0)
   QtCore.QMetaObject.connectSlotsByName(self)
   self.setWindowTitle('Create HTML Helper.')
   self.pest_code.setTabText(self.pest_code.indexOf(self.tab),'Codigo')
   self.pest_code.setTabText(self.pest_code.indexOf(self.tab_2), 'Prevista')
   self.connect(self.boton_previw, QtCore.SIGNAL('clicked()'), self.done)  

 def make_bold(self):

   self.html_final = "%s<br />\n<b></b>"%self.html_plano.toPlainText()
   self.html_plano.setPlainText(self.html_final)  

 def make_italic(self):

   self.html_final = "%s<br />\n<i></i>"%self.html_plano.toPlainText()
   self.html_plano.setPlainText(self.html_final)  

 def make_underline(self):

   self.html_final = "%s<br />\n<u></u>"%self.html_plano.toPlainText()
   self.html_plano.setPlainText(self.html_final)  

 def done(self):

   self.salida = self.html_plano.toPlainText()
   temporal = open('tmp.html','w')
   temporal.write(self.salida)
   temporal.close()
   self.vista_web.setUrl(QtCore.QUrl('tmp.html'))
   self.pest_code.setCurrentIndex(1)

 def guardar(self):

   self.obtener_html = self.html_plano.toPlainText()
   try:

     nombre_save = QtGui.QFileDialog.getSaveFileName(self, 'Guardar Archivo','/home')
     guardando_html = open(nombre_save, 'w')
     guardando_html.write(self.obtener_html)
     guardando_html.close()
     alertas.show()
     alertas.alerta('Advertencia','Guardado!')
   except:

     alertas.show()
     alertas.alerta('Advertencia','No Guardado')

 def abrir(self):

   nombre_open = QtGui.QFileDialog.getOpenFileName(self, 'Abrir Archivo','/home')
   abriendo_html = open(nombre_open, 'r')
   contenido = abriendo_html.read()
   self.html_plano.setPlainText(contenido)

 def add_textarea(self):

   rows, respuesta_rows = QtGui.QInputDialog.getText(self, 'Rows','Numero de Lineas:')
   if respuesta_rows:

     rows = " rows=\"%s\""%str(rows)
   else:

     rows = ""
   cols, respuesta_cols = QtGui.QInputDialog.getText(self, 'Cols','Numero de Columnas:')
   if respuesta_cols:

     cols = " cols=\"%s\""%str(cols)
   else:

     cols = ""
   self.html_final = "%s<br />\n<textarea%s%s></textarea>"%(self.html_plano.toPlainText(),rows,cols)
   self.html_plano.setPlainText(self.html_final)  

 def add_input(self):

   value, respuesta_value = QtGui.QInputDialog.getText(self, 'Valor','Valor por defecto:')
   if respuesta_value:

     value = " value=\"%s\""%str(value)
   else:

     value = ""
   self.html_final = "%s<br />\n<input%s>"%(self.html_plano.toPlainText(),value)
   self.html_plano.setPlainText(self.html_final)  

 def add_button(self):

   button, respuesta_boton = QtGui.QInputDialog.getText(self, 'Valor','Valor del Boton:')
   if respuesta_boton:

     button = " value=\"%s\""%str(button)
   else:

     button = ""
   self.html_final = "%s<br />\n<input  type=\"Submit\"%s>"%(self.html_plano.toPlainText(),button)
   self.html_plano.setPlainText(self.html_final)  

 def add_imagen(self):

   imagen, respuesta_imagen = QtGui.QInputDialog.getText(self, 'Valor','URL de la Imagen:')
   if respuesta_imagen:

     imagen = " src=\"%s\""%str(imagen)
   else:

     imagen = ""
   width, respuesta_width = QtGui.QInputDialog.getText(self, 'Valor','Ancho:')
   if respuesta_width:

     width = " width=\"%s\""%str(width)
   else:

     width = ""
   height, respuesta_height = QtGui.QInputDialog.getText(self, 'Valor','Alto:')
   if respuesta_height:

     height = " height=\"%s\""%str(height)
   else:

     height = ""
   self.html_final = "%s<br />\n<img%s%s%s>"%(self.html_plano.toPlainText(),imagen,width,height)
   self.html_plano.setPlainText(self.html_final)  

 def add_fondo(self):

   color = QtGui.QColorDialog.getColor()
   if color.isValid():

     if not "<body" in self.html_plano.toPlainText():
       self.html_final = "<body bgcolor=\"%s\">%s</body>"%(color.name(),self.html_plano.toPlainText())
       self.html_plano.setPlainText(self.html_final)
     else:

       for i in re.findall('<body bgcolor=\"(.*)\">',self.html_plano.toPlainText()):
         anterior=i
       self.html_final = self.html_plano.toPlainText().replace(anterior,color.name())

       self.html_plano.setPlainText(self.html_final)
   else:

     self.html_final = "<body bgcolor=\"#FFFFFF\">%s</body>"%(self.html_plano.toPlainText())
     self.html_plano.setPlainText(self.html_final)

 def find_color(self):

   busca_color= QtGui.QColorDialog.getColor()
   if busca_color.isValid():
     alertas.show()
     alertas.alerta('Advertencia','Color %s'%busca_color.name())

 def get_source(self):

   url, respuesta_url = QtGui.QInputDialog.getText(self, 'Get','URL:')
   try:

     self.html_plano.setPlainText(urllib2.urlopen(str(url)).read())

   except:

     alertas.show()
     alertas.alerta('Advertencia','Contenido no encontrado')

 def add_link(self):

   link, respuesta_link = QtGui.QInputDialog.getText(self, 'Link','Link:')
   if respuesta_link:

     link = " href=\"%s\""%link

   else:

     link = ""

   name, respuesta_name = QtGui.QInputDialog.getText(self, 'Nombre','Nombre:')
   if respuesta_name:

     name = "%s"%name

   else:

     name = "%s"%link
   self.html_final = "%s<br />\n<a%s>%s</a>"%(self.html_plano.toPlainText(),link,name)
   self.html_plano.setPlainText(self.html_final)  

 def find_font(self):

   QtGui.QFontDialog.getFont()
 
class myalert(QtGui.QMainWindow):

 def __init__(self):

   QtGui.QMainWindow.__init__(self)
   #self.resize(130,50)
   self.setGeometry(400,300,250,50)
   self.label_problema = QtGui.QLabel(self)
   self.label_problema.setGeometry(40,17,180,20)
 
 def alerta(self,error,razon):

   self.setWindowTitle(error)
   self.label_problema.setText(razon)


class twitter(QtGui.QWidget):

 def __init__(self, parent=None):

   QtGui.QWidget.__init__(self,parent)
   cookie = urllib2.HTTPCookieProcessor()
   opener = urllib2.build_opener(cookie)
   urllib2.install_opener(opener)
   self.resize(546, 525)
   self.usuario = QtGui.QLineEdit(self)
   self.usuario.setGeometry(70, 10, 201, 21)
   self.l_usuario = QtGui.QLabel('Usuario :',self)
   self.l_usuario.setGeometry(10, 14, 57, 15)
   self.clave = QtGui.QLineEdit(self)
   self.clave.setGeometry(70, 40, 201, 21)
   self.clave.setEchoMode(QtGui.QLineEdit.Password)
   self.l_clave = QtGui.QLabel('Clave :',self)
   self.l_clave.setGeometry(10, 44, 57, 15)
   self.mencion = QtGui.QTextBrowser(self)
   self.mencion.setGeometry(10, 100, 531, 411)
   self.l_menciones = QtGui.QLabel('Tus Menciones : ',self)
   self.l_menciones.setGeometry(10, 70, 111, 16)
   self.login = QtGui.QPushButton('Ingresar !',self)
   self.login.setGeometry(300, 25, 171, 25)
   self.setWindowTitle('Menciones Twitter - [JaAViEr]')
   self.connect(self.login,QtCore.SIGNAL('clicked()'),self.ingreso)
   self.refresh = QtGui.QPushButton('Refrescar',self)
   self.refresh.setGeometry(0,0,0,0)

 def ingreso(self):

   user=str(self.usuario.text());passwd=str(self.clave.text())
   for token in re.findall('name=\"authenticity_token\" type=\"hidden\" value=\"(.*)\"',urllib2.urlopen('https://mobile.twitter.com/session').read()):
     dato = {'authenticity_token':token,'username':user,'password':passwd}
     urllib2.urlopen('https://mobile.twitter.com/session',urllib.urlencode(dato)).read()
     if "Sign out" in urllib2.urlopen('https://mobile.twitter.com/').read():

       self.refresh.setGeometry(300, 60, 171, 25)
       self.connect(self.refresh,QtCore.SIGNAL('clicked()'),self.mentions)
       self.mentions()
     
 def mentions(self):

   mensaje=""
   for persona,msj in zip(re.findall('<strong><a href=\"(.*)\">(.*)</a></strong>',urllib2.urlopen('https://mobile.twitter.com/replies').read()),re.findall('<span class=\"status\">(.*)</span>',urllib2.urlopen('https://mobile.twitter.com/replies').read())):
     if not persona in ["Find people','Help','Sign out"]:

       mensaje+="<b>%s</b> %s<hr>"%(persona[1],msj)
   self.mencion.setHtml('<body bgcolor=#c0deed><div style=color:black>%s</div>'%mensaje)


class calculadora(QtGui.QWidget):

   def __init__(self, parent=None):

       QtGui.QWidget.__init__(self, parent)
       self.setWindowTitle('Calculadora')
       self.resize(119, 145)
       self.temp=""
       self.igual = QtGui.QPushButton('=',self)
       self.igual.setGeometry(90, 120, 31, 24)
       self.multiplica = QtGui.QPushButton('*',self)
       self.multiplica.setGeometry(0, 120, 31, 24)
       self.connect(self.multiplica,QtCore.SIGNAL('clicked()'),self.multiplicar)
       self.clean = QtGui.QPushButton('AC',self)
       self.clean.setGeometry(30, 120, 31, 24)
       self.connect(self.clean,QtCore.SIGNAL('clicked()'),self.clear)
       self.divide = QtGui.QPushButton('/',self)
       self.connect(self.divide,QtCore.SIGNAL('clicked()'),self.dividir)
       self.divide.setGeometry(0, 90, 31, 24)
       self.connect(self.igual,QtCore.SIGNAL('clicked()'),self.resultado)
       self.resta = QtGui.QPushButton('-',self)
       self.resta.setGeometry(0, 60, 31, 24)
       self.connect(self.resta,QtCore.SIGNAL('clicked()'),self.restar)
       self.suma = QtGui.QPushButton('+',self)
       self.suma.setGeometry(0, 30, 31, 24)
       self.connect(self.suma,QtCore.SIGNAL('clicked()'),self.sumar)
       self.lineEdit = QtGui.QLineEdit(self)
       self.lineEdit.setGeometry(QtCore.QRect(0, 0, 121, 25))
       self.uno = QtGui.QPushButton('1',self)
       self.connect(self.uno,QtCore.SIGNAL('clicked()'),self.inu)
       self.uno.setGeometry(QtCore.QRect(30, 30, 31, 24))
       self.dos = QtGui.QPushButton('2',self)
       self.connect(self.dos,QtCore.SIGNAL('clicked()'),self.ind)
       self.dos.setGeometry(QtCore.QRect(60, 30, 31, 24))
       self.tres = QtGui.QPushButton('3',self)
       self.connect(self.tres,QtCore.SIGNAL('clicked()'),self.intr)
       self.tres.setGeometry(QtCore.QRect(90, 30, 31, 24))
       self.cuatro = QtGui.QPushButton('4',self)
       self.connect(self.cuatro,QtCore.SIGNAL('clicked()'),self.inc)
       self.cuatro.setGeometry(QtCore.QRect(30, 60, 31, 24))
       self.cinco = QtGui.QPushButton('5',self)
       self.connect(self.cinco,QtCore.SIGNAL('clicked()'),self.inci)
       self.cinco.setGeometry(QtCore.QRect(60, 60, 31, 24))
       self.seis = QtGui.QPushButton('6',self)
       self.connect(self.seis,QtCore.SIGNAL('clicked()'),self.ins)
       self.seis.setGeometry(QtCore.QRect(90, 60, 31, 24))
       self.nueve = QtGui.QPushButton('9',self)
       self.connect(self.nueve,QtCore.SIGNAL('clicked()'),self.inn)
       self.nueve.setGeometry(QtCore.QRect(90, 90, 31, 24))
       self.ocho = QtGui.QPushButton('8',self)
       self.connect(self.ocho,QtCore.SIGNAL('clicked()'),self.ino)
       self.ocho.setGeometry(QtCore.QRect(60, 90, 31, 24))
       self.siete = QtGui.QPushButton('7',self)
       self.connect(self.siete,QtCore.SIGNAL('clicked()'),self.insi)
       self.siete.setGeometry(QtCore.QRect(30, 90, 31, 24))
       self.cero = QtGui.QPushButton('0',self)
       self.cero.setGeometry(QtCore.QRect(60, 120, 31, 24))
       self.connect(self.cero,QtCore.SIGNAL('clicked()'),self.ince)

   def clear(self):

     self.temp=""
     self.lineEdit.setText('')

   def restar(self):

     self.temp+="-"
     self.lineEdit.setText(self.temp)

   def dividir(self):

     self.temp+="/"
     self.lineEdit.setText(self.temp)

   def multiplicar(self):

     self.temp+="*"
     self.lineEdit.setText(self.temp)

   def sumar(self):

       self.temp+="+"
       self.lineEdit.setText(self.temp)

   def resultado(self):

       if len(self.temp)>0:

         final=eval(self.temp)
         self.lineEdit.setText(str(final))
         self.temp=str(final)

       else:

         final=eval(str(self.lineEdit.text()))
         print final
         self.lineEdit.setText(str(final))
         self.temp=str(final)

   def inu(self):

       self.temp+="1"
       self.lineEdit.setText(self.temp)

   def ind(self):

       self.temp+="2"
       self.lineEdit.setText(self.temp)

   def intr(self):

       self.temp+="3"
       self.lineEdit.setText(self.temp)

   def inc(self):

       self.temp+="4"
       self.lineEdit.setText(self.temp)

   def inci(self):

       self.temp+="5"
       self.lineEdit.setText(self.temp)

   def ins(self):

       self.temp+="6"
       self.lineEdit.setText(self.temp)

   def insi(self):

       self.temp+="7"
       self.lineEdit.setText(self.temp)

   def ino(self):

       self.temp+="8"
       self.lineEdit.setText(self.temp)

   def inn(self):

       self.temp+="9"
       self.lineEdit.setText(self.temp)

   def ince(self):

       self.temp+="0"
       self.lineEdit.setText(self.temp)


class view_source(QtGui.QWidget):

   def __init__(self, parent=None):

       QtGui.QWidget.__init__(self,parent)
       self.resize(466, 407)
       self.vercode = QtGui.QPushButton('View Source',self)
       self.vercode.setGeometry(200, 380, 105, 24)
       self.http_host = QtGui.QLineEdit(self)
       self.http_host.setGeometry(90, 10, 371, 25)
       self.http_host.setEchoMode(QtGui.QLineEdit.Normal)
       self.url = QtGui.QLabel('Host / URL',self)
       self.url.setGeometry(20, 17, 71, 16)
       self.viewcode = QtGui.QLabel('View Source',self)
       self.viewcode.setGeometry(10, 35, 121, 16)
       self.code = QtGui.QPlainTextEdit(self)
       self.code.setGeometry(0, 50, 461, 331)
       self.code.setFrameShadow(QtGui.QFrame.Raised)
       self.setWindowTitle('View Source - JaAViEr')
       self.connect(self.vercode,QtCore.SIGNAL('clicked()'),self.vista_code)
   
   def vista_code(self):
     
     pagina=urllib2.urlopen(str(self.http_host.text()))
     self.code.setPlainText(pagina.read())

correr = QtGui.QApplication(sys.argv)
formulario = all_in_one()
formulario.show()
calculadora = calculadora()
twitter = twitter()
html_helper = html_helper()
secuencia = secuencia()
extractor = extractor()
digito = formulario_rut()
source = view_source()
correr.exec_()

Screenshot :


Luego es cuestión de dar clic en los botones para utilizar las herramientas !

Fuente : http://rootcodes.com/pyqt4all-in-one-recopilatorio-de-qt4-jaavier

Saludos, Javier