versión color - PET: Python Entre Todos - Python Argentina

23 Vectorización
El módulo struct y mmap nos puede ayudar mucho con esto. Imaginemos, pues, que tenemos un registro que son dos enteros
de 32 bits más una cadena de 12 caracteres. En total, ocupará 20 bytes. Imaginemos, además, que queremos todo un array de
estas cosas, 100 digamos. Ocupará, a lo mejor, 2000 bytes.
>>> formato = 'ii 12s'
>>> longitud = len(struct.pack(formato, 0, 0, ''))
>>> buffer = mmap.mmap(-1, longitud*100)
>>> buffer[0:longitud] = struct.pack(formato, 1, 2, 'hola')
>>> struct.unpack(formato, buffer[0:longitud])
(1, 2, 'hola\x00\x00\x00\x00\x00\x00\x00\x00')
Ahí se podemos ver un pequeño inconveniente: la forma en que se guarda la cadena (con bytes nulos al final), pero cuando
trabajemos con datos masivos y altamente estructurados (como registros de bases de datos), puede que sea una opción a tener
en cuenta. En particular, si no querremos acceder muy frecuentemente a los datos.
No es muy pythónico, pero la diferencia en uso de memoria es importante. El módulo mmap utiliza al sistema operativo para
proveer un pedazo de memoria en el cual se puede escribir datos (de hecho, el pedazo de memoria puede mapearse a un archivo
o compartir entre procesos). Pero es sólo eficiente si los datos van a ocupar más (mucho más) de 4kb, pues el sistema reserva
una cantidad integral de páginas de memoria, no sólo bytes.
La técnica puede funcionar igualmente bien con cadenas, con el inconveniente de que las cadenas no son mutables, así que
cambiar su contenido conlleva el costo de copiar la estructura entera.
Vectorización
Esta técnica se puede llevar a una forma mucho más eficiente y cómoda de utilizar aplicando una técnica conocida como
vectorización.
Donde los registros de datos que usemos sean prominentemente numéricos, hay un módulo que nos permitirá guardar listas
enteras de ellos de forma eficiente: array.
>>> pos_x = array.array('i')
>>> pos_y = array.array('i')
>>> for i in xrange(1000):
... pos_x.append(i)
... pos_y.append(i)
Eso creará dos arreglos de 1000 enteros, y ocupará exactamente lo que ocuparía ese mismo arreglo en C. Lo cual es muy
eficiente. Y no es tan difícil de usar, puesto que array es idéntico a list en cuanto a su operación, con la diferencia de que
sólo acepta un tipo predefinido de datos (i = integer, hay muchos otros), y los mantiene en memoria de forma realmente
compacta y eficiente.
De hecho, se puede armar una clase que funcione de “vista”:
class Point(object):
__slots__ = ('_x','_y','_i')
def __init__(x, y, i):
self._x = x
self._y = y
self._i = i
@property
def x(self):
return self._x[self._i]
@x.setter(self, value):
self._x[self._i] = value
@property
def y(self):
return self._y[self._i]
Python Entre Todos (número 5, Marzo 2012) — http://revista.python.org.ar