import csv
with open('zaragoza_2010_10.csv') as fin:
    reader = csv.reader(fin, delimiter=";")
    for fila in reader:
        print fila

['Países', 'HOMBRES', 'MUJERES', 'TOTAL']
['Rumania', '16704', '14487', '31191']
['Ecuador', '5612', '5713', '11325']
['Marruecos', '5042', '3007', '8049']

with open('codigo_ascii.txt', 'w') as fout:
    writer = csv.writer(fout)
    ascii_a = ord('a')
    for n in range(26):
        writer.writerow((chr(ascii_a+n), ascii_a + n))

with open('zaragoza_2010_10.csv') as fin:
    # cuidado, toma la primera fila como títulos
    # usad parámetro fieldnames si no
    reader = csv.DictReader(fin, delimiter=";")

# ejemplo lectura
import xlrd
datos = {} # Dicc. vacío
book = xlrd.open_workbook('sampledata.xls')
hoja = book.sheet_by_index(0)
for i in range(1,sh.nrows): #salta la primera línea
    datos[hoja.cell_value(rowx=i, colx=1)] = hoja.cell_value(rowx=i, colx=2)

# ejemplo escritura
import xlwt
lista1 = [1,2,3,4,5]
lista2 = [234,267,281,301,331]
wb = xlwt.Workbook()
ws = wb.add_sheet('Primera hoja')
ws.write(0,0,'Column A')
ws.write(0,1,'Column B')
i = 1
for x,y in zip(lista1,lista2): # Recorre las dos listas a la vez
    ws.write(i,0,x) # Fila, Columna, Datos.
    ws.write(i,1,y)
    i += 1
wb.save('hoja.xls')

# Fuente: http://mundogeek.net/archivos/2008/06/25/bases-de-datos-en-python
import sqlite3 as dbapi
 
# 1. Creamos objeto conexión
bbdd = dbapi.connect("bbdd.dat")
 
# 2. Creamos un cursor
cursor = bbdd.cursor()
 
# 3. Usamos cursor para acceder a la  base de datos
# 3.1. create
cursor.execute("""create table empleados (dni text,
                  nombre text,
                  departamento text)""")
 
# 3.2. insert
cursor.execute("""insert into empleados
                  values ('12345678-A', 'Manuel Gil', 'Contabilidad')""")
 
bbdd.commit()

# 3.3 select
cursor.execute("""select * from empleados
                  where departamento='Contabilidad'""")
 
# extraer resultados de select --> están almacenados en cursor
for tupla in cursor.fetchall():
    print tupla

import MySQLdb
 
dbusername = "user" 
dbname = 'user_private' 
dbpassword = 'some_password'
 
# connect to the database 
db = MySQLdb.Connect(db = dbname, user = dbusername, passwd = dbpassword)
 
#To perform a query, you first need a cursor, and then you can execute queries on it. 
cursor = db.cursor()
 
# create and exe the query 
query = "SELECT * FROM foo"
cursor.execute(query)
 
# retrieve the result 
results = cursor.fetchall()
 
for firstname, age, city in results: 
    print firstname, age, city

>>> import pickle
>>> s = pickle.dumps({1:'a',2:'b'},0) >>> s
"(dp0\nI1\nS'a'\np1\nsI2\nS'b'\np2\ns."
>>> print pickle.loads(s) {1: 'a', 2: 'b'}

>>>import shelve
>>> d = shelve.open('alumnos.dat') # abrir archivo 
>>> d['12cd'] = {'nombre': 'Luis', 'apellido': 'Pérez'}
>>> data = d['12cd'] # leer una COPIA de los datos 
>>> del d['12cd'] # borra los datos almacenados

cursor.execute(“SELECT * FROM personas WHERE edad=20")
for row in cursor.fetchall():
    id = row[0]
    edad = row[1]
    cursor.execute(“UPDATE personas WHERE id=%s SET edad=%d” % (id, edad+1))

for p in Personas.listado(edad=20): # ejecuta SELECT
    p.edad = p.edad + 1
    p.update() # ejecuta UPDATE

# -*- coding: utf-8 -*-
from elixir import *
 
metadata.bind = "sqlite:///peliculas.sqlite"
metadata.bind.echo = True
 
class Pelicula(Entity):
    titulo = Field(Unicode(30))
    year = Field(Integer)
    descripcion = Field(UnicodeText)
 
    def __repr__(self):
        return u'<Peli: "%s" (%d)>' % (self.titulo, self.year)

>>> from modelo import *
>>> setup_all()   # crea el objeto Tabla SQLAlchemy y el objeto Mapper para la clase Película.
>>> create_all()  # crea las tablas SQL correspondientes a la Tabla SQLAlchemy

>>> Pelicula(titulo=u"Blade Runner", year=1982)
<Peli: "Blade Runner" (1982)>
>>> session.commit()

>>> Pelicula.query.all()
[<Peli: "Blade Runner" (1982)>]

>>> peli = Pelicula.query.first() # .first() equivalente a .all()[0]
>>> peli.year = 1983
>>> session.commit()
>>> Pelicula.query.all()
[<Peli: "Blade Runner" (1983)>]

>>> movie.delete()
>>> session.commit()
>>> Pelicula.query.all()
[]

class Pelicula(Entity):
    titulo = Field(Unicode(30))
    year = Field(Integer)
    descripcion = Field(UnicodeText)
    director = ManyToOne('Director')    # <-- Añade esta línea
 
    def __repr__(self):
        return '<Peli: "%s" (%d)>' % (self.titulo, self.year)
 
class Director(Entity):
    nombre = Field(Unicode(60))
    peliculas = OneToMany('Pelicula')         # <-- Añade esta línea
 
    def __repr__(self):
        return '<Director "%s">' % self.nombre

>>> from model import *
>>> setup_all(True)

# directores
>>> rscott = Director(nombre=u"Ridley Scott")
>>> glucas = Director(nombre=u"George Lucas")
# películas
>>> alien = Pelicula(titulo=u"Alien", year=1979)
>>> swars = Pelicula(titulo=u"Star Wars", year=1977)
>>> brunner = Pelicula(titulo=u"Blade Runner", year=1982)
# Añadimos películas a los directores
>>> rscott.peliculas.append(brunner) 
>>> rscott.peliculas.append(alien)
>>> swars.director = glucas
# comprobación
>>> glucas.peliculas
[<Pelicula "Star Wars" (1977)>]
>>> session.commit()

>>> Pelicula.query.filter_by(titulo=u"Alien").one()
<Pelicula "Alien" (1979)>
>>> Pelicula.query.filter(Pelicula.year > 1980).all()
[<Pelicula "Blade Runner" (1982)>]
>>> Pelicula.query.filter(Pelicula.director.has(nombre=u'Ridley Scott')).all()
[<Pelicula "Alien" (1979)>, <Pelicula "Blade Runner" (1982)>]
>>> Pelicula.query.filter(Pelicula.director.has(Director.nombre.endswith(u'Scott'))).all()
[<Pelicula "Alien" (1979)>, <Pelicula "Blade Runner" (1982)>]

>>> d = Director.get_by(nombre=u'Ridley Scott') # Class.get_by(xxx) es un atajo para Class.query.filter_by(xxx).first()
>>> q = Pelicula.query.filter_by(director=d)
>>> q.filter_by(year=1979).all()
[<Pelicula "Alien" (1979)>]
>>> from sqlalchemy import desc
>>> q.order_by(desc(Pelicula.year)).all()
[<Pelicula "Blade Runner" (1982)>, <Pelicula "Alien" (1979)>]

class Genero(Entity):
    nombre = Field(Unicode(15), primary_key=True)
    peliculas = ManyToMany('Pelicula')
    def __repr__(self):
        return '<Genero "%s">' % self.nombre
 
class Pelicula(Entity):
    titulo = Field(Unicode(30), primary_key=True)   # <-- modifica esta línea
    year = Field(Integer, primary_key=True)        # <-- y ésta
    descripcion = Field(UnicodeText)
    director = ManyToOne('Director')
    generos = ManyToMany('Genero')                   # <-- añade esta línea
 
    def __repr__(self):
        return '<Pelicula "%s" (%d)>' % (self.titulo, self.year)

>>> from model import *
>>> setup_all(True)
>>> scifi = Genero(nombre=u"Science-Fiction")
>>> rscott = Director(nombre=u"Ridley Scott")
>>> glucas = Director(nombre=u"George Lucas")
>>> alien = Pelicula(titulo=u"Alien", year=1979, director=rscott, generos=[scifi, Genero(nombre=u"Horror")])
>>> brunner = Pelicula(titulo=u"Blade Runner", year=1982, director=rscott, generos=[scifi])
>>> swars = Pelicula(titulo=u"Star Wars", year=1977, director=glucas, generos=[scifi])
>>> session.commit()
>>> Pelicula.query.filter(Pelicula.generos.any(nombre=u"Horror")).all()
[<Pelicula "Alien" (1979)>]

class Persona(Entity):
    using_options(inheritance='multi')
    nombre = Field(Unicode(60))
    def __repr__(self):
        return '<Persona "%s">' % self.nombre

class Actor(Persona):
    using_options(inheritance='multi')
    peliculas = ManyToMany('Pelicula')
    def __repr__(self):
        return '<Actor "%s">' % self.nombre
 
class Director(Persona):
    using_options(inheritance='multi')
    peliculas = OneToMany('Pelicula')
    def __repr__(self):
        return '<Director "%s">' % self.nombre

>>> rscott = Director(nombre=u"Ridley Scott")
>>> glucas = Director(nombre=u"George Lucas")
>>> hford = Actor(nombre=u"Harrison Ford")
>>> mhamill = Actor(nombre=u"Mark Hamill")
>>> sweaver = Actor(nombre=u"Sigourney Weaver")
>>> session.commit()

>>> Persona.query.all()
[<Director "Ridley Scott">,  <Director "George Lucas">,
 <Actor "Harrison Ford">,  <Actor "Mark Hamill">,
 <Actor "Sigourney Weaver">]
>>> Actor.query.all()
[<Actor "Harrison Ford">, <Actor "Mark Hamill">, <Actor "Sigourney Weaver">]

from urllib import urlopen
URL = 'http://mipagina.com'
doc = urlopen(URL).read()

import amara
URL = '....'  # URL puede ser una url, una ruta de un fichero o una cadena de texto
doc = amara.parse(URL)

from amara import bindery
URL = '....'  
doc = bindery.parse(URL)

from amara.bindery import html
URL = '....'  
doc = html.parse(URL)

>>> from amara.bindery import html
>>> URL = 'http://heraldo.es'
>>> doc = html.parse(URL)
>>> imagenes = doc.xml_select(u'//img') # las imágenes van en etiquetas img
>>> len(imagenes)
65
>>> primera_imagen = imagenes[0]

>>> print primera_imagen.xml_encode()
<img src="/MODULOS/global/publico/interfaces/img/logo-Heraldo.png" alt="Últimas noticias de Aragón, Zaragoza, Huesca y Teruel del periódico digital Heraldo.es"/>
>>> for im in imagenes:
        print im.src
/MODULOS/global/publico/interfaces/img/logo-Heraldo.png
/uploads/imagenes/iconos/titulos/jmj.jpg
/uploads/imagenes/rec70/_cuatrovientos6_011b2ad5.jpg
...

>>> from amara.bindery import html
>>> from amara.lib import U  # Extrae los nodos de texto de un fragmento
>>> articulos = doc.xml_select(u'//div[@class="article"]')
>>> len(articulos)
15
>>> for ar in articulos:
	print U(ar.div).strip()  # Navega por el nodo artículo.
                                 # Cuidado con los espacios en blanco y saltos
 
Software Libre: Todo listo para la celebración de los 20 años de Linux
Publicado SmartOS, sistema operativo basado en Illumos
Un dispositivo permite a los invidentes ver a través de su lengua
El fin de la ley de Moore
...

# Nodo que contenga una cadena de texto:
expresion = u'.//text()[contains(., "python")]'
expresion = u'.//text()[contains(., "%s")]' % cadena.decode('utf-8')
# Nodos o atributos que contengan una cadena:
expresion = u'.//@*[contains(., "%s")]'