Python R2


Python + Cairo

Posted in Python por Arturo Elias Antón en 15 mayo 2009
Tags: , , , , , ,

Estaba en casa arreglando mi cuarto cuando de pronto me encontre con una nota de la revista  mundo linux donde decia

“Cairo es una completa librería gráfica que permite la renderización tanto a pantralla como a impresora de gráficos en 2D. El trabajo con gráficos vectoriales, la integración con GTK+ y OpenGL son características fuertes. Si a esto le sumamos la utilización de un lenguaje como Python, la productividad está asegurada “

De esta misma nota saque un Script de demo que pondré aquí.

import cairo
WIDTH, HEIGHT = 600, 400

def draw_spiral (ctx, width, height):
	wd = 0.02 * width
        hd = 0.02 * height

        width  -= 2
        height -= 2
        ctx.move_to( width + 1, 1-hd)

        for i in range (9):
        	ctx.rel_line_to(0, height - hd * (2 * i - 1))
                ctx.rel_line_to(-(width - wd * (2 * i)),0)
                ctx.rel_line_to(0,- (height- hd * (2 * i)))
                ctx.rel_line_to(width - wd * (2 * i + 1),0)
	ctx.set_source_rgb(0,0,1)
        ctx.stroke()

surface = cairo.ImageSurface (cairo.FORMAT_ARGB32, WIDTH,HEIGHT)
ctx = cairo.Context(surface)

ctx.set_source_rgb(1,1,1)
ctx.set_operator(cairo.OPERATOR_SOURCE)
ctx.paint()

draw_spiral(ctx,WIDTH,HEIGHT)
surface.write_to_png('spiral.png')

Como siempre espero que les guste en la próxima integrare Cairo con GTK+ pero como eso no estaba en la revista me va a llevar mas tiempo jejejeje 😛

Anuncios

Agregar un Nodo a un XML

Para agregar un nodo a un XML es simple solo tendremos que seguir en siguiente algoritmo.

  • Crear un nodo elemento
  • Crear un nodo texto (si lo requiere)
  • Agregarle el nodo texto al nodo elemento creado
  • Agregar el nodo elemento creado a algún nodo del documento xml

Observemos en el siguiente ejemplo como lo hace

#!/usr/bin/python
# Nombre : xml3.py
import xml.dom.minidom
xmldoc = xml.dom.minidom.parse("./xml1.xml")

for n in  xmldoc.childNodes :
    print n.tagName
    for contacto in n.childNodes:
        if contacto.nodeType == xml.dom.minidom.Node.ELEMENT_NODE:
            nodo = xmldoc.createElement("ElemntoAgrgado")
            nodo.appendChild(xmldoc.createTextNode("Agregue un textnode"))
            contacto.appendChild(nodo)
        for registro in contacto.childNodes:
            if registro.nodeType == xml.dom.minidom.Node.ELEMENT_NODE:
                print registro.nodeName ,"-" , registro.firstChild.data
                registro.firstChild.data =  registro.firstChild.data

fp = open("./xml2.xml", 'w')

xmldoc.writexml(fp)
fp.close()

Crea el nodo elemento por medio del método “createElement” y luego le agrega el nodo texto, creado por medio de “createTextNode”, con el método “appendChild”. Y por último también con el metodo appendChild lo agrega al nodo contacto del documento.
Para guardar los cambios crea un archivo y lo guarda por medio del método “writexml”

Gracias a la aclaracion de Alejandro J. Cura decidi rearmar el ejemplo anterior con la libreria “elementtree”.

#!/usr/bin/python
# Nombre : xml4.py
from elementtree.ElementTree import  SubElement
from elementtree import ElementTree

xmlFp = open("xml1.xml", "r")
xmldoc = ElementTree.parse(xmlFp)
agenda = xmldoc.getroot()

print dir(agenda)
print agenda.text
for c in agenda.getiterator("contacto"):
    nodo = SubElement(c, "ElemntoAgrgado")
    nodo.text = "Agregue un textnode"
    for registro in c.getiterator():
        if registro != c:print registro.tag ,"-", registro.text

xmldoc.write(file="./xml2.xml")

Gracias Alejandro.
y todas sus ideas son bien recibidas!!!!!!!!!!!

XML en Python

XML (Extensible Markup Language): Es un meta-lenguaje que permite definir lenguajes de marcado. En la práctica es un estándar que permite a diferentes aplicaciones interactuar con facilidad.  XML fue creado con la supervisión del World Wide Web Consortium (W3C), organismo que maneja los estándares de la Web, basándose en las especificaciones del lenguaje SGML. Su desarrollo se comenzó en 1996 y la primera versión salió a la luz el 10 de febrero de 1998.

Estructura de XML

El XML consta de con 4 especificaciones:

  • DTD (Document Type Definition): Definición del tipo de documento. Es en general, un archivo que encierra una definición formal de un tipo de documento y, a la vez, especifica la estructura lógica de cada documento. El DTD del XML es opcional.
  • XSL (eXtensible Stylesheet Language): Es el lenguaje de estilo del XML. Es el que le cambia el aspecto al documento.
  • XLL (eXtensible Linking Language): Define el modo de enlace entre diferentes enlaces.
  • XUA (XML User Agent): Estandarización de navegadores XML. Todavía está en proceso de creación de borradores de trabajo.

Con el XML que trabajaremos en esta entrada es:

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<agenda>
    <contacto>
        <nombre>Ariadna</nombre>
        <apellido>Bouzo</apellido>
        <numero tipo="tel">43050412</numero>
        <direccion>okla 4501</direccion>
    </contacto>
    <contacto>
        <nombre>Arturo Elias</nombre>
        <apellido>Anton</apellido>
        <numero tipo="cel">1563442356</numero>
        <direccion>pepiri 1524</direccion>
    </contacto>
    <contacto>
        <nombre>Pedro</nombre>
        <apellido>Colono</apellido>
        <numero tipo="cel">1565214578</numero>
        <direccion>av Colon 1245</direccion>
    </contacto>
    <contacto>
        <nombre>Eduardo</nombre>
        <apellido>Ramos</apellido>
        <numero tipo="tel">45213652</numero>
        <direccion>Luna 4512</direccion>
    </contacto>
    <contacto>
        <nombre>Rocio</nombre>
        <apellido>Gomez</apellido>
        <numero tipo="cel">1551253652</numero>
        <direccion>Cordoba 1254</direccion>
    </contacto>
</agenda>

Observe que si bien uno en XML puede crear sus propias tag o marcas, siempre lo tienen que escribir igual ya que XML es sensible a minúsculas y mayúsculas. Otra cosa que XML nos exige, es que cada marca que abrimos la cerremos. En otras palabras XML nos exige que el documento que armemos sea “bien formado”.
Python para el manejo de estos documentos nos facilita de un paquete “xml” y dentro del mismo estarán los parse de DOM y SAX.

DOM y SAX

DOM y SAX, son las dos herramientas  mas extendidas que sirven para analizar XML y definir la estructura de un documento, aunque existen otras. Una de las diferencias más grandes entre ellas es que las primeras verifican que el documento, además de estar bien formado de acuerdo a las reglas de XML, responda a una estructura definida en una Definición del Tipo de Documento (DTD).

Leer un XML

Para leer un XML lo primero que haremos es importar xml.dom.minidom luego obtendremos un objeto que represente nuestro documento “xml1.xml” mediante la palabra xml.dom.minidom.parse de la siguiente manera:

#!/usr/bin/python
# Nombre : xml1.py
import xml.dom.minidom
xmldoc = xml.dom.minidom.parse("./xml1.xml")

for n in xmldoc.getElementsByTagName("contacto"):
    print n.toxml()
    print n.firstChild.data

for n in xmldoc.getElementsByTagName("nombre"):
    print n.toxml()
    print n.firstChild.data

for n in xmldoc.getElementsByTagName("direccion"):
    print n.toxml()
    print n.firstChild.data

for n in xmldoc.getElementsByTagName("numero"):
    print n.toxml()
    print n.firstChild.data
    print n.getAttribute("tipo")
    print n.attributes.keys()
    print n.attributes["tipo"].value

Para leer un XML lo primero que haremos es importar xml.dom.minidom luego obtendremos un objeto que represente nuestro documento “xml1.xml” mediante la palabra xml.dom.minidom.parse de la siguiente manera
También podemos observar en este código como obtenemos los distintos nodos por medio de getElementByTagName. Este  metodo tan familiar para los programadores JavaScript  es de gran utilidad ya que nos retorna una lista con todos los nodos hijos desde el nodo donde se invoque y que coincidan con el nombre del tag. También observamos algunos métodos y propiedades como son:

  • toxml: este método nos devuelve el código XML.
  • firstChild: esta propiedad es el enlace al primer nodo hijo
  • getAttribute: obtiene el valor de una propiedad determinada del tag
  • attributes: es un diccionario de propiedades del tag

También se podría haber recorrido de esta manera

#!/usr/bin/python
# Nombre : xml2.py
import xml.dom.minidom
xmldoc = xml.dom.minidom.parse("./xml1.xml")

for n in  xmldoc.childNodes :
    print n.tagName
    for contacto in n.childNodes:
        for registro in contacto.childNodes:
            if registro.nodeType == xml.dom.minidom.Node.ELEMENT_NODE:
                print registro.nodeName ,"-" , registro.firstChild.data

Después de instanciar nuestro objeto xml lo que hacemos es recorrer todos los nodos hijos de él, y luego recorremos todos sus hijos  gracias a childNodes que no es mas que una lista con todos los nodos hijos de  un nodo padre. Luego tendremos que tener cuidado  la hora de imprimir ya que no todos son nodos de tipo element también existen los nodos de tipo text. Los nodos de tipo text son siempre los nodos hojas del árbol DOM y tienen el atributo data para recuperar su valor.

Socket en Python

Posted in Python por Arturo Elias Antón en 3 septiembre 2008
Tags: , , , ,

¿Que es un socket?
Según Beej un socket es:

“Una forma de comunicarse con otros programas usando descriptores de fichero estándar de Unix..”[Guía Beej de Programación en Redes por Brian “Beej” Hall Link]

La programación de sockets se diferencia de la programación de aplicación tradicional, en que trabajamos con procesos que funcionan concurrentemente. Los socket enlazan procesos asincrónicos con un solo canal bidireccional.

En esta entrada solamente hablaremos de los sockets de dominio de internet, los de la familia AF_INET, existen otras familias de socket como las AF_UNIX, AF_FILE, AF_IPX, AF_AX25, etc., pero esos no serán tratados en esta entrada.

Los tipos de socket son

  • SOCK_STREAM: Este protocolo nos da una comunicación fiable de dos direcciones en un flujo de datos(TCP)
  • SOCK_DGRAM: Este protocolo nos da una conexión no fiable. (UDP)
  • SOCK_RAW: este protocolo es para acceder a los campos e interfaces internos de la red.
  • SOCK_RDM: Este protocolo garantiza el la llegada de paquetes pero no garantiza el orden de llegada
  • SOCK_SEQPACKET: datagramas fiables y secundarios, de longitud fija, basado en la conexión.
  • SOCK_PACKET Coloca el socket en modo promiscuo en la que recibe todos los paquetes de la red.

Para el parámetro type nosotros solo trataremos el del tipo SOCK_STREAM.

Métodos del Socket

Los métodos más importantes del socket son:

  • socket.socket: Crea un canal bidireccional con el que generalmente se establece una conexión de red
  • socket.bind: Define un puerto y un nombre para un socket.
  • socket.listen: Convierte el socket en un socket en escucha
  • socket.accept: Espera que llegue una conexión. Al llegar la descripción devuelve un socket nuevo para dicha conexión especifica
  • socket.connect: Conecta un socket con otro que lo este esperando en un puerto y dirección especifica
  • socket.send: Es por el método que enviaremos los mensajes
  • socket.recv: Es por el método que recibiremos los mensajes
  • socket.close: Cierra el socket.

Pasos para la creación de un programa que utiliza Socket

Los sockets, primero que nada necesitan un proceso que sea  servidor. Un servidor genérico realiza las siguientes tareas:

  • Crea un socket mediante socket.socket(famili,tipo)
  • Asocia el puerto por medio del método bind()
  • Pasa al socket a modo esperas mediante el método listen()
  • Espera una conexión con el método accept()
  • Lee o escribe los mensajes por medio del método recv() o send()
  • Al termino de la conexión se realiza con el método close()

Un ejemplo de un servidor simple es:

#!/usr/bin/python
# Nombre de Fichero : servidor.py

import socket

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("", 8000))
server.listen(10)
while 1:
    add, port = server.accept()
    add.send("Usted se conecte al servidor")

Observemos que el parámetro de bind es una tupla.
El servidor que simplemente nos deja conectarnos y nos envía la cadena “Usted se a conectado al servidor” por medio del método send.

Los sockets tienen también otros procesos denominados cliente, lo que realizan estos son:

  • Crea un socket
  • Conectarse a una dirección y puerto de destino por medio del método connect()
  • Lee o escribe los mensajes por medio del método recv() o send()
  • Al termino de la conexión se realiza con el método close()

Un ejemplo de un cliente simple es:

#!/usr/bin/python
# Nombre de Fichero : servidor.py

#!/usr/bin/python
# Nombre de Fichero: cliente.py

import socket

cliente = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cliente.connect(("127.0.0.1", 8000))
print cliente.recv(255)
cliente.close()

Observemos  que el parámetro de connect es una tupla

Enviando y recibiendo datos

Los métodos de un socket para enviar y recibir mensajes son iguales para el servidor que para el cliente.  Estos métodos ya vistos en los dos ejemplos anteriores son.

•    recv: Recibe la cantidad del largo del buffer a recibir
•    send: Envía por parámetro el dato a enviar

Observemos en este servidor que imprime todos los datos que llega

#!/usr/bin/python
# Nombre de Fichero : servidor.py

#!/usr/bin/python
# Nombre de Fichero: servidoMuestraTodo.py
import socket

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("", 8002))
server.listen(10)
while 1:
    add, port = server.accept()
    print add.recv(255)
    add.close()

La salida de este programa, si nos conectamos a el por medio de un browser como puede ser firefox, será parecida a esta

>>>
GET / HTTP/1.1
Host: 127.0.0.1:8002
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; es-ES; rv:1.9.0.1) Gecko/2008070208 Firefox/3.0.1
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: es-es,es;q=0.8,en-us;q=

Bien analizando esto podremos ver que el navegador no solicita con el comando GET la pagina que tenemos en el raíz y nos envía mucha mas información como el sistema operativo en el que esta trabajando.

Lambda en python

Posted in Python por Arturo Elias Antón en 28 agosto 2008
Tags: , , , , ,

Me gusto mucho la explicación de lambda de la wikipedia:

“El cálculo lambda es un sistema formal diseñado para investigar la definición de función, la noción de aplicación de funciones y la recursión. Fue introducido por Alonzo Church y Stephen Kleene en la década de 1930; Church usó el cálculo lambda en 1936 para resolver el Entscheidungsproblem. Puede ser usado para definir de manera limpia y precisa qué es una “función computable”. El interrogante de si dos expresiones del lambda cálculo son equivalentes no puede ser resuelto por un algoritmo general. Esta fue la primera pregunta, incluso antes que el problema de la parada, para el cual la indecidibilidad fue probada. El cálculo lambda tiene una gran influencia sobre los lenguajes funcionales, como Lisp, ML y Haskell.
Se puede considerar al cálculo lambda como el más pequeño lenguaje universal de programación. Consiste en una regla de transformación simple (sustitución de variables) y un esquema simple para definir funciones.
El cálculo lambda es universal porque cualquier función computable puede ser expresada y evaluada a través de él. Por lo tanto, es equivalente a las máquinas de Turing. Sin embargo, el cálculo lambda no hace énfasis en el uso de reglas de transformación y no considera las máquinas reales que pueden implementarlo. Se trata de una propuesta más cercana al software que al hardware.”[ http://es.wikipedia.org/wiki/C%C3%A1lculo_Lambda%5D

Lambda es el feacture con el cual podremos ejecutar funciones anónimas. Es decir funciones sin ningún nombre.
La sintaxis de lambda en python es:

lambda :

lambda <aParameterList> : <a Python expression using the parameters>

por ejemplo

lambda x: x+1

Los ejemplos de la entrada de programación funcional con lambda quedarían:

lambda y map:

Ejemplo:

#!/usr/bin/python
# Nombre de Fichero : map_lambda.py

lt = range(5)
print lt
print map (lambda x:x + 1,lt)
print lt


lambda y filter:

Ejemplo:

#!/usr/bin/python
# Nombre de Fichero : filter_lambda.py

lt = range(5)
print lt
print map (lambda x:x in (1,3,6),lt) #como ya sabemos manejar map ;-).
print filter (lambda x:x in (1,3,6),lt)
print lt

lambda y reduce:

Ejemplo:

#!/usr/bin/python
# Nombre de Fichero : reduce.py

lt = range(5)
lts = ["hola ","como ","estas."]

print " lt -> %s"%lt
print " lts -> %s" %lts

print " reduce lt  -> %s" %reduce (lambda x,y : x+y,lt)
print " reduce lts -> %s" %reduce (lambda x,y : x+y,lts)