Monthly Archives: April 2012

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++

      Category: #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!

         

          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!