UNIVERSIDAD NACIONAL AUTÓNOMA DE MÉXICO

Facultad De Ingeniería
División De Ingeniería Eléctrica
Departamento En Computación
Arquitecturas Cliente servidor
Sockets en Python

Bautista Neri Alejandro

Corona Falcon Juan

Gonzalez Castillo Ignacio

Quiroz Martinez Ezequiel

Fecha de entrega: 08 de septiembre del 2009

 Índice

Historia ......................................................................................................................... 4

La última versión liberada fue Python 1.2. En 1995 ............................................... 4

Características ....................................................................................................... 5

¿Qué es un socket?...................................................................................................... 5

Dominios de comunicación .................................................................................... 5

Rapido vistazo a algunos elementos de los sockets en Python. ............................ 6

Creación del socket ...................................................................................................... 6

Ejemplo. ....................................................................................................................... 8

Servidor ................................................................................................................. 8

Cliente ................................................................................................................... 9

Referencias .................................................................................................................. 9
Historia
Python fue creado a finales de los ochenta por Guido van Rossum en CWI en los Países Bajos como
un sucesor del lenguaje de programación ABC, capaz de manejar excepciones e interactuar con el
sistema operativo Amoeba.

En 1991, van Rossum publicó el código (versión 0.9.0) en alt.sources. En esta etapa del desarrollo
ya estaban presentes clases con herencia, manejo de excepciones, funciones, y los tipos modulares:
list, dict, str.

El modelo de excepciones en Python es parecido al de Modula-3, con la adición de una cláusula else

En el año 1994 se formó comp.lang.python, el foro de discusión principal de Python

Python alcanzó la versión 1.0 en enero de 1994. Una característica de este lanzamiento fueron las
herramientas de la programación funcional: lambda, map, filter y reduce.

La última versión liberada fue Python 1.2. En 1995

Durante su estancia en CNRI, van Rossum lanzó la iniciativa Computer Programming for Everybody,
con el fin de hacer la programación más accesible, con un nivel de 'alfabetización' básico en
lenguajes de programación, similar a la alfabetización básica en inglés y habilidades matemáticas
indispensables para los trabajadores.

Python tuvo un papel crucial en este proceso: debido a su orientación hacia una sintaxis limpia,
presentaban similitudes con su predecesor, ABC.

Python 2.0 tomó una característica del lenguaje de programación Haskell: list comprehensions.
Python tiene una sintaxis muy similar a la de Haskell, salvo por la preferencia de los caracteres de
puntuación en Haskell.

Python 2.0 introdujo además un sistema de recolección de basura capaz de recolectar referencias
cíclicas.

Python License, incluía una cláusula estipulando que estaba gobernada por el estado de Virginia,
bajo la óptica de los abogados de Free Software Foundation (FSF), se hacía incompatible con GNU
GPL. CNRI y FSF se relacionaron para cambiarla a software libre de Python y hacerla compatible
con GPL.

En Python 2.2 fue la unificación de los tipos en Python (tipos escritos en C), y clases (tipos escritos
en Python) dentro de una jerarquía. Esa unificación logró un modelo de objetos de Python puro y
consistente. También se agregaron generadores para el lenguaje Icon.
Las adiciones a la biblioteca estándar de Python y las decisiones sintácticas fueron influenciadas
fuertemente por Java en algunos casos: el package logging, en la versión 2.3, el parser SAX, en 2.0,
y la sintaxis del patrón decorator que usa el @, agregado en la versión 2.4.

Características
Se compara habitualmente con Tcl, Perl, Scheme, Java y Ruby. En la actualidad Python se
desarrolla como un proyecto de código abierto, administrado por la Python Software Foundation. La
última versión estable del lenguaje es 3.1.

Python permite dividir el programa en módulos reutilizables desde otros programas Python. Viene
con una gran colección de módulos estándar que se pueden utilizar como base a los programas.
También hay módulos incluidos que proporcionan E/S de ficheros, llamadas al sistema, sockets y
hasta interfaces a GUI (interfaz gráfica con el usuario) como Tk, GTK, Qt entre otros.

Python se utiliza como lenguaje de programación interpretado, ahorrando un tiempo considerable en

el desarrollo del programa, no es necesario compilar ni enlazar. El intérprete se puede utilizar de
modo interactivo, lo que facilita experimentar las características del lenguaje.

Otro objetivo del diseño del lenguaje es la facilidad de extensión. Nuevos módulos se pueden
escribir fácilmente en C o C++. Python puede utilizarse como un lenguaje de extensión para módulos
y aplicaciones que necesitan de una interfaz programable.

¿Qué es un socket?
Un socket nos permite comunicarnos con otras computadoras, de esta manera la información puede
viajar libremente por todos lados.Los sockets son las tuberías de plomo de las redes
computacionales que le permiten conectarse con otros dispositivos para que la información fluya
libremente. As you might expect, they're widely used on the Internet. Como es de esperar, son
ampliamente utilizados en Internet.

Los programas utilizan sockets para comunicarse con otros programas, que pueden estar situados
en computadoras distintas.

Un socket queda definido por la dirección IP de la máquina, el puerto en el que escucha, y el

protocolo que utiliza.

Los sockets se clasifican en sockets de flujo (socket.SOCK_STREAM) o sockets de datagramas

(socket.SOCK_DGRAM) dependiendo de si el servicio utiliza TCP, que es orientado a conexión y
fiable, o UDP, respectivamente. En esta lección sólo cubriremos los sockets de flujo, que cubren un
90% de las necesidades comunes.

Dominios de comunicación
Existen tres dominios de comunicación para un socket:
  a) El dominio de UNIX. (AF_UNIX)
 b) El dominio de internet. (AF_INET)
 c) El dominio NS.

El dominio de UNIX. (AF_UNIX)

Se utiliza para la comunicación entre procesos del sistema.

El dominio de internet. (AF_INET)

Se utiliza en procesos que se están comunicando a través de TCP(UDP)/IP, es el que veremos.

El dominio NS.
Se utilizaba sobre los procesos que se comunicaban sobre el protocolo de
comunicación de Xerox.

Python solo soporta los dos primeros tipos de comunicación, como mencionamos
solamente trataremos con la familia AF_INET en este documento.

Rapido vistazo a algunos elementos de los sockets en Python.

Socket Descripcion

socket Crea un socket del tipo y familia especificada.

socket.accept Acepta nuevas conexiones.

socket.connect Conecta el socket a la dirección dada en el puerto dado.

socket.send Envia datos al socket especificado.

socket.recv Recive información.

Creación del socket

Los tipos y funciones necesarios para trabajar con sockets se encuentran en Python en el módulo
socket.
Los sockets se clasifican en sockets de flujo (socket.SOCK_STREAM) o sockets de datagramas
(socket.SOCKET_DGRAM) dependiendo de si el servicio utiliza TCP o UDP.

Veremos los sockets de flujo que cubren un 90% de las necesidades comunes.

Utilizaremos sockets UNIX: socket.AF_UNIX

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 default se utiliza la familia AF_INET y el tipo
SOCK_STREAM.

Lo primero que se hace es crear un objeto socket para el servidor

Socket_s=socket.socket( )

Tenemos ahora que indicar en qué puerto se va a mantener a la escucha nuestro servidor
utilizando el método bind. Para sockets IP, como es nuestro caso, el argumento de bind es una tupla
que contiene el host y el puerto. El host se puede dejar vacío, indicando al método que se puede
utilizar cualquier nombre que esté disponible.

Socket_s.bind((“Local host”, 9999))

Por último utilizamos listen para hacer que el socket acepte conexiones entrantes y accept para
comenzar a escuchar. El método listen requiere de un parámetro que indica el número de
conexiones máximas que queremos aceptar.

El método accept se mantiene a la espera de conexiones entrantes, bloqueando la ejecución hasta

que llega 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 puerto de dicha conexión.

socket_s.listen(10)

socket_c, (host_c, puerto_c)=socket_s.accept( )

Una vez que tenemos este objeto socket podemos comunicarnos con el cliente a través suyo,
mediante los métodos recv y send (o recvfrom y sendfrom en UDP) que permiten recibir o enviar
mensajes respectivamente. El método send toma como parámetros los datos a enviar, mientras que
el método recv toma como parámetro el número máximo de bytes a aceptar.

recibido=socket_c.recv(1024)

print “Recibido: ”, recibio

socket_c.send(recibido)
Una vez que hemos terminado de trabajar con el socket, lo cerramos con close.

Crear un cliente es aún más sencillo. Sólo tenemos que crear el objeto socket, utilizar el método
connect para conectarnos al servidor y utilizar los métodos send y recv. El argumento de connect es
una tupla con host y puerto, exactamente igual que bind.

socket_c=socket.socket( )

socket_c.connect((“localhost”, 9999))

socket_c.send(“hola”)

Ejemplo.
//El cliente manda al servidor cualquier mensaje que escriba el usuario y el servidor no hace más
que repetir el mensaje recibido. La ejecución termina cuando el usuario escribe quit

Servidor
//en el lado del 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
//en el lado del CLIENTE

import socket

c=socket.socket

c.connect((“Localhost”, 9999))

Referencias

http://es.wikipedia.org/wiki/Python

http://mundogeek.net/archivos/2008/04/12/sockets-en-python/

http://www.slideshare.net/mephistodark/sockets-en-python-por-antoni-luque-delgado-presentation-
891002

http://www.xinug.org/drupal/files/charlas/intro-python.pdf

http://wiki.python.org/moin/HowTo/Sockets

http://www.slideshare.net/mephistodark/sockets-en-python-por-antoni-luque-delgado-presentation-
891002