Python R2


Mi notebook se bloquea cuando no la miro!!! OpenCV – Python

Posted in Python por Arturo Elias Antón en 10 febrero 2009
Tags: , , , , , ,

Con este pequeño script y el haarcascade: haarcascade_frontalface_alt.xml nuestra PC/notebook con gnome se bloqueara cuando no la miremos y si pasamos el ultimo parametro con “true” se activara volver a mirarla sin pedirnos ninguna contraseña.
El xml lo podran sacar del archivo zip que se puso en el post anterior “Introduccion a Python – OpenCV ”

#!/usr/bin/python

import pygame
import Image
import sys
import os
from pygame.locals import *
import opencv
from opencv import adaptors
from opencv import highgui,cv

scale = 2
def sincroImg(image):
	image_size  = cv.cvGetSize(image)
	grayscale   = cv.cvCreateImage(image_size, 8, 1)
	image_small = cv.cvCreateImage(cv.cvSize(cv.cvRound(image.width/scale),cv.cvRound(image.height/scale)), 8, 1)
	cv.cvCvtColor(image, grayscale, cv.CV_BGR2GRAY)
	cv.cvResize(grayscale,image_small,cv.CV_INTER_LINEAR)
	cv.cvEqualizeHist(grayscale, grayscale)
    	return grayscale

def dectect(img,cascade,storage):
	cv.cvClearMemStorage(storage)
	return cv.cvHaarDetectObjects(
                                   img,
                                   cascade,
                                   storage,
                                   scale,
                                   2,
                                   cv.CV_HAAR_DO_CANNY_PRUNING)

camara = highgui.cvCreateCameraCapture(0)

fps = 30
pygame.init()
ventana = pygame.display.set_mode((320,240))
pygame.display.set_caption("Lock-See")
screen = pygame.display.get_surface()

print "OpenCV version: %s (%d, %d, %d)" % (cv.CV_VERSION,
                                               cv.CV_MAJOR_VERSION,
                                               cv.CV_MINOR_VERSION,
                                               cv.CV_SUBMINOR_VERSION)

cascade_name       = sys.argv[1]
storage = cv.cvCreateMemStorage(0)
cascade = cv.cvLoadHaarClassifierCascade(cascade_name, cv.cvSize(14,14))

paramTime = 10
paramClave = "false"

if len(sys.argv) >= 3: paramTime = int(sys.argv[2])
if len(sys.argv) == 4: paramClave = sys.argv[3]

print "Lock-See v0.1"
print paramTime,",",paramClave

scale = 2
notPresent = 0
while True:
	img1 = highgui.cvQueryFrame(camara)

        # face detection
	sincroImg(img1)
        faces = dectect(img1,cascade,storage)
	if faces.total != 0:
		if (notPresent !=0) and paramClave == "true":
			 os.system("gnome-screensaver-command --deactivate")

		notPresent = 0
		for face in  faces:
			cv.cvRectangle(img1,
				cv.cvPoint( int(face.x), int(face.y)),
				cv.cvPoint(int(face.x + face.width), int(face.y + face.height)),
				cv.CV_RGB(255,0,0), 3, 8, 0)
	else:
		notPresent += 1
		if notPresent >= paramTime:
			os.system("gnome-screensaver-command --lock")

	img = adaptors.Ipl2PIL(img1).resize((320,240))
	pgimg = pygame.image.frombuffer(img.tostring(), img.size, img.mode)
    	screen.blit(pgimg, (0,0))
    	pygame.display.flip()
    	pygame.time.delay(int(1000 * 1.0/fps))

Como siempre espero que les guste y cualquier duda solo tienen que preguntarme a mi mail o consultarlo en el grupo binsd

Saludos y espero que les guste.

Antes que nada quiero decir que me parecio mas util el bloqueador por bluetooth de javier perez

Python 3D

Posted in Python por Arturo Elias Antón en 17 noviembre 2008
Tags: , , ,

Después de mi visita a rosario y encontrarme con gente muy copada y sobre todo encantarme con la OLPC de humito 🙂 . Decidí publicar un mini ejemplo de la modulo VPython. Ya que una de las preguntas que se me hizo fue en que estaba programado pyWars3D.

Gracia a visual podremos programar juegos presentaciones y demás cosas en 3D.

Para instalar VPython en Ubuntu solo hay que hacer:

sudo apt-get install python-visual

También se puede instalar en el sistema operativo MS-Voldemort (el que nunca debe ser instalado 🙂 ) bajando (http://www.vpython.org/) de la pagina el msi.

Para empezar solo crearemos dos objetos 3D uno un cubo y otro una esfera. Donde la esfera se encuentre al lado del cubo

import visual
v = visual.vector (6,6,-1)
s = (2.,2.,2.)
c = color=visual.color.red
cubo = visual.box(pos=v,size=s,color=c)
ve = v
ve.x = ve.x - visual.mag(s)
esfera=visual.sphere(pos=ve, radius=visual.mag(s)/2)

Más adelante veremos un poco mas de este modulo que me a dado muchas alegrías.

JSON

Posted in Python por Arturo Elias Antón en 14 octubre 2008
Tags: , , , ,

Para empezara a ver JSON veremos lo que nos dice la wikipedia:

JSON, acrónimo de “JavaScript Object Notation”, es un formato ligero para el intercambio de datos. JSON es un subconjunto de la notación literal de objetos de JavaScript que no requiere el uso de XML.
La simplicidad de JSON ha dado lugar a la generalización de su uso, especialmente como alternativa a XML en AJAX. Una de las supuestas ventajas de JSON sobre XML como formato de intercambio de datos en este contexto es que es mucho más sencillo escribir un analizador semántico de JSON. En JavaScript, JSON puede ser analizado trivialmente usando el procedimiento eval(), lo cual ha sido fundamental para la aceptación de JSON por parte de la comunidad de desarrolladores Ajax, debido a la ubicuidad de JavaScript en casi cualquier navegador web.
[“http://es.wikipedia.org/wiki/JSON”]

Si bien JSON tiene origen en JavaScript, el sitio oficial de JSON www.json.org, nos ofrece librerías que no permiten trasformar los objetos JSON en objetos nativos de cada lenguaje o viceversa

Un objeto JSON está encerrado entre llaves “{}” y contiene propiedades separadas por coma, cada propiedad tiene un valor separado por dos punto “:” y cada valor puede ser:

  • String
  • Numero
  • Array
  • Función
  • Otro Objeto JSON

Un ejemplo de un JSON simple seria:

{
	“Nombre”:”Pedro”,
	“Apellido”: “Canoero”,
	“Edad”: 16,
	“Padres”: [“Maria”,”Juan”]
}

Las ventajas de JSON son muchas, es simple y rápido de escribir, su lectura es comprensible. JSON como todo objeto JavaScript se puede recorrer con un “for in” para saber todas las propiedades que posee.
JSON es indicado para el transporte de objetos entre un programa cliente y uno servidor en reemplazo de XML. Yo utilizo JSON en PyWars para el intercambio de datos entre el servidor de PyWars escrito en python y los clientes escritos en distintos lenguajes.

Un ejemplo en python seria.

#!/usr/bin/python
import json

dato="""
        {
            "Nombre":"Pedro",
            "Apellido": "Canoero",
            "Edad": 16,
            "Padres": ["Maria","Juan"]
     }
     """

obj=json.read(dato)

print obj["Nombre"]
print obj["Apellido"]
print obj["Edad"]
print obj["Padres"]

El efecto inverso

#!/usr/bin/python
import json
obj =  {
            "Nombre":"Pedro",
            "Apellido": "Canoero",
            "Edad": 16,
            "Padres": ["Maria","Juan"]
     }

print json.write(obj)

Observemos que parecido es escribir un JSON a un diccionario python 😉

Modulos en python

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

Un módulo es una colección de funciones procedimientos y clases en un fichero que acaba en “.py”. El nombre del fichero determina el nombre del módulo. Para poder usar los contenidos del modulo que creemos simplemente lo tendremos que importarlo con la palabra reservada “import”.

Por ejemplo armaremos un archivo llamado cuadratica.py

# Nombre : cuadratica.py
import math

def determinante(a,b,c):
    return (b*b)-(4*a*c)

def calculaRaiz(a,b,c):
    det = determinante(a,b,c)
    if det < 0:
        print "tiene raices imaginarias"
    else:
        print "La rais 1 es " + str((b + math.sqrt(det))/(2*a))
        print "La rais 2 es " + str((b - math.sqrt(det))/(2*a))

Y luego lo usaremos en el archivo usa_modulo.py

#!/usr/bin/python
# Nombre : usa_modulo.py
import cuadratica
cuadratica.calculaRaiz (3,9,6)

Otra forma de uso o mejor dicho de invocación del modulo es invocar solo la función que necesitamos de dicho modulo. Esto nos da la ventaja de que no tendremos que poner el nombre del modulo antes de la función que queramos invocar.

#!/usr/bin/python
# Nombre : usa_modulo2.py
from cuadratica import calculaRaiz
calculaRaiz(3,9,6)

Navegando con Python (urllib2)

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

Modulo para lectura de URLs

Python nos facilita el módulo urllib2 para la interacción con URLs, tambien existe urllib. Pero aunque su uso  es muy parecido, es menos completa que urllib2.
El modulo urllib2 puede leer datos de una URL usando varios protocolos como HTTP, HTTPS, FTP, o Gopher.

Obtener una Web

Para obtener un streem con el contenido de una página Web solicitaremos a la función urlopen del cualquiera de los módulos ya mencionados. Luego este stream podrá ser leído por medio de los métodos read, readline. Y también podrá ser cerrado por medio del método close.

El ejemplo más simple es el que veremos aquí:

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

import urllib2
response = urllib2.urlopen('http://www.yahoo.com.ar/')
html = response.read()

HTTP se basa en pedidos y respuestas. El cliente hace una solicitud al servidor y el servidor responde. El modulo urllib2 nos permite crear nuestra petición que representa la petición HTTP que están haciendo. En su forma más simple de crear una Solicitud de objeto que especifica la URL que desea buscar. Luego llama a urlopen con esta solicitud objeto como parámetro y urlopen nos devuelve una respuesta objeto de la URL solicitada:

El ejemplo se puede ver aca:

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

import urllib2
import sys

web=raw_input("Web es http://")
userAgent = 'NuestroNavegador'
headers = { 'User-Agent' : userAgent }
req = urllib2.Request("http://"+web , None, headers)
response = urllib2.urlopen(req)
print response.read()
response.close()

También podremos necesitar que nuestro cliente Web se valida ante un proxy, esto es muy común cuando nuestro script corre dentro de una empresa.

La modificación de urllib2.py se valida ante un proxy seria proxy.py

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

import urllib2
import getpass
import sys

proxyuser=raw_input("Ingrese usuario:")
proxypass= getpass.getpass("Enter proxy password:")
httpproxy=raw_input("Ingrese la direccion del proxy:")
proxy=urllib2.ProxyHandler({"http":'http://'+proxyuser+':'+proxypass+'@'+httpproxy})
authinfo=urllib2.HTTPBasicAuthHandler()
opener=urllib2.build_opener(proxy, authinfo,urllib2.HTTPHandler)
urllib2.install_opener(opener)

web=raw_input("Web es http://")
userAgent = 'NuestroNavegador'
headers = { 'User-Agent' : userAgent }
req = urllib2.Request("http://"+web , None, headers)
response = urllib2.urlopen(req)
print response.read()
response.close()

HTTPError y URLError

Dos errores que tenemos que tener en cuenta cuando manejamos urllib2 son:

  • URLError: son errores que lanza la librería.
  • HTTPError: es el error que nos envía el servidor como el conocido 404 cuando no encuentra la pagina

También nos podemos encontrar con errores lanzados por módulos que utiliza urllib2 como httplib o el propio módulo e socket

Leer Archivos Binarios en Python

En la entrada anterior vimos como abrir y manejarnos con archivos de texto. Pero como hago para leer archivos binarios. Bien para este propósito necesitaremos usar el modulo struct. Y la estructura binaria del archivo que queremos leer.

Bien a modo de ejemplo yo pondré un programita en C que genere un archivo binario simple y luego un script python que levante este archivo y lo imprima en pantalla.

Programita en C  es muy simple, solo genera el archivito.

#include <stdio.h>

struct rec
{
 int x;
 char y;
 int z;
};

int main()
{
    char i;
    FILE *f;
    struct rec r;
    f=fopen("prueba.bin","wb");
    if (!f) return 1;
    for (i=1;i<=20; i++)
    {
         r.x = i;
         r.y = i;
         r.z = i + 1;
         fwrite(&r,sizeof(struct rec),1,f);
         printf ("(%i,%i,%i)\n",r.x,r.y,r.z);
    }
    fclose(f);
    printf("Peso de la estructura rec %i\n", sizeof(struct rec));
    return 0;
}

En mi caso el compilador C que usa como minimo una palabra de 32 bit (4 bytes) para la escritura, por eso cada registro rec pesa 12 bytes. 4 del primer int 1 del char , otros 4 del segundo int y 3 mas que usa para completar el char.

El ejemplo en python se puede ver en readBin.py

#!/usr/bin/python
# Nombre de Fichero : readBin.py
import struct

f = file('prueba.bin','r')
i=1
f.seek(0,2) #vamos al final del archivo
fin = f.tell()
f.seek(0,0) #vamos al principio del archivo

while (f.tell() < fin):
    s = f.read(12)
    dato = str(struct.unpack("i b i", s)) # desempaquetamos
    print i ," ->",dato
    i+=1;

Mascara de struct

Lo que sigue es una traducción de print struct.__doc__

Como opción podemos indicar en el  formato  de la mascara, el primer char byte que indica el orden, el tamaño y la alineación:

@: native order, tamaño y la alineación (default)
=: native order, std. tamaño y la alineación
<: little-endian, std. tamaño y la alineación
>: big-endian, std. tamaño y la alineación
!: es igual que  >

Los demás caracteres indican los tipos de los  datos atómicos del registro que utilizaremos y debe coincidir exactamente.

x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;
h:short; H:unsigned short; i:int; I:unsigned int;
l:long; L:unsigned long; f:float; d:double.

Casos especiales (decimal contar anterior indica la longitud):
s: cadena (array de char); p: cadena de pascal.

Un caso especial (sólo disponible en formato nativo):
P: Un tipo que es lo suficientemente amplia como para celebrar un puntero.

Un caso especial (no en modo nativo a menos que ‘long long’ en la plataforma C):
q: largo tiempo; Q: unsigned long long

El espacio en blanco entre los formatos se ignora.
La variable struct.error es una excepción planteada por los errores.

Archivos en Python

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

Python no s facilita la función open que recibe dos argumentos y nos devuelve un objeto tipo file. El primer argumento es el nombre del archivo en formato string,  el segundo también en formato string es el modo de acceso al archivo. Esto podrá ser “r” para lectura,  “w” para escritura.

Algunos ejemplos de apertura de archivo podria ser:

f = open(“archivo.txt”,”w”)
f = open(“archivo.txt”,”r”)

Algunos de los metodos y propiedades del objeto file son:

Propiedades

  • closed: nos devuelve true si esta cerrado y false si esta abierto el archivo
  • fileno: nos retorna el Descriptor del archivo.
  • mode: retorna el modo con el que esta abierto el archivo
  • name: retorna el nombre del archivo

Métodos

  • close: lo invocaremos siempre que terminemos de usar el archivo.
  • next: trae el siguiente valor del archivo.
  • read:  le la cantidad de bytes que se le pasa por parámetro, si no se le pasa parámetro le todo el archivo
  • readline: le una línea del archivo
  • readlines: le la cantidad de líneas que le pasamos por parámetro y nos la devuelve en una lista de strings.
  • seek: nos mueve por el archivo.
  • tell: nos dice la posición en la que estamos del archivo
  • truncate:  trunca el archivo
  • write: escribe el archivo
  • xreadlines: devuelve una matriz con todas sus lineas (“disen por hay que se discontinuara en la versión 3.0 de python”)

Un ejemplo de generacion de un archivo de texto y luego otro ejemplo que le ese archivo seria fileT1.py y fileT2.py

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

f = open("arch.txt","w")
f.write("Esto es un archivo de texto\n");
f.write("Generado con python\n");
f.write("no es hermoso\n")
f.close()

y  ahora a leerlo

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

f = open("arch.txt","r")
print f.readline(), # le la primer linea
print f.read(29),   # le los siguientes 29 bytes
print f.read(2),    # le los siguientes 2 bytes
print f.next()      # le todos los bytes desde donde esta hasta el final
f.close()

Otra forma de leer el archivo podria aver sido con xreadlines que lo ejemplificamos en xreadlines.py

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

f = open("arch.txt","r")
for i in f.xreadlines():
    print i,
f.close()

Un ejemplo del contador de palabras que no pretende ser ilustrativo sino simplemente mostrar lo que se puede hacer en una line con python 😉 . Aca va cuentaPalabras.py

#!/usr/bin/python
# Nombre de Fichero : cuentaPalabras.py
import string;
f = open("arch.txt","r")
print reduce(lambda x , y : x + len(y.split()), [0] + f.readlines())
f.close()

Un lindo ejemplo de manejo de archivos lo pone LuAuF en http://luauf.com/2008/04/07/python-gestion-de-archivos/ en  el ejemplo veran como leer la información ID3 tag de un MP3

Tuplas en Python

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

Una tupla es una lista se va a poder modificar después de haberla creado.
Las tuplas se definen como las listas salvando que en lugar de encerrarlas entre corchetes se encierran entre paréntesis.
Los índices de las tuplas empiezan en 0 e  índices negativos empiezan a contar desde el final de la lista.

Formas de recorrer una tupla y el manejo de índices podemos ver en tupla1.py

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

tupla = (1,[2,3,4],2,"Pedro");

for r in tupla:
    print str(r)

print "----------------------------"

for i in range(len(tupla)):
    print str(i),"->",str(tupla[i])

print "----------------------------"
print "El ultimo elemento de la tupla es %s" % tupla[-1]
print "----------------------------"
print "Una tupla el segundo y tercer",
print "elemento de la tupla original %s" % str(tupla[1:3])
print "Los tres ultimos elementos %s" % str(tupla[1:])

Si bien las tuplas no se pueden modificar las tuplas se pueden trasformar a listas por medio del método list y las listas se pueden trasformar a tuplas por medio del método tuple.
Para ilustrar esto pondré un extracto de mi interprete python, con la salida del programa anterior

1
[2, 3, 4]
2
Pedro
----------------------------
0 -> 1
1 -> [2, 3, 4]
2 -> 2
3 -> Pedro
----------------------------
El ultimo elemento de la tupla es Pedro
----------------------------
Una tupla el segundo y tercer elemento de la tupla original ([2, 3, 4], 2)
Los tres ultimos elementos ([2, 3, 4], 2, 'Pedro')
>>> list(tupla)
[1, [2, 3, 4], 2, 'Pedro']
>>> tuple(list(tupla))
(1, [2, 3, 4], 2, 'Pedro')

La ventaja de las tuplas contra las listas es que las tuplas son más rápidas

Encapsulamiento en python

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

La idea de encapsulamiento segun Grady Booch es

“La abstracción y el encapsulamiento son conceptos complementarios: la abstracción se centra en el comportamiento observable de un objeto, mientras el encapsulamiento se centra en la implementación que da lugar a este comportamiento. El encapsulamiento se consigue a menudo mediante la ocultación de información, que es el proceso de ocultar todos secretos de un objeto que no contribuyen a sus caracteristicas esenciales; típicamente, la estructura de un objeto esta oculta, así como la implementación de sus metodos.”[Análisis y diseño orientado a objetos con aplicaciones *]

En otras palabras es impedir el acceso al los métodos o variables del objeto, para que solo se puedan usar dentro de la instancia del objeto. Esto en los lenguajes como Java o C# lo logran con unos modificadores de acceso (anteponen a la definición del método o propiedad public, private, protected, etc.).
Los modificadores de acceso permiten al diseñador de clases delimitar la frontera entre lo que es accesible para los usuarios de la clase, lo que es estrictamente privado y ‘no importa’ a nadie más que al diseñador de la clase e incluso lo que podría llegar a importar a otros diseñadores de clases que quisieran alterar, completar o especializar el comportamiento de la clase.
Python no cuenta con estos modificadores de acceso para lograr el encapsulamiento. Por que el acceso a una variable o método viene dado por su nombre. Para que un método sea privado en Python lo que hay que hacer es anteponerle dos guiones bajos “__” antes del nombre y no dejar que termine con dos guiones bajos “__”. Lo mismo para las variable.

Un ejemplo se vera en encapsulacion.py

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

class Persona(object) :
    "Calse Persona"
    def __init__(self, pNombre,pEdad,pSueldo) :
        self.setNombre(pNombre)
        self.setEdad(pEdad)
        self.__setSueldo(pSueldo);

    def setEdad(self, pEdad) :
        self.__edad = pEdad

    def getEdad(self) :
        return self.__edad

    def setNombre(self, pNombre) :
        self.__nombre = pNombre

    def getNombre(self) :
        return self.__nombre

    def __setSueldo(self,pSueldo):
        self.__sueldo = pSueldo
    def getSueldo(self):
        return self.__sueldo

    nombre = property(getNombre, setNombre)
    edad = property(getEdad, setEdad)

class Gerente(Persona) :
    def __init__(self, pNombre,pEdad):
        Persona.__init__(self, pNombre,pEdad,5000)

class Secretaria(Persona) :
    def __init__(self, pNombre,pEdad) :
        Persona.__init__(self, pNombre,pEdad,500)

if __name__ == '__main__':
    g = Gerente("Mariano", 56)
    s  = Secretaria("Rocio", 33)

    print "El Gerente es", g.nombre , " gana ", g.getSueldo()
    print "La Secretaria es ", s.getNombre(), " gana ",s.getSueldo()

Veran que la clase Persona hereda de object esto es asi por que tiene que usar propiedades.
También varan que el objeto “g” imprime su nombre por medio de su propiedad.

*ISBN 968 444 3528 Editorial Pearson

Polimorfismo en Python

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

El lenguaje Python soporta el polimorfismo de forma muy cómoda, ya que al ser de tipado dinámico deja que el programador pase cualquier objeto como parámetro de un método.
En otras palabras, si el método le envía un mensaje que el objeto no entiende, el mensaje dará error en el tiempo de ejecución y no en tiempo de diseño.
El polimorfismo es cuando dos o más objetos entienden los mismos mensajes (métodos).

Un ejemplo de esto lo daremos en polimorfismo.py

#!/usr/bin/python
# Nombre de Fichero : polimorfismo.py
class Gato:
    "Clsase Gato"
    def __init__(self):
        self.pos = 0
    def trepar(self):
        pass
    def caminar(self):
        self.pos = self.pos + 10

    def maullar(self):
        print "Miu Miu"

class Perro:
    "Clase Perro"
    def __init__(self):
        self.pos = 0
    def caminar(self):
        self.pos = self.pos +4
    def ladrar(self):
        print "Gua Gua"

def pasearMascota(mascota):
    for i in range(5):
        mascota.caminar()
    print "La mascota quedo en " + str(mascota.pos)

perro=Perro()
gato=Gato()
pasearMascota(perro)
pasearMascota(gato)

La salida de este programa no dará error aunque le pase distintos parámetros al proceso pasearMascota ya que los dos saben caminar.

El resultado que dará será.

>>>
La mascota quedo en 20
La mascota quedo en 50

Observé que los objetos perro y gato son polimorficos en el método caminar, pero no en los métodos maullar y ladrar

Página siguiente »