denklab | Artículos en la categoría »PyMOTW«

PyMOTW: anydbm (y módulos relacionados)

Sun, 21 Sep 2008 23:09:21 -0400

Traducción de PyMOTW: anydbm el módulo anydbm y módulos relacionados de la columna semana de Doug Hellman

Módulo:	anydbm
Propósito:	El módulo anydbm proporciona una interfaz genérica similar a diccionarios para base de datos del estilo DBM con cadenas como llaves.
Versión de Python:	1.4 y posterior

anydbm es un front-end para bases de datos del estilo DBM que usan cadenas (de texto) simples como llaves para acceder a registros que contienen cadenas. Utiliza el módulo whichdb para identificar bases de datos dbhash, gdbm y dbm, luego las abre con el módulo apropiado. Es usado como backend para shelve, que sabe como guardar objetos usando pickle.

Creando una nueva base de datos

El formato de almacenamiento para nuevas bases de datos es seleccionado buscando cada uno de estos módulo en orden:

dbhash
gdbm
dbm
dumbdbm

La función open() acepta flags para controlar como es gestionado el archivo de base de datos. Para crea una base de datos nuevo cuando sea necesario, usa 'c'. Para crear una nueva base de datos siempre, usa 'n'.

import anydbm

db = anydbm.open('/tmp/ejemplo.db', 'n')
db['llave'] = 'valor'
db['hoy'] = 'Domingo'
db['autor'] = 'Ernesto'
db.close()

En este ejemplo, el archivo siempre es re inicializado. Para ver qué tipo de base de datos ha sido creada, podemos usar whichdb.

import whichdb

print whichdb.whichdb('/tmp/ejemplo.db')

Los resultado pueden variar dependiendo qué módulos están instalados en tu sistema.

$ python anydbm_whichdb.py
dbhash

Abriendo una base de datos existente

Para abrir una base de datos existente, usa flags 'r' (para sólo lectura) o 'w' (para lectura y escritura). No necesitas preocuparte por el formato, porque bases de datos existentes son automáticamente se dan whichdb para su identificación. Si un file puede ser identificado, el módulos apropiado es utilizado para abrirlo.

import anydbm

db = anydbm.open('/tmp/ejemplo.db', 'r')
try:
    print 'keys():', db.keys()
    for k, v in db.iteritems():
        print 'iterando:', k, v
    print 'db["autor"] =', db['autor']
finally:
    db.close()

Una vez abierto, db es un objeto similar a un diccionario, con soporte para los métodos habituales.

$ python anydbm_existing.py
keys(): ['llave', 'hoy', 'autor']
iterando: llave valor
iterando: hoy Domingo
iterando: autor Ernesto
db["autor"] = Ernesto

Casos de error

Las llaves de la base de datos tienen que ser cadenas.

import anydbm

db = anydbm.open('/tmp/ejemplo.db', 'w')
try:
    db[1] = 'uno'
finally:
    db.close()

Pasar otro tipo (de objeto) resulta en un TypeError.

$ python anydbm_intkeys.py
Traceback (most recent call last):
  File "anydbm_intkeys.py", line 16, in <module>
    db[1] = 'uno'
  File "/home/ers/Projects/PyMOTW-es/anydbm/__init__.py", line 230, in __setitem__

  File "bsddb/dbutils.py", line 62, in DeadlockWrap
  File "/home/ers/Projects/PyMOTW-es/anydbm/__init__.py", line 229, in wrapF

TypeError: Integer keys only allowed for Recno and Queue DB's

Los valores tienen que ser cadenas o None.

import anydbm

db = anydbm.open('/tmp/ejemplo.db', 'w')
try:
    db['uno'] = 1
finally:
    db.close()

Un TypeError similar es lanzado si el valor no es una cadena.

$ python anydbm_intvalue.py
Traceback (most recent call last):
  File "anydbm_intvalue.py", line 16, in <module>
    db['uno'] = 1
  File "/home/ers/Projects/PyMOTW-es/anydbm/__init__.py", line 230, in __setitem__

  File "bsddb/dbutils.py", line 62, in DeadlockWrap
  File "/home/ers/Projects/PyMOTW-es/anydbm/__init__.py", line 229, in wrapF

TypeError: Data values must be of type string or None.

Referencias

PyMOTW Home
Descarga los ejemplos
Documentación biblioteca estándar: anydbm

PyMOTW: exceptions

Sun, 21 Sep 2008 23:06:19 -0400

Traducción de PyMOTW: exceptions, el módulo exceptions de la columna semanal de Doug Hellmann.

Módulo	exceptions
Propósito	El módulo exceptions define los errores incorporados que se usan en la biblioteca estándar y por el intérprete.
Versión de Python	1.5 y posterior

Descripción

En el pasado, Python ha soportado cadenas simples de mensajes como excepciones así como clases. Desde la versión 1.5, todos los módulos de la biblioteca estándar usan clases para excepciones. A partir de Python 2.5, excepciones de cadenas resultan en una advertencia DeprecationWarning, y el soporte para excepciones de cadenas va a ser retirado en el futuro.

Clases base

Las clases de excepciones están definidas en una jerarquía, que está descrita en la documentación de la biblioteca estándar. Adicionalmente a los beneficios obvios de organización, la herencia de excepciones es útil porque excepciones relacionadas pueden ser atrapadas atrapando su clase base. En la mayoría de los casos, estas clases base no están destinadas a ser lanzadas directamente.

BaseException

Clase base para todas las excepciones. Implementa la lógica para crear una cadena que represente la excepciones usando str() con los argumentos que se pasan al constructor.

Exception

Clase base para excepciones que no resultan en la terminación de la aplicación que se está ejecutando. Todas las excepciones definidas por el usuario deberían usar Exception como clase base.

StandardError

Clase base para excepciones incorporadas usadas en la biblioteca estándar.

ArithmeticError

Clase base para errores matemáticos.

LookupError

Clase base para errores que son lanzados cuando algo no puede ser encontrado.

EnvironmentError

Clase base para errores que vienen de fuera de Python (el sistema operativo, el sistema de archivos, etc.).

Excepciones lanzadas

AssertionError

Un AssertionError es lanzado por una instrucción assert fallida.

assert False, 'La afirmación ha fallado'

$ python exceptions_AssertionError_assert.py
Traceback (most recent call last):
  File "exceptions_AssertionError_assert.py", line 12, in <module>
    assert False, 'La afirmación ha fallado'
AssertionError: La afirmación ha fallado

También es usado en el módulo unittest en métodos como failIf().

import unittest

class AssertionExample(unittest.TestCase):

    def test(self):
        self.failUnless(False)

unittest.main()

$ python exceptions_AssertionError_unittest.py
F
======================================================================
FAIL: test (__main__.AssertionExample)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "exceptions_AssertionError_unittest.py", line 17, in test
    self.failUnless(False)
AssertionError

----------------------------------------------------------------------
Ran 1 test in 0.000s

FAILED (failures=1)

AttributeError

Cuando una referencia o una asignación a un atributo fallan, AttributeError es lanzado.

Por ejemplo, cuando se trata de referencias a una atributo que no existe:

class NoAttributes(object):
    pass

o = NoAttributes()
print o.attribute

$ python exceptions_AttributeError.py
Traceback (most recent call last):
  File "exceptions_AttributeError.py", line 16, in <module>
    print o.attribute
AttributeError: 'NoAttributes' object has no attribute 'attribute'

O cuando se trata de modificar un atributo sólo de lectura.

class MyClass(object):

    @property
    def attribute(self):
        return 'Este es el valor de attribute'

o = MyClass()
print o.attribute
o.attribute = 'Nuevo valor'

$ python exceptions_AttributeError_assignment.py
Este es el valor de attribute
Traceback (most recent call last):
  File "exceptions_AttributeError_assignment.py", line 20, in <module>
    o.attribute = 'Nuevo valor'
AttributeError: can't set attribute

EOFError

Un EOFError es lanzado cuando una función incorporada como input() o raw_input() no lee ningún dato antes de encontrar en final de su flujo de entrada. Los métodos de archivo como read() devuelven una cadena vacía al final del archivo.

while True:
    data = raw_input('prompt:')
    print 'LEIDO:', data

$ echo hello | python exceptions/exceptions_EOFError.py
prompt:LEIDO: hello
prompt:Traceback (most recent call last):
  File "exceptions_EOFError.py", line 13, in <module>
    data = raw_input('prompt:')
EOFError: EOF when reading a line

FloatingPointError

Es lanzada por operaciones con números de coma flotante que resultan en errores, cuando el control de excepción de coma flotante (fpectl, floating point exception control) está activado. Activar fpectl requiere de un intérprete compilado con --with-fpectl. El uso de fpectl no se recomienda en la documentación de la biblioteca estándar http://docs.python.org/lib/module-fpectl.html.

import math
import fpectl

print 'Control desactivado:', math.exp(1000)
fpectl.turnon_sigfpe()
print 'Control activado:', math.exp(1000)

GeneratorExit

Es lanzada dentro de un generador si el método close() del generador es invocado.

def my_generator():
    try:
        for i in range(5):
            print 'Rindiendo', i
            yield i
    except GeneratorExit:
        print 'Saliendo anticipadamente'

g = my_generator()
print g.next()
g.close()

$ python exceptions_GeneratorExit.py
Rindiendo 0
0
Saliendo anticipadamente

IOError

Es lanzada cuando la entrada o salida fallan, por ejemplo si un disco se llena o un archivo de entrada no existe.

f = open('/no/existe', 'r')

$ python exceptions_IOError.py
Traceback (most recent call last):
  File "exceptions_IOError.py", line 12, in <module>
    f = open('/no/existe', 'r')
IOError: [Errno 2] No such file or directory: '/no/existe'

ImportError

Es lanzada cuando un módulo, o un miembro de un módulo no puede ser importado. Hay algunas condiciones en las que ImportError puede ser lanzada.

Si un módulo no existe.

import module_no_existe

$ python exceptions_ImportError_nomodule.py Traceback (most recent call last): File "exceptions_ImportError_nomodule.py", line 12, in import module_no_existe ImportError: No module named module_no_existe
Si from X import Y es usado y Y no puede ser encontrado dentro del módulo X, un ImportError es lanzado.

from exceptions import NombreInventado

$ python exceptions_ImportError_missingname.py Traceback (most recent call last): File "exceptions_ImportError_missingname.py", line 12, in from exceptions import NombreInventado ImportError: cannot import name NombreInventado

IndexError

Un IndexError es lanzado cuando una referencias en una secuencia está fuera de rango.

my_seq = [ 0, 1, 2 ]
print my_seq[3]

$ python exceptions_IndexError.py
Traceback (most recent call last):
  File "exceptions_IndexError.py", line 13, in <module>
    print my_seq[3]
IndexError: list index out of range

KeyError

De manera similar, un KeyError es lanzado cuando un valor no es encontrado como llave de un diccionario.

d = { 'a':1, 'b':2 }
print d['c']

$ python exceptions_KeyError.py
Traceback (most recent call last):
  File "exceptions_KeyError.py", line 13, in <module>
    print d['c']
KeyError: 'c'

KeyboardInterrupt

Un KeyboardInterrupt ocurre cuando el usuario presiona Control-C (o Delete) para detener un programa en ejecución. A diferencias de la mayoría de las excepciones, KeyboardInterrupt se deriva directamente de BaseException para evitar ser atrapada por gestores de excepción globales que atrapan Exception.

try:
    print 'Presiona Return o Control-C:',
    ignored = raw_input()
except Exception, err:
    print 'Excepción atrapada:', err
except KeyboardInterrupt, err:
    print 'Excepción KeyboardInterrupt'
else:
    print 'Ninguna excepción'

Presionando Control-C en la consola ocasiona una excepción KeyboardInterrupt.

$ python exceptions_KeyboardInterrupt.py
Presiona Return o Control-C: Excepción KeyboardInterrupt

MemoryError

Si tu programa se queda sin memoria y es posible recuperarse (eliminando algunos objetos, por ejemplo), un MemoryError es lanzado.

import itertools

# Intenta crear un MemoryError asignando un montón de memoria
l = []
for i in range(3):
    try:
        for j in itertools.count(1):
            print i, j
            l.append('*' * (2**30))
    except MemoryError:
        print '(error, descartando la lista existente)'
        l = []

$ python exceptions_MemoryError.py
0 1
0 2
(error, descartando la lista existente)
1 1
1 2
(error, descartando la lista existente)
2 1
2 2
(error, descartando la lista existente)

NameError

NameErrors son lanzados cuando tu código hace referencia a un nombre que no existe en el ámbito (scope) actual. Por ejemplo, el nombre de una variable.

def func():
    print nombre_desconocido

func()

$ python exceptions_NameError.py
Traceback (most recent call last):
  File "exceptions_NameError.py", line 15, in <module>
    func()
  File "exceptions_NameError.py", line 13, in func
    print nombre_desconocido
NameError: global name 'nombre_desconocido' is not defined

NotImplementedError

Clases base definidas por el usuario pueden lanzar NotImplementedError para indicar que un método o comportamiento tiene que ser definido por una sub clase, simulado así una interfaz.

class BaseClass(object):
    """Define la interfaz"""
    def __init__(self):
        super(BaseClass, self).__init__()
    def do_something(self):
        """La interfaz, sin implementar"""
        raise NotImplementedError(self.__class__.__name__ + '.do_something')

class SubClass(BaseClass):
    """Implementa la interfaz"""
    def do_something(self):
        """hace algo de verdad"""
        print self.__class__.__name__ + ' doing something!'

SubClass().do_something()
BaseClass().do_something()

$ python exceptions_NotImplementedError.py
SubClass haciendo algo!
Traceback (most recent call last):
  File "exceptions_NotImplementedError.py", line 27, in <module>
    BaseClass().do_something()
  File "exceptions_NotImplementedError.py", line 18, in do_something
    raise NotImplementedError(self.__class__.__name__ + '.do_something')
NotImplementedError: BaseClass.do_something

OSError

OSError sirve como la clase de error para el módulo os, y es lanzado cuando un error surge de una función específica del sistema operativo.

import os

for i in range(10):
    print i, os.ttyname(i)

$ python exceptions_OSError.py
0 /dev/pts/0
1 /dev/pts/0
2 /dev/pts/0
3
Traceback (most recent call last):
  File "exceptions_OSError.py", line 15, in <module>
    print i, os.ttyname(i)
OSError: [Errno 9] Bad file descriptor

OverflowError

Cuando una operación aritmética supera los límites del tipo de variable, un OverflowError es lanzado. Número enteros grandes asignan más espacio a medida que los valores crece, entonces terminan lanzando MemoryError. La gestión de excepciones de números de coma flotante no está estandarizada, entonces los números de coma flotante no se comprueban. Número enteros normales son convertidos a valores long según sea necesario.

import sys

print 'Número entereo normal: (maxint=%s)' % sys.maxint
try:
    i = sys.maxint * 3
    print 'Sin rebalse para ', type(i), 'i =', i
except OverflowError, err:
    print 'Rebalse en ', i, err

print
print 'Número entero largo:'
for i in range(0, 100, 10):
    print '%2d' % i, 2L ** i

print
print 'Valores de coma flotante:'
try:
    f = 2.0**i
    for i in range(100):
        print i, f
        f = f ** 2
except OverflowError, err:
    print 'Rebalse luego de ', f, err

$ python exceptions_OverflowError.py
Número entereo normal: (maxint=2147483647)
Sin rebalse para  <type 'long'> i = 6442450941

Número entero largo:
 0 1
10 1024
20 1048576
30 1073741824
40 1099511627776
50 1125899906842624
60 1152921504606846976
70 1180591620717411303424
80 1208925819614629174706176
90 1237940039285380274899124224

Valores de coma flotante:
0 1.23794003929e+27
1 1.53249554087e+54
2 2.34854258277e+108
3 5.5156522631e+216
Rebalse luego de  5.5156522631e+216 (34, 'Numerical result out of range')

ReferenceError

Cuando un proxy weakref es usado para acceder a un objeto que ya ha sido recolectado (garbage collected), un ReferenceError ocurre.

import gc
import weakref

class ExpensiveObject(object):
    def __init__(self, name):
        self.name = name
    def __del__(self):
        print '(Borrando %s)' % self

obj = ExpensiveObject('obj')
p = weakref.proxy(obj)

print 'ANTES:', p.name
obj = None
print 'DESPUÉS:', p.name

$ python exceptions_ReferenceError.py
ANTES: obj
(Borrando <__main__.ExpensiveObject object at 0xb7d1d64c>)
DESPUÉS:
Traceback (most recent call last):
  File "exceptions_ReferenceError.py", line 26, in <module>
    print 'DESPUÉS:', p.name
ReferenceError: weakly-referenced object no longer exists

RuntimeError

Una excepción RuntimeError es usada cuando ninguna otra excepción más específica es aplicable. El intérprete no lanza esta excepción con mucha frecuencia, pero código de usuario lo hace.

StopIteration

Cuando un iterador ha terminado, su método next() lanza StopIteration. Esta excepción no es considerada un error.

l=[0,1,2]
i=iter(l)

print i
print i.next()
print i.next()
print i.next()
print i.next()

$ python exceptions_StopIteration.py
<listiterator object at 0xb7d6fb2c>
0
1
2
Traceback (most recent call last):
  File "exceptions_StopIteration.py", line 19, in <module>
    print i.next()
StopIteration

SyntaxError

Un SyntaxError ocurre cada vez que el analizador (parser) encuentra código fuente que no entiende. Esto puede ser al importar un módulo, invocando exec, o invocando eval(). Los atributos de la excepción pueden ser usados para encontrar exactamente qué parte del texto de entrada ocasionó la excepción.

try:
    print eval('cinco por tres')
except SyntaxError, err:
    print 'Error de sintaxis %s (%s-%s): %s' % \
        (err.filename, err.lineno, err.offset, err.text)
    print err

$ python exceptions_SyntaxError.py
Error de sintáxis <string> (1-9): cinco por tres
invalid syntax (<string>, line 1)

SystemError

Cuando un error ocurre en el intérprete mismo y hay alguna oportunidad de continuar la ejecución con éxito, lanza un SystemError. SystemErrors probablemente indican una falla (bug) en el intérprete y deberían ser reportados al mantenedor.

SystemExit

Cuando sys.exit() es invocada, lanza SystemExit en lugar de salir inmediatamente. Esto permite ejecutar código de limpieza en bloques try:finally y a los que invocan el código (como depuradores y frameworks de prueba) capturar las excepciones y evitan salir.

TypeError

TypeErrors son ocasionados al combinar tipos equivocados de objetos o invocando una función con el tipo de objeto equivocado.

result = ('tupla',) + 'cadena'

$ python exceptions_TypeError.py
Traceback (most recent call last):
  File "exceptions_TypeError.py", line 12, in <module>
    result = ('tupla',) + 'cadena'
TypeError: can only concatenate tuple (not "str") to tuple

UnboundLocalError

Un UnboundLocalError es un tipo de NameError específico para nombres de variables locales.

def throws_global_name_error():
    print unknown_global_name

def throws_unbound_local():
    local_val = local_val + 1
    print local_val

try:
    throws_global_name_error()
except NameError, err:
    print 'Error de nombre global:', err

try:
    throws_unbound_local()
except UnboundLocalError, err:
    print 'Error de nombre local:', err

La diferencia entre el NameError global y el UnboundLocalError es la manera en que el nombre es usado. Ya que el nombre "local_val" aparece en el lado izquierdo de una expresión, es interpretada como un nombre de variable local.

$ python exceptions_UnboundLocalError.py
Error de nombre global: global name 'unknown_global_name' is not defined
Error de nombre local: local variable 'local_val' referenced before assignment

UnicodeError

UnicodeError es una sub clase de ValueError y es lanzado cuando surge un problema con Unicode. Hay clases sub clases separadas para UnicodeEncodeError, UnicodeDecodeError, y UnicodeTranslateError.

ValueError

Un ValueError es usado cuando una función recibe un valor que tiene el tipo correcto pero un valor inválido.

print chr(1024)

$ python exceptions_ValueError.py
Traceback (most recent call last):
  File "exceptions_ValueError.py", line 12, in <module>
    print chr(1024)
ValueError: chr() arg not in range(256)

ZeroDivisionError

Cuando cero aparece en el denominador de una operación de división, un ZeroDivisionError es lanzado.

print 1/0

$ python exceptions_ZeroDivisionError.py
Traceback (most recent call last):
  File "exceptions_ZeroDivisionError.py", line 12, in <module>
    print 1/0
ZeroDivisionError: integer division or modulo by zero

Categorías de Warning

También hay varias excepciones definidas para ser usadas con el módulo warnings.

Warning: La clase base para todas las advertencias (*warnings*).
UserWarning: Clase base para advertencias que surgen en código del usuario.
DeprecationWarning: Usada para características que ya no están siendo mantenidas.
PendingDeprecationWarning: Usada para características que van a ser obsoletas pronto.
SyntaxWarning: Usada para sintáxis dudosa.
RuntimeWarning: Usada para para eventos que suceden en la ejecución que pueden causar problemas.
FutureWarning: Advertencia sobre cambios al lenguaje o la biblioteca en el futuro.
ImportWarning: Advertencia sobre problemas al importar un módulo.
UnicodeWarning: Advertencia sobre problemas con texto unicode.

Referencias

Documentación biblioteca estándar: exceptions

PyMOTW: profile, cProfile, pstats

Wed, 03 Sep 2008 21:52:50 -0400

Traducción de PyMOTW: profile, cProfile, pstats los módulos profile y cProfilede la columna semanal de Doug Hellmann.

Los módulos profile y cProfile proporcionan interfaces de programación para coleccionar y analizar estadísticas sobre cómo código Python consume recursos de procesamiento.

Módulo:	profile
Propósito:	Análisis de de rendimiento de programas en Python
Versiones de Python:	1.4 y posterior, estos ejemplos son para Python 2.5

run():

El punto más básico de inicio en el módulo profile es run(). Acepta una cadena como argumento, y crea un reporte del tiempo empleado ejecutando diversas líneas de código mientras ejecuta la instrucción.

import profile

def fib(n):
    # de http://en.literateprograms.org/Fibonacci_numbers_(Python)
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib(n-1) + fib(n-2)

def fib_seq(n):
    seq = [ ]
    if n > 0:
        seq.extend(fib_seq(n-1))
    seq.append(fib(n))
    return seq

print 'RUDIMENTARIO'
print '=' * 80
profile.run('print fib_seq(20); print')

Esta versión recursiva de un calculador de una secuencia Fibonacci es especialmente útil para demostrar el módulo profile porque podemos tanto mejorar el rendimiento. El formato estándar del reporte muestra un sumario y detalles de cada función ejecutada.

$ python profile_fibonacci_raw.py
RUDIMENTARIO
================================================================================
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]

         57356 function calls (66 primitive calls) in 0.584 CPU seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
       21    0.000    0.000    0.000    0.000 :0(append)
       20    0.000    0.000    0.000    0.000 :0(extend)
        1    0.000    0.000    0.000    0.000 :0(setprofile)
        1    0.000    0.000    0.580    0.580 <string>:1(<module>)
        1    0.004    0.004    0.584    0.584 profile:0(print fib_seq(20); print)
        0    0.000             0.000          profile:0(profiler)
 57291/21    0.580    0.000    0.580    0.028 profile_fibonacci_raw.py:13(fib)
     21/1    0.000    0.000    0.580    0.580 profile_fibonacci_raw.py:22(fib_seq)

Como puedes ver, la ejecución requiere de 57356 invocaciones de función y toma 1/2 segundo. Ya que hay tan solo 66 invocaciones primitivas, sabemos que la gran mayoría de las 57 mil invocaciones fueron recursivas. Los detalles sobre donde se pasó el tiempo están separados por función en el listado que muestra el numero de invocaciones, el tiempo total transcurrido en la función, el tiempo por invocación (tottime/ncalls), tiempo acumulado transcurrido en una función y la relación de tiempo acumulado a invocaciones primitivas.

No es sorprendente que la mayoría del tiempo aquí transcurre invocando fib() en repetidas ocasiones. Podemos añadir un decorador memoize para reducir el número de invocaciones recursivas y obtener un impacto importante en el rendimiento de esta función.

import profile

class memoize:
    # de http://avinashv.net/2008/04/python-decorators-syntactic-sugar/
    def __init__(self, function):
        self.function = function
        self.memoized = {}

    def __call__(self, *args):
        try:
            return self.memoized[args]
        except KeyError:
            self.memoized[args] = self.function(*args)
            return self.memoized[args]

@memoize
def fib(n):
    # de http://en.literateprograms.org/Fibonacci_numbers_(Python)
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib(n-1) + fib(n-2)

def fib_seq(n):
    seq = [ ]
    if n > 0:
        seq.extend(fib_seq(n-1))
    seq.append(fib(n))
    return seq

if __name__ == '__main__':
    print 'MEMOIZADO'
    print '=' * 80
    profile.run('print fib_seq(20); print')

Recordando el valor de (la serie) Fibonacci podemos evitar la mayoría de la recursión y reducir a 145 las invocaciones que tan sólo toman 0.008 segundos. También nota que el contador ncalls para fib() muestra que nunca entra en recursión.

$ python profile_fibonacci_memoized.py
MEMOIZADO
================================================================================
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]

         145 function calls (87 primitive calls) in 0.008 CPU seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
       21    0.000    0.000    0.000    0.000 :0(append)
       20    0.000    0.000    0.000    0.000 :0(extend)
        1    0.004    0.004    0.004    0.004 :0(setprofile)
        1    0.000    0.000    0.004    0.004 <string>:1(<module>)
        1    0.000    0.000    0.008    0.008 profile:0(print fib_seq(20); print)
        0    0.000             0.000          profile:0(profiler)
    59/21    0.000    0.000    0.000    0.000 profile_fibonacci_memoized.py:19(__call__)
       21    0.000    0.000    0.000    0.000 profile_fibonacci_memoized.py:26(fib)
     21/1    0.004    0.000    0.004    0.004 profile_fibonacci_memoized.py:36(fib_seq)

runctx():

Obviamente, no siempre es fácil construir la expresión para pasar a run(). Algunas veces es más fácil construir una expresión simple y ejecutarla en un contexto con (variables) globales y locales, usando runctx().

import profile
from profile_fibonacci_memoized import fib, fib_seq

if __name__ == '__main__':
    profile.runctx('print fib_seq(n); print', globals(), {'n':20})

En este ejemplo, el valor de "n" es pasado mediante el contexto de variables locales en lugar de estar embebido directamente en la instrucción que se pasa a runctx().

$ python profile_runctx.py
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]

         145 function calls (87 primitive calls) in 0.004 CPU seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
       21    0.000    0.000    0.000    0.000 :0(append)
       20    0.000    0.000    0.000    0.000 :0(extend)
        1    0.000    0.000    0.000    0.000 :0(setprofile)
        1    0.000    0.000    0.004    0.004 <string>:1(<module>)
        1    0.000    0.000    0.004    0.004 profile:0(print fib_seq(n); print)
        0    0.000             0.000          profile:0(profiler)
    59/21    0.000    0.000    0.004    0.000 profile_fibonacci_memoized.py:19(__call__)
       21    0.004    0.000    0.004    0.000 profile_fibonacci_memoized.py:26(fib)
     21/1    0.000    0.000    0.004    0.004 profile_fibonacci_memoized.py:36(fib_seq)

`pstats`: Guardando y trabajando con estadíticas:

Si el reporte estándar no está formateado de la manera que lo necesitas, ambos run() y runctx() aceptan un nombre de archivo como argumento para guardar los datos en un archivo en lugar de mostrar el reporte. La clase Stats del módulo pstats sabe cómo leer el archivo y puede ser usada para manipular los datos.

Por ejemplo, para ejecutar varias veces el mismo test y combinar los resultados, puede hacer algo como esto:

import profile
import pstats
from profile_fibonacci_memoized import fib, fib_seq

# Crea 5 conjuntos de estadística
filenames = []
for i in range(5):
    filename = 'profile_stats_%d.stats' % i
    profile.run('print %d, fib_seq(20)' % i, filename)

# Lee los 5 archivos con estadísticas en un solo objeto 
stats = pstats.Stats('profile_stats_0.stats')
for i in range(1, 5):
    stats.add('profile_stats_%d.stats' % i)

# Limpia nombres de archivos para el reporte
stats.strip_dirs()

# Ordena las estadísticas por el tiempo acumulado en la función
stats.sort_stats('cumulative')

stats.print_stats()

El reporte resultante está ordenado en orden descendiente de tiempo acumulado transcurrido en la función y los nombres de directorios son eliminados de los archivos mostrados para ahorra espacio horizontal.

$ python profile_stats.py
0 [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
1 [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
2 [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
3 [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
4 [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
Wed Sep  3 21:22:27 2008    profile_stats_0.stats
Wed Sep  3 21:22:27 2008    profile_stats_1.stats
Wed Sep  3 21:22:27 2008    profile_stats_2.stats
Wed Sep  3 21:22:27 2008    profile_stats_3.stats
Wed Sep  3 21:22:27 2008    profile_stats_4.stats

         489 function calls (351 primitive calls) in 0.032 CPU seconds

   Ordered by: cumulative time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        5    0.004    0.001    0.024    0.005 <string>:1(<module>)
    105/5    0.012    0.000    0.020    0.004 profile_fibonacci_memoized.py:36(fib_seq)
        1    0.000    0.000    0.012    0.012 profile:0(print 0, fib_seq(20))
  143/105    0.004    0.000    0.008    0.000 profile_fibonacci_memoized.py:19(__call__)
        1    0.004    0.004    0.008    0.008 profile:0(print 3, fib_seq(20))
        1    0.004    0.004    0.008    0.008 profile:0(print 1, fib_seq(20))
       21    0.004    0.000    0.004    0.000 profile_fibonacci_memoized.py:26(fib)
        1    0.000    0.000    0.004    0.004 profile:0(print 4, fib_seq(20))
      105    0.000    0.000    0.000    0.000 :0(append)
        5    0.000    0.000    0.000    0.000 :0(setprofile)
      100    0.000    0.000    0.000    0.000 :0(extend)
        1    0.000    0.000    0.000    0.000 profile:0(print 2, fib_seq(20))
        0    0.000             0.000          profile:0(profiler)

Limitando el contenido del reporte:

Ya que estamos estudiando el rendimiento de fib() y fib_seq(), podemos también restringir la salida del reporte para incluir estas funciones usando una expresión regular que coincida con los valores de archivo:línea(función) que queremos.

import profile
import pstats
from profile_fibonacci_memoized import fib, fib_seq

# Lee los 5 archivos con estadísticas en un solo objeto
stats = pstats.Stats('profile_stats_0.stats')
for i in range(1, 5):
    stats.add('profile_stats_%d.stats' % i)
stats.strip_dirs()
stats.sort_stats('cumulative')

# Limita el resulato a líneas con "(fib"
stats.print_stats('\(fib')

La expresión regular incluye un paréntesis izquierdo literal (() para coincidir con la parte del nombre de la función del valor location.

$ python profile_stats_restricted.py
Wed Sep  3 21:22:27 2008    profile_stats_0.stats
Wed Sep  3 21:22:27 2008    profile_stats_1.stats
Wed Sep  3 21:22:27 2008    profile_stats_2.stats
Wed Sep  3 21:22:27 2008    profile_stats_3.stats
Wed Sep  3 21:22:27 2008    profile_stats_4.stats

         489 function calls (351 primitive calls) in 0.032 CPU seconds

   Ordered by: cumulative time
   List reduced from 13 to 2 due to restriction <'\\(fib'>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
    105/5    0.012    0.000    0.020    0.004 profile_fibonacci_memoized.py:36(fib_seq)
       21    0.004    0.000    0.004    0.000 profile_fibonacci_memoized.py:26(fib)

Grafos de funciones invocadas e invocadoras (caller/callee):

Stats también incluye métodos para mostrar las funciones invocadas y quienes las invocan.

import profile
import pstats
from profile_fibonacci_memoized import fib, fib_seq

# Lee los 5 archivos con estadísticas en un solo objeto
stats = pstats.Stats('profile_stats_0.stats')
for i in range(1, 5):
    stats.add('profile_stats_%d.stats' % i)
stats.strip_dirs()
stats.sort_stats('cumulative')

print 'INVOCACIONES ENTRANTES:'
stats.print_callers('\(fib')

print 'INVOCACIONES SALIENTES:'
stats.print_callees('\(fib')

Los argumentos de print_callers() y print_callees() funciona de la misma manera que los argumentos de restricción de print_stats(). El resultado muestra en invocador (caller), el invocado (callee) y el tiempo acumulado.

$ python profile_stats_callers.py
INVOCACIONES ENTRANTES:
   Ordered by: cumulative time
   List reduced from 13 to 2 due to restriction <'\\(fib'>

Function                                   was called by...
profile_fibonacci_memoized.py:36(fib_seq)  <- <string>:1(<module>)(5)    0.024
                                              profile_fibonacci_memoized.py:36(fib_seq)(100)    0.020
profile_fibonacci_memoized.py:26(fib)      <- profile_fibonacci_memoized.py:19(__call__)(21)    0.008


INVOCACIONES SALIENTES:
   Ordered by: cumulative time
   List reduced from 13 to 2 due to restriction <'\\(fib'>

Function                                   called...
profile_fibonacci_memoized.py:36(fib_seq)  -> :0(append)(105)    0.000
                                              :0(extend)(100)    0.000
                                              profile_fibonacci_memoized.py:19(__call__)(105)    0.008
                                              profile_fibonacci_memoized.py:36(fib_seq)(100)    0.020
profile_fibonacci_memoized.py:26(fib)      -> profile_fibonacci_memoized.py:19(__call__)(38)    0.008

Referencias:

Python Module of the Week Home
Descarga el código
profile y cProfile
pstats

La implementación del ejemplo Fibonacci es de Fibonacci numbers (Python) - LiteratePrograms).

El decorador memoize es de Python Decorators: Syntactic Sugar | avinash.vora.

PyMOTW: signal

Tue, 19 Aug 2008 13:01:15 -0400

Traducción de PyMOTW: signal el módulo signal de la columna semanal de Doug Hellmann.

Recibe notificaciones de eventos asíncronos del sistema con el módulo signal.

Módulo:	signal
Propósito:	Manejar eventos asíncronos.
Versión de Python:	1.4 y posterior

Descripción:

Programar con manipuladores de señales Unix es un esfuerzo nada trivial. Ésta es una introducción y no incluye todos los detalles que puedes necesitar para usar exitosamente señales en cualquier plataforma. Hay una cierta estandarización en las versiones de Unix, pero también hay también algunas diferencias, así que consulta la documentación de tu sistema operativo si tienes problemas.

Señales son medios para notificar a tu programa de un evento, y manipularlo asíncronamente. Pueden ser generadas por el mismo sistema, o enviadas desde un proceso a otro, es posible que algunas operaciones (especialmente de entrada/salida, I/O) puedan producir errores si reciben una señal en el medio (de su ejecución).

Las señales están identificadas por número enteros y son definidas en los encabezados C del sistema operativo. Python define las señales apropiadas para la plataforma como símbolos en el módulo signal. En los ejemplos a continuación, voy a usar SIGINT y SIGUSR1. Ambas están normalmente definidas para todos lo sistemas Unix y similares a Unix.

Recibiendo señales:

Como con otras formas de programación basada en eventos, las señales se reciben estableciendo una función de retorno (callback), invocada por el manipulador de la señal, que es invocada cuando la señal ocurre. Los argumentos para tu manipulador de señal son el número de la señal y el marco de la pila (stack frame) del punto en tu programa que fue interrumpido por la señal.

import signal
import os
import time

def receive_signal(signum, stack):
    print 'Recibida', signum

signal.signal(signal.SIGUSR1, receive_signal)
signal.signal(signal.SIGUSR2, receive_signal)

print 'Mi PID es:', os.getpid()

while True:
    print 'Esperando...'
    time.sleep(3)

Este ejemplo relativamente simple repite el bucle indefinidamente, pausando por unos cuantos segundos cada vez. Cuando una señal llega, la invocación de sleep es interrumpida y el manipulador de la señal receive_signal() muestra el número de la señal. Cuando el manipulador de la señal retorna, el bucle continua.

Para enviar señales a programas en ejecución, yo uso el programa de línea de comandos kill. Para producir el resultado a continuación, ejecuto signal_signal.py en una ventana, luego kill -USR1 7810, kill -USR2 7810 y kill -INT 7810 en otra.

$ python signal_signal.py 
Mi PID es: 7810
Esperando...
Esperando...
Recibida 10
Esperando...
Esperando...
Recibida 12
Esperando...
Esperando...
Traceback (most recent call last):
  File "signal_signal.py", line 25, in <module>
    time.sleep(3)
KeyboardInterrupt

`getsignal()`:

Para ver qué manipulador están registrados para una señal, usa getsignal(). Pasa el número de la señal como argumento. El valor de retorno es el manipulador registrado, o uno de los valores especiales signa.SIG_IGN (si la señal está siendo ignorada), signal.SIG_DFL (si el comportamiento por defecto es usado), o None (si el manipulador existente de la señal fue registrado desde C, en lugar de Python).

import signal

def alarm_received(n, stack):
    return

signal.signal(signal.SIGALRM, alarm_received)

signals_to_names = {}
for n in dir(signal):
    if n.startswith('SIG') and not n.startswith('SIG_'):
        signals_to_names[getattr(signal, n)] = n

for s, name in sorted(signals_to_names.items()):
    handler = signal.getsignal(s)
    if handler is signal.SIG_DFL:
        handler = 'SIG_DFL'
    elif handler is signal.SIG_IGN:
        handler = 'SIG_IGN'
    print '%-10s (%2d):' % (name, s), handler

Una vez más, ya que cada sistema operativo define distintas señales, el resultado que ves ejecutando ésto en otros sistemas puede variar. Ésto es Linux:

$ python signal_getsignal.py
SIGHUP     ( 1): SIG_DFL
SIGINT     ( 2): <built-in function default_int_handler>
SIGQUIT    ( 3): SIG_DFL
SIGILL     ( 4): SIG_DFL
SIGTRAP    ( 5): SIG_DFL
SIGIOT     ( 6): SIG_DFL
SIGBUS     ( 7): SIG_DFL
SIGFPE     ( 8): SIG_DFL
SIGKILL    ( 9): SIG_DFL
SIGUSR1    (10): SIG_DFL
SIGSEGV    (11): SIG_DFL
SIGUSR2    (12): SIG_DFL
SIGPIPE    (13): SIG_IGN
SIGALRM    (14): <function alarm_received at 0xb7dd2fb4>
SIGTERM    (15): SIG_DFL
SIGCLD     (17): SIG_DFL
SIGCONT    (18): SIG_DFL
SIGSTOP    (19): SIG_DFL
SIGTSTP    (20): SIG_DFL
SIGTTIN    (21): SIG_DFL
SIGTTOU    (22): SIG_DFL
SIGURG     (23): SIG_DFL
SIGXCPU    (24): SIG_DFL
SIGXFSZ    (25): SIG_IGN
SIGVTALRM  (26): SIG_DFL
SIGPROF    (27): SIG_DFL
SIGWINCH   (28): SIG_DFL
SIGPOLL    (29): SIG_DFL
SIGPWR     (30): SIG_DFL
SIGSYS     (31): SIG_DFL
SIGRTMIN   (34): SIG_DFL
SIGRTMAX   (64): SIG_DFL

Enviando señales:

La función para enviar señales es os.kill(). Su uso está descrito en el artículo PyMOTW que describe el módulo os

(La traducción del artículo sobre el módulo os estará disponible pronto.)

Alarmas:

Alarmas son una clase algo especial de señales, donde tu programa le pide al sistema operativo que lo notifique después de que un período de tiempo ha transcurrido. Como la documentación estándar del módulo señala, ésto es útil para evitar bloquearse indefinidamente en una operación de entrada/salida (I/O) u otra operación del sistema operativo.

import signal
import time

def receive_alarm(signum, stack):
    print 'Alarma  :', time.ctime()

# Invoca receive_alarm luego de 2 segundos
signal.signal(signal.SIGALRM, receive_alarm)
signal.alarm(2)

print 'Antes   :', time.ctime()
time.sleep(4)
print 'Después :', time.ctime()

En este ejemplo, la invocación de sleep() no dura los 4 segundos completos.

$ python signal_alarm.py
Antes   : Tue Aug 19 10:53:19 2008
Alarma  : Tue Aug 19 10:53:21 2008
Después : Tue Aug 19 10:53:21 2008

Ignorando Señales:

Para ignorar una señal, registra SIG_IGN como el manipulador. Este script remplaza el manipulador por defecto para SIGINT con SIG_IGN, y registra un manipulador para SIGUSR1. Luego usa signal.pause() para esperar una señal.

import signal
import os
import time

def do_exit(sig, stack):
    raise SystemExit('Saliendo')

signal.signal(signal.SIGINT, signal.SIG_IGN)
signal.signal(signal.SIGUSR1, do_exit)

print 'Mi PID:', os.getpid()

signal.pause()

Normalmente SIGINT (la señal enviada por la línea de comandos a tu programa cuando presionas Control-C) eleva KeyboardInterrupt. En este caso, ignoramos SIGINT y elevamos SystemExit cuando vemos SIGUSR1. Cada ^C representa un intento de usar Control-C para terminar el script desde la terminal. Usando kill -USR1 7820 desde otra terminal ocasiona que el script finalice.

$ python signal_ignore.py 
My PID: 7820
^C^C^CSaliendo

Señales e hilos de ejecución (threads):

Generalmente señales e hilos de ejecución no combinan bien. Sólo el hilo principal de ejecución de un proceso recibe señales, entonces generalmente no es útil usarlas en hilos de ejecución. El siguiente ejemplo de un manipulador de señales espera por una señal en un hilo de ejecución, y envía la señal desde otro.

import signal
import threading
import os
import time

def signal_handler(num, stack):
    print 'Recibe señal %d en %s' % (num, threading.currentThread())

signal.signal(signal.SIGUSR1, signal_handler)

def wait_for_signal():
    print 'Esperando por señal en', threading.currentThread()
    signal.pause()
    print 'Dejando de esperar'

# Inicia un hilo que no recibirá la señal
receiver = threading.Thread(target=wait_for_signal, name='receiver')
receiver.start()
time.sleep(0.1)

def send_signal():
    print 'Enviando señal en', threading.currentThread()
    os.kill(os.getpid(), signal.SIGUSR1)

sender = threading.Thread(target=send_signal, name='sender')
sender.start()
sender.join()

# Espera que el hilo vea la señal (no va a suceder!)
print 'Esperando por', receiver
signal.alarm(2)
receiver.join()

Nota que todos los manipuladores de señal fueron registrados en el hilo principal. Este es un requerimiento de la implementación del módulo signal para Python, sin importar el soporte subyacente de plataforma mezclar hilos de ejecución y señales. Aunque el hilo receptor invoca signal.pause(), no recibe la señal. La invocación signal.alarm(2) cerca al final del ejemplo evita un bloqueo sin fin, ya que el hilo receptor nunca terminará.

$ python signal_threads.py 
Esperando por señal en <Thread(receiver, started)>
Enviando señal en <Thread(sender, started)>
Recibe señal 10 en <_MainThread(MainThread, started)>
Esperando por <Thread(receiver, started)>
Alarm clock

Si bien se puede definir alarmas en hilos de ejecución, también son recibidas por el hilo principal.

import signal
import time
import threading

def signal_handler(num, stack):
    print time.ctime(), 'Alarma en', threading.currentThread()

signal.signal(signal.SIGALRM, signal_handler)

def use_alarm():
    print time.ctime(), 'Ajustando alarma en', threading.currentThread()
    signal.alarm(1)
    print time.ctime(), 'Durmiendo en', threading.currentThread()
    time.sleep(3)
    print time.ctime(), 'Dejando de dormir'

# Inicia un hilo que no recibirá la señal
alarm_thread = threading.Thread(target=use_alarm, name='alarm_thread')
alarm_thread.start()
time.sleep(0.1)

# Espera que el hilo vea la señal (no va a suceder!)
print time.ctime(), 'Esperando por', alarm_thread
alarm_thread.join()

print time.ctime(), 'Saliendo normalmente'

Nota que la alarma no aborta la invocación de sleep() en use_alarm().

$ python signal_threads_alarm.py
Tue Aug 19 11:49:47 2008 Ajustando alarma en <Thread(alarm_thread, started)>
Tue Aug 19 11:49:47 2008 Durmiendo en <Thread(alarm_thread, started)>
Tue Aug 19 11:49:47 2008 Esperando por <Thread(alarm_thread, started)>
Tue Aug 19 11:49:50 2008 Dejando de dormir
Tue Aug 19 11:49:50 2008 Alarma en <_MainThread(MainThread, started)>
Tue Aug 19 11:49:50 2008 Saliendo normalmente

Referencias:

Python Module of the Week Home
Descarga el código

PyMOTW: platform

Tue, 12 Aug 2008 21:56:04 -0400

Traducción de PyMOTW: platform el módulo platform de la columna semanal de Doug Hellmann.

Prueba la arquitectura de una plataforma e infórmate de versiones con el módulo platform.

Módulo:	platform
Proposito:	Acceder a información sobre las versiones del hardware, el sistema operativo y el intérprete.
Versión de Python	2.3 y posterior

Descripción:

A pesar de que Python es usado como un lenguaje multi-plataforma, ocasionalmente es necesario saber qué clase de sistema estás usando. Herramientas de compilación obviamente necesitan esta información, pero también sabrás que algunas librerías o comandos externos tienen distintas interfaces en distintos sistemas operativos. Por ejemplo, si estás escribiendo una herramienta que gestione la configuración de red de un sistema operativo, puedes tener una representación portable de las interfaces de red, aliases, direcciones IP, etc. Peto una vez que estés realmente editando los archivos de configuración, necesitas saber más acerca del sistema anfitrión y cómo está configurado. El módulo platform te da algunas herramientas para aprender acerca del intérprete, el sistema operativo y la plataforma de hardware que está ejecutando tu programa.

Ejemplos:

Los resultados de los ejemplos a continuación han sido generados en una MacBook Pro corriendo OS X 10.5.2, una VAIO corriendo Ubuntu Linux 7.10 y Windows Vista.

(El artículo original de Doug Hellmann muestra los resultados de los ejemplos ejecutados en la MacBook mencionada y una instancia de WMWare corriendo CentOS 4.6.)

Intérprete:

Existen cuatro funciones para obtener información sobre el intérprete actual de Python. python_version() y python_version_tuple() devuelven de forma distinta la versión del intérprete con componentes mayor (major), menor (minor) y parche (patchlevel). python_compiler() reporta el compilador usado para crear el intérprete. Y python_build() da una cadena con la versión de compilación del intérprete.

import platform

print 'Version      :', platform.python_version()
print 'Version tuple:', platform.python_version_tuple()
print 'Compiler     :', platform.python_compiler()
print 'Build        :', platform.python_build()

OS X:

$ python platform_python.py
Version      : 2.5.1
Version tuple: ['2', '5', '1']
Compiler     : GCC 4.0.1 (Apple Computer, Inc. build 5367)
Build        : ('r251:54869', 'Apr 18 2007 22:08:04')

Linux:

$ python platform_python.py 
Version      : 2.5.1
Version tuple: ['2', '5', '1']
Compiler     : GCC 4.1.3 20070929 (prerelease) (Ubuntu 4.1.2-16ubuntu2)
Build        : ('r251:54863', 'Jul 31 2008 23:17:40')

Windows Vista:

> python.exe platform_python.py
Version      : 2.5.2
Version tuple: ['2', '5', '2']
Compiler     : MSC v.1310 32 bit (Intel)
Build        : ('r252:60911', 'Feb 21 2008 13:11:45')

Plataforma:

Un identificador de propósito general está disponible a través de la función platform(). platform() acepta dos argumentos binarios opcionales. Si aliased es True, los nombres en el valor de retorno son convertidos de un nombre formal a su forma más común. Cuando terse es True, la función devuelve un valor mínimo con algunas partes recortadas.

import platform

print 'Normal :', platform.platform()
print 'Aliased:', platform.platform(aliased=True)
print 'Terse  :', platform.platform(terse=True)

OS X:

$ python platform_platform.py
Normal : Darwin-9.2.2-i386-32bit
Aliased: Darwin-9.2.2-i386-32bit
Terse  : Darwin-9.2.2

Linux:

$ python platform_platform.py 
Normal : Linux-2.6.22-15-generic-i686-with-debian-lenny-sid
Aliased: Linux-2.6.22-15-generic-i686-with-debian-lenny-sid
Terse  : Linux-2.6.22-15-generic-i686-with-glibc2.4

Windows Vista:

> python.exe platform_platform.py
Normal : Windows-Vista-6.0.6001
Aliased: Windows-Vista-6.0.6001
Terse  : Windows-Vista

Información sobre el sistema operativo y el hardware:

Información más detallada sobre el sistema operativo y el hardware en el que se está ejecutando el intérprete puede ser obtenida también. uname() devuelve una tupla que contiene valores del sistema (operativo), el nodo, el release, la versión, la máquina y el procesador. Se puede acceder a valores individuales a través de funciones con los mismos nombres:

system() devuelve el nombre del sistema operativo. node() devuelve el nombre del nodo, sin calificación completa. release() devuelve el número de release del sistema operativo. version() devuelve el número versión más detallada del sistema. machine() da un identificador del tipo de hardware como 'i386'. processor() devuelve un identificador real para el procesador, o el mismo valor que machine() en muchos casos.

import platform

print 'uname:', platform.uname()

print
print 'system   :', platform.system()
print 'node     :', platform.node()
print 'release  :', platform.release()
print 'version  :', platform.version()
print 'machine  :', platform.machine()
print 'processor:', platform.processor()

OS X:

$ python platform_os_info.py
uname: ('Darwin', 'farnsworth.local', '9.2.2', 'Darwin Kernel Version 9.2.2: Tue Mar  4 21:17:34 PST 2008; root:xnu-1228.4.31~1/RELEASE_I386', 'i386', 'i386')

system   : Darwin
node     : farnsworth.local
release  : 9.2.2
version  : Darwin Kernel Version 9.2.2: Tue Mar  4 21:17:34 PST 2008; root:xnu-1228.4.31~1/RELEASE_I386
machine  : i386
processor: i386

Linux:

$ python platform_os_info.py 
uname: ('Linux', 'notizbuch', '2.6.22-15-generic', '#1 SMP Fri Jul 11 19:25:33 UTC 2008', 'i686', '')

system   : Linux
node     : notizbuch
release  : 2.6.22-15-generic
version  : #1 SMP Fri Jul 11 19:25:33 UTC 2008
machine  : i686
processor:

Windows Vista:

> python.exe platform_os_info.py
uname: ('Windows', 'Klapprechner', 'Vista', '6.0.6001', '', '')

system   : Windows
node     : Klapprechner
release  : Vista
version  : 6.0.6001
machine  :
processor:

Arquitectura ejecutable:

Información individual sobre la arquitectura de un programa se puede obtener usando la función architecture(). El primer argumento el la ruta de un programa ejecutable (por defecto es sys.executable, el intérprete de Python). El valor de retorno es una tupla que contiene la arquitectura de bits y el formato de linkage usado.

import platform

print 'interpreter:', platform.architecture()
print '/bin/ls    :', platform.architecture('/bin/ls')

OS X:

$ python platform_architecture.py
interpreter: ('32bit', '')
/bin/ls    : ('32bit', '')

Linux:

$ python platform_architecture.py 
interpreter: ('32bit', '')
/bin/ls    : ('32bit', 'ELF')

Windows Vista:

> python.exe platform_architecture.py
interpreter: ('32bit', 'WindowsPE')
/bin/ls    : ('32bit', '')

Referencias:

Python Module of the Week Home Descarga el código

denklab | Artículos en la categoría »PyMOTW«

PyMOTW: anydbm (y módulos relacionados)

Creando una nueva base de datos

Abriendo una base de datos existente

Casos de error

Referencias

PyMOTW: exceptions

Descripción

Clases base

BaseException

Exception

StandardError

ArithmeticError

LookupError

EnvironmentError

Excepciones lanzadas

AssertionError

AttributeError

EOFError

FloatingPointError

GeneratorExit

IOError

ImportError

IndexError

KeyError

KeyboardInterrupt

MemoryError

NameError

NotImplementedError

OSError

OverflowError

ReferenceError

RuntimeError

StopIteration

SyntaxError

SystemError

SystemExit

TypeError

UnboundLocalError

UnicodeError

ValueError

ZeroDivisionError

Categorías de Warning

Referencias

PyMOTW: profile, cProfile, pstats

run():

runctx():

pstats: Guardando y trabajando con estadíticas:

Limitando el contenido del reporte:

Grafos de funciones invocadas e invocadoras (caller/callee):

Referencias:

PyMOTW: signal

Descripción:

Recibiendo señales:

getsignal():

Enviando señales:

Alarmas:

Ignorando Señales:

Señales e hilos de ejecución (threads):

Referencias:

PyMOTW: platform

Descripción:

Ejemplos:

Intérprete:

OS X:

Linux:

Windows Vista:

Plataforma:

OS X:

Linux:

Windows Vista:

Información sobre el sistema operativo y el hardware:

OS X:

Linux:

Windows Vista:

Arquitectura ejecutable:

OS X:

Linux:

Windows Vista:

Referencias:

`pstats`: Guardando y trabajando con estadíticas:

`getsignal()`: