Linphone VoIP

Ayudando a un amigo con una tarea , tuve que usar Linphone .

Linphone es una aplicación de VoIP disponible en PCs con GNU / Linux o Windows, los ordenadores de Apple con Mac OS X y Android y el iPhone los teléfonos móviles. Utiliza el Session Initiation Protocol (SIP) para la comunicación y está licenciado bajo la GNU General Public License (GPL). Linphone usa GTK + para el GUI y que en GNU/ Linux también se puede ejecutar como una aplicación de consola en modo. Es compatible con la telefonía mediante el uso de un proveedor de servicios de telefonía por Internet (ITSP).
Software de Linphone se ejecuta en un teléfono móvil Android

Soporte de codec de audio: Speex (banda estrecha y banda ancha), G.711 (μ-ley, una ley), GSM y iLBC (a través de un plugin opcional) de soporte de codec de vídeo: H263-1998, MPEG-4, Theora y H 0.264 (gracias a un plugin basado en x264), con resoluciones de QCIF (176×144) a SVGA (800×600), siempre que el ancho de banda y potencia de CPU son suficientes.

instalación :
apt-get install linphone
Ver Programa

Saludos!

Algorimo de Compresión Huffman

La Necesidad del ser humano de procesar mayor cantidad datos en alguna computadora ha causado un problema debido  a que se ha maximizado la cantidad de información generada y transmitida, este incremento ha llevado a la necesidad de establecer mecanismos que permitan aprovechar de manera más eficiente los recursos a la hora de generar o transmitir datos.

Para resolver este problema representantes del mundo de la ciencia de la computación han trabajando en  la codificación eficiente de los símbolos (alfabeto), obteniendo representaciones de la información original utilizando una menor cantidad de unidades de información (bits).

 

Existen dos formar para comprimir información una es con pérdida de datos y la otra es sin pérdida de datos.

 

La compresión con pérdida de datos puede llegar a reducir el número de bits usados para su representación en mayor grado que los algoritmos de compresión sin pérdida, el problema está en que al reducir con pérdida de datos la reconstrucción será solo una aproximación de los datos originales. Por otra parte esta la codificación sin pérdidas de binarios será la reconstrucción exacta.

Shannon establece una cota inferior de la longitud del código en términos de Entropía (el mínimo al que puede llegar la información, a ser comprimida para que sea sin pérdida)  y Huffman genera un ambicioso algoritmo el cual comprime sin pérdida de datos.

¿Cómo lograr una codificación eficiente de los datos?, supongamos  que un texto posee los caracteres A, B, C., vamos a representar cada carácter con 2 bits, A=00; B=01; C=10, al hacer esto ya estamos proporcionando un ahorro en bits a la hora de representar estos caracteres, a diferencia de la representación ASCII  o Unicode la cual usaría 8 bits o más para cada carácter. Bajo esta misma lógica se puede representar un alfabeto que contiene N símbolos diferentes mediante log2(n) bits por símbolo.

Descargar Informe

Descargar Programa C++

MATE 1.2 disponible el fork de #GNOME 2

 

Install

 

Debian

Debian Sid/Wheezy: add the following repository to your ”/etc/apt/sources.list”:

deb http://packages.mate-desktop.org/repo/debian wheezy main

To install MATE:

sudo apt-get update
sudo apt-get install mate-archive-keyring
sudo apt-get update
# this install the base packages
sudo apt-get install mate-core
# this install more packages
sudo apt-get install mate-desktop-environment

Ubuntu

Ubuntu Oneiric Ocelot (11.10) repository

Add the repo to /etc/apt/sources.list via the following command:

sudo add-apt-repository "deb http://packages.mate-desktop.org/repo/ubuntu oneiric main"

or using a text editor of your choice add the following mirror to /etc/apt/sources.list:

deb http://packages.mate-desktop.org/repo/ubuntu oneiric main

Ubuntu Precise Pangolin (12.04) repository

Add the repo to /etc/apt/sources.list via the following command:

sudo add-apt-repository "deb http://packages.mate-desktop.org/repo/ubuntu precise main"

or using a text editor of your choice add the following mirror to /etc/apt/sources.list:

deb http://packages.mate-desktop.org/repo/ubuntu precise main

MATE Installation (both Oneiric/Precise)

Then run the following command to update your repositories and install MATE:

sudo apt-get update
sudo apt-get install mate-archive-keyring
sudo apt-get update
# this install base packages
sudo apt-get install mate-core
# this install more packages
sudo apt-get install mate-desktop-environment

Linux Mint

Linux Mint Lisa has MATE packages (1.0 release). See http://packages.linuxmint.com/list.php?release=Lisa#import.

Latest packages (1.2 release)

If you want to try the latest MATE packages, you can use the MATE repository for Ubuntu. Once set up the repository, you need to edit the /etc/apt/preferences file as follow:

Package: *
Pin: release o=linuxmint
Pin-Priority: 700

Package: *
Pin: origin packages.linuxmint.com
Pin-Priority: 700

Package: *
Pin: release o=Ubuntu
Pin-Priority: 500

Package: *
Pin: origin packages.mate-desktop.org
Pin-Priority: 700

LMDE

Linux Mint Debian Edition has MATE 1.2 packages.

Salix/Slackware

Salix and Slackware users can install Mate using the packages in the Salix repositories. See here.

Fedora

To install MATE on Fedora, follow those steps:

yum install http://dl.dropbox.com/u/49862637/Mate-desktop/mate-desktop-fedora/releases/16/noarch/mate-desktop-release-16-5.fc16.noarch.rpm
yum groupinstall MATE-Desktop

Archlinux

To install MATE, open

/etc/pacman.conf

and append this: (for i686 or x86_64).

[mate]
# Official MATE repo:
Server = http://packages.mate-desktop.org/repo/archlinux/mate/$arch

After do a pacman update

pacman -Syy

And install the package normally. You are likely to get file conflicts when installing, especially when you have Gnome or Xfce installed. Simply rename the offending files or install with the ”–force” flag.

pacman -Sff mate mate-extra mate-desktop-environment

Source

Source are hosted on http://pub.mate-desktop.org/releases/1.2.

fuente : http://mate-desktop.org/

 

ver en :MATE 1.2 disponible el fork de # 2 http://ur1.ca/90wyo

sitio web : http://mate-desktop.org/

Cliente Servidor #Python Ejemplo 2

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ó :P )

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!

 

Nodo, Listas, colas, Arbol Binario #C++

Hace ya mucho tiempo que tenia pensado subir esto , y cuando digo mucho tiempo es más de un año xD.

 

Lo subo por que por allí necesite tener una lista en C++ y tuve que recordar como rayos era C++ xD

Descargar Lista Simple y Doblemente enlazada

Descargar Pila

Descargar Cola

Descargar Arbol Binario

ojo los programas están compilados sobre GNU Linux

Saludos!

Free Network Fundation #FNF

ver documental Liberad la Red!

Free Network Fundation ,organización comprometida con los principios de la libre información, la cultura libre, y una sociedad libre, creada por Hackers usuarios de Software libre y Open Source, con el fin de descentralizar el flujo del internet creando su propia red mediante P2P usando antenas wifi.

 

Cambia el paradigma actual de la red como una infraestructura de comunicaciones que pertenece a una coorporacion , por una red operada de forma cooperativa por el conjunto de la humanidad usando la tecnología peer to peer, con el fin de crear una red global inmune a la censura.

 

Cómo ayudar

  • Dile a tus amigos. Nos usan formas no libres de medios de comunicación social, por lo que es de vital importancia que se corra la voz. Muchos de nosotros estamos trabajando duro para llevar a cabo las alternativas abiertas a Facebook y Twitter, pero en la media hora, se pueden utilizar para ayudar a la http://freenetworkfoundation.org/
  • Suscríbase a la  lista de correo electrónico, mediante la presentación de su información a continuación.
  • Haga una donación en efectivo, haciendo clic en “Done”, en el lado derecho de la página. La FNF soporta completamente las crowdsourcing. Eso significa que una gran cantidad de pequeñas donaciones de personas como usted. El dinero va a pagar por hospedaje y máquinas de desarrollo.

como opinión :

Lastima y susto ver como un país que habla de libertad y democracia hace todo lo contrario.

Al ver vídeos como estos y pensar como en este caso movimientos relacionados con el software libre y el Opensource han impulsado este tipo de movimientos me enorgullece y reafirma mi posición de que el Software Libre es el camino para lograr el día de mañana una sociedad informada, con un acceso a la cultura e información , lejos de ser dominada y abusada.

freenetworkfoundation.org

 

Sistema Distribuido Cliente/Servidor #Python

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!

Python Herencia

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!