2. Introducción a la Librería Estándar
Biblioteca de módulos estándar; Pilas Incluídas!
Modulos: Archivos .py (fuentes) y .c (compilados)
Incluida con el interprete por defecto
Algunos modulos depende de la plataforma (ej.
winreg)
Documentada en la Referencia Standard Library
Más de 300 módulos!
3. Introducción a la Librería Estándar
Cadenas: string, re, StringIO, codecs
Tipos de datos: datetime, array, queue, copy, ...
Números y Matemática: decimal, math, random
Archivos: os.path, glob, stat, tempfile
Persistencia: pickle, shelve, dbm, sqlite3
Compresión: zlib, bz2, zipfile, tarfile
Formatos: csv, ConfigParser
Criptografía: haslib, md5, sha
Sistema operativo: os, time, logging
Comunicación: subprocess, socket, signal, popen2
5. Sistema (python): sys
Funciones y atributos ppales:
exit(estado): sale del interprete (devuelve
estado)
path: lista de rutas para ubicar módulos de python
argv: lista de argumentos de la linea de comando
stdin, stdout, stderr: entrada, salida y error
estandar (simil archivos)
>>> import sys
>>> sys.stdout = open("salida.txt","w")
>>> print "hola mundo" # graba en salida.txt
6. Tiempo: time
Funciones y atributos ppales:
time(): tiempo (en segundos) desde la epoca
unix
gmtime(): tiempo en UTC (GMT)
localtime(): fecha y hora local (como tupla)
sleep(segundos): duerme por x segundos
clock(): reloj de la CPU
mktime: convierte una tupla en tiempo time()
strftime(formato, tiempo): convierte a string
>>> from time import gmtime, strftime
>>> strftime("%a, %d %b %Y %H:%M:%S +0000")
'Thu, 13 Aug 2009 02:24:32 +0000'
7. Expesiones Regulares: re
Funciones:
compile(patrón): compila una regex
match(patrón, cadena): comprueba
coincidencia
search(patrón, cadena): busca coincidencia
split(patrón, cadena): divide según coincidencias
findall(patrón, cadena): devuelve una lista de
todas coincidencias que no se superponen
sub(patrón, reemplazo, cadena): busca todas
coincidencias y realiza los reemplazos
>>> import re
>>> re.match("c", "abcdef") # no hay coincidencia
>>> re.search("c", "abcdef") # coincidencia!
<_sre.SRE_Match object at ...>
8. Expesiones Regulares: re
Caracteres especiales:
.: todos los caracteres menos n
^: comienzo de linea/cadena
$: fin de linea/cadena
*: cero o más repeticiones
+: una o más repeticiones
?: cero o una repetición
{m,n}: m a n repeticiones
[]: conjunto de caracteres
|: separa expresiones regulares (una o la otra)
>>> re.match(".*c.*", "abcdef") # coincidencia!
9. Expesiones Regulares: re
Grupos:
(...): si coincide, almacena comienzo y final
grupo
(?P<name>...): idem pero grupo con nombre
(?P=name): coincide con el grupo con nombre
>>> regex = re.compile(r"(?P<apellido>w+), (?P<nombre>w+)")
>>> match = re.match(regex,"Reingart, Mariano")
>>> print match.group("nombre")
>>> print match.group("apellido")
Mariano
Reingart
10. Entrada/Salida en memoria: StringIO
import StringIO
# creo un archivo (buffer en memoria)
output = StringIO.StringIO()
output.write('Primera linea.n')
print >>output, 'Segunda linea.'
# obtengo el contenido del archivo en memoria
print output.getvalue()
# cierro el archivo y descarto el buffer
output.close()
11. Fechas y horas: datetime
>>> import datetime
>>> hoy = datetime.date.today()
>>> print hoy
2009-02-26
>>> ahora = datetime.datetime.now()
>>> print ahora
2009-02-26 14:15:16.025000
>>> hoy + datetime.timedelta(days=4)
datetime.date(2009, 3, 2)
>>> cumple = datetime.date(2009, 07, 23)
>>> cumple - hoy
datetime.timedelta(147)
>>> cumple.strftime("%d de %B de %Y")
'23 de Julio de 2009'
12. Numeros de "punto fijo": decimal
>>> f = 1.1 # float o (punto flotante binario)
>>> f
1.1000000000000001
>>> f * 2
2.2000000000000002
>>> import decimal
>>> d = decimal.Decimal("1.1")
>>> d * 2
Decimal("2.2")
>>> decimal.getcontext().prec = 6 # ajusto la precisión
>>> decimal.Decimal(1) / decimal.Decimal(7)
Decimal("0.142857")
13. Números aleatorios: random
>>> import random
>>> random.choice(['manzana', 'pera', 'banana'])
'manzana'
>>> random.sample(xrange(100), 10) # elección sin reemplazo
[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]
>>> random.random() # un float al azar
0.17970987693706186
>>> random.randrange(6) # un entero al azar tomado de range(6)
4
14. Matemática: math
>>> import math
>>> math.cos(math.pi / 4.0)
0.70710678118654757
>>> math.log(1024, 2)
10.0
Funciones:
Exponenciales y Logarítmicas: exp, log, pow
Trigonométricas: cos, sin, tan, acos, asin, atan
Ángulos: degree, radians
Hiperbólicas: cosh, sinh, tanh...
Constantes: pi y e
15. Archivos y directorios: os
Funciones de os:
listdir(ruta): devuelve la lista de entradas (dir)
remove(ruta): elimina un archivo
rename(ruta): cambia el nombre de un archivo
chdir(ruta): cambia a un directorio de trabajo
getcwd(): devuelve el directorio actual
mkdir(ruta): crea un directorio
rmdir(ruta): borra un directorio
mkdirs(ruta): crea una jerarquia de directorios
removedirs(ruta): elimina recursivamente
renames(ruta): renombra recursivamente
16. Archivos y directorios: os
Funciones de os.path:
basename(ruta): nombre base (archivo)
dirname(ruta): extrae ruta (directorio)
abspath(ruta): ruta absoluta
isfile(ruta), isdir(ruta): verifica el tipo
exists(ruta): verifica si existe la ruta
splitext(ruta): divide una ruta en (nombre, ext)
walk(path, visit, arg): recorre recursivamente los
directorios, llamando a visit(arg, dirname, names)
17. Archivos y directorios: os
>>> import os
>>> os.listdir("c:/")
['Archivos de programa', 'AUTOEXEC.BAT' …]
>>> os.path.isdir("C:/AUTOEXEC.BAT")
False
>>> os.mkdir("C:/prueba")
>>> os.path.join("C:prueba","mi-archivo.txt")
'C:pruebami-archivo.txt'
>>> os.path.exists('C:pruebami-archivo.txt')
False
>>> os.path.splitext('mi-archivo.txt')
('mi-archivo', '.txt')
>>> os.path.dirname('C:pruebami-archivo.txt')
'C:prueba'
>>> os.path.basename('C:pruebami-archivo.txt')
'mi-archivo.txt'
18. Procesos: os
Funciones de os:
execv(ruta, args): ejecuta un nuevo programa
system(comando): ejecuta un comando del s.o.
fork(): inica un proceso hijo
kill(pid, señal): envía una señal a un proceso
waitpid(pid, options): espera un proceso
>>> import os
>>> os.execv("C:PROGRAMA.EXE", ["A","B","C"])
>>> os.system("notepad.exe")
>>> pid = os.spawnv(os.P_NOWAIT,"notepad.exe",[])
>>> os.kill(pid, 9) # enviar señal, solo unix
>>> os.waitpid(pid, 0) # esperar al proceso
(304, 0)
19. Procesos: subprocess
Engendrar nuevos procesos
Conectart a las pipas de entrada/salida/error
Obtener el valor de retorno
(os.system, os.spawn*, os.popen*, popen2.*)
>>> from subprocess import Popen, PIPE
>>> p1 = Popen(["ipconfig"], stdout=PIPE) # crear una “pipa”
>>> output = p1.communicate(input=None)
>>> output
('Configuración IP … Adaptador Ethernet coLinux: … Dirección IP:
192.168.0.2 ...', None)
20. Hilos: threading
import threading, time
class MiHilo(threading.Thread):
def __init__(self, parametros):
threading.Thread.__init__(self)
self.params = parametros
def run(self):
print "ejecutando thread con ", params
time.sleep(5) # duerme 5 seg (ver GIL**)
print "terminando thread"
seg_plano = MiHilo('parametros')
seg_plano.start() # inicio la tarea
print 'continúa la ejecución en primer plano.'
seg_plano.join() # esperar que termine la tarea
print 'el segundo plano listo.'
21. Procesos múltiples: (multi)processing
from processing import Process
import time
def f(name):
print 'hola', name
time.sleep(10)
print 'chau', name
if __name__ == '__main__':
# creo el proceso
p = Process(target=f, args=('bob',))
p.start() # lo inicio
p.join() # espero que termine
22. Conexiones: sockets (servidor)
# Servidor de Ecos
import socket
HOST = '' # todas las interfases
PORT = 50007 # puerto no privilegiado (>1024)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, PORT)) # me vinculo al host/puerto
s.listen(1) # escucho por conexiones
conn, addr = s.accept() # acepto la conexión
print 'Connectado de', addr
while 1:
data = conn.recv(1024) # recibo datos
if not data: break
conn.send(data) # envio datos
conn.close() # cierro el socket
23. Conexiones: sockets (cliente)
# Cliente de Eco
import socket
HOST = 'localhost' # equipo remoto
PORT = 50007 # puerto del servidor
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT)) # me conecto
s.send('Hola mundo') # envío datos
data = s.recv(1024) # recibo datos
s.close() # cierro el socket
print 'Recibido:', repr(data)
24. Conexiones asincrónicas: asyncore
import asyncore, time; from socket import *
class TimeChannel(asyncore.dispatcher):
def handle_write(self):
self.send(time.strftime("%x %X"))
self.close()
class TimeServer(asyncore.dispatcher):
def __init__(self, port=37):
asyncore.dispatcher.__init__(self)
self.create_socket(AF_INET, SOCK_STREAM)
self.bind(("", port))
self.listen(5)
def handle_accept(self):
channel, addr = self.accept()
TimeChannel(channel)
server = TimeServer(8037)
asyncore.loop()
25. Internet: cliente web (http)
urllib2: cliente http de alto nivel
httplib: cliente http de bajo nivel
>>> import urllib2
>>> URL='http://tycho.usno.navy.mil/cgi-bin/timer.pl'
>>> for line in urllib2.urlopen(URL):
... if 'EST' in line or 'EDT' in line:
... print line
>>> import httplib
>>> conn = httplib.HTTPConnection("www.python.org")
>>> conn.request("GET", "/index.html")
>>> r1 = conn.getresponse()
>>> print r1.status, r1.reason
200 OK
>>> data1 = r1.read()
26. Internet: servidor web (http)
from BaseHTTPServer
import BaseHTTPRequestHandler, HTTPServer
class Handler(BaseHTTPRequestHandler):
def do_GET(self):
if self.path != "/":
self.send_error(404, "File not found")
else:
self.send_response(200)
self.send_header("Content-type", "text/html")
self.end_headers()
self.wfile.write("<html><body><p>Hola Mundo!
</p></body></html>n")
httpd = HTTPServer(("", 8000), Handler)
httpd.serve_forever()
27. Internet: analizador de páginas html / xhtml
from HTMLParser import HTMLParser
from urllib2 import urlopen
class Spider(HTMLParser):
"Buscar links (<A>) de una página web"
def __init__(self, url):
HTMLParser.__init__(self)
req = urlopen(url)
self.feed(req.read())
def handle_starttag(self, tag, attrs):
if tag == 'a' and attrs:
print "Link encontrado => %s" % attrs[0][1]
Spider('http://www.python.org')
28. Internet: codificaciones (base64, json)
>>> import base64
>>> encoded = base64.b64encode('data to be encoded')
>>> encoded
'ZGF0YSB0byBiZSBlbmNvZGVk'
>>> data = base64.b64decode(encoded)
>>> data
'data to be encoded'
# javascript object notation (py2.6)
>>> import json
>>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
'["foo", {"bar": ["baz", null, 1.0, 2]}]'
29. Internet: correo electrónico (smtp)
email: objetos para construir correos electrónicos
smtplib: cliente smtp para transferir mails
import smtplib
from email.mime.text import MIMEText
# creo el mail
msg = MIMEText("Mensaje de texto")
msg['Subject'] = 'Motivo del mail'
msg['From'] = "remitente@prueba.com"
msg['To'] = "destinatario@prueba.com"
# envio el mail
smtp = smtplib.SMTP("smtp.prueba.com.ar")
smtp.sendmail(msg['From'], msg['To'],
msg.as_string())
30. Internet: correo electrónico (pop3 e imap)
import poplib, imaplib, getpass
m = poplib.POP3('localhost') # conexión
m.user(getpass.getuser()) # inicio sesión
m.pass_(getpass.getpass())
numMessages = len(m.list()[1]) # cantidad de mails
print m.retr(1)[1] # imprimo el 1ro
m = imaplib.IMAP4()
m.login(getpass.getuser(), getpass.getpass())
m.select()
typ, data = m.search(None, 'ALL') # busco los msg
for num in data[0].split():
typ, data = m.fetch(num, '(RFC822)') # obtengo msg
print 'Mensaje %sn%sn' % (num, data[0][1])
m.close()
m.logout()
32. Internet: mails multiparte (ej. imagenes)
import email.mime
msg = email.mime.Multipart.MIMEMultipart()
msg['Subject'] = 'Esto es una prueba'
msg['From'] = 'yo@example.com'
msg['Reply-to'] = 'responder-aca@example.com'
msg['To'] = 'vos@example.com'
msg.preamble = 'Mensaje de multiples partes.n'
part = email.mime.Text.MIMEText("Texto")
msg.attach(part)
imagen = open("serpiente.png","rb").read()
email.mime.Image.MIMEImage(imagen)
part.add_header('Content-Disposition', 'attachment', filename="imagen.
jpg")
msg.attach(part) # Se pueden seguir agregando partes
msg.as_string()
33. Internet: transferencias de archivos (ftp)
>>> from ftplib import FTP
>>> ftp = FTP('ftp.prueba.com') # conectar
>>> ftp.login() # usuario anónimo
>>> ftp.retrlines('LIST') # listar directorio total 24418
drwxrwsr-x 5 ftp-usr pdmaint 1536 Mar 20 09:48 README
>>> ftp.retrbinary('RETR README', open('README', 'wb').write)
'226 Transfer complete.'
>>> ftp.quit()
34. Planillas delimitadas por coma: csv
import csv
# abrir el archivo y procesar el archivo csv
csv_reader = csv.reader(open("archivo.csv"))
# recorrer las filas de la planilla
for fila in csv_reader:
# leer las columnas y asignarlas a las variables
celda1, celda2, celda3 ... = fila
# muestro las celdas
print celda1, celda2
35. Manejo simple de XML: xml.dom.
minidom
>>> from xml.dom.minidom import parse, parseString
>>> dom3 = parseString('<myxml>Some data<empty/> some more
data</myxml>')
>>> dom3
<xml.dom.minidom.Document instance at 0x01F508A0>
>>> dom3.childNodes
[<DOM Element: myxml at 0x1f545a8>]
>>> node = dom3.childNodes[0]
>>> node.toxml()
u'<myxml>Some data<empty/> some more data</myxml>'
>>> node.tagName
u'myxml'
>>> node.childNodes[0].nodeValue
u'Some data'
37. Compresión con zlib
>>> import zlib
>>> s = 'witch which has which witches wrist watch'
>>> len(s)
41
>>> t = zlib.compress(s)
>>> len(t)
37
>>> zlib.decompress(t)
'witch which has which witches wrist watch'
>>> zlib.crc32(s)
226805979
38. Compresión con zip: zipfile
import zipfile
file = zipfile.ZipFile("ejemplo.zip", "r")
# listar nombres de archivos
for name in file.namelist():
print name,
# listar información de archivos zipeados
for info in file.infolist():
print info.filename, info.date_time, info.file_size
# leo los archivos comprimidos
for name in file.namelist():
data = file.read(name)
print name, len(data), repr(data[:10])
39. Registro: logging
import logging
logging.debug('Información de depuración')
logging.info('Mensaje informativo')
logging.warning('Atención: archivo de configuración %s no se
encuentra',
'server.conf')
logging.error('Ocurrió un error')
logging.critical('Error crítico -- cerrando')
40. Depuración: pdb
Funciones de pdb:
set_trace(): comienza depuración
pm(): comienza modo post-mortem
run(orden): ejecuta orden en depuración
import pdb
for i in xrange(1000):
if i==500:
pdb.set_trace()
> debug.py(3)<module>()
-> for i in xrange(1000):
(Pdb) p i
500
(Pdb) c
41. Depuración: pdb
Comandos principales de pdb:
p: imprime contenido de expresión
s: ejecuta entrando a las funciones
n: ejecuta hasta la próxima linea
c: continua con la ejecución normal
r: ejecuta hasta finalizar la función
w: muestra la traza actual
l: lista el código fuente
b: inserta una interrupción para el archivo y linea
j: salta a una linea predeterminada
q: termina el programa
42. Prueba por documentación: doctest
def promedio(valores):
"""Calcula la media aritmética de una lista
>>> print promedio([20, 30, 70])
40.0
"""
return sum(valores, 0.0) / len(valores)
import doctest
# valida automáticamente las pruebas integradas
doctest.testmod()
