Bien, hoy estando aburrido decidi programar esto xD

#!/usr/bin/env python
#[Z]tuX
#Importamos las librerias de GTK
import pygtk
pygtk.require("2.0")
import gtk
import hashlib, base64

class Ventana_Inicial:   
    def cerrar(self,widget,data="None"):
        gtk.main_quit()              
              
    def md5(self,widget):
        texto = self.CajaEntrada.get_text() #Pedimos el Texto
        texto = hashlib.md5(texto).hexdigest() #Encriptamos El Texto   
        self.EntradaEncriptar.set_text(texto) #Mostramos el Texto
    
    def code_base64(self,wideget):
        texto = self.CajaEntrada.get_text()
        texto = base64.b64encode(texto)
        self.EntradaEncriptar.set_text(texto)
        
    def sha1(self,widget):
        texto = self.CajaEntrada.get_text() #Pedimos el Texto
        texto = hashlib.sha1(texto).hexdigest() #Encriptamos El Texto   
        self.EntradaEncriptar.set_text(texto) #Mostramos el Texto
    
    def sha256(self,widget):
        texto = self.CajaEntrada.get_text() #Pedimos el Texto
        texto = hashlib.sha256(texto).hexdigest() #Encriptamos El Texto   
        self.EntradaEncriptar.set_text(texto) #Mostramos el Texto
        
    def sha384(self,widget):
        texto = self.CajaEntrada.get_text() #Pedimos el Texto
        texto = hashlib.sha384(texto).hexdigest() #Encriptamos El Texto   
        self.EntradaEncriptar.set_text(texto) #Mostramos el Texto
        
    def sha512(self,widget):
        texto = self.CajaEntrada.get_text() #Pedimos el Texto
        texto = hashlib.sha512(texto).hexdigest() #Encriptamos El Texto   
        self.EntradaEncriptar.set_text(texto) #Mostramos el Texto
        
    def option(self,widget):
        opc = widget.get_active_text()
        if opc=="MD5":
            self.md5(widget)
        elif opc=="Base64":
            self.code_base64(widget)
        elif opc=="sha1":
            self.sha1(widget)
        elif opc=="sha256":
            self.sha256(widget)
        elif opc=="sha384":
            self.sha384(widget)
        elif opc=="sha512":
            self.sha512(widget)
        else:
            self.EntradaEncriptar.set_text("Hash NO Valido...")
       
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_position(gtk.WIN_POS_MOUSE)#Posicion Por Default
        self.window.set_title("EncryptMe by [Z]tuX") #Titulo
        self.window.set_size_request(250,160) #Tamanio
        
        #Botones########################################
        self.Titulo = gtk.Label("Texto a Encriptar: ")
        self.CajaEntrada = gtk.Entry()
        self.Hash = gtk.Label(">Hash")
        #COMBOBOX#######################################
        self.ComboBox = gtk.combo_box_entry_new_text()
        self.ComboBox.connect("changed",self.option)
        self.ComboBox.append_text("Base64")
        self.ComboBox.append_text("MD5")
        self.ComboBox.append_text("sha1")
        self.ComboBox.append_text("sha256")
        self.ComboBox.append_text("sha384")
        self.ComboBox.append_text("sha512")
        ################################################
        self.EtiquetaEncriptar= gtk.Label("> Texto Encriptado")
        self.EntradaEncriptar= gtk.Entry()      
        self.BotonSalir = gtk.Button(">Salir") #BotonSalir
        ###############FIN BOTONES#######################
        
        
        #Llmamos a las Funciones de Botones y Cajas
        self.CajaEntrada.connect("changed",self.md5)
        self.CajaEntrada.connect("changed",self.code_base64)
        self.BotonSalir.connect("clicked",self.cerrar)
        
        #Posicion de Botones y Cajas de Entrada
        Colocar = gtk.Fixed()
        Colocar.put(self.Titulo,10,5)
        Colocar.put(self.CajaEntrada,10,25)
        Colocar.put(self.Hash,10,55)
        Colocar.put(self.ComboBox,10,75)
        Colocar.put(self.EtiquetaEncriptar,10,105)
        Colocar.put(self.EntradaEncriptar,10,125)
        Colocar.put(self.BotonSalir,180,125)
        
        self.window.add(Colocar)#Mostramos
        self.window.show_all()
        self.window.connect("destroy",self.cerrar)
            
    def main(self):
        gtk.main()
 
if __name__=="__main__":
    WindowIni = Ventana_Inicial()
    WindowIni.main()

Ya habia hecho una version en modo Consola xD, la pueden ver aquí...
Y una Captura:
Salud[OS]
[Z]tuX

Bien iniciamos con esto:

#!/usr/bin/env python

#Importamos las librerias Necesarias de GTK
import pygtk
pygtk.require("2.0")
import gtk

class Base:
    def destruir(self,widget, data="None"):
        gtk.main_quit()
     
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
#TITULO DEL PROGRAMA
        self.window.set_title("Python & GTK With [Z]tuX xD!")
#AJUSTES DE LA VENTANA
        self.window.set_position(gtk.WIN_POS_MOUSE)
        self.window.set_size_request(600,200)
#BOTONES
        self.BotonSalir = gtk.Button("Salir")
        self.BotonSalir.connect("clicked",self.destruir)
        #Posicionamos el Boton usando Fixed
        Posicion = gtk.Fixed() #Creamos un objeto para posicionar el boton
        Posicion.put(self.BotonSalir, 20 ,30) #Especificamos el boton que quermos ajustar
                                              #Y ponemos el boton en la coordenada (20,30)
         
                
#MOSTRAMOS LA VENTANA 
        self.window.add(Posicion)
        #self.window.show()  --> Vamos a cambiar esta linea por la de abajo... :D
        self.window.show_all() #Para mostrar TODOS lo que esta contendido 
        self.window.connect("destroy",self.destruir)
   
    def main(self):
        gtk.main()

if __name__=="__main__":
    base = Base()
    base.main()

:O No se espanten, es muy sencillo bien que es esto?:

self.BotonSalir = gtk.Button("Salir")
self.BotonSalir.connect("clicked",self.destruir)

Simplemente estamos creando un botón nuevo, que lo llamamos "BotonSalir", es un objeto de tipo "Button" (Botón) y dentro del paréntesis ("Salir") se coloca el texto que se desea mostrar en el botón...
La segunda linea nos dice que a "BotonSalir" cuando se haga click en el botón [("clicked") --> Importante eso en paréntesis ] el botón va a llamar a la función  "destruir", que ya habíamos creado anteriormente, asi que al hacer click en ese botón la ventana se cerrará...

Ahora bien, las lineas:

#Posicionamos el Boton usando Fixed
        Posicion = gtk.Fixed() #Creamos un objeto para posicionar el boton
        Posicion.put(self.BotonSalir, 20 ,30) #Especificamos el boton que quermos ajustar
                                              #Y ponemos el boton en la coordenada (20,30)

Estas lineas nos ayudaran a posicionar el botón en la ventana... Primero asignamos a "Posicion" un ajuste:

Posicion = gtk.Fixed() #Creamos un objeto para posicionar el botón

Después ponemos ("put") dicho botón en algún lugar de la ventana, para ello, la linea:

Posicion.put(self.BotonSalir, 20 ,30)

Nos ayudara a colocar el "BotonSalir" en la coordenada (20,30).

Como se darán cuenta dentro del paréntesis se escribe algo como:
(self.BotonQueQueremos, Coordenada X, Coordenada Y)

Ahora lo importante... mostrar dichos botones D:
Es sencillo... Simplemente hacemos:

#MOSTRAMOS LA VENTANA 
        self.window.add(Posicion)
        #self.window.show()  --> Vamos a cambiar esta linea por la de abajo... :D
        self.window.show_all() #Para mostrar TODOS lo que esta contendido 
        self.window.connect("destroy",self.destruir)

En self.window.add(Posicion) ---> Lo que hacemos es añadir a la ventana principal "Posicion", pero "Posicion" como sabemos esta definido como de tipo Ajuste...

#Posicionamos el Boton usando Fixed
        Posicion = gtk.Fixed() #Creamos un objeto para posicionar el boton

Entonces lo que hacemos es añadir los botones a la ventana, después cambiamos  show() por show_all(), para mostrar TODO, y eso es todo....
Al final tenemos:

self.window.connect("destroy",self.destruir)

Que sirve para terminar la aplicación correctamente en caso de cerrar la ventana con el Botón "Close" (la x que esta en la esquina)

Así que si hacemos correr el programa, podremos ver algo como esto:


Si damos click en "Salir" el programa se cerrará con éxito... :D
Pero también podemos añadir una Ayuda ese botón, lo que haremos ahora es que cuando pasemos el puntero arriba de el botón salir nos muestre un cuadro de ayuda que diga algo como "Este botón cerrara la aplicación", bien para ello agregaremos las lineas:

self.BotonSalir.set_tooltip_text(u"Este botón cerrará la aplicación")  

Guardamos nuestro archivo y probamos... Claro está que esta linea se agrega despues de haber creado el boton, no antes, si no obviamente python no encontrara el botón y nos tirará un error...
Otra cosa, si se dan cuenta en el texto hay Acentos o Tildes, python asi como asi no las va a reconocer y nos va a tirar un error de algo como:

"SyntaxError: Non-ASCII character '\xc3' in file interfaz1.py on line 27, but no encoding declared; see http://www.python.org/peps/pep-0263.html for details
"
Para esto agregamos una "u" antes de el texto en comillas y agregamos:
# -*- encoding: utf-8  -*-
Una vez hecho esto tenemos algo como:

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

#Importamos las librerias Necesarias de GTK
import pygtk
pygtk.require("2.0")
import gtk

class Base:
    def destruir(self,widget, data="None"):
        gtk.main_quit()
     
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
#TITULO DEL PROGRAMA
        self.window.set_title("Python & GTK With [Z]tuX xD!")
#AJUSTES DE LA VENTANA
        self.window.set_position(gtk.WIN_POS_MOUSE)
        self.window.set_size_request(600,200)
#BOTONES
        self.BotonSalir = gtk.Button("Salir")
        self.BotonSalir.connect("clicked",self.destruir)
        #Posicionamos el Boton usando Fixed
        Posicion = gtk.Fixed() #Creamos un objeto para posicionar el boton
        Posicion.put(self.BotonSalir, 20 ,30) #Especificamos el boton que quermos ajustar
                                              #Y ponemos el boton en la coordenada (20,30)
        #Ayuda Del Boton
        self.BotonSalir.set_tooltip_text(u"Este botón cerrara la aplicación")    
                
#MOSTRAMOS LA VENTANA 
        self.window.add(Posicion)
        #self.window.show()
        self.window.show_all() #Para mostrar TODO lo que esta contendido 
        self.window.connect("destroy",self.destruir)
   
    def main(self):
        gtk.main()

if __name__=="__main__":
    base = Base()
    base.main()

Y finalmente corremos el programa y podremos ver la ayuda:


[Z]tuX

Bien, siguiendo con el code que anteriormente habíamos trabajado:

#!/usr/bin/env python

#Importamos las librerias Necesarias de GTK
import pygtk
pygtk.require("2.0")
import gtk

class Base:
    def destruir(self,widget, data="None"):
        gtk.main_quit()

    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.show()
        self.window.connect("destroy",self.destruir)

    def main(self):
        gtk.main()

if __name__=="__main__":
    base = Base()
    base.main()

Ahora vamos a aprender a darle algunos ajustes muy básicos a la ventana... En primera, el posicionamiento de la ventana cuando se inicia la aplicación. Podemos hacer que por "default" la ventana se muestre en el centro, para esto agregamos la linea:

self.window.set_position(gtk.WIN_POS_CENTER)

Esta linea la colocaremos dentro de la función inicial...


También podemos probar con:

self.window.set_position(gtk.WIN_POS_MOUSE) 
#Posicionamos la ventana En donde se encuentre el Puntero

self.window.set_position(gtk.WIN_CENTER_ALWAYS) 
#La ventana siempre aparecerá Centrada

self.window.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
#La ventana se posiciona centrada según otras ventanas

Recuerden, estas lineas van dentro de la función inicial:

#!/usr/bin/env python

#Importamos las librerias Necesarias de GTK
import pygtk
pygtk.require("2.0")
import gtk

class Base:
    def destruir(self,widget, data="None"):
        gtk.main_quit()

    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        #AJUSTES DE LA VENTANA
        self.window.set_position(gtk.WIN_POS_CENTER_ON_PARENT)  

        #MOSTRAMOS LA VENTANA   
        self.window.show()
        self.window.connect("destroy",self.destruir)

    def main(self):
        gtk.main()

if __name__=="__main__":
    base = Base()
    base.main()

También podemos cambiar el tamaño de la ventana... La siguiente linea También va dentro de la función inicial, para ello usamos:

self.window.set_size_request(600,200)

Y dentro de los paréntesis va el tamaño de la ventana, esto es: (columnas,filas)

#!/usr/bin/env python

#Importamos las librerias Necesarias de GTK
import pygtk
pygtk.require("2.0")
import gtk

class Base:
    def destruir(self,widget, data="None"):
        gtk.main_quit()

    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        #AJUSTES DE LA VENTANA
        self.window.set_position(gtk.WIN_POS_MOUSE)
        self.window.set_size_request(600,200)
        #MOSTRAMOS LA VENTANA   
        self.window.show()
        self.window.connect("destroy",self.destruir)

    def main(self):
        gtk.main()

if __name__=="__main__":
    base = Base()
    base.main()

También podemos agregar un titulo a nuestra ventana. Bien para ello usamos set_title("Nombre del Programa"), donde dentro de los paréntesis colocamos el texto que deseamos mostrar, y como esto es parte del objeto "window", tenemos que escribir algo como:

self.window.set_title("Python & GTK With [Z]tuX xD!")

Y bien eso es todo por el momento, ya pronto veremos como agregar botones y demás cosas...
Salud[OS]

Hola, que tal!!
Hoy vamos a aprender a crear interfaces gráficas usando Python y GTK, bien para ello es necesario tener conocimientos de python a nivel "intermedio", trabajar un poco con POO, entre algunas otras cosas.

Bien para ello necesitaremos tener Python, yo uso actualmente la versión 2.7 y con esa trabajaré, también es necesario tener las librerías para poder trabajar con GTK, para ello si eres usuario de windows puedes bajar los archivos binarios desde la web oficial, (te recomiendo el paquete all-in-one installer, ahi viene todo lo necesario para usar pyGTK, y descarga el paquete apropiado ya sea python 2.6 o 2.7, etc... ), y si eres usuario de GNU/Linux, probablemente en tu distribución las librerías ya estén instaladas... o por lo menos eso dice en la web oficial xD



Una vez instaladas las librerías, ahora si es hora de programar ;D
Bien para ello abrimos nuestro editor favorito, (IDLE de Python, Bloc de notas, VIM, NANO, Notepad++ etc.. ) y escribiremos lo siguiente:

#!/usr/bin/env python

#Importamos las librerias Necesarias de GTK
import pygtk
pygtk.require("2.0")
import gtk

class Base:    
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.show()
          
    def main(self):
        gtk.main()

if __name__=="__main__":
    base = Base()
    base.main()

Y bien tratare de explicar el code...

Las lineas:

#!/usr/bin/env python

#Importamos las librerias Necesarias de GTK
import pygtk
pygtk.require("2.0")
import gtk

Son para llamar al interprete de Python, después tenemos en la cuarta linea la importación de la librería pyGTK, también decimos que requerimos de la versión 2.0, e importamos la librería gtk, no se asusten en realidad esto no es importante de entender, simplemente deben saber que es para poder trabajar con GTK...

Después tenemos las lineas:

class Base:    
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.show()
          
    def main(self):
        gtk.main()

Creamos una clase llamada "Base", en ella vamos a escribir las funciones, la primera:

def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.show()

Bien, en esta parte como dije al inicio ya debemos de saber un poco de Python, asi que solo explicare los objetos que se crean:

        
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.show()

En la primera linea creamos una ventana, asignamos a la variable self.window el valor gtk.Window(gtk.WINDOW_TOPLEVEL) , con esto ya creamos la ventana, despues en la segunda linea hacemos que se muestre...

Después creamos una función llamada main, ahí se almacenará gtk.main(), que posteriormente llamaremos a esta función con las siguientes lineas:

if __name__=="__main__":
    base = Base()
    base.main()

Si necesitan ayuda sobre estas lineas recomiendo visitar este link, talvez ahí se aclare su duda :D
Y bien con eso ya tenemos nuestra primer ventana... pueden probar el code desde su terminal haciendo:

python interfaz1.py

Bien, si se dan cuenta, al dar click en cerrar, la terminal se ve como si siguiera corriendo el proceso, es decir no se a terminado, no se cerró el programa, bien para ello vamos a agregar  unas lineas al code, asi que apretaremos en la terminal CTR+C y veremos algo como esto:


Ahora si editaremos el code...
Vamos a crear una función "destruir", o asi la llamare yo, en realidad puede tener cualquier nombre, pero es recomendable que a la hora de escribir código sea entendible :D

Bien escribiremos antes de:

def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.show()

Las siguientes lineas:

class Base:
    #Creamos la funcion Destruir
    def destruir(self,widget, data="None"):
        gtk.main_quit()
     
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.show()
        #Agregamos esta linea
        self.window.connect("destroy",self.destruir)

Como podemos ver también agregamos una linea en la función __init__ esto para que cuando se haga click en el botón cerrar se llame a la función destruir y se cierre la ventana correctamente, es IMPORTANTE que a la linea:

self.window.connect("destroy",self.destruir)

se le pase como parámetros "destroy" coma (,) seguidamente de la función para destruir la ventana (self.desruir)...
Ahora si si probamos el code veremos que ya no nos sucede que, la terminal seguía como si aun hubiera un proceso corriendo, esto es porque ahora SI SE CIERRA el proceso correctamente :D

Asi que el codigo finalmente nos queda algo como:


En rojo están las lineas que agregamos...
Y bien esta es nuestro primer programa con Python y GTK, realmente es algo sencillo, después veremos algunas funciones mas para personalizar la ventana, como tamaño, titulo, etc...

Finalmente el código nos quedó así:

#!/usr/bin/env python

#Importamos las librerias Necesarias de GTK
import pygtk
pygtk.require("2.0")
import gtk

class Base:
    def destruir(self,widget, data="None"):
        gtk.main_quit()
     
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.show()
        self.window.connect("destroy",self.destruir)
   
    def main(self):
        gtk.main()

if __name__=="__main__":
    base = Base()
    base.main()

Si se preguntan que editor usé, se llama VIM...
¿Alguna duda? Comenta!!
Salud[OS]
[Z]tuX

Bien, como podemos saber en Python El famoso Switch de C/C++, Java, Pascal, etc... no existe, pero podemos simularlo.¿Como podemos hacer esto?Bien pues en Python podemos hacer uso de los famosos Diccionarios, para ello crearemos un diccionario llamado "switch" y dentro de el van las opciones, para dejar mas claro esto podemos ver el siguiente ejemplo:

def ztux():
    print "ZtuX"
def blog():
    print "Blog"
def programacion():
    print "Programacion"

def main():
    while True:
        switch={1:ztux,
                2:blog,
                3:programacion,
                }
        print """Elige una Opcion
[1] ZtuX
[2] Blog
[3] Programacion
"""
        opc = input("> ")
        switch[opc]()
        
main()

¿Facil no?¿Dudas? Comenta!!

Hola que tal.... hoy estaba aburrido así que me puse a jugar con Python y pues estoy creando una librería para trabajar con vectores...
Aun empecé y la verdad no se si después la continué, son libres de tomar el code y modificarlo xD

#Libreria ZVectores - by [Z]tuX
import math

class punto3D(object):
 def __init__(self,x=0,y=0,z=0):
     self.x=x
     self.y=y
     self.z=z
 def __str__(self):
     return "Vector ["+str(self.x)+","+str(self.y)+","+str(self.z)+"]"
 def modulo(self):
     return math.sqrt(self.x+self.y+self.z)
 def show(self):
     return self.x,self.y,self.x     
 #SUMA DE DOS VECTORES
 def __add__(self,point):
     return punto(self.x+point.x,self.y+point.y,self.z+point.z)
 #RESTA DE DOS VECTORES
 def __sub__(self,point):
     return punto(self.x-point.x,self.y-point.y,self.z-point.z)
 #COMPARAMOS DOS VECTORES
 def __cmp__(self,point):
     if self.x==point.x and self.y==point.y:
         return 0
  
class punto2D(punto3D):
 def __init__(self,x=0,y=0):
     punto3D.__init__(self,x,y)
  
#OPERACIONES CON 2 VECTORES
class opc_ptos(object):
 '''Opera dos Vectores'''
 def __init__(self,x,y,z,a,b,c):
     self.x=x
     self.y=y
     self.z=z
     self.a=a
     self.b=b
     self.c=c
 def pp(self):
     '''Producto Punto'''
     return (self.x*self.a)+(self.y*self.b)+(self.z*self.c)
 def pc(self):
     '''Producto Cruz'''
     i=(self.y*self.c)-(self.z*self.b)
     j=-((self.x*self.c)-(self.z*self.a))
     k=(self.x*self.b)-(self.y*self.a)
     return i,j,k

En este sencillo tutorial, les enseñaré el uso de la herramienta 2to3 de Python.
Si no te familiarizas todavía con la versión 3 esta herramienta te guiará en ello :)



By KodeInfect
Link Video