Un hermoso lenguaje de programación a mi gusto, algo sensible con los espacios pero muy simple manejar cuando te acostumbras a la sintaxis.

esta es una recopilación de sitios para partir entendiendo python y echar vuelo en la programación.

Aprendiendo Python Programando – en Maestros del Web
http://www.maestrosdelweb.com/editorial/guia-python/

Recomendado:

Online Python Tutor.
Curso gratuito que permite escribir código Python online y ejecutarlo haciendo un debug paso a paso. Muy bueno gráficamente

http://www.pythontutor.com/

http://www.pythontutor.com/visualize.html

Permite ejecutar código en Python 2.7 y 3.2

Sitios de interés

• Instalación de Python
• un pequeño script para enviar email…
• Tiro parabolico con pygame
• Pygame: Pequeño graficador
• Crear juegos en Python + Pygame
• libmail
• Autómatas en python
• Serie de Fibonacci
• Un juego
• Como recuperar mensajes de una bandeja de entrada IMAP
• Encriptar un archivo con gnupg (gpg)
• Sencilla implementación de grafos
• Vectores en 3D
• Números primos
• Lista de utilidades
• Video tutoriales
• Keylogger
• Evaluar expresiones aritmeticas
• Problema de la mochila
• Comprensión de listas
• Artículos de Django (Y python) en castellano.
• Debugger Online para python
• Número decimal a binario [aporte]
• Servidor que funciona incluso en equipos PDA.
• VirtualEnv en Linux
• Lleva producción tu app hecha en Django con Heroku

Wallpapers

• Wallpaper estilo HTML5

Recursos:

• Inmersión a Python – traducción de Dive into Python
  http://www.gulic.org/almacen/diveintopython-5.4-es/toc/
• Dive into Python
  http://diveintopython.org/
• Python para Todos. De Raúl González Duque
  http://rapidshare.com/files/11490060…para_todos.pdf
  Un excelente recurso para empezar con python es este libro (en español, Licencia Creative Commons)
• Guía de Estilo de código Python
  http://mundogeek.net/traducciones/gu…ilo-python.htm
• Modismos y Anti-modismos a usar/evitar en python
  http://mundogeek.net/traducciones/modismos-python.htm
• Si a uno le gustan los juegos y entiende el inglés
  http://www.pythonchallenge.com
• Video tutoriales de django
  http://teamtreehouse.com/library/archive/django/basics

Fuente: http://www.forosdelweb.com/f130/documentacion-aportes-python-591012/

Simple Chat que permite hablar con 5 personas de forma simultanea.

hay una parte del chat el cual es el programa login , que mediante una base de datos en postgres valida al usuario, el código de esto esta comentado pero esta disponible para ser usado.

algunos comandos del chat

• ADD , permite asignar un nick para comenzar a hablar en el chat

• LIST . muestra una lista con los usuarios conectados

• TEXT TO: permite mandar un mensaje privado a algún usuario especifico

• END abandonar el chat

conexión con la Base de datos

#!/usr/bin/python2.4

import psycopg2

try:
    conn = psycopg2.connect("dbname='freetalk' user='@' host='@' password='@)
except:
    print "I am unable to connect to the database"

 #!/usr/bin/python
import psycopg2

def login (name, passwd):
    log = "false"
    try:
        conn = psycopg2.connect("dbname='@' user='@' host='@' password='@' ")
            cur = conn.cursor()
            try:
            cur.execute("SELECT id from users where name=(%s) and passwd=(%s);", (name,passwd))
            except:
            print "I can't SELECT from bar"

        row_s = cur.fetchone()[0]
        if row_s != 0:
            log="true"

    except:
        print "I am unable to connect to the database."

    return log

Chat para el servidor

 #!/usr/bin/python
#Servidor chat

import string
import threading
import socket
import bdd

clients = {'name':[], 'socket':[]}

class clientCenter(threading.Thread):

    def __init__(self, socket):
        threading.Thread.__init__(self)
    self.conn = socket
    self.conected = False
    self.data = ''
    def run(self):
    while True:
        self.data = self.conn.recv( 1024 )
        if 'ADD' in self.data:
            #Busca si ya ha sido insertado
            if(self.conected == False):
                self.conected = True                    
                clients['name'].append(self.data[4:])
                clients['socket'].append(self.conn)
                for i in clients['socket']:
                    if i != self.conn:
                        i.send(self.data[4:]+" ha entrado en el chat.")
            else:
                self.conn.send("Ya estas en el chat.")
            print clients

        if ('LIST' in self.data) and (self.conected == True):
            for i in clients['name']:
                    print "enviado a "+str(self.conn)+" "+str(i)
                    self.conn.send(i+" ")
            print clients

        if ('HELP' in self.data):
            msn = "--->Commands:\n[LIST] see users\n[TEXT] send message\n[TEXT TO] send message to\n[END] close\n[ADD] enter to chat\n[HELP] help"
            self.conn.send(msn)

                if ('EXIT' in self.data):
                        if (self.conected == True):
                                for i in clients['socket']:
                                        if i == self.conn:
                                                name = clients['name'][clients['socket'].index(i)]
                                                clients['name'].remove(name)
                                                clients['socket'].remove(i)
                                                self.conected = False
                                for i in clients['socket']:
                                        if i != self.conn:
                                                i.send(name+" ha salido del chat.")
                                self.conn.send(" ")
                        else:
                                self.conn.send(" ")
            self.conn.close()
            break

        if ('END' in self.data):
            if (self.conected == True):
                for i in clients['socket']:
                    if i == self.conn:
                        name = clients['name'][clients['socket'].index(i)]
                        clients['name'].remove(name)
                        clients['socket'].remove(i)
                        self.conected = False
                for i in clients['socket']:
                    if i != self.conn:        
                        i.send(name+" ha salido del chat.")
                self.conn.send(" ")
            else:
                self.conn.send(" ")
        if ('TEXT' in self.data and 'TEXT TO' not in self.data) and (self.conected == True):
            for i in clients['socket']:
                if i != self.conn:
                    i.send(clients['name'][clients['socket'].index(self.conn)]+" dice: "+self.data[5:])
            print clients

        if ('TEXT TO' in self.data) and (self.conected == True):
            palabras = self.data[8:].split()
            #busca si existe alguien con ese alias
            for i in clients['name']:
                if i == palabras[0]:
                    #Prepara el mensaje
                    del palabras[0]
                    mensaje = string.join(palabras, ' ')
                    clients['socket'][clients['name'].index(i)].send(clients['name'][clients['socket'].index(self.conn)]+" dice: "+mensaje)

    self.conn.close()

Servidor

 #!/usr/bin/python
import socket
import threading
import chatserver

s = socket.socket( socket.AF_INET, socket.SOCK_STREAM )
s.bind( ( socket.gethostname(), 6969 ) )
s.listen( 5 )

print "Start ..."
print "FREETALK SERVER [OK]"

while(True):
	conn, addr = s.accept()
	chatserver.clientCenter(conn).start()

conn.close()
s.close()

Cliente

#!/usr/bin/python

import socket
import bdd
import os, sys
import threading 

miSocket = socket.socket( socket.AF_INET, socket.SOCK_STREAM )
miSocket.connect( (socket.gethostname(), 6969 ) )

class write(threading.Thread):
	def __init__(self, socket):
		threading.Thread.__init__(self)
		self.mensaje = ''
		self.conn = socket
	def run(self):
		while True:
			self.mensaje = raw_input("> ")
			if 'ADD' in self.mensaje:
				self.conn.send(self.mensaje)

			elif self.mensaje == "TALK":
				os.system("xterm -e 'python cliente_sonido.py'")#ejecuta el cliente para hablar
			elif self.mensaje == "VOLU":
				os.system("xterm -bg steelblack4 -fg green alsamixer")
			else:
				self.conn.send("TEXTO"+self.mensaje)
		self.conn.close()

class read(threading.Thread):
	def __init__(self, socket):
		threading.Thread.__init__(self)
		self.mensaje = ''
		self.conn = socket
	def run(self):
		while True:
			self.mensaje = self.conn.recv( 1024 )
			print(self.mensaje)
		self.conn.close()

def login():
	u_status = "false"
	while u_status == "false":
	        #os.system("clear")
	        print "User:"
		name_s = raw_input(">>")
		if name_s == "EXIT":
	                break
	        print "Password:"
		passwd_s = raw_input(">>")
		if passwd_s == "EXIT":
	                break
		u_status = bdd.login(name_s, passwd_s)
		if u_status == "false":
	                print "\nYour details are not valid\n"
        return u_status
	conn.close()

#log = "false"

threads = [write(miSocket), read(miSocket)]

#if log == "false":
# 	log=login()

print "-----------------------"
print "-                     -"
print "-     Free Talk       -"
print "-                     -"
print "-      v 0.0.1        -"
print "-                     -"
print "-----------------------"
print ""
print "--->Commands:\n[LIST] see users\n[TEXT] send message\n[TEXT TO] send message to\n[END] close\n[HELP] help"
print ""
print "--->To Talk select a nickname with: ADD YourName"

for h in threads:
    h.start()

Saludos

Ya terminando una tarea de sistemas distribuidos donde por allí necesite aprender como grabar, reproducir y transmitir audio en python . A continuación coloco algunos programas a modo ejemplo:

 ojo deben tener instalado pyaudio

Grabar Audio

 """ Record a few seconds of audio and save to a WAVE file. """

import pyaudio
import wave
import sys

chunk = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 44100
RECORD_SECONDS = 5
WAVE_OUTPUT_FILENAME = "output.ogg"

p = pyaudio.PyAudio()

stream = p.open(format = FORMAT,
                channels = CHANNELS,
                rate = RATE,
                input = True,
                frames_per_buffer = chunk)

print "* recording"
all = []
for i in range(0, RATE / chunk * RECORD_SECONDS):
    data = stream.read(chunk)
    all.append(data)
print "* done recording"

stream.close()
p.terminate()

# write data to WAVE file
data = ''.join(all)
wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
wf.setnchannels(CHANNELS)
wf.setsampwidth(p.get_sample_size(FORMAT))
wf.setframerate(RATE)
wf.writeframes(data)
wf.close()

Grabar y Reproducir Audio

""" A wire between input and output. """

import pyaudio
import sys

chunk = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 44100
RECORD_SECONDS = 5

p = pyaudio.PyAudio()

stream = p.open(format = FORMAT,
                channels = CHANNELS,
                rate = RATE,
                input = True,
                output = True,
                frames_per_buffer = chunk)

print "* recording"
for i in range(0, 44100 / chunk * RECORD_SECONDS):
    data = stream.read(chunk)
    #send data
    stream.write(data, chunk)
print "* done"

stream.stop_stream()
stream.close()
p.terminate()

Mandar Audio a un servidor y este reproduzca el sonido enviado , mediante UDP (El cliente captura el sonido y el servidor captura el dato enviado vía UDP y lo reproduce)

#
#    CLIENTE
#
import socket
import pyaudio
import sys


#UDP_IP="127.0.0.1"
UDP_IP= socket.gethostname()

UDP_PORT=5005
MESSAGE="Hello, World!"
 
print "UDP target IP:", UDP_IP
print "UDP target port:", UDP_PORT
print "message:", MESSAGE


chunk = 2048
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 44100
RECORD_SECONDS = 5

p = pyaudio.PyAudio()

stream = p.open(format = FORMAT,
                channels = CHANNELS,
                rate = RATE,
                input = True,
                output = True,
                frames_per_buffer = chunk)

sock = socket.socket( socket.AF_INET, 
                      socket.SOCK_DGRAM ) # UDP
sock.sendto( MESSAGE, (UDP_IP, UDP_PORT) )

print "* recording"
#for i in range(0, 44100 / chunk * RECORD_SECONDS):
while True:
    MESSAGE = stream.read(chunk)
    sock = socket.socket( socket.AF_INET,socket.SOCK_DGRAM )#internet # UDP
    sock.sendto( MESSAGE, (UDP_IP, UDP_PORT) )
    sock.sendto( MESSAGE, (UDP_IP, UDP_PORT) )
    sock.sendto( MESSAGE, (UDP_IP, UDP_PORT) )


print "* done"

#
# SERVIDOR
#

import socket
import pyaudio
import sys
 
#UDP_IP="127.0.0.1"
UDP_IP = socket.gethostname()
UDP_PORT=5005

chunk = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 44100
RECORD_SECONDS = 5

p = pyaudio.PyAudio()

stream = p.open(format = FORMAT,
                channels = CHANNELS,
                rate = RATE,
                input = True,
                output = True,
                frames_per_buffer = chunk)

sock = socket.socket( socket.AF_INET,
                      socket.SOCK_DGRAM ) # UDP
sock.bind( (UDP_IP,UDP_PORT) )

data, addr = sock.recvfrom( 3072 )
print "received message:", data



print "* playing"
#for i in range(0, 44100 / chunk * RECORD_SECONDS):
#   print "get chunk %i" %i
while True:
   #data,addr = s.recvfrom(1024)
   data, addr = sock.recvfrom( 3072 )
   stream.write(data, chunk)
   #stream.write(data, chunk)
print "* done"

Este ultimo es algo grotesco, el sonido es horrible el de recepción a si que acepto mejoras a la propuesta de ejemplo, a medida que llegan las iré colocando

Saludos!

Es mas que nada un juguete , nada serio, ya que tiene muchos pero muchos detalles, a medida que iré lvl en Python voy publicando algunas casillas .

El asunto Dice así:

“Se le a pedido crear un sistema de administración para una cadena hotelera, la cual ha solicitado crear un sistema de registro de clientes, los cuales al llegar al hotel solicitan la disponibilidad de habitaciones, en caso de haber habitaciones disponibles se debe imprimir en pantalla que habitaciones están disponibles, en caso de no haber habitaciones disponibles se debe informar al cliente que no se posee habitaciones para asignar. Este sistema debe poseer funciones para listar los precios de las habitaciones, como también para asignar la habitación al cliente.

Esta plataforma debe contar con un inicio de sesión antes de entrar al sistema. El hotel consta de 100 habitaciones entre ellas un penthouse, 9 habitaciones king, 70 habitaciones dobles y 20 habitaciones simples.

Como está de moda, a querido implementar una estructura distribuida, cliente-servidor,  utilizando socket TCP, para la comunicación entre cliente y servidor, donde en el servidor estarán almacenadas las funciones que procesaran la información del hotel y en el cliente se mostrará la interfaz para comunicarse con dicho servidor, el cual estará a la espera de los parámetros para ser procesados.”

primero cree la estructura del hotel , cree una clase para las pesas y mediante herencia las subdividí en los != tipo que tenia, otra opción es crear una matriz y otra opción es utilizar una Base de datos , etc hasta el infinito de opciones. (La idea de la Base de datos me gusto, el único problema es que ya tenia echa la tarea cuando se me ocurrió )

el asunto me quedo así:

#!/usr/bin/python

class habitacion:
    def __init__(self,numero, estado, precio):
        self.numero = numero
        self.estado = estado
        self.precio = precio
    def tell(self):
        print 'Numero = "%i" , Estado = "%i" , Precio = "%i"  ' %(self.numero, self.estado, self.precio),
    def getNumero(self):
        return self.numero
    def getEstado(self):
        return self.estado    
    def getPrecio(self):
        return self.precio
    def setEstado(self, estado):
        self.estado=estado

class penthouse(habitacion):
    def __init__(self,numero, estado, precio):
        habitacion.__init__(self,numero, estado,precio)
        self.tipo="Penthouse"
    def getTipo(self):
        return self.tipo
        def getNumero(self):
                return self.numero
        def getEstado(self):
                return self.estado
        def getPrecio(self):
                return self.precio
        def setEstado(self, estado):
                self.estado=estado
    def tell(self):
        print 'Tipo = "%s",Numero = "%i" , Estado = "%i" , Precio = "%i"  ' %(self.tipo, self.numero, self.estado, self.precio),

class h_king(habitacion):
    def __init__(self, numero, estado, precio):
        habitacion.__init__(self,numero, estado,precio)
        self.tipo="King"
        def getTipo(self):
                return self.tipo
        def getNumero(self):
                return self.numero
        def getEstado(self):
                return self.estado
        def getPrecio(self):
                return self.precio
        def setEstado(self, estado):
                self.estado=estado
    def tell(self):
        print 'Tipo = "%s",Numero = "%i" , Estado = "%i" , Precio = "%i"  ' %(self.tipo, self.numero, self.estado, self.precio),

class h_dobles(habitacion):
        def __init__(self, numero, estado, precio):
                habitacion.__init__(self,numero, estado,precio)
                self.tipo="Doble"
        def getTipo(self):
                return self.tipo
        def getNumero(self):
                return self.numero
        def getEstado(self):
                return self.estado
        def getPrecio(self):
                return self.precio
        def setEstado(self, estado):
                self.estado=estado
        def tell(self):
                print 'Tipo = "%s",Numero = "%i" , Estado = "%i" , Precio = "%i"  ' %(self.tipo, self.numero, self.estado, self.precio),

class h_simple(habitacion):
        def __init__(self, numero, estado, precio):
                habitacion.__init__(self,numero, estado,precio)
                self.tipo="Simple"
        def getTipo(self):
                return self.tipo
        def getNumero(self):
                return self.numero
        def getEstado(self):
                return self.estado
        def getPrecio(self):
                return self.precio
        def setEstado(self, estado):
                self.estado=estado
        def tell(self):
                print 'Tipo = "%s",Numero = "%i" , Estado = "%i" , Precio = "%i"  ' %(self.tipo, self.numero, self.estado, self.precio),

ahora vamos a crear el servidor, por allí explique el mecanismo cliente servidor , en este programa agregue solamente algunas funciones para que interactuaran a lvl de habitaciones , pero básicamente es el mismo.

acá el servidor tanto como el cliente se responden.

#!/usr/bin/python

import hab
import socket

s = socket.socket()
s.bind(("localhost", 4949))
s.listen(1)
sc, addr = s.accept()

print "Cargando Usuarios"

usuarios =['admin', 'leo', 'otro'] #todos los usuarios
claves=['admin', '123qwe', '123'] #las contrasenas de los usuarios

u="false" #validar usuario
p="false" #validar contrasena
cont=-1 #contador para relacionar usuario[cont] con su contrasena ( clave[cont])
cont2=0 #contador de intentos para ingresar contrasena
print "Cargando Habitaciones ....."

h = {}

#Creando el arreglo de habitaciones :

for i in range(1, 100):
    if i == 1:
        h[i] = hab.penthouse(i,0,150000)
    if i >1 and i <= 10:
        h[i]= hab.h_king(i,0,85000)
    if i>10 and i<=71:
        h[i]= hab.h_dobles(i,0,35000)
    if i>71:
        h[i] = hab.h_simple(i,0,17000)

print "Conectado ..."

#ingreso de usuario
while u == "false":
    recibido = sc.recv(1024)
    if recibido == "exit":
        print "Cerrando"
        break
    for i in range(0, 3):
        if usuarios[i] == recibido:
            u = "true"
            cont =i
    sc.send(u)
#ingreso de clave
while p == "false" and cont2 <=3:
    recibido = sc.recv(1024)
    if claves[cont]==recibido:
        p="true"
    cont2 = cont2+1
    if cont2 > 3:
        p="error"
    sc.send(p)
    if p=="error":
        break

#Hotel

while True and p != "error":
        recibido = sc.recv(1024)
        if recibido == "exit":
                break
#ver habitaciones disponibles
    #ver habitaciones Penthouse
    if recibido == "1":
        mensaje = "Penthouse diponible \n"
        bool = "false"
         for i in range(1,100):
            if h[i].getTipo()=="Penthouse" and h[i].getEstado() == 0:
                if bool == "false":
                    mensaje = "----------------------\n| Numero   | Estado  |\n----------------------\n"
                numero = h[i].getNumero()
                mensaje = mensaje + "|   %i     |Disponble|\n"  %numero
                bool = "true"

        if bool == "false":
            mensaje = mensaje + "===> No hay habitaciones disponibles\n"
        if bool == "true":
            mensaje = mensaje + "----------------------\n"
        sc.send(mensaje)
    #ver habitaciones king
    if recibido == "2":
        mensaje = "Habitaciones King disponibles \n"
        bool = "false"
                for i in range(1,100):
                        if h[i].getTipo()=="King" and h[i].getEstado() == 0:
                                if bool == "false":
                                        mensaje = "----------------------\n| Numero   | Estado  |\n----------------------\n"
                                numero = h[i].getNumero()
                                mensaje = mensaje + "|   %i     |Disponble|\n"  %numero
                                bool = "true"

                if bool == "false":
                        mensaje = mensaje + "===> No hay habitaciones disponibles\n"
                if bool == "true":
                        mensaje = mensaje + "----------------------\n"
                sc.send(mensaje)

    #ver habitaciones dobles
        if recibido == "3":
                mensaje = "Habitaciones Dobles disponibles"
        bool = "false"
                for i in range(1,100):
                        if h[i].getTipo()=="Doble" and h[i].getEstado() == 0:
                                if bool == "false":
                                        mensaje = "----------------------\n| Numero   | Estado  |\n----------------------\n"
                                numero = h[i].getNumero()
                                mensaje = mensaje + "|   %i     |Disponble|\n"  %numero
                                bool = "true"

                if bool == "false":
                        mensaje = mensaje + "===> No hay habitaciones disponibles\n"
                if bool == "true":
                        mensaje = mensaje + "----------------------\n"
                sc.send(mensaje)

    #ver habitaciones simples
        if recibido == "4":
                mensaje = "Habitaciones Simple disponibles"
        bool = "false"
                for i in range(1,100):
                        if h[i].getTipo()=="Simple" and h[i].getEstado() == 0:
                                if bool == "false":
                                        mensaje = "----------------------\n| Numero   | Estado  |\n----------------------\n"
                                numero = h[i].getNumero()
                                mensaje = mensaje + "|   %i     |Disponble|\n"  %numero
                                bool = "true"

                if bool == "false":
                        mensaje = mensaje + "===> No hay habitaciones disponibles\n"
                if bool == "true":
                        mensaje = mensaje + "----------------------\n"
                sc.send(mensaje)

    #Ocupar una habitacion
    if recibido == "5":
        print "entro en 5"
        mensaje =" "
        recibido2 = sc.recv(1024)
        for i in range(1,100):
                        if h[i].getNumero() == int(recibido2) and h[i].getEstado() == 1:
                                mensaje = "===> Habitacion Ocupada"

            if h[i].getNumero() == int(recibido2) and h[i].getEstado() == 0:
                h[i].setEstado(1)
                mensaje = mensaje + "===> Habitacion %i tomada" %i
        sc.send(mensaje)

    #Desocupar una habitacion
        if recibido == "6":
                print "entro en 6"
                mensaje =" "
                recibido2 = sc.recv(1024)
                for i in range(1,100):

                        if h[i].getNumero() == int(recibido2) and h[i].getEstado() == 0:
                                mensaje = "===> Habitacion ya estaba Desocupada"
                        if h[i].getNumero() == int(recibido2) and h[i].getEstado() == 1:
                                h[i].setEstado(0)
                                mensaje = "===> Habitacion %i Desocupada" %i
                sc.send(mensaje)

    if recibido == "7":
        print "entro en 7"
        mensaje = "----------------------\n"
        mensaje = mensaje + "|Habitacion |  $     |\n"
        mensaje = mensaje + "----------------------\n"
        mensaje = mensaje + "| Penthouse | %i |\n" %h[1].getPrecio()
        mensaje = mensaje + "|   King    | %i  |\n" %h[2].getPrecio()
        mensaje = mensaje + "|   Doble   | %i  |\n" %h[50].getPrecio()
        mensaje = mensaje + "|   Simple  | %i  |\n" %h[90].getPrecio()
        mensaje = mensaje + "----------------------"
        sc.send(mensaje)

    if recibido >"7":
        sc.send("===> Opcion no valida")

    print "Recibido:", recibido
print "Desconectado"

sc.close()
s.close()

y por ultimo el cliente , lo más fácil, ya que solo consulta y espera respuesta, nada que procesar.

import socket
import os, sys

s = socket.socket()
s.connect(("localhost", 4949))
#s.connect(("localhost", 9999))

u="false"
p="false"
#usuario
while u=="false":
    print "USUARIO:\n"
    mensaje = raw_input("> ")
    s.send(mensaje)
    if mensaje == "exit":
        print "===> Cerrando"
        break
    datos = s.recv(1024)
    if datos == "true":
        u="true"
#clave
while p=="false":
        print "CLAVE:\n"
        mensaje = raw_input("> ")
        s.send(mensaje)
        datos = s.recv(1024)
    if datos == "error":
        print "===> limite de intentos"
        p = "error"
        break
        if datos == "true":
                p="true"

while True and p != "error":
    os.system("clear")
    print "----------------------"
    print "-                    -"
    print "-     MENU HOTEL     -"
    print "-                    -"
    print "----------------------"
    print
    print "HABITACIONES DISPONIBLES"
    print "   1-Ver Penthouse "
    print "   2-Ver King"
    print "   3-Ver Dobles"
    print "   4-Ver Simples"
    print
    print "TOMAR UNA HABITACION"
    print "   5-Tomar Habitacion"
    print
    print "DESOCUPAR HABITACION"
    print "   6-Desocupar Habitacion"
    print
    print "VER PRECIOS"
    print "   7-Ver Precios"
    print        
    print "exit para salir ..."

    mensaje = raw_input("> ")
    s.send(mensaje)

    if mensaje == "exit":
        break

    if mensaje == "5":
        #s.send("5")
        print  "Ingrese el numero de la habitacion"
        mensaje = raw_input("> ")
            s.send(mensaje)
        #datos = s.recv(1024)
        #print datos

        if mensaje == "6":
                #s.send("5")
                print  "Ingrese el numero de la habitacion"
                mensaje = raw_input("> ")
                s.send(mensaje)
                #datos = s.recv(1024)
                #print datos

        print "Mensaje enviado, esperando respuesta..."
        # Imprimimos la respuesta del server.
        datos = s.recv(2048)
        print datos

    raw_input("Enter para continuar...")
print "adios"
s.close()

bueno espero que por allí , saquen más de una duda, el código esta bien simple por todos lados.

obviamente hay mejor formas de implementar una solución mejor pero el fin de esto es usar socket TCP .

“Supuestamente” ahora debería estar trabajando en una especie de Skype para GNU Linux, onda mandar mensaje (chat) + Video + Sonido , en cuando lo tenga màs o menos armado lo publico

Saludos!

Conceptos Básicos

Qué es una ip? >> http://blog.vermiip.es/2008/03/11/que-es-el-numero-ip-que-significa-ip/
Qué es un puerto? >> http://es.wikipedia.org/wiki/Puerto_(inform%C3%A1tica)
Qué es un socket? >> http://es.wikipedia.org/wiki/Socket_de_Internet
Python para todos >> https://launchpadlibrarian.net/18980633/Python%20para%20todos.pdf
Socket en Java >> http://www.dlsi.ua.es/asignaturas/sid/JSockets.pdf

Socket TCP

Socket TCP en Python
Antes de empezar debemos aclarar algunos conceptos para entender un poco más lo que realizaremos posteriormente.
¿Qué es un socket?
Sirve para que dos programas interactúen mediante una red, así logrando el
intercambio de datos entre ellos.
Permiten implementar una arquitectura Cliente-Servidor

Un socket (enchufe), es un método para la comunicación entre un programa del cliente y un programa del servidor en una red. Un socket se define como el punto final en una conexión. Los sockets se crean y se utilizan con un sistema de peticiones o de llamadas de función a veces llamados interfaz de programación de aplicación de sockets (API, application programming interface).
Un socket posee una dirección ip seguido de un puerto, por el cual se establece la
conexión.
¿Qué es TCP?
Es uno de los protocolos más usados en internet, TCP (Trasmission Control Protocol), sirve para enviar datos de forma segura, este protocolo asegura la llegada de los datos a su destino  sin errores.
3-way Handshake
TCP se compone de tres etapas, establecimiento de conexión, transferencia de datos y fin de la conexión.

• Establecimiento de conexión

Servidor: Aunque es posible que un par de entidades finales comiencen una conexión entre ellas simultáneamente, normalmente una de ellas abre un socket en un  determinado puerto tcp y se queda a la escucha de nuevas conexiones.
Cliente: El cliente de una conexión realiza una apertura activa de un puerto enviando un
paquete SYN inicial al servidor como parte de la negociación en tres pasos.
Servidor: Se comprueba si el puerto está abierto, es decir, si existe algún proceso escuchando en ese puerto. En caso de no estarlo, se envía al cliente un paquete de respuesta con el bit RST activado, lo que significa el rechazo del intento de conexión. En caso de que sí se encuentre abierto el puerto, el lado servidor respondería a la petición SYN válida con un paquete SYN/ACK.
Cliente: Debería responderle al servidor con un ACK, completando así la negociación en tres pasos (SYN, SYN/ACK y ACK) y la fase de establecimiento de conexión.
Es interesante notar que existe un número de secuencia generado por cada lado, ayudando de este modo a que no se puedan establecer conexiones falseadas (spoofing).

• Fin de la conexión

La fase de finalización de la conexión usa una negociación en cuatro pasos (four-way handshake), terminando la conexión desde cada lado independientemente. Cuando uno de los dos extremos de la conexión desea parar su “mitad” de conexión transmite un paquete FIN, que el otro interlocutor asentirá con un ACK. Por tanto, una desconexión típica requiere un par de segmentos FIN y ACK desde cada lado de la conexión.
Una conexión puede estar “medio abierta” en el caso de que uno de los lados la finalice pero el otro no.
El lado que ha dado por finalizada la conexión no puede enviar más datos pero la otra parte si podrá.

Programación en Python

Para empezar analizaremos el modulo socket que posee Python, la cual nos proveerá
de los distintos métodos y funciones para poder efectuar una conexión TCP por el
momento.
Como había dicho antes, en esta ocasión utilizaremos el Protocolo TCP para crear
nuestro Programa Cliente-Servidor con socket.
Se define entonces “socket.sock_stream” el cual significa que se utilizara un socket
TCP.
Para crear un socket se utiliza el constructor “socket.socket()” que puede tomar como
parámetros opcionales la familia, el tipo y el protocolo. Por defecto se utiliza la familia
AF_INET y el tipo SOCK_STREAM
Lo primero que debemos hacer es crear el objeto socket:

socket_s = socket.socket()

Luego debemos asignar una ip y un puerto por el cual el servidor esperara la llegada de algún cliente para comenzar las distintas acciones que vayamos a programar, para esto
utilizaremos la instrucción bind, aquí como parámetro deberemos pasarle una tupla
con la cual le asignaremos una ip y un puerto.

socket_s.bind(("localhost", 9999))

Por último utilizamos listen para hacer que el socket comience a escuchar y accept
para aceptar las conexiones. Listen requiere de un parámetro que indica el número de
conexiones máximas que queremos aceptar; evidentemente, este valor debe al menos
ser 1.
Accept se mantiene a la espera de conexiones entrantes, bloqueando la ejecución
hasta que llegue un mensaje.
Cuando llega un mensaje, accept desbloquea la ejecución, devolviendo un objeto
socket que representa la conexión del cliente y una tupla que contiene el host y el
puerto de dicha conexión.

socket_s.listen(2)
socket_c, addr = socket_s.accept()

Una vez establecidas estas variables, debemos comunicarnos entre el cliente y el
servidor, para lo cual utilizaremos dos métodos.
Send y recv, los cuales nos sirven para enviar o recibir datos.
El método send toma como parámetro los datos a enviar.
El método recv toma como parámetro el largo máximo de bits que aceptará como
mensaje.

recibido = socket_c.recv(1024)
socket_c.send("mensaje")

Una vez terminado todo debemos cerrar la conexión y liberar el socket, para esto
utilizaremos el método close()

socket_c.close()
socket_s.close()

Desde el lado Cliente destacar el método connect el cual nos sirve para conectarnos
con el servidor y este recibe como parámetro una tupla con la dirección del servidor y
el puerto donde este acepta conexiones.

socket_c = socket.socket()
socket_c.connect(("localhost", 9999))

Con esto terminamos lo básico para crear una conexión TCP con socket en Python,
ahora les mostraré un pequeño ejemplo de un sistema Cliente-Servidor en Python.
Servidor:

servidor.py

#Servidor
 import socket
 s = socket.socket()
 s.bind(("localhost", 9999))
 s.listen(1)
 sc, addr = s.accept()
 while True:
    recibido = sc.recv(1024)
    if recibido == "quit":
        break
    print "Recibido:", recibido
    sc.send(recibido)
 print "adios"
 sc.close()
 s.close()

cliente.py

# Cliente:
 import socket
 s = socket.socket()
 s.connect(("localhost", 9999))
 while True:
    mensaje = raw_input("> ")
    s.send(mensaje)
    if mensaje == "quit":
        break
        print "adios"
 s.close()

para ejecutarlo abres 2 terminales y en cada una con

python nombre.py

corres el programa
Adicionalmente para los que no sepan mucho de python pueden buscar el manual
“Python para todos” el cual explica lo básico de este lenguaje de programación el cual
es bastante simple.
Fuentes:
- mundogeek
- wikipedia TCP

===> DESCARGAR PYTHON PARA TODOS

Saludos!

Continuando con Python , ahora es el turno de explicar herencia.

Para los que ya están relacionados con herencia en C++ u otro lenguaje se darán cuenta que el asunto es muy similar y algo más simple

A modo de ejemplo usare algo que ya tengo programado el cual se trata de un hotel el cual posee diferentes tipos de habitaciones , este hotel tiene un Penthouse , habitaciones King, Dobles y Simples, cada una de estas posee un precio, un numero y es estado dependiendo si esta ocupada o no.

para hacernos una idea gráfica de como sera la herencia , pueden verlo en el siguiente dibujo.

Ahora veamos como se ve el código.

#!/usr/bin/python

class habitacion:
	def __init__(self,numero, estado, precio):
		self.numero = numero
		self.estado = estado
		self.precio = precio
	def tell(self):
		print 'Numero = "%i" , Estado = "%i" , Precio = "%i"  ' %(self.numero, self.estado, self.precio),
	def getNumero(self):
		return self.numero
	def getEstado(self):
		return self.estado
	def getPrecio(self):
		return self.precio
	def setEstado(self, estado):
		self.estado=estado

class penthouse(habitacion):
	def __init__(self,numero, estado, precio):
		habitacion.__init__(self,numero, estado,precio)
		self.tipo="Penthause"
	def getTipo(self):
		return self.tipo
        def getNumero(self):
                return self.numero
        def getEstado(self):
                return self.estado
        def getPrecio(self):
                return self.precio
        def setEstado(self, estado):
                self.estado=estado
	def tell(self):
		print 'Tipo = "%s",Numero = "%i" , Estado = "%i" , Precio = "%i"  ' %(self.tipo, self.numero, self.estado, self.precio),

class h_king(habitacion):
	def __init__(self, numero, estado, precio):
		habitacion.__init__(self,numero, estado,precio)
		self.tipo="King"
        def getTipo(self):
                return self.tipo
        def getNumero(self):
                return self.numero
        def getEstado(self):
                return self.estado
        def getPrecio(self):
                return self.precio
        def setEstado(self, estado):
                self.estado=estado
	def tell(self):
		print 'Tipo = "%s",Numero = "%i" , Estado = "%i" , Precio = "%i"  ' %(self.tipo, self.numero, self.estado, self.precio),

class h_dobles(habitacion):
        def __init__(self, numero, estado, precio):
                habitacion.__init__(self,numero, estado,precio)
                self.tipo="Doble"
        def getTipo(self):
                return self.tipo
        def getNumero(self):
                return self.numero
        def getEstado(self):
                return self.estado
        def getPrecio(self):
                return self.precio
        def setEstado(self, estado):
                self.estado=estado
        def tell(self):
                print 'Tipo = "%s",Numero = "%i" , Estado = "%i" , Precio = "%i"  ' %(self.tipo, self.numero, self.estado, self.precio),

class h_simple(habitacion):
        def __init__(self, numero, estado, precio):
                habitacion.__init__(self,numero, estado,precio)
                self.tipo="Simple"
        def getTipo(self):
                return self.tipo
        def getNumero(self):
                return self.numero
        def getEstado(self):
                return self.estado
        def getPrecio(self):
                return self.precio
        def setEstado(self, estado):
                self.estado=estado
        def tell(self):
                print 'Tipo = "%s",Numero = "%i" , Estado = "%i" , Precio = "%i"  ' %(self.tipo, self.numero, self.estado, self.precio),

Bueno las funciones “get” retornan un valor y las “set” , son para insertar un valor

ahora para crear los objetos en este caso las habitaciones solo hay que realizar

p = penthouse(1,0,150000)

k = king(2,0,85000)

d = doble(3,0,35000)

s = simple(4,1,25000)

ahora si queremos algún atributo por ejemplo el precio de una habitación doble

precio_doble = d.getPrecio()

y si queremos imprimir algo de alguna habitación por ejemplo de la habitación simple

s.tell()

o si queremos imprimir toda la información de las habitaciones

habitaciones = [p, k, d, s]
for habitaciones in habitaciones:
        habitaciones.tell()

Saludos!

Python cuenta con una clase llamada file que nos permite crear, escribir y leer datos de un archivo de texto.

Para crear un objeto de la clase file debemos utilizar la función open. Cuando llamamos a dicha función le pasamos como primer parámetro el nombre del archivo de texto y el modo de apertura del mismo:

open(nombre del archivo,modo)

Si el archivo de texto se encuentra en la misma carpeta que nuestro programa no necesitamos indicar el path (camino). Los modos de apertura del archivo de texto pueden ser:

• ‘r’ Abre el archivo para lectura (debe existir el archivo)
• ‘w’ Crea el archivo y lo abre para escribir
• ‘a’ Abre el archivo para escribir. Se crea si el archivo no existe. Solo podemos agregar datos al final

Creación de un archivo de texto

El siguiente algoritmo crea en disco un archivo de texto llamado ‘datos.txt’ y no graba datos. Si queremos luego de ejecutar el programa podemos verificar la existencia del archivo en la misma carpeta donde almacenamos nuestro programa.

Cuando lo grabamos el archivo fuente en Python debemos darle un nombre al programa (por ejemplo texto1.py)

def creaciontxt():
    archi=open('datos.txt','w')
    archi.close()

creaciontxt()

Creamos una función llamada creaciontxt donde primero llamamos a la función open pasando como parámetros el nombre del archivo de texto a crear y el modo de apertura (‘w’)

La función open retorna la referencia del objeto file. Luego llamamos al método close de la clase file. Si luego queremos ver si se a creado el archivo de textos podemos hacerlo desde algun explorador de archivos, en la carpeta donde se encuentra nuestro programa en Python veremos un archivo llamado ‘datos.txt’ que tiene un tamaño de 0 bytes.

Grabación de líneas en el archivo de texto

def creartxt():
    archi=open('datos.txt','w')
    archi.close()

def grabartxt():
    archi=open('datos.txt','a')
    archi.write('Linea 1\n')
    archi.write('Linea 2\n')
    archi.write('Linea 3\n')
    archi.close()

creartxt()
grabartxt()

La función creartxt es similar al ejemplo anterior, y la función grabartxt tiene por objetivo abrir el archivo en modo de agregado. Cada vez que grabamos un string en el archivo de texto insertamos un salto de línea ‘\n’. Finalmente liberamos el archivo llamando al método close.

Para ver el contenido de nuestro archivo de texto debemos utilizar un editor de texto (bloc de notas o el mismo entorno del Idle nos puede servir para ver el contenido de un archivo txt)

Lectura línea a línea de un archivo de texto

La clase file tiene un método llamado readline() que retorna toda una línea del archivo de texto y deja posicionado el puntero de archivo en la siguiente línea. Cuando llega al final del archivo readline retorna un string vacío.

def creartxt():
    archi=open('datos.txt','w')
    archi.close()

def grabartxt():
    archi=open('datos.txt','a')
    archi.write('Linea 1\n')
    archi.write('Linea 2\n')
    archi.write('Linea 3\n')
    archi.close()

def leertxt():
    archi=open('datos.txt','r')
    linea=archi.readline()
    while linea!="":
        print linea
        linea=archi.readline()
     archi.close()

creartxt()
grabartxt()
leertxt()

Luego de de abrir el archivo para lectura procedemos a leer la primer línea:

    archi=open('datos.txt','r')
    linea=archi.readline()

El while se repite mientras el método readline() no retorne un string vacío. Dentro del while procedemos a imprimir la línea que acabamos de leer y leemos la siguiente (el método readline() retorna el contenido de toda la línea inclusive el salto de línea \n):

    while linea!="":
        print linea
        linea=archi.readline()

Podemos leer todo el contenido de un archivo de texto y almacenarlo en una lista (esto tiene sentido si el archivo de texto no es muy grande):

def creartxt():
    archi=open('datos.txt','w')
    archi.close()

def grabartxt():
    archi=open('datos.txt','a')
    archi.write('Linea 1\n')
    archi.write('Linea 2\n')
    archi.write('Linea 3\n')
    archi.close()

def leertxtenlista():
    archi=open('datos.txt','r')
    lineas=archi.readlines()
    print lineas
    archi.close()

creartxt()
grabartxt()
leertxtenlista()

Utilizamos el método readlines() en lugar de readline(). El método readlines() retorna una lista con cada línea del archivo de texto.

Recordemos que podemos procesar luego cada elemento de la lista recorriéndola con una estructura repetitiva:

def leertxtenlista():
    archi=open('datos.txt','r')
    lineas=archi.readlines()
    for li in lineas:
        print li
    archi.close()

fuente: pythonya.appspot.com/detalleconcepto?deta=Creación, carga y lectura de archivos de texto

Saludos!