crear_archivo = open('ejecutable.exe','w')

crear_archivo = open('ejecutable.exe','wb')

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

import urllib


def hexadecimal(texto):
    return texto.encode("hex")

def quote(texto):
    return urllib.quote(texto)

def switch(opcion):
    return {
            "bin2hex": "hexadecimal",
            "encode": "quote",
    }[opcion]

print locals()[switch("encode")]("http://underc0de.org/foro/python/?action=post")

# -*- coding: utf-8 -*-

# Envio de archivos: cliente
# 11Sep

import socket

# Creamos una lista con la dirección de
# la máquina y el puerto donde
# estara a la escucha
CONEXION = (socket.gethostname(), 9001)
ARCHIVO = "a.pdf"


# Instanciamos el socket y nos
# conectamos
cliente = socket.socket()
cliente.connect(CONEXION)

# Abrimos el archivo en modo lectura binaria
# y leemos su contenido
with open(ARCHIVO, "rb") as archivo:
    buffer = archivo.read()

while True:
    # Enviamos al servidor la cantidad de bytes
    # del archivo que queremos enviar
    print "Enviando buffer"
    cliente.send(str(len(buffer)))
    
    # Esperamos la respuesta del servidor
    recibido = cliente.recv(10)
    if recibido == "OK":
        # En el caso que la respuesta sea la correcta
        # enviamos el archivo byte por byte
        # y salimos del while
        for byte in buffer:
            cliente.send(byte)
        break

# -*- coding: utf-8 -*-

# Envio archivos: servidor
# 11Sep

import socket

# Creamos una lista con los datos del la conexión
CONEXION = (socket.gethostname(), 9001)

servidor = socket.socket()

# Ponemos el servidor a la escucha
servidor.bind(CONEXION)
servidor.listen(5)
print "Escuchando {0} en {1}".format(*CONEXION)
# Aceptamos conexiones
sck, addr = servidor.accept()
print "Conectado a: {0}:{1}".format(*addr)
while True:
    # Recibimos la longitud que envia el cliente
    recibido = sck.recv(1024).strip()
    if recibido:
        print "Recibido:", recibido
    # Verificamos que lo que recibimos sea un número
    # en caso que así sea, enviamos el mensaje "OK"
    # al cliente indicandole que estamos listos
    # para recibir el archivo
    if recibido.isdigit():
        sck.send("OK")
        
        # Inicializamos el contador que
        # guardara la cantidad de bytes recibidos
        buffer = 0
        # Abrimos el archivo en modo escritura binaria
        with open("archivo", "wb") as archivo:
            # Nos preparamos para recibir el archivo
            # con la longitud específica
            while (buffer <= int(recibido)):
                data = sck.recv(1)
                if not len(data):
                    # Si no recibimos datos
                    # salimos del bucle
                    break
                # Escribimos cada byte en el archivo
                # y aumentamos en uno el buffer
                archivo.write(data)
                buffer += 1
            
            if buffer == int(recibido):
                print "Archivo descargado con éxito"
            else:
                print "Ocurrió un error/Archivo incompleto"
        break

while (i=1):

#!/usr/bin/env python

num1 = input('Escribe un numero: ')

i = 0

while (True):
        i=i+1
        num2 = input('Escribe un numero: ')

        if (num2<num1):
                break
        else:
                num1=num2
        print 'Se han contado',i,'veces'

import re
import urllib

text = urllib.urlopen("http://www.sensacine.com/peliculas/en-cartelera/cines/").read()

expresion = re.compile("(<h2.+?</h2>)", re.DOTALL)

data = expresion.findall(text)

for u in data:
    print u, "\r\n"

from threading import Thread as Process

import socket
import cPickle as pickle

class servidor():
    def __init__(self):
        self.port = 9001
        self.host = socket.gethostname()
        self.conectados = []
        self.escuchar()
    
    def escuchar(self):
        try:
            ser = socket.socket()
            ser.bind((self.host, self.port))
            ser.listen(5)
            while True:
                (sck, addr) = ser.accept()
                if not sck in self.conectados:
                    self.conectados.append(sck)
                    Process(target=self.indpt, args=(sck,addr)).start()
        except KeyboardInterrupt:
            print c.FAIL % ("Saliendo")
            ser.close()
            return
    
    def indpt(self, sck, addr):
        try:
            direccion = "%s:%i" % addr
            print c.OKGREEN % ("conectado a: " + direccion)
            sck.send(pickle.dumps(("Servidor", "Conectado al servidor")))
            while True:
                buff = sck.recv(10024).strip()
                if not len(buff):
                    print c.FAIL % (direccion + " desconectado")
                    self.conectados.remove(sck)
                    sck.close()
                    return
                else:
                    for i in self.conectados:
                        if i != sck:
                            print i.send(buff + "\r\n")
        except:
            print c.FAIL % (direccion + " desconectado")
            sck.close()
            return

class c:
    OKGREEN = '\033[92m[*] %s\033[0m'
    FAIL = '\033[91m[-] %s\033[0m'

servidor()

from PyQt4.QtCore import *
from PyQt4.QtGui import *

import cPickle as pickle
import socket
import time
import sys


class Gui(QWidget):
    def __init__(self, host, port):
        QWidget.__init__(self)
        
        self.nick = "Yo"
        
        self.recv = QTextEdit()
        self.send = QLineEdit()
        self.btn_send = QPushButton("Enviar")
        self.btn_connect = QPushButton("Conectar")
        
        hbox = QHBoxLayout()
        vbox = QVBoxLayout()
        
        vbox.addWidget(self.recv)
        vbox.addLayout(hbox)
        vbox.addWidget(self.btn_connect)
        
        hbox.addWidget(self.send)
        hbox.addWidget(self.btn_send)
        
        self.setLayout(vbox)

        self.btn_send.clicked.connect(self.enviar)
        self.btn_connect.clicked.connect(self.conectar)
    
    def conectar(self):
        self.con = Conectar()
        self.connect(self.con, SIGNAL("conexion"), self.conexion)
        self.con.show()
    
    def conexion(self, data, nick):
        self.nick = nick
        self.sck = socket.socket()
        self.sck.connect(data)
        
        self.e_thread = Escuchar(self.sck)
        self.connect(self.e_thread, SIGNAL("message"), self.mensaje)
        self.e_thread.start()
    
    def mensaje(self, data):
        mensaje = '<font color="red">%s: </font>%s' % data
        self.recv.append(mensaje)
    
    def enviar(self):
        data = str(self.send.text().toAscii())
        
        paquete = (self.nick, data)
        paquete = pickle.dumps(paquete)
        
        if data:
            self.sck.send(paquete)
            self.send.setText("")
            self.mensaje((self.nick, data))
    

class Conectar(QWidget):
    def __init__(self):
        QWidget.__init__(self)
        
        self.host = QLineEdit(socket.gethostname())
        self.port = QLineEdit()
        self.nick = QLineEdit()
        self.btn_connect = QPushButton("Conectar")
        
        hport = QHBoxLayout()
        hhost = QHBoxLayout()
        hnick = QHBoxLayout()
        vbox = QVBoxLayout()
        
        hhost.addWidget(QLabel("Host:"))
        hhost.addWidget(self.host)
        
        hport.addWidget(QLabel("Port:"))
        hport.addWidget(self.port)
        
        hnick.addWidget(QLabel("Nick:"))
        hnick.addWidget(self.nick)
        
        vbox.addLayout(hhost)
        vbox.addLayout(hport)
        vbox.addLayout(hnick)
        vbox.addWidget(self.btn_connect)
        
        self.setLayout(vbox)
        
        self.btn_connect.clicked.connect(self.comprobar)
    
    def comprobar(self):
        port = int(self.port.text().toAscii())
        host = str(self.host.text().toAscii())
        nick = str(self.nick.text().toAscii())
        
        if not nick:
            nick = host
        
        if port and host:
            self.emit(SIGNAL("conexion"), (host, port), nick)

class Escuchar(QThread):
    def __init__(self, sck):
        QThread.__init__(self)
        self.sock = sck
        
    def run(self):
        while True:
            buff = self.sock.recv(10024).strip()
            serialized = pickle.loads(buff)
            time.sleep(0.3)
            self.emit(SIGNAL("message"), serialized)
    
    def __del__(self):
        self.wait()

App = QApplication(sys.argv)
GUI = Gui("192.168.1.7", 9001)
GUI.show()
App.exec_()