Joyitas en la stdlib: collections

Dentro de la biblioteca estándar de Python dispones de auténticas joyas, muchas veces ignoradas u olvidadas. Es por ello que voy a empezar un breve pero intenso recorrido por algunas piezas de arte disponibles de serie.

Módulo collections

Con la ayuda de este módulo puedes aumentar las estructuras de datos típicas disponibles en Python (listas, tuplas, diccionarios,...). Veamos algunas utilidades disponibles:

ChainMap

Solo Python 3. Actualízate!!

Dicho en bruto, es un conglomerado de diccionarios (también conocidos como mappings o hash tables).

Para que puede ser útil:

Ejemplo, imaginemos que tenemos un diccionario de configuración dict_a, que posee las claves a y b, y queremos actualizar sus valores con otros pares clave:valor que están en el diccionario dict_b, que posee las claves b y c. Podemos hacer:

from collections import ChainMap

dict_a = {'a': 1, 'b': 10}
dict_b = {'b': 100, 'c': 1000}

cm = ChainMap(dict_a, dict_b)
for key, value in cm.items():
    print(key, value)
a 1
c 1000
b 10

Hemos añadido el valor de la clave c de dict_b sin necesidad de modificar nuestro diccionario original de configuración dict_a, es decir, hemos hecho un 'cambio' reversible. También podemos 'sobreescribir' las claves que están en nuestro diccionario original de configuración, dict_b variando los parámetros del constructor:

cm = ChainMap(dict_b, dict_a)
for key, value in cm.items():
    print(key, value)
b 100
a 1
c 1000

Vemos que, además de añadir la clave c, hemos sobreescrito la clave b.

Los diccionarios originales están disponibles haciendo uso del atributo maps:

cm.maps
[{'b': 100, 'c': 1000}, {'a': 1, 'b': 10}]

Ejercicio: haced un dir de cm y un dir de dict_a y veréis que los atributos y métodos disponibles son parecidos.

Más información en este hilo de stackoverflow en el que me he basado para el ejemplo anterior (¿basar y copiar no son sinónimos?).

Counter

Permite contar ocurrencias de forma simple. En realidad, su funcionalidad se podría conseguir sin problemas con algunas líneas extra de código pero ya que lo tenemos, está testeado e implementado por gente experta vamos a aprovecharnos de ello.

En la documentación oficial hay algunos ejemplos interesantes y en github podéis encontrar unos cuantos más. Veamos un ejemplo simple pero potente, yo trabajo mucho con datos meteorológicos y uno de los problemas recurrentes es tener fechas repetidas que no deberían existir (pero pasa demasiado a menudo). Una forma rápida de buscar problemas de estos en ficheros y lanzar una alarma cuando ocurra lo que buscamos, sería:

from io import StringIO
from collections import Counter

virtual_file = StringIO("""2010/01/01 2.7
2010/01/02 2.2
2010/01/03 2.1
2010/01/04 2.3
2010/01/05 2.4
2010/01/06 2.2
2010/01/02 2.2
2010/01/03 2.1
2010/01/04 2.3
""")

if Counter(virtual_file.readlines()).most_common(1)[0][1] > 1:
    print('fichero con fecha repetida')
fichero con fecha repetida

namedtuple

A veces me toca crear algún tipo de estructura que guarda datos y algunos metadatos. Una forma simple sin crear una clase ad-hoc sería usar un diccionario. Un ejemplo simple sería:

import numpy as np
import datetime as dt
from pprint import pprint

datos = {
    'valores': np.random.randn(100),
    'frecuencia': dt.timedelta(minutes = 10),
    'fecha_inicial': dt.datetime(2016, 1, 1, 0, 0),
    'parametro': 'wind_speed',
    'unidades': 'm/s'
}

pprint(datos)
{'fecha_inicial': datetime.datetime(2016, 1, 1, 0, 0),
 'frecuencia': datetime.timedelta(0, 600),
 'parametro': 'wind_speed',
 'unidades': 'm/s',
 'valores': array([-3.02664796, -0.59492715, -1.36233816, -0.27333458,  0.34971592,
        1.43105631,  1.12980511,  0.49542105,  0.37546829,  1.37230197,
       -1.00757915,  1.39334713,  0.73904326,  0.01129817,  0.12431242,
        0.4388826 , -0.49561972, -0.9777947 ,  0.6009799 ,  0.89101799,
        0.48529884,  1.80287157,  1.56321415, -0.62089358, -2.22113341,
       -0.04751354,  0.89715794, -0.23252567,  0.2259216 ,  0.35214745,
       -1.50915239, -1.46547279, -0.4260315 ,  0.20851012,  1.60555432,
        0.4221521 , -1.03399518,  1.68276277,  0.5010984 ,  0.01294853,
       -0.80004557,  1.72141514, -1.38314354,  0.41374512,  0.32861028,
       -2.22385654,  0.80125671, -0.84757451,  0.66896035, -0.26901047,
       -0.06195842, -0.60743183, -0.15538184,  1.16314508, -0.42198419,
        0.61174838,  0.97211057, -1.19791368, -0.68773007,  2.96956504,
       -1.13000346, -0.24523032,  1.6312053 ,  0.77060561, -1.69925633,
       -0.31417013,  0.44196826, -0.59763569,  0.91595894,  1.47587324,
        0.5520219 , -0.62321715,  0.32543574, -1.26181508,  0.94623275,
       -0.25690824,  1.36108942,  0.15445091, -1.25607974,  0.50635589,
        0.65698443, -0.82418166, -0.34054522,  0.23511397, -1.5096761 ,
       -1.12291338, -1.82440698, -0.47433931, -1.86537903,  1.29256869,
        1.78898905,  0.72081117, -0.15169929, -1.24106944,  0.68920997,
        0.36932816, -1.15901835, -0.93990956,  0.37258685, -0.41316085])}

Lo anterior es simple y rápido pero usando una namedtuple dispongo de algo parecido con algunas cosas extra. Veamos un ejemplo similar usando namedtuple:

from collections import namedtuple

Datos = namedtuple('Datos', 'valores frecuencia fecha_inicial parametro unidades')

datos = Datos(np.random.randn(100), 
              dt.timedelta(minutes = 10),
              dt.datetime(2016, 1, 1, 0, 0),
              'wind_speed',
              'm/s')
print(datos)
Datos(valores=array([ 1.50377059, -1.48083897, -0.76143985,  0.15346996, -0.01094251,
        0.42117233,  1.07136364, -0.24586714,  1.2001748 ,  0.56880926,
        0.56959121,  0.63811853,  0.4621489 ,  1.06636058,  0.32129287,
        2.42264145, -1.25830559, -0.27102862,  2.04853711,  2.07166845,
       -0.27138347, -0.07075163, -0.43547714,  1.69140984,  2.57150371,
        0.80336641, -0.78767876, -2.22281324,  0.23112338, -0.0605485 ,
        0.58304378,  3.33116997, -1.1285789 , -0.2047658 , -0.39240644,
       -1.69724959, -0.0313781 , -0.22892613, -0.06029154, -0.32368036,
       -0.12969429,  1.06231438,  0.05429922, -1.12206555,  1.33383161,
        0.92582424,  0.51615352,  0.93188459,  0.65273332,  0.39108396,
        1.56345696, -0.33158622, -0.27455745,  0.69101563,  1.61244861,
        0.7961402 ,  0.38661924, -0.99864208, -0.10720116,  0.40919342,
       -0.43784138, -3.06455306,  1.69280852,  1.82180641,  0.03604298,
        0.17515747,  1.4370723 , -0.47437528,  1.14510249,  1.36360776,
        0.34575948, -0.14623582,  1.1048332 , -0.2266261 ,  1.34319382,
        0.75608216, -0.62416011, -0.27821722,  0.45365802, -0.98537653,
        0.20172051,  1.70476797,  0.55529542, -0.07833625, -0.62619796,
       -0.02892921, -0.07349236,  0.94659497,  0.20823509,  0.91628769,
       -1.14603843, -0.20748714,  1.13008222, -0.93365802, -0.48125316,
        0.45564591, -0.03136778, -0.86333962,  1.04590165, -0.51757806]), frecuencia=datetime.timedelta(0, 600), fecha_inicial=datetime.datetime(2016, 1, 1, 0, 0), parametro='wind_speed', unidades='m/s')

Ventajas que le veo con respecto a lo anterior:

  • Puedo acceder a los 'campos' o claves del diccionario usando dot notation
print(datos.valores)
[ 1.50377059 -1.48083897 -0.76143985  0.15346996 -0.01094251  0.42117233
  1.07136364 -0.24586714  1.2001748   0.56880926  0.56959121  0.63811853
  0.4621489   1.06636058  0.32129287  2.42264145 -1.25830559 -0.27102862
  2.04853711  2.07166845 -0.27138347 -0.07075163 -0.43547714  1.69140984
  2.57150371  0.80336641 -0.78767876 -2.22281324  0.23112338 -0.0605485
  0.58304378  3.33116997 -1.1285789  -0.2047658  -0.39240644 -1.69724959
 -0.0313781  -0.22892613 -0.06029154 -0.32368036 -0.12969429  1.06231438
  0.05429922 -1.12206555  1.33383161  0.92582424  0.51615352  0.93188459
  0.65273332  0.39108396  1.56345696 -0.33158622 -0.27455745  0.69101563
  1.61244861  0.7961402   0.38661924 -0.99864208 -0.10720116  0.40919342
 -0.43784138 -3.06455306  1.69280852  1.82180641  0.03604298  0.17515747
  1.4370723  -0.47437528  1.14510249  1.36360776  0.34575948 -0.14623582
  1.1048332  -0.2266261   1.34319382  0.75608216 -0.62416011 -0.27821722
  0.45365802 -0.98537653  0.20172051  1.70476797  0.55529542 -0.07833625
 -0.62619796 -0.02892921 -0.07349236  0.94659497  0.20823509  0.91628769
 -1.14603843 -0.20748714  1.13008222 -0.93365802 -0.48125316  0.45564591
 -0.03136778 -0.86333962  1.04590165 -0.51757806]
  • Puedo ver el código usado para crear la estructura de datos usando verbose = True. Usa exec entre bambalinas (o_O). Puedo ver que todas las claves se transforman en property's. Puedo ver que se crea documentación... MAGIA en estado puro!!!

(Si no quieres usar la keyword verbose = True puedes seguir teniendo acceso en un objeto usando obj._source)

Datos = namedtuple('Datos', 'valores frecuencia fecha_inicial parametro unidades', verbose = True)
from builtins import property as _property, tuple as _tuple
from operator import itemgetter as _itemgetter
from collections import OrderedDict

class Datos(tuple):
    'Datos(valores, frecuencia, fecha_inicial, parametro, unidades)'

    __slots__ = ()

    _fields = ('valores', 'frecuencia', 'fecha_inicial', 'parametro', 'unidades')

    def __new__(_cls, valores, frecuencia, fecha_inicial, parametro, unidades):
        'Create new instance of Datos(valores, frecuencia, fecha_inicial, parametro, unidades)'
        return _tuple.__new__(_cls, (valores, frecuencia, fecha_inicial, parametro, unidades))

    @classmethod
    def _make(cls, iterable, new=tuple.__new__, len=len):
        'Make a new Datos object from a sequence or iterable'
        result = new(cls, iterable)
        if len(result) != 5:
            raise TypeError('Expected 5 arguments, got %d' % len(result))
        return result

    def _replace(_self, **kwds):
        'Return a new Datos object replacing specified fields with new values'
        result = _self._make(map(kwds.pop, ('valores', 'frecuencia', 'fecha_inicial', 'parametro', 'unidades'), _self))
        if kwds:
            raise ValueError('Got unexpected field names: %r' % list(kwds))
        return result

    def __repr__(self):
        'Return a nicely formatted representation string'
        return self.__class__.__name__ + '(valores=%r, frecuencia=%r, fecha_inicial=%r, parametro=%r, unidades=%r)' % self

    def _asdict(self):
        'Return a new OrderedDict which maps field names to their values.'
        return OrderedDict(zip(self._fields, self))

    def __getnewargs__(self):
        'Return self as a plain tuple.  Used by copy and pickle.'
        return tuple(self)

    valores = _property(_itemgetter(0), doc='Alias for field number 0')

    frecuencia = _property(_itemgetter(1), doc='Alias for field number 1')

    fecha_inicial = _property(_itemgetter(2), doc='Alias for field number 2')

    parametro = _property(_itemgetter(3), doc='Alias for field number 3')

    unidades = _property(_itemgetter(4), doc='Alias for field number 4')


# Lo mismo de antes
print(datos._source)
from builtins import property as _property, tuple as _tuple
from operator import itemgetter as _itemgetter
from collections import OrderedDict

class Datos(tuple):
    'Datos(valores, frecuencia, fecha_inicial, parametro, unidades)'

    __slots__ = ()

    _fields = ('valores', 'frecuencia', 'fecha_inicial', 'parametro', 'unidades')

    def __new__(_cls, valores, frecuencia, fecha_inicial, parametro, unidades):
        'Create new instance of Datos(valores, frecuencia, fecha_inicial, parametro, unidades)'
        return _tuple.__new__(_cls, (valores, frecuencia, fecha_inicial, parametro, unidades))

    @classmethod
    def _make(cls, iterable, new=tuple.__new__, len=len):
        'Make a new Datos object from a sequence or iterable'
        result = new(cls, iterable)
        if len(result) != 5:
            raise TypeError('Expected 5 arguments, got %d' % len(result))
        return result

    def _replace(_self, **kwds):
        'Return a new Datos object replacing specified fields with new values'
        result = _self._make(map(kwds.pop, ('valores', 'frecuencia', 'fecha_inicial', 'parametro', 'unidades'), _self))
        if kwds:
            raise ValueError('Got unexpected field names: %r' % list(kwds))
        return result

    def __repr__(self):
        'Return a nicely formatted representation string'
        return self.__class__.__name__ + '(valores=%r, frecuencia=%r, fecha_inicial=%r, parametro=%r, unidades=%r)' % self

    def _asdict(self):
        'Return a new OrderedDict which maps field names to their values.'
        return OrderedDict(zip(self._fields, self))

    def __getnewargs__(self):
        'Return self as a plain tuple.  Used by copy and pickle.'
        return tuple(self)

    valores = _property(_itemgetter(0), doc='Alias for field number 0')

    frecuencia = _property(_itemgetter(1), doc='Alias for field number 1')

    fecha_inicial = _property(_itemgetter(2), doc='Alias for field number 2')

    parametro = _property(_itemgetter(3), doc='Alias for field number 3')

    unidades = _property(_itemgetter(4), doc='Alias for field number 4')


  • Puedo seguir obteniendo un diccionario (un OrderedDict, también incluido en el módulo collections) si así lo deseo:
datos._asdict()['valores']
array([ 1.50377059, -1.48083897, -0.76143985,  0.15346996, -0.01094251,
        0.42117233,  1.07136364, -0.24586714,  1.2001748 ,  0.56880926,
        0.56959121,  0.63811853,  0.4621489 ,  1.06636058,  0.32129287,
        2.42264145, -1.25830559, -0.27102862,  2.04853711,  2.07166845,
       -0.27138347, -0.07075163, -0.43547714,  1.69140984,  2.57150371,
        0.80336641, -0.78767876, -2.22281324,  0.23112338, -0.0605485 ,
        0.58304378,  3.33116997, -1.1285789 , -0.2047658 , -0.39240644,
       -1.69724959, -0.0313781 , -0.22892613, -0.06029154, -0.32368036,
       -0.12969429,  1.06231438,  0.05429922, -1.12206555,  1.33383161,
        0.92582424,  0.51615352,  0.93188459,  0.65273332,  0.39108396,
        1.56345696, -0.33158622, -0.27455745,  0.69101563,  1.61244861,
        0.7961402 ,  0.38661924, -0.99864208, -0.10720116,  0.40919342,
       -0.43784138, -3.06455306,  1.69280852,  1.82180641,  0.03604298,
        0.17515747,  1.4370723 , -0.47437528,  1.14510249,  1.36360776,
        0.34575948, -0.14623582,  1.1048332 , -0.2266261 ,  1.34319382,
        0.75608216, -0.62416011, -0.27821722,  0.45365802, -0.98537653,
        0.20172051,  1.70476797,  0.55529542, -0.07833625, -0.62619796,
       -0.02892921, -0.07349236,  0.94659497,  0.20823509,  0.91628769,
       -1.14603843, -0.20748714,  1.13008222, -0.93365802, -0.48125316,
        0.45564591, -0.03136778, -0.86333962,  1.04590165, -0.51757806])
  • Puedo crear subclases de forma simple para añadir funcionalidad. Por ejemplo, creamos una nueva clase con un nuevo método que calcula la media de los valores:
class DatosExtendidos(Datos):
    def media(self):
        "Calcula la media de los valores."
        return self.valores.mean()

datos_ext = DatosExtendidos(**datos._asdict())

print(datos_ext.media())
0.27764229179

deque

Otra joyita que quizá debería usar más a menudo sería deque. Es una secuencia mutable (parecido a una lista), pero con una serie de ventajas. Es una cola/lista cuyo principio y fin es 'indistinguible', es thread-safe y está diseñada para poder insertar y eliminar de forma rápida en ambos extremos de la cola (ahora veremos qué significa todo esto). Un uso evidente es el de usar, por ejemplo, una secuencia como stream de datos con un número de elementos fijo y/o rápidamente actualizable:

  • Podemos limitar su tamaño y si añadimos elementos por un lado se eliminan los del otro extremo.
  • Podemos rotar los datos de forma eficiente.
  • ...

Veamos un ejemplo:

from collections import deque

dq = deque(range(10), maxlen = 10)
lst = list(range(10))
print(dq)
print(lst)
deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# los tres últimos elementos los anexa nuevamente al principio de la secuencia.
dq.rotate(3)
print(dq)

lst = lst[-3:] + lst[:-3]
print(lst)
deque([7, 8, 9, 0, 1, 2, 3, 4, 5, 6], maxlen=10)
[7, 8, 9, 0, 1, 2, 3, 4, 5, 6]

Veamos la eficiencia de esta operación:

tmp = deque(range(100000), maxlen = 100000)
%timeit dq.rotate(30000)
tmp = list(range(100000))
%timeit tmp[-30000:] + tmp[:-30000]
The slowest run took 9.62 times longer than the fastest. This could mean that an intermediate result is being cached.
1000000 loops, best of 3: 519 ns per loop
100 loops, best of 3: 3.07 ms per loop

Con una queue podemos anexar de forma eficiente a ambos lados:

dq.append(100)
print(dq)
dq.appendleft(10000)
print(dq)
deque([8, 9, 0, 1, 2, 3, 4, 5, 6, 100], maxlen=10)
deque([10000, 8, 9, 0, 1, 2, 3, 4, 5, 6], maxlen=10)
dq.extend(range(10))
print(dq)
dq.extendleft([10, 100])
print(dq)
deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
deque([100, 10, 0, 1, 2, 3, 4, 5, 6, 7], maxlen=10)

Etc.

Puedes hacer cosas similares a las hechas con listas pero de forma más eficiente y práctica en determinados casos!!

Recordad que, además, disponemos del módulo queue en la librería estándar.

Conclusión

Este módulo esconde cosas muy interesantes, algunas que no hemos visto. Por tanto, si no lo conocéis, deberíais explorar el módulo collections, si lo conocéis nos podéis indicar como lo usáis en los comentarios que puedes encontrar más abajo.

Resaca PyData Madrid 2016

Este es un mini resumen de parte del trabajo y experiencias vividas durante muchos meses trabajando en la organización de la primera PyData por estos lares.

¿Cómo?

Muchos de los que nos leéis, seguramente, ya estéis envueltos en meetups locales, talleres,... Estos eventos son importantísimos para que la comunidad se conozca a pequeña escala y es una labor regular de mucha gente que os agradezco ya que es el germen de cosas más grandes. Una vez que hay comunidad local, esta puede contactar con otras comunidades locales o pueden intentar crear un evento que salga de ese ámbito más pequeño o cerrado. Estos eventos mayores hacen que las comunidades locales puedan interactuar en persona con el resto de comunidades locales.

De la experiencia vivida detrás de la asociación Python España desde sus inicios hasta hoy (en realidad, hasta anteayer) he venido observando que, sin duda, el interactuar en persona es mucho más eficiente, amigable y productivo que andar hablando por las listas de correo, twitter, etc. Por ejemplo, de la primera PyConES, celebrada en Madrid en 2013, surgieron o se consolidaron grupos, PyBirras y/o meetups en Valencia, Vigo, Tenerife, Barcelona, Madrid,... Y más tarde han venido otros en Granada, Sevilla, Murcia, Castellón,... (recordad que la asociación provee de ciertas herramientas para las comunidades locales).

En torno a todo esto, además, han surgido interesantes iniciativas como un calendario de eventos, un podcast, openbadges para reconocer el esfuerzo de muchos dando charlas de forma desinteresada o asociándose,..., otras iniciativas que se están incubando y, además, hemos seguido celebrando eventos como la PyConES (este año se celebrará en Almería la 4ª edición) y han surgido nuevos como la PyData Madrid 2016 (ya nos acercamos...).

¿Por qué todo este rollo?

Todo lo anterior es un poco de contexto para saber como se llega a las cosas. El núcleo de la organización local de la PyData hemos sido Salvador, Guillem y yo. Pero a Salvador y a Guillem, seguramente, no los habría conocido si no existiera el meetup local de Python Madrid (con Juanlu, Pablo, Jesús Cea, Yamila, Jesús Espino, Andrey,... empujando por detrás durante muuuuuchos años ) o la PyConES (organizada por gente de Madrid, Valencia, Zaragoza, Almería,..., LO SIENTO, no me caben todos los nombres). Y de aquellos polvos, estos lodos. Empezamos a hablar de una PyData hace varios años en la PyConES de Zaragoza. Esos días me junté con gente como Christine, Samuel Guerra, Guillem, Nuria, Antònia, Fran (Cacheme), Álex (AeroPython),..., y de ahí surgió la lista SciPyData-ES  donde se fue apuntando gente, donde empezamos los primeros contactos para la PyData que celebramos la semana pasada y donde hemos intentado informar de todo lo que acontecía además de intentar convocar a nuevos locos en el esfuerzo de la organización.

¿Y nos vamos acercando a la PyData Madrid 2016?

Además del núcleo duro hemos tenido asistencia remota de Christine (desde Texas, Madrid, Barcelona,...GRACIAS!!!). Christine nos ayudó a poner en marcha todas las comunicaciones con NumFocus, responsable final de las PyData. Dentro de NumFocus hemos hablado (mucho) con Leah, Gina, Lynn, Savannah, Martey,..., que se han encargado de cosas importantísimas como la web, la facturación, promoción,...

¿Qué es una PyData?

Son un tipo de conferencias donde se habla de computación científica realizada con ayuda de software libre. Las organiza NumFocus con ayuda de comunidades locales alrededor del mundo.

¿Qué es NumFocus?

Es una organización sin ánimo de lucro que se encarga de velar por la continuidad de muchos de esos proyectos que usamos a diario (Numpy, Scipy, Julia, Matplotlib, pandas, PyTables,...).

¿Qué envuelve la organización de un evento de este tipo?

MUCHOS CORREOS.

MÁS CORREOS.

Y UNOS POCOS CORREOS MÁS.

Hablando en serio. Hemos conversado con gente que está en la otra parte del mundo, con organizadores de otras PyData como Ian (Ozsvald, Londres),... Con todo ello, hemos intentado hacerlo lo mejor posible.

El lugar.

  • Lo más importante es encontrar el lugar adecuado. En este caso consideramos usar dos sitios diferentes y partimos el evento en dos mini-eventos (talleres y charlas) para poder controlar el aforo de uno y de otro (diferente aforo en los dos sitios). Gracias CIBBVA y Campus Madrid por las facilidades ofrecidas desde el primer momento. Y a Reinaldo en CIBBVA y Patricia en Campus Madrid por contestar a las millones de dudas y resolver los problemas en todo momento.
  • El lugar elegido te dictará una serie de cosas como el aforo, número de tracks, posibilidad de vídeo, wifi, facilidad de acceso,... Al final nos quedó un día completo de talleres y dos días completos de charlas en un único track.

Los patrocinadores.

  • Desde el primer momento contamos con la ayuda de la Python Software Foundation, que fue nuestro primer patrocinador oficial y que nos hizo facilísimo contar con algo de dinero desde un primer momento (Thanks Betsy and others, You rule!!!).
  • Luego hemos contactado con muchas posibilidades y hemos acabado teniendo un conjunto de patrocinadores muy involucrados con el evento. Los cito por orden tal como están en la web: Continuum Analytics, Synergic partners, NFQ solutions, KSchool, OpenSistemas, Mozilla, ScrapingHub, Paradigma digital y GMV. Empresas punteras trabajando en ciencia aplicada, en nuevas tecnologías, en formación,... Muchas españolas y algunas extranjeras. GRACIAS A TODAS!!!

Los ponentes.

  • Un gran aplauso para todos!!! Gente que, de forma desinteresada, comparte su conocimiento con todos nosotros después de perder tiempo en casa preparando materiales con su experiencia adquirida durante años, que tiene que buscar hoteles, coches, aviones,...
  • Gracias Jaime, Peque, Claudia, Antònia, Álex, Jesús, Pablo, Tomás, Ricardo, Nathan, Siro, Guillem, Marc, Juanlu, Manu, José Manuel,...
  • Quiero agradecer personalmente a nuestros dos keynoters, Christine y Francesc, que desde un primer momento nos facilitaron muchísimo la vida ayudándonos en todo lo posible. Christine es la persona de referencia en toda la explosión de la analitica de datos y nuevas herramientas que están impulsando desde Continuum y Francesc es una de las personas detrás de proyectos tan importantes como PyTables, numexpr, blosc, bcolz,..., que nos muestra desde hace años (lo difícil) cosas que solo se están empezando a aceptar/adoptar ahora (ahora es fácil subirse al carro).

El público.

  • Sin el público no hay PyData que valga por lo que todo está hecho para vosotros.

Los voluntarios.

  • Carlos, Manú, Luís, Yami, Guillermo, Álex,... Los cuales velaron para que todos estuviéramos cómodos durante el evento, montaron, desmontaron, subieron, bajaron,....

Otras muchas cosas en las que pensar.

  • Catering, el alérgico a las nueces de brasil, la alérgica a los frutos secos, los vegetarianos, las veganas, los celíacos, las intolerantes a la lactosa,...
  • Los lanyards, identificaciones, camisetas de tallas correctas, bolsas, productos de patrocinadores, cartelería, papelería, impresión....
  • Montar stands, desmontar stands,...
  • Gestionar el tema del vídeo.
  • Pagar facturas.
  • Preocuparse porque todo esté correcto durante las charlas.
  • Gestionar PyBirras.
  • Gestionar cena para ponentes y patrocinadores.
  • Hacer de maestros de ceremonias (Guillem haciendo de cabeza visible de forma excelente, Salva actuando en la sombra para que todo estuviera en forma y tiempo, yo molestando por ahí,...).
  • Certificados de asistencia.
  • Certificados de pago.
  • Mover cajas de un sitio a otro.
  • Gestionar viajes.
  • Actualizar webs.
  • Buscar información de ayuda para los asistentes.
  • Comité de selección de charlas.
  • Gestionar voluntarios.
  • Gestionar el tema de venta de ropa con freewear.
  • ...

Agradecimientos.

He agradecido a lo largo del texto a muchisima gente. Este rinconcito lo dejo para Salva y Guillem. Los cuales me han aguantado mis neuras durante meses y han sido, en todo momento, unos profesionales cualificados, educados, eficientes,.... Me pongo de pie y les aplaudo virtualmente. Si en el futuro me piden ayuda en una empresa de estas saben que me tendrán listo para ello.

Objetivos cumplidos.

  • Hemos plantado la semilla de una conferencia a nivel nacional/internacional de ciencia con Python y otras herramientas de software libre.
  • Hemos recaudado dinero para NumFocus (todavia no conocemos el total).
  • Hemos recaudado dinero para la asociación Python España a traves de la venta de ropa de freewear (102€).
  • Hemos recaudado dinero para otros proyectos de software libre como Emacs, la PSF, Arch,..., a través de la venta de ropa de freewear (34€).
  • Hicimos una cena de ponentes y patrocinadores que se salía de las cenas normales (hicimos una cata de vinos solidaria que realizó una amiga) en un  sitio, Turkana,  que dona gran parte de la recaudación a un proyecto de cirugía en Kenia. Al final creo que se han ido unos 400€ de donación, principalmente donados por el 'trabajo gratuito' de mi amiga Ana con las catas, el fee de los vinos y el restaurante.
  • Creo que alguno de los asistentes disfrutó del evento.

Y seguimos trabajando en la sombra.

Nos queda cerrar el tema de los vídeos, cerrar algunas facturas, mandar algunos correos,...

A ver si salen los vídeos pronto porque me perdí la mayoría!!!!!

Materiales de las charlas.

Además de ponernos a organizar no se nos ocurre otra cosa que liarnos la manta a la cabeza con talleres y demás. Los materiales de mi taller sobre Pandas los tenéis aquí.

También dí una charla relámpago sobre brythonmagic un poco deslucida ya que en el portátil no me funcionó correctamente el mouse pad ni el monitor (cosas del directo). Estoy intentando repararla ya que está un poco rota. Avisaré por twitter cuando esté funcionando correctamente.

El resto de materiales de las charlas y talleres está en este repo de github.

Otros testimonios sobre la PyData Madrid 2016.

En el blog de Guillem.

En el blog de Álex.

¿Futuro?

Decididlo vosotros.

Como véis, esto no son tres dias de charlas y talleres, es el trabajo de mucha gente (decenas nombradas solo en este post) durante mucho tiempo.

Hay muchas semillas plantadas, mucha experiencia adquirida, mucho trabajo hecho,... 🙂

Espero que nos veamos pronto.

Instala pypy 5.0 y numpypy en un virtualenv y juega con Jupyter

Hoy voy a mostrar como usar la última versión de pypy y numpypy en vuestro linux. Para instalar pypy usaremos la versión portable creada por squeaky-pl. Numpypy lo instalaremos en un entorno virtual juntamente con Jupyter para poder hacer las pruebas en un entorno más amigable que la consola de pypy.

Requerimientos

Necesitaremos tener instalada una versión reciente de virtualenv y git.

Al lío

¡Si queréis la versión TL;DR pinchad aquí! Si sois un poco más pacientes y queréis entender un poco lo que vamos a hacer seguid leyento.

Todos los comandos que vienen a continuación los tenéis que meter en un terminal. Primero creamos un directorio que se llamará pypy50 en vuestro $HOME

mkdir $HOME/pypy50

Ahora nos vamos al directorio recién creado y nos descargamos el fichero comprimido que contiene el pypy portable de 64 bits

cd $HOME/pypy50
wget https://bitbucket.org/squeaky/portable-pypy/downloads/pypy-5.0-linux_x86_64-portable.tar.bz2

Lo desempaquetamos:

tar xvfj pypy-5.0-linux_x86_64-portable.tar.bz2

Ahora creamos un directorio bin en nuestro $HOME. Si ya existe te puedes saltar este paso:

mkdir $HOME/bin

Creamos un enlace simbólico al ejecutable del pypy portable que hemos descargado que se encontrará en la carpeta bin del directorio $HOME:

ln -s $HOME/pypy50/pypy-5.0-linux_x86_64-portable/bin/pypy $HOME/bin

Cambiamos los permisos al ejecutable para darle permisos de ejecución:

chmod +x $HOME/pypy50/pypy-5.0-linux_x86_64-portable/bin/pypy

Al final de nuestro .bashrc vamos a añadir unas pocas líneas para que se añada el directorio bin de nuestro $HOME al $PATH:

echo "" >> $HOME/.bashrc
echo "# Added path to include pypy by $USER" >> $HOME/.bashrc
echo "export PATH=$PATH:$HOME/bin" >> $HOME/.bashrc
source $HOME/.bashrc

Creamos el virtualenv con pypy (en este paso necesitaréis tener virtualenv instalado). El virtualenv se creará en la carpeta bin de nuestro $HOME y se llamará pypyvenv:

virtualenv -p pypy $HOME/bin/pypyvenv

Instalamos numpypy (numpy para pypy) en el nuevo virtualenv creado (aquí necesitarás tener git instalado). Para ello usamos el pip del entorno virtual.

$HOME/bin/pypyvenv/bin/pip install git+https://bitbucket.org/pypy/numpy.git

Instalamos Jupyter haciendo algo parecido a lo anterior (aunque esta vez lo instalamos desde pypi, no confundir con pypy):

$HOME/bin/pypyvenv/bin/pip install jupyter

Y, por último, hacemos un poco de limpieza eliminando el fichero comprimido del pypy portable que hemos descargado anteriormente:

rm $HOME/pypy50/pypy*.tar.bz2

¡¡¡Listo!!!

Usando pypy

Para usar pypy (sin numpy) puedes lanzar una consola con pypy 5.0 (compatible con CPython 2.7) escribiendo en el terminal:

pypy

Usando pypy con numpy en un notebook de jupyter

Activamos el entorno virtual recien creado. Desde el terminal escribimos:

. ~/bin/pypyvenv/bin/activate

Y arrancamos jupyter:

jupyter notebook

Y después venís aquí y me contáis vuestras experiencias con pypy y numpypy o, si habéis encontrado fallos o queréis añadir mejoras, os vais a github y abrís un issue o mandáis un Pull Request y salimos ganando todos.

Ideas para mejorar el script (con vuestros pull requests)

  • Que pregunte donde instalar el pypy portable.
  • Que pregunte si queremos una carpeta bin o no.
  • Que pregunte cómo queremos llamar al entorno virtual y dónde lo queremos instalar.
  • Que pregunte si queremos instalar Jupyter y/u otras librerías.
  • ...

Saludos.

 

Fórmula para el amor

Esta entrada se proyectó hace unos doscientos cuarenta y pico días.

Vamos a representar la siguiente fórmula:

\({x}^2 + (y - \sqrt{x^2})^2 = 1\)

Si despejamos la \(y\) nos quedarán las siguientes soluciones:

\(y_{1} = \sqrt{x^2} + \sqrt{1 - x^2}\)
\(y_{2} = \sqrt{x^2} - \sqrt{1 - x^2}\)

En código Python usando Numpy y Matplotlib tendremos lo siguiente:

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
x = np.linspace(-1,1,50)
y1 = np.sqrt(x * x) + np.sqrt(1 - x * x)
y2 = np.sqrt(x * x) - np.sqrt(1 - x * x)
plt.plot(x, y1, c='r', lw = 3)
plt.plot(x, y2, c='r', lw = 3)
plt.show()

Felicidades a quien corresponda.

Idea copiada literalmente de aquí.

Reglas para refactorizar funciones lambda

Un gran ejercicio que podéis hacer de vez en cuando es revisar la documentación oficial de Python. La misma me parece increiblemente completa aunque también un poco anárquica o sin un guión mínimamente claro para seguir diferentes tópicos.

Hoy, revisando el HOWTO de programación funcional, casi al final del documento y sin llamar la atención, he encontrado la siguiente documentación para refactorizar funciones lambda sugerida por Fredrik Lundh. Las reglas que propone para la refactorización de las funciones lambda dicen lo siguiente:

  1. Escribe una función Lambda.
  2. Escribe un comentario explicando qué se supone que hace la función lambda.
  3. Estudia el comentario durante un rato y piensa un nombre que capture la esencia del comentario.
  4. Convierte la función lambda a una declaración def usando el nombre pensado en el anterior paso.
  5. Elimina el comentario.

😛

Feliz año 2016.

Joyas Python del 2015

Este es un resumen de algunas joyas que he descubierto este 2015 dentro del mundo Python. Que las haya descubierto en el 2015 no significa que necesariamente sean cosas novedosas pero la mayoría siguen de actualidad. Tampoco es un resumen ordenado. de hecho, es un pequeño cajón de sastre. Tampoco es temático sobre ciencia, aunque la mayoría están relacionadas con ciencia ya que es a lo que me dedico. En las siguientes líneas nombro muchas cosas pero solo incluyo enlaces sobre las joyas de las que quiero hablar.

WEB:

  • En el pasado he trasteado algo con Django para hacer cosas que se puedan compartir con mucha otra gente. Django es un framework web muy completo o, como se suele decir, con baterías incluidas y el de más amplio uso dentro del mundo Python. El hecho de incluir tantas cosas de uso habitual en un desarrollo web es su fuerte para la mayoría de desarrolladores pero también su talón de Aquiles para gente que solo lo usa de vez en cuando para hacer cosas simples. Demasiado sobrecargado para acordarte de todo ello cuando lo usas muy eventualmente y demasiado condicionante para hacer cosas simples sin un guión claro. Es por ello que este año he empezado a trastear con Flask. Lo recomiendo para gente que quiere convertir una idea simple en algo usable en poco tiempo. He prestado algo de atención a wagtail y me gustaría encontrar un tutorial para gente especialmente lerda en desarrollo web (que no se lo vendan a un desarrollador Django, vamos) y que no tiene tiempo.
  • Relacionado con el trasteo anterior, he empezado a trastear también con SQLAlchemy. Como Flask no te aporta de serie su propia idea de ORM, como sí hace Django, puedes acoplar el ORM que elijas, usar SQL a capón, Mongo,... Facilita mucho el trabajo con BBDD. Y aquí puedes encontrar una serie de recursos relacionados con SQLAlchemy.
  • También relacionado con el uso de Flask, he estado trasteando con Babel para internacionalizar 'cosas' (poder hacer uso de distintos idiomas). Es increible la facilidad de uso pero he encontrado ciertos problemas que no he sabido resolver (aun no sé muy bien porqué, seguramente mi poca experiencia con la biblioteca).

GRÁFICAS:

  • ¿Quieres hacer un mapa interactivo con Python? Hasta ahora había usado mis propias soluciones. Mis soluciones son fáciles de usar y fácilmente portables a la web de forma independiente pero requieren aprender, por ejemplo, OpenLayers o Leaflet y para hacer algo simple puede resultar excesivo. Pero para otros casos de uso hay otras soluciones que pueden resultar más convenientes. Es por ello que en los últimos tiempos he estado usando Folium. Es muy simple de usar y para según que necesidad es muy apropiado. Por otra parte, quizá su diseño limite un poco las posibilidades reales. Es por ello que, después de investigar un poco, descubrí mplleaflet. Esta última librería sigue la misma filosofía que mpld3, usa matplotlib y exporta el código en algo que es capaz de interpretar la librería javascript de turno (d3js para el caso de mpld3 o leaflet para el caso de mplleaflet). Las posibilidades de uso que se me ocurren para mplleaflet son muchas.
  • Otra joyita para hacer análisis estadístico y visualización es Seaborn. Es una delicia ver como con tan poco se puede hacer tanto. Una capa sobre otra capa sobre otra capa,..., dan un gran poder con un mínimo esfuerzo. Se pierde poder de personalización pero se gana inmediatez y, en el mundo del 'loquieroparahoy', es una gran ventaja eso de la inmediatez.
  • Una pequeña tontería pero que te puede resultar útil en algún sistema donde es difícil usar un interfaz gráfico o quieres tener algo ligero para hacer gráficas de ¿baja calidad? sería bashplotlib (hasta el nombre mola).
  • He empezado a trastear algo con Plotly pero los resultados no han sido especialmente buenos (le tendré que dar una nueva oportunidad en 2016):

UTILIDADES:

  • Una pequeña tontada para el día a día sería tqdm, que te añade una barra de progreso a los bucles de tu código.

RENDIMIENTO:

  • La depuración y optimización de código siempre es algo árido y gris. La optimización prematura es la raiz de todo mal. Juntamos las churras con las merinas y nos sale que tienes que probar line_profiler sin ningún género de dudas. Date un paseo por tú código paso a paso y descubre qué es lo que está haciendo que tooooodo sea tan lento.
  • Para correr código más rápido en Python mis opciones de hoy en día serían, por orden de qué es lo que intentaría antes, numba (si es código científico) o pypy (si solo uso numpy mezclado con cosas más estándar que no dependan de bibliotecas que usan la C-API de CPython). Si Numba no funciona y pypy no resuleve la papeleta valoro si el código lo voy a necesitar ejecutar muchas veces y el tiempo que tarda es inasumible en la mayoría de ocasiones y, si es así, tiro de Cython que, con un poco de esfuerzo y afeando un poco el código Python original, permite obtener velocidades cercanas a o del mismo orden que C/C++/Fortran.

LIBRERÍA ESTÁNDAR Y ALGUNAS ALTERNATIVAS:

  • De la librería estándar he estado usando bastante argparse, collections e itertools. Los tres no tienen nada que ver, los tres son muy potentes y, sabiendo usarlos, los tres se hacen imprescindibles. Quizá para el año que viene me ponga como deberes mirar más a fondo click como mejora a argparse y functools, toolz y/o CyToolz en combinación con collections e itertools.

AÑO 2016 (DEBERES QUE ME PONGO):

  • dask
  • Más PyTables.
  • Creo que le voy a dar bastante más a d3js (por dictadura del navegador).
  • scikit-extremes, mi propia solución al análisis de extremos univariantes en Python (se aceptan ayudas).
  • PyMC y/o PyMC3.

¿Y vuestras joyitas? Animáos a compartirlas en los comentarios, independientemente que estén relacionadas con ciencia o no.

Saludos y feliz año!!

Aprende historia gracias a geocodificación inversa, mapping y wikipedia

El otro día, mientras esperaba en Juan Bravo a un amigo, tuve algo de tiempo para divagar y entre esas divagaciones junté Juan Bravo, Python, Internet, geolocalización, historia,... En fin, que estaba en Juan Bravo, no tenía ni idea de quien era ese señor (llamadme ignorante), tenía algo de tiempo y se me ocurrió poder obtener información de calles a partir de un mapa y de la wikipedia y, de aquellos polvos, estos lodos, y nació map2wiki.

¿Qué es map2wiki?

En pocas palabras, es una aplicación web que te permite buscar una calle/avenida/plaza/... en un mapa y obtener información sobre lo que le da nombre a esa dirección.

¿Por qué no buscarlo directamente en la wikipedia?

Porque eso no es tan divertido y no hubiera aprendido nada sobre Flask, Jinja2, geocodificación inversa, OpenStreetMap, Nominatim, OpenLayers, Javascript, Brython, la API de la wikipedia, mis nulas aptitudes para el diseño web (de forma expresa no quería usar cosas como bootstrap para mantenerlo lo más simple posible) aunque podría ser peor, el infierno CSS...

CSS hell

Pero vayamos por partes...

¿Qué es la geocodificación inversa?

La geocodificación inversa (reverse geocoding en inglés) permite, a partir de unas coordenadas geográficas, obtener información sobre una dirección, por ejemplo, u otras cosas que se encuentren en esas coordenadas o cerca.

OpenStreetMap ofrece una API, Nominatim, que permite hacer eso mismo, a partir de unas coordenadas geográficas se obtiene información de su base de datos.

¿Cómo funciona?

En este post voy a relatar un poco el Así se hizo sin ver código, que a veces es más interesante que la película en sí. En otro post comentaré un poco el código por si alguien quiere utilizar alguna parte para otros proyectos.

Existen varias partes que se conectan entre sí.

  • Accedes a una página servida por Flask que ofrece un mapa, gracias a openlayers + openstreetmap.
  • En el mapa, nos podemos mover hasta una dirección que debe estar en español, ya que solo está pensada para ser usada en español. En el frontend tenemos la dirección central del mapa almacenada en una variable para la latitud y otra para la longitud (gracias a Brython/JS).
  • Con la dirección definida, pulsamos sobre el botón de buscar en la wikipedia. Este botón conecta un formulario en HTML, en el cliente, con Flask, en el servidor. Tenemos un formulario con algunos campos ocultos al que le pasaremos las coordenadas obtenidas en el frontend para que sean manejadas en Python gracias a Flask.
  • Una vez que tenemos las coordenadas en Python hacemos varias cosas:
    • Primero, vamos a la API de Nominatim y le metemos las coordenadas para que nos devuelva un JSON con la información de la dirección relacionada con esas coordenadas.
    • De ese JSON extraemos la información relevante a la dirección y la 'limpiamos' (sanitizar no está en el diccionario de la RAE). En la dirección se eliminan los siguientes términos junto con los posibles preposiciones y/o artículos que pueden acompañar a esa dirección ('calle de ...', 'avenida de los ...',...)
 
["alameda", "avenida", "bulevar", "calle", "camino", 
 "carrera", "cuesta", "pasaje", "pasadizo", "paseo", "plaza", 
 "rambla", "ronda", "travesia", "via"]
  • Seguimos:
    • Con la dirección sanitizada solo nos debería quedar el nombre de la dirección ya limpio. Por ejemplo, 'Paseo de la Marquesa de Python' debería quedar como 'Marquesa de Python'. Esa dirección ya limpia se la pasamos a la API de la Wikipedia usando la librería wikipedia que podéis encontrar en pypi. Si es posible encontrar algo en la wikipedia usando el valor que le hemos pasado nos devolverá un objeto con la información relevante del artículo.
    • Con el objeto con la información de la wikipedia obtenido extraemos parte de la información y la formateamos para mostrarla en la página.
    • Una vez tenemos la información de Nominatim (el JSON con la información de la dirección) y la información devuelta por la Wikipedia tenemos todo listo para que, mediante Flask, pasar esa información a una plantilla Jinja2, que construirá el HTML final con la información del JSON obtenido y de la Wikipedia, en caso de que sea posible, o un mensaje de error, en el caso de que no sea posible.

Y este es, principalmente, todo el proceso.

En el próximo artículo nos meteremos un poco más en las tripas para poder entender mejor como se unen las piezas. Lo que veamos no pretenderá ser algo exhaustivo sobre Flask, Jinja2 u otras tecnologías.

Espero que a alguien le resulte útil:

  1. la aplicación en sí, para aprender algo de historia,
  2. la explicación del como se hizo la aplicación, para entender como se juntan las piezas del rompecabezas en una aplicación con una estructura extremadamente simple y sin base de datos detrás.

Hasta la próxima entrada.

¿Cómo funciona el método append de una lista en CPython?

Vamos a empezar con más preguntas que respuestas.

Como sabéis, las listas de Python son arrays dinámicos. Por otro lado, las tuplas son arrays estáticos.

¿Qué implica que las listas sean arrays dinámicos?

Al ser un array dinámico podemos modificar sus elementos así como extender el array (lista).

¿Cómo funciona lo de extender el array (lista)?

Cada vez que usamos el método append de las listas se crea una copia de la lista original y se añade un elemento a esa copia para luego borrar el array original.

¿Es esto último cierto?

Más o menos.

Todos estaréis conmigo que si cada vez que añadimos un nuevo elemento tenemos que crear una copia y luego eliminar el array original podríamos crear cierto coste/gasto de recursos (en memoria, principalmente, creando copias).

Veamos un poco de código:

import sys

lista = []
for i in range(100):
    lista.append(i)
    txt = 'número de elementos = {0:>3} , tamaño de la lista = {1:>4}'
    print(txt.format(i + 1, sys.getsizeof(lista)))
número de elementos =   1 , tamaño de la lista =   96
número de elementos =   2 , tamaño de la lista =   96
número de elementos =   3 , tamaño de la lista =   96
número de elementos =   4 , tamaño de la lista =   96
número de elementos =   5 , tamaño de la lista =  128
número de elementos =   6 , tamaño de la lista =  128
número de elementos =   7 , tamaño de la lista =  128
número de elementos =   8 , tamaño de la lista =  128
número de elementos =   9 , tamaño de la lista =  192
número de elementos =  10 , tamaño de la lista =  192
número de elementos =  11 , tamaño de la lista =  192
número de elementos =  12 , tamaño de la lista =  192
número de elementos =  13 , tamaño de la lista =  192
número de elementos =  14 , tamaño de la lista =  192
número de elementos =  15 , tamaño de la lista =  192
número de elementos =  16 , tamaño de la lista =  192
número de elementos =  17 , tamaño de la lista =  264
número de elementos =  18 , tamaño de la lista =  264
número de elementos =  19 , tamaño de la lista =  264
número de elementos =  20 , tamaño de la lista =  264
número de elementos =  21 , tamaño de la lista =  264
número de elementos =  22 , tamaño de la lista =  264
número de elementos =  23 , tamaño de la lista =  264
número de elementos =  24 , tamaño de la lista =  264
número de elementos =  25 , tamaño de la lista =  264
número de elementos =  26 , tamaño de la lista =  344
número de elementos =  27 , tamaño de la lista =  344
número de elementos =  28 , tamaño de la lista =  344
número de elementos =  29 , tamaño de la lista =  344
número de elementos =  30 , tamaño de la lista =  344
número de elementos =  31 , tamaño de la lista =  344
número de elementos =  32 , tamaño de la lista =  344
número de elementos =  33 , tamaño de la lista =  344
número de elementos =  34 , tamaño de la lista =  344
número de elementos =  35 , tamaño de la lista =  344
número de elementos =  36 , tamaño de la lista =  432
número de elementos =  37 , tamaño de la lista =  432
número de elementos =  38 , tamaño de la lista =  432
número de elementos =  39 , tamaño de la lista =  432
número de elementos =  40 , tamaño de la lista =  432
número de elementos =  41 , tamaño de la lista =  432
número de elementos =  42 , tamaño de la lista =  432
número de elementos =  43 , tamaño de la lista =  432
número de elementos =  44 , tamaño de la lista =  432
número de elementos =  45 , tamaño de la lista =  432
número de elementos =  46 , tamaño de la lista =  432
número de elementos =  47 , tamaño de la lista =  528
número de elementos =  48 , tamaño de la lista =  528
número de elementos =  49 , tamaño de la lista =  528
número de elementos =  50 , tamaño de la lista =  528
número de elementos =  51 , tamaño de la lista =  528
número de elementos =  52 , tamaño de la lista =  528
número de elementos =  53 , tamaño de la lista =  528
número de elementos =  54 , tamaño de la lista =  528
número de elementos =  55 , tamaño de la lista =  528
número de elementos =  56 , tamaño de la lista =  528
número de elementos =  57 , tamaño de la lista =  528
número de elementos =  58 , tamaño de la lista =  528
número de elementos =  59 , tamaño de la lista =  640
número de elementos =  60 , tamaño de la lista =  640
número de elementos =  61 , tamaño de la lista =  640
número de elementos =  62 , tamaño de la lista =  640
número de elementos =  63 , tamaño de la lista =  640
número de elementos =  64 , tamaño de la lista =  640
número de elementos =  65 , tamaño de la lista =  640
número de elementos =  66 , tamaño de la lista =  640
número de elementos =  67 , tamaño de la lista =  640
número de elementos =  68 , tamaño de la lista =  640
número de elementos =  69 , tamaño de la lista =  640
número de elementos =  70 , tamaño de la lista =  640
número de elementos =  71 , tamaño de la lista =  640
número de elementos =  72 , tamaño de la lista =  640
número de elementos =  73 , tamaño de la lista =  768
número de elementos =  74 , tamaño de la lista =  768
número de elementos =  75 , tamaño de la lista =  768
número de elementos =  76 , tamaño de la lista =  768
número de elementos =  77 , tamaño de la lista =  768
número de elementos =  78 , tamaño de la lista =  768
número de elementos =  79 , tamaño de la lista =  768
número de elementos =  80 , tamaño de la lista =  768
número de elementos =  81 , tamaño de la lista =  768
número de elementos =  82 , tamaño de la lista =  768
número de elementos =  83 , tamaño de la lista =  768
número de elementos =  84 , tamaño de la lista =  768
número de elementos =  85 , tamaño de la lista =  768
número de elementos =  86 , tamaño de la lista =  768
número de elementos =  87 , tamaño de la lista =  768
número de elementos =  88 , tamaño de la lista =  768
número de elementos =  89 , tamaño de la lista =  912
número de elementos =  90 , tamaño de la lista =  912
número de elementos =  91 , tamaño de la lista =  912
número de elementos =  92 , tamaño de la lista =  912
número de elementos =  93 , tamaño de la lista =  912
número de elementos =  94 , tamaño de la lista =  912
número de elementos =  95 , tamaño de la lista =  912
número de elementos =  96 , tamaño de la lista =  912
número de elementos =  97 , tamaño de la lista =  912
número de elementos =  98 , tamaño de la lista =  912
número de elementos =  99 , tamaño de la lista =  912
número de elementos = 100 , tamaño de la lista =  912

En el anterior código hemos creado una lista vacía y le hemos ido añadiendo elementos y hemos obtenido el tamaño de la lista usando la función getsizeof que nos indica el tamaño del objeto en bytes. Luego hemos mostrado en pantalla el número de elementos que tiene la lista y el tamaño que ocupa.

Pero, ¿qué ocurre?, ¿por qué aumentando el número de elementos, a veces, no aumenta el tamaño del objeto?, ¿por qué luego cambia?, ¿por qué a medida que hay más elementos en la lista tarda más en cambiar el tamaño de la misma?

Veamos qué dice el código original de las listas en el repo de Python localizado en Objects/listobject.c.

A partir de la línea 42 del código C podemos leer:

/* This over-allocates proportional to the list size, making room
 * for additional growth.  The over-allocation is mild, but is
 * enough to give linear-time amortized behavior over a long
 * sequence of appends() in the presence of a poorly-performing
 * system realloc().
 * The growth pattern is:  0, 4, 8, 16, 25, 35, 46, 58, 72, 88, ...
 */
new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6);

La última línea traducida a Python sería algo así:

new_allocated = (newsize >> 3) + (3 if newsize < 9 else 6)

En el primer paréntesis tenemos el operador bitwise right shift, similar a la versión en C (no hay que olvidar que CPython está escrito en C) mientras que en el segundo paréntesis tenemos el operador ternario (sin duda, un poco más legible que la versión en C).

¿Qué está pasando aquí?

Los buenos de los core developers de CPython han pensado que si usas un array dinámico será porque quieres hacer 'perrerías' con él, como ampliarlo. Y si lo amplías una vez es probable que lo amplíes varias veces. Es por ello que, normalmente, se usa un un tamaño un poco mayor, basado en el tamaño y siquiendo la regla mostrada más arriba, para el array (lista) y, de esta forma, podemos ampliarlo sin necesidad de crear tantas copias.

Veamos esto gráficamente:

Importamos matplotlib para poder crear los gráficos.

import matplotlib.pyplot as plt
plt.style.use('ggplot')
%matplotlib inline

Creamos nuestra lista y otra lista que almacenará los tamaños en bytes, sizes.

lista = list([1])
sizes = [sys.getsizeof(lista)]

for i in range(2, 100000):
    lista.append(i)
    sizes.append(sys.getsizeof(lista))

Y ahora dibujamos los tamaños en función del número de elementos dentro de la lista:

plt.figure(figsize = (10,10))
plt.plot(lista, sizes)
plt.xlabel('Número de elementos en la lista')
plt.ylabel('Tamaño en bytes para la lista de tamaño $N$')
<matplotlib.text.Text at 0x7f0655169c88>

Vemos como los "escalones" en el tamaño de la lista con N elementos va aumentando y el escalón cada vez es más largo a medida que aumenta el tamaño de la lista.

Veamos como es el valor del tamaño dividido por el número de elementos de la lista a medida que va aumentando el mismo (los ejes de la gráfica tienen escala logarítmica):

increment = [s/l for s, l in zip(sizes, lista)]

plt.figure(figsize = (10,10))
plt.yscale('log')
plt.xscale('log')
plt.ylim(7, max(increment))
plt.plot(lista, increment)
plt.xlabel('Número de elementos en la lista')
plt.ylabel('Bytes por número de elementos')
<matplotlib.text.Text at 0x7f06552ada20>

Curioso, ¿no?

Espero que hayáis aprendido tanto como he aprendido yo elaborando esta entrada.

Vamos a comernos el mundo y [Argentina] en Python


 

Edit (2015/11/14):

Quiero agradecer a todos los que se han prestado al juego de la subasta. Al final hemos conseguido donar más de 120 € al proyecto Argentina en Python.

¡¡¡Sois grandes!!!!

Quiero agradecer, especialmente, a Yami y a Ariel su generosidad


 

Hoy nos alejamos un poco de la temática general del blog pero nos metemos de lleno en el tema de cómo crear comunidad, con amor, con dedicación y con mucho esfuerzo, en una apuesta personal de unas personas admirables.

Además del apasionante relato que tenemos hoy, si sigues leyendo, puedes llegar a conseguir una entrada para la PyConES 2015 en Valencia.

En la presente entrada vamos a charlar con Johanna, Manuel y Errante, equipo fullstack de Argentina en Python.

Pero, -¿quiénes son estos?-, os preguntáreis.

Todo esto empezó como la apuesta vital de una persona que ve la vida de una forma diferente y hermosa a la que después se le fueron sumando esfuerzos.

Pero, ¿sigo sin saber qué es todo esto?

En su propia página web podemos leer, -todo esto es un proyecto que promueve el uso del lenguaje de programación Python para resolver problemas cotidianos en usuarios comunes, como así también desarrollar programas poderosos y complejos de una forma sencilla, estimulando el aprendizaje colaborativo y la filosofía del Software Libre-.

Y, -¿cómo llevan esto adelante?-

-Para poder promover Python (entre otras cosas de interés personal) van viajando por diferentes ciudades, siguiendo la energía de las comunidades de Software Libre regionales y contactando con gente que esté interesada en un curso o una charla sobre el tema. Así como también, simplemente, compartir momentos en común charlando sobre otras actividades y conociendo diferentes culturas y formas de vida-.

Aprovechando que en el reciente viaje de Pybonacci a Argentina les pude ver en acción y quedarme, literalmente, alucinado con su buena energía ante la vida he decidido intentar aportar mi granito de arena a su proyecto promocionándolo en este humilde blog. Para ello, hemos mantenido una conversación con nuestros protagonistas a unos 11.000 km de distancia para que nos cuenten sus motivaciones, anhelos, planes, ideas, sueños,...

Empecemos:

Kiko: Primero de todo, Manuel, ¿por qué?, ¿qué te movió a dar el paso para empezar Argentina en Python?

Humitos: "La descentralización del conocimiento". ¿Qué quiero decir con esto? Me imagino que en muchos países del mundo sucede lo mismo. A mí me tocó nacer en Argentina y «en el interior». Si bien nací en la capital (Paraná) de una provincia (Entre Ríos), esta ciudad tiene muy poco movimiento en el ámbito informático, ya sea de programación como en cualquier otro.

La verdad de la Argentina es que si no vivís en una de las 3 grandes/principales ciudades del país, no existís. Estas ciudades son Buenos Aires, Córdoba y Rosario -en algún órden en particular.

Entonces, durante mis épocas de Universidad y aprendizaje feroz, me dediqué a viajar por Argentina a cuanto evento de programación/software libre había. Y claro, como te decía, todos esos eventos eran algunas de estas ciudades "principales". Así conocí mucha gente grosa de Python Argentina, creé lazos fuertes y me fui metiendo en el mundo de la informática y las comunidades.

Muchas veces intenté hacer "algo" en Paraná, donde nací, y nunca lo logré. Al menos, hablando desde la informática. Nadie utilizaba Software Libre, nadie programaba en Python, a nadie le gustaba el trabajo de sysadmin... Entonces, me sentía, y estaba, muy solo. Probé hacer algunas cosas y siempre terminé decepcionado. Incluso, ni siquiera llegaba a juntar un equipo de organizadores.

Sentía que en muchos lugares de Argentina (y el mundo) había mucha gente con mucho potencial que podía sentirse muy sola. Que tenía ganas de compartir lo que hacían con el mundo. Que querían crear una comunidad igual de buena a las de las grandes ciudades, y colaborar para que sigan creciendo con el tiempo e incluso tengan las mismas competencias que estos monstruos.

¡Salgamos a divulgar Python y a crear comunidades en todos lados!

Kiko: ¿Desde el principio pensaste en un proyecto en solitario?, ¿nadie te comentó que quisiera unirse a esta loca aventura desde la concepción de la misma?

Humitos: Bueno, en primer lugar, no es fácil sumarse (en nada) a un loco como yo. Sin embargo, tampoco pensaba en un proyecto solitario. Siempre pensé en la comunidad de Python Argentina que, aunque no estén aquí físicamente conmigo, siento que me están acompañando y apoyando en todo esto.

Pero como decía, es difícil sumarse a un loco como yo. ¿Por qué digo esto? Porque todo el mundo me decía que estaba loco y que nada de todo esto iba a funcionar. Muy pocos amigos me apoyaron desde el primer día y me dijeron que era una idea grandiosa.

Sin embargo, cuando contaba mi proyecto muchos soñaban con esto de "viajar y trabajar desde la playa" pero, por otro lado, ninguno tenía/tuvo/tiene la valentía de «dejarlo todo» y salir a comerse el mundo empezando una nueva vida. Y hoy en día, te puedo decir que dejé todo lo que tenía en Paraná, pero no fue en vano. Sino que ahora tengo mucho más; sobre todo, mucha más «vida». Sí, mi familia, mis amigos, mi ex novia y un sin fin de cosas quedaron en Paraná, pero el crecimiento personal, social y comunitario ha sido tan pero tan grande que sigue valiendo el esfuerzo.

A unas pocas semanas de emprender viaje, mientras pensaba si los que me decían que estaba loco tenían razón, me escribe un amigo de Rosario (Emiliano Dalla Verde Marcozzi) y me dice que le parecía una idea grandiosa y que sí, quería acompañarme en esta aventura. Yo, que soy un tipo bastante estructura y que tenía muchas cosas ya armadas en la cabeza, le dije: "Genial, juntémosno un fin de semana para conversar cuáles son tus expectativas y cuales las mías. Coordinemos todo y empecemos".

Luego, esta reunión se pospuso, fue pasando el tiempo y, por este motivo de "tener que dejarlo todo", se canceló. En cambio, yo como estaba dispuesto a dejarlo todo para encontrar algo mejor, seguí con mis ideas firmes y emprendí viaje...

Kiko: ¿Cuáles fueron tus expectativas iniciales cuando iniciaste el proyecto? A día de hoy, ¿estás contento con la aventura y el resultado?

Humitos: Sinceramente, nunca tuve muchas expectativas y el objetivo fue cambiando de a poquito desde el inicio hasta lo que es hoy el proyecto. En principio, cuando salí por primera vez, lo que quería era poder encontrar esa armonía de trabajo en cualquier lugar: tenía que trabajar en un bar, en una estación de gasolina, en restaurantes y hostels; no tenía una oficina fija. El trabajo me daba el dinero para poder seguir adelante (todo salía de mi bolsillo), y por eso, era muy importante.

Por eso al principio quería encontrar esa armonía laboral para luego empezar a hacer experimentos, mezclarla con los eventos, ver de hacer talleres entre semana, empezar a disfrutar los lugares en los que me encontraba y encontrar la «organización ideal». Todo esto fue cambiando con el tiempo, a tal punto que renuncié a mi trabajo por tener más tiempo para dedicarle al proyecto.

Al día de hoy, estoy muy contento con la aventura. Como decía antes, crecí mucho como persona, me relacioné con gente que, de no ser por Argentina en Python, nunca hubiese conocido, conocí muchas culturas y formas de vida diferentes, estuve en lugares maravillosos en los que muchas personas harían cualquier cosa por estar ahí, etc. Así que, por el lado de la aventura ha sido todo un éxito y no puedo pedir más 😀

Ahora, con respecto al resultado del proyecto Argentina en Python, creo que he logrado varias veces el objetivo, pero como también lo fui adaptando/modificando/incrementando todavía queda mucho por hacer. Sin embargo, mostré Python en lugares donde quizás hubiesen tenido que pasar 5~10 años para que llegue, hicimos cursos para gente que quizás le tuvo miedo a la computadora toda su vida, estuvimos programando en Django con personas mayores de edad (más de 60) y logramos que muchas mujeres se acerquen a la computación sin miedo o sin que se sientan discriminadas.

Por otro lado, ¡siempre quiero más! y siento/creo que a Argentina en Python le falta mucho. Principalmente, le falta ser más conocido. Esto nos permitiría comenzar a organizar más eventos a la distancia, sin tener que llegar al lugar para comenzar con la gestión. De esta forma, podríamos estar organizando varios eventos en paralelo y realizar más de 1 o 2 por mes en ciudades cercanas. ¡Y claro! Quiero hacer más cosas. Quiero terminar de diseñar el curso de pilas-engine que lo tengo en mente (y parte en código) para realizar un taller de videojuegos en 2d muy sencillo pero muy divertido y atrapante.

También quiero poder contagiar Argentina en Python y que se creen otros Bolivia en Python, Venezuela en Python, México en Python, Australia en Python y, ¿por qué no?, un España en Python?. ¡Quiero haya más locos de Python (como yo) por todo el mundo!

Kiko: Argentina en Python tuvo una intersección con Química & Nómada hace un tiempo. En España hay un dicho que dice 'la unión hace la fuerza' (no sé si por allí se usa esa expresión). La pregunta, ¿la unión hace la fuerza?

Johanna: Citar ese refrán me da pauta a responder con otro “¡Sin duda!, dos cabezas piensan más que una” y esto se puede ver reflejado en todo lo que hemos logrado hasta este momento y todo lo que queremos seguir logrando, pero sin dejar de resaltar que Manuel venía labrando un arduo camino desde hace un año atrás, antes de conocerlo y sumarme al proyecto.

Humitos: Primero que nada, Argentina en Python tuvo una intersección con Johanna (antes que con su proyecto) ya que ella fue de gran ayuda cuando yo estuve en Santiago del Estero, proveyéndome un alojamiento cómodo, una conexión a Internet para poder trabajar y mucha buena onda.

Luego, una vez que decidimos comenzar a viajar juntos y luego de un mes en Corrientes, Argentina, donde nos estábamos alojando en la casa de Pablo (por CouchSurfing) que vivía en frente de una plaza en un barrio muy carenciado donde había más de 15 niños (entre 5 y 14 años aprox) todos los días jugando en los árboles y demás ella dijo: "Tenemos que hacer algo con esos chicos que están ahí, sedientos de saber, de conocer y aprender"

Ahí, con esos chicos y en esa plaza, se realizó la primera Jornada de Ciencias: Jugando al científico loco que fue un éxito rotundo. Jugamos y nos divertimos por horas con esos niños. Luego de eso, ella creó su proyecto llamado Química & Nómada con la misma idea de compartir el conocimiento pero contagiando al mundo de las ciencias con esto de «compartir» que tiene el Software Libre. Así nació su proyecto un tiempo después que comenzamos a viajar juntos.

En fin, eso a modo de introducción y anécdota.

"La unión hace la fuerza", eso está más que claro en los resultados: en un año que hace que estoy viajando con ella, hicimos sólo con el proyecto de Argentina en Python más de 18 eventos en 4 países y todo el año que viajé solo, hice nada más que 4 eventos y muchísimo más chicos 😀 . Sin embargo, en todo ese año que viajé solo, aprendí a manejar el 90% de las situaciones que hemos atravesado en el año que viajé con ella. Por eso digo, si bien no pude hacer muchos eventos durante el primer tiempo, aprendí muchísimas cosas sobre el proyecto y sobre todo como hacerlo crecer.

Kiko: ¿Qué habéis ganado cada uno con la unión?

Johanna: Creo que hemos ganado demasiado ambos en esta experiencia de recorrer Latinoamérica con el objetivo principal de compartir conocimiento, el aprendizaje que trae cada día es inmenso en todos los aspectos en ocasiones inimaginables, sin embargo a nivel personal puedo contarte que mi forma de pensar, de visualizar ideas, proyecto, metas y objetivos personales han dado un giro total; si antes pensaba lograr cosas sola o con la ayuda de un director de investigación, ahora sé que puedo generar infinitos proyectos que tendrán continuidad y un acercamiento próximo a la sociedad. Me cuesta mucho salirme de los parámetros invisibles de la ciencia en solitario y ser más relajada al comunicar ideas y propuestas, pero este se convierte en un objetivo constante de cada día: aprender a comunicar con contenido y de forma sencilla.

Humitos: Como decía en la respuesta anterior, Johanna ha colaborado en todos los eventos del último año: desde hacer el Flyer, ayudar con la difusión, darme miles de opiniones sobre la organización, haciendo la registración el día del evento y poniéndose la camiseta de los eventos todos los días.

Además, participó en todos los Django Girls como Coach ayudando a otras chicas a resolver sus problemas con sus computadoras. Eso está buenísimo porque siempre tenemos, al menos, una mujer como Coach lo cual no es menor porque si hacemos eventos destinados a mujeres y no tenemos mujeres Coach "se ve raro", ¿no?

Un detalle no menor, incluso probablemente podría ser el mayor, es su indispensable ayuda en cuanto a toda la organización del viaje, matar la soledad y aumentar la socialización. ¿Qué quiero decir con esto? Cuando estaba solo, absolutamente todo pasaba por mí, decisiones, búsqueda de hospedaje, conversaciones y demás. Era muy difícil y agotador -quita mucho tiempo. Hoy en día, tenemos las tareas muy bien diferenciadas sobre quién se ocupa de cada cosa y ella está muy ligada a lo social, ya que tiene una tonada Colombiana que enamora a cualquiera que le habla y siempre conseguimos, de alguna u otra forma, lo que necesitamos 😀

Kiko: Johanna, ahora que no nos escucha Manuel y puedes hablar mal 😛 , ¿cuéntanos por qué te uniste a la aventura?

Johanna: Varias razones me llevaron a unirme en este viajar por Latinoamérica y el mundo con el proyecto Argentina en Python, pero lo que realmente afirma y concreta esta decisión de unirme finalmente al proyecto, fue la experiencia vivida en el cierre del primer día de la PyCon Ar 2014 en Rafaela, Argentina. Fue allí donde vi con mis propios ojos como trabajan en comunidad. Alguien presentaba una propuesta de algo con lo que tenia inconvenientes o quería mejorar e invitaba al resto a participar. Luego los participantes se unían al proyecto que más les gustaba y entre todos trabajaban resolviendo, mejorando y creando cosas fantásticas. Dije "¿Qué es esto?" Ten en cuenta que vengo del mundo académico de la ciencia en donde los congresos científicos tienen otra modalidad y otra forma de compartir conocimiento. Así que pensé mientras los observaba colaborar "¡Yo quiero ser parte de esta comunidad!" y aquí estoy aprendiendo a colaborar.

Kiko: Johanna, ¿nos puedes contar un poco sobre Química & Nómada?

Johanna: Química & Nómada nace de una búsqueda personal de compartir “ciencia” de una manera informal, con el objetivo principal de acercar a la comunidad al entorno científico, desde la esencia del descubrir y aprender a través de vivir la experiencia de realizar un experimento en donde se aprende a través del juego. Para llevar a cabo este compartir de ciencia, realizamos: jornadas de ciencia para chicos y cafés científicos.

El proyecto tomó forma en el mes de febrero del 2015 en el barrio obrero “Laguna Seca” de la provincia de Corrientes, Argentina. Inspirado a entrar en acción inmediata por 6 niños que jugaban en la plaza ubicada en frente de la casa que nos hospedábamos en esa estación del viaje, ahora nos encontramos en Perú, pero hemos recorrido 3 países y queremos seguir recorriendo Latinoamérica y el mundo compartiendo ciencia.

Cada experiencia que tenemos al realizar los eventos es maravillosa, en especial en las jornadas de ciencia cuando los chicos proponen modificaciones a un experimento que permite realizar ese dialogo abierto de hipótesis y análisis de resultados para comprobar el objetivo de investigación.

En conclusión, más ciencia para la comunidad, empezando por los más chicos que serán en un futuro la población pensante y para los científicos actuales una invitación a ser parte del compartir y acercar ciencia a la comunidad.

Kiko: Tengo entendido que organizásteis un teen track en la ScipyLa 2015 en Posadas (Argentina). ¿Nos podéis comentar la experiencia?

Johanna: El teen track en la ScipyLA, fue una experiencia importante y maravillosa, en el que dos aspectos esenciales se unían para que deseara participar como co-organizadora de esta jornada.

El primer aspecto es a nivel personal, era primordial el participar en la SciPy Latinoamérica, teniendo en cuenta que este evento reúne dos ámbitos de mi interés: ciencia y programación, que lo hacen ideal para mí. Teniendo en cuenta que soy una química interesada en la programación.

El segundo aspecto fue tener la posibilidad de generar un aporte al evento del cual participaría y esto era factible siendo parte de la organización de la jornada del teen track. Esta jornada además cumplía con el objetivo del proyecto Química & Nómada de acercar ciencia a la comunidad. El cual fue posible junto a Manuel Kaufmann cuando asumimos y llevamos a cabo la jornada.

En una apreciación personal sobre el resultado de la jornada Track Teen se puede definir en felicidad y motivación para  continuar gestionando estos espacios en el marco de otras conferencias sobre programación o ciencia.

Previo a eso debo agradecer a los disertantes que compartieron toda su pasión y amor por lo que hacen en su día a día en diferentes profesiones, “¡capos!”. Es la expresión que me viene a la mente en el momento de pensar en como puedo definir su maravillosa gestión dentro de la jornada. Motivamos a más de 50 adolescentes de ultimo grado de secundario de diferentes instituciones académicas de la ciudad de Posadas, Argentina, a ser los científicos o programadores del futuro.

Puedes leer más sobre el evento aquí.

Humitos: "Increíble" creo que queda chico. Cuando desde la organización de SciPyLA nos propusieron hacer esto teníamos mucho miedo y lo dudamos al principio. Lo pensamos unos días, hablamos entre nosotros y tratamos de pre-organizar lo que queríamos organizar. Pusimos mil ideas sobre la mesa, proyectos de desarrollo y un sin fin de opciones sobre qué hacer ese día.

Decidimos hacerlo y emprendernos en esa locura de organización de un evento grande, de forma remota y en el que mientras tanto íbamos a estar organizando otros eventos en otros países también. Esta parte fue muy tensa y estresante pero...

¡Los resultados fueron increíbles y valió muchísimo el esfuerzo! Tuvimos un día entero, dentro de una conferencia internacional de ciencia y tecnología, a ~30 chicos de secundaria a los que le pudimos hablar de programación, astronomía, química, electrónica, circo, comunidad y Software Libre. Además, tuvieron la oportunidad de hablar con profesionales en estos campos durante todo ese día. Logramos mezclar adolescentes con programadores profesionales del mundo real.

Personalmente, aprendí un millón de cosas y me puso en contacto con muchísima gente maravillosa: desde los docentes que fueron acompañando a los chicos hasta con Juan Luis Cano y Kiko (de @pybonacci), quienes me volaron la cabeza en diferentes universos. Incluso, Juan nos dió una mano enorme durante el Track Teen hablándole a los chicos sobre las cosas locas que pasan fuera de la tierra y captó la atención de todos los chicos, como así también la mía y se me pasaron algunas tareas que tenía asignada para hacer, Jajaja!

Hubo varios chicos que luego de la jornada se acercaron a preguntarme "¿Cómo seguir?", "¿Porqué en la escuela nos enseñan PASCAL si Python está mucho mejor?", "¿Cómo podemos hacer para participar más de este mundo?" y cosas similar. Traté de motivar a todos esos diamantes en bruto a que se sumen a todo lo que puedan. Espero haberlo logrado con algunos.

Los docentes que fueron a acompañar a los chicos, maravilloso. Todavía no puedo creer que un preceptor que fue con un curso sabía tanto de tantas cosas y participaba muy bien. Habló de programación hasta química con un conocimiento del tema que me dejó helado. A él también le dí toda la información y recursos que pude, incluso me contactó por email unos días más tarde.

Entonces, "Increíble" queda muy chico. Creo que con esa jornada logramos abrirle la cabeza a una pequeña parte de la próxima generación y eso me pone muy contento.

Kiko: Para ir terminando, Manuel, ¿por qué te llaman Humitos?

Humitos: ¡Qué buena pregunta! Nunca escribí la historia oficial en ningún lado. La he contado verbalmente, pero nunca lo registré. Así que el blog de Pybonacci va a tener la primicia 😛

De adolescente, digamos unos 13 años, cuando usábamos MS-DOS y esas computadoras (que no cualquiera podía acceder) corrían juegos como el Monkey Island, Prince of Persia, Asterix y Obelix; nosotros nos juntábamos con mi primo Gustavo en su casa en Rosario, Santa Fe y nos pasábamos muchas horas jugando y debatiendo sobre cómo avanzar al siguiente nivel -sobre todo en los de aventura gráfica.

Una de las vacaciones que viajo a Rosario para visitarlos, me encuentro que tenía un juego nuevo, también de aventura gráfica, llamado "Flight of the Amazon Queen" que en algún momento mostraba una animación donde el avión donde estaba viajando el personaje principal se estrellaba en una isla (creo que así comenzaba el juego). Entonces, uno comenzaba a caminar por toda la pantalla y en momento, cuando estaba muy lejos, se mostraba el mapa completo desde arriba en el cuál uno podía seleccionar a dónde ir para seguir con la aventura.

Ahí, en ese mapa, en el lugar dónde se había estrellado el avión, salía mucho humo y a mí eso me llamaba la atención. Pasamos horas jugando con mi primo y un amigo de él, Adrián, durante todo el día. Yo ya venía diciendo que en el "humito" estaba la solución sobre cómo seguir avanzando en el videojuego, pero como era más chico que ellos, no me prestaban mucha atención.

Luego, en un momento cuando estaban trabados y no podían seguir adelante en el juego, volví a insistir: "Andá al humito", y nada. Pasó el tiempo y de nuevo: "Andá al humito" y me dijeron: "No se puede ir al humito, nene", pero nunca habían hecho click, o sea, no sabían realmente. Así, cada vez que se preguntaban cómo resolver el acertijo yo decía: "Andá al humito, andá al humito" repetidas veces de una forma insoportable, hasta que se cansaron de mí y me echaron de la habitación por molesto.

Días más tarde, se ve que la historia se popularizó dentro del grupo de amigos de mi primo (todos más grandes que yo) ya que todos me empezaron a decir "humito" luego de esa historia y además, se reían y la contaban una y otra vez.

Finalmente, cuando me empecé a involucrar en el mundo de la informática y la tecnología vi que todos tenía un nickname y yo no tenía -si bien en Rosario me decían "humito", ese grupo era el único que me llamaba así- asi que decidí aprovecharlo para empezar a navegar la internet.

"Pero, ellos te decían «humito» y no «humitos» con 's' al final", dirás, y bueno, la historia de la 's' la voy a guardar para cuando escriba un libro 😛

Kiko: Y la última pregunta sería para Errante, ¿cómo logras soportar a estos dos durante tantas horas?

Errante: Ante todo, gracias a vos, Kiko, ya que eres el primero que me entrevista, esto me hace entregarte la primicia de toda la aventura.

Te diría que no es una tarea nada fácil, pero soy consciente del compromiso que tengo y el cambio que podemos generar con todo esto.

Por otro lado, estoy muy agradecido de estos dos locos que me han llevado por lugares extraordinarios y me hicieron conocer paisajes que de otra forma no hubiese sido posible.

Sin embargo, agradezco cuando llegamos a las metrópolis -que no me gustan para nada- ya que me dejan muchos días estacionado y no tengo que escuchar las boludeces que hablan entre ellos. Me puedo relajar, dormir tranquilo y recargar baterías para la próxima aventura...

"Mi apariencia es de un auto familiar, pero mi alma y potencia tienen todo el carácter de un 4x4."

¿Y la entrada para la PyConES 2015?

Este año adquirí mi entrada para la PyConES pero, por diversas circunstancias, no voy a poder ir. Mi entrada queda libre a disposición del que quiera participar en una ¡¡subasta!!

¿De qué se trata eso de la subasta? Como he visto que hay varias personas que se habían quedado sin entrada la idea es que la gente que quiera la entrada puje por ella empezando por 35 € (el precio original de la entrada).

¿Dónde irá el dinero de la entrada? Los 35 € que yo pagué no irán a mi bolsillo, los dono a Argentina en Python. Todo lo que pase de los 35 € lo donará el ganador de la subasta también a Argentina en Python. Por tanto, el ganador de la puja, si la misma llega, por ejemplo, a los a 50€, 35 € los pagará para la entrada y otros 15 € los donará a un proyecto tan bonito como Argentina en Python.

Para participar deja un comentario con el valor de tu puja (introduciendo un correo electrónico válido) e indicando #pujaPyConES en el comentario, por ejemplo:

#pujaPyConES

5000€

La subasta termina el día 13 a las 00.00 (es decir, podéis pujar hasta las 23.59 del día 12). Hora local de la Península Ibérica (España).

Muchas gracias a Manuel y a Johanna.

Análisis Cluster (III): Clasificación no supervisada mediante K-medias

(Este es el tercer capítulo de la mini-serie de artículos sobre análisis cluster que estamos haciendo en pybonacci, si todavía no has leído los anteriores artículos les puedes echar un ojo ahora. Escribir esta tercera parte solo ha tardado ¡¡¡tres años en salir!!!).
El algoritmo de k-medias es uno de los algoritmos más sencillos de agrupamiento dentro del campo del aprendizaje automático (machine learning para los hipsters). Sirve para agrupar $N$-elementos en $K$-grupos distintos.

Agrupamiento

(Breve resumen de lo visto en anteriores artículos).
Las técnicas de agrupamiento o análisis Cluster son un tipo de aprendizaje no supervisado ya que no requieren un aprendizaje previo a partir de los datos.
Son métodos para agrupar datos sin etiqueta en subgrupos. Estos subgrupos pretenden reflejar algún tipo de estructura interna.

K-medias

El algoritmo de K-medias es un algoritmo de agrupamiento particional que nos crea $K$ particiones de los $N$ datos (con $N \geqslant K$). El algoritmo se puede resumir en los siguientes pasos:

  • Seleccionar $K$ puntos de forma aleatoria en un dominio que comprende todos los puntos del conjunto de datos. estos $K$ puntos representan los centros iniciales de los grupos (lo veremos en el método _init_centroids de la clase KMeans que luego explicaremos más en detalle). No vamos a implementar ningún método de posicionamiento inicial complejo, los centros iniciales serán valores aleatorios colocados entre los umbrales mínimos y máximos del conjunto de puntos (entre las $x$, $y$ mínimas y máximas). El problema que resolveremos será en dos dimensiones, como ya podéis intuir.
  • Asignar cada punto del conjunto de datos al grupo con el centro más próximo (lo veremos en el método _assign_centroids de la clase KMeans, llegaremos en breve).
  • Recalculamos los centros de los grupos a partir de todos los datos asignados a cada grupo, es decir, calculamos el centroide de cada grupo método _recalculate_centroids de la clase (KMeans).
  • Repetir los dos pasos anteriores hasta que se cumpla un condición que puede ser:
    • Se ha alcanzado un número máximo de iteraciones (no deseable).
    • Los centroides ya no cambian más allá de un rango.

    Nosotros solo comprobaremos el segundo ya que solo vamos a manejar conjuntos pequeños de datos. Le pondremos un límite de variación a nuestra clase KMeans que deberán cumplir todos los centroides. La comprobación sobre si parar las iteraciones se realizarán en el método _check_stop de la clase KMeans.

Todo esto pretende ser más educativo que riguroso

La implementación que vamos a hacer será en Python puro ya que pretende ser educativa de cara a ayudar a conocer el funcionamiento del algoritmo paso a paso. Tenéis implementaciones mucho más desarrolladas, precisas, con mejor rendimiento,..., en paquetes como scipy, scikit-learn u otros.

La implementación

[AVISO PARA NAVEGANTES: Todo el código está pensado para funcionar en Python 3. Si usas Python 2 deberías empezar a pensar en actualizarte].
Primero escribo la clase a capón y luego la voy desgranando poco a poco. La he escrito como un iterador de forma que nos permita iterar fácilmente paso a paso (la iteración paso a paso la veremos de forma visual para intentar aportar aun mayor claridad). Para ver más sobre iteradores podéis DuckDuckGoear o ver este enlace.

class KMeans:
    def __init__(self, x, y, n_clusters = 1, limit = 10):
        self.x = x
        self.x_min = min(x)
        self.x_max = max(x)
        self.y = y
        self.y_min = min(y)
        self.y_max = max(y)
        self.n_clusters = n_clusters
        self.limit = limit
        self._init_centroids()        
        self.iterations = 0

    def _init_centroids(self):
        self.x_centroids = []
        self.y_centroids = []
        self.colors = []
        for i in range(self.n_clusters):
            self.x_centroids.append(randint(self.x_min, self.x_max))
            self.y_centroids.append(randint(self.y_min, self.y_max))
            r = randint(0,255)
            g = randint(0,255)
            b = randint(0,255)
            color = 'rgb({0},{1},{2})'.format(r, g, b)
            self.colors.append(color)
        self._assign_centroids()

    def _assign_centroids(self):
        self.c = []
        # Maximum possible distance to a centroid
        dmax  = sqrt((self.x_min - self.x_max)**2 + 
                     (self.y_min - self.y_max)**2)
        for xi, yi in zip(self.x, self.y):
            cluster = 0
            d0 = dmax
            for i in range(self.n_clusters):
                d = sqrt((xi - self.x_centroids[i])**2 + 
                         (yi - self.y_centroids[i])**2)
                if d < d0:
                    cluster = i
                    d0 = d
            self.c.append(cluster)

    def _recalculate_centroids(self):
        self._x_centroids = self.x_centroids[:]
        self._y_centroids = self.y_centroids[:]
        for n in range(self.n_clusters):
            x0 = 0
            y0 = 0
            cont = 0
            for i, c in enumerate(self.c):
                if c == n:
                    cont += 1
                    x0 += self.x[i]
                    y0 += self.y[i]
            self.x_centroids[n] = x0 / cont
            self.y_centroids[n] = y0 / cont
        self._assign_centroids()

    def _check_stop(self):
        for i in range(self.n_clusters):
            d = sqrt(
                (self._x_centroids[i] - self.x_centroids[i])**2 +
                (self._y_centroids[i] - self.y_centroids[i])**2
                )
            if d > self.limit:
                return False
        return True

    def __iter__(self):
        return self

    def __next__(self):
        self.iterations += 1
        self._recalculate_centroids()
        stop = self._check_stop()
        if stop == True:
            raise StopIteration
        return self

La clase anterior paso a paso:

método __init__

def __init__(self, x, y, n_clusters = 1, limit = 10):
        self.x = x
        self.x_min = min(x)
        self.x_max = max(x)
        self.y = y
        self.y_min = min(y)
        self.y_max = max(y)
        self.n_clusters = n_clusters
        self.limit = limit
        self._init_centroids()        
        self.iterations = 0

Inicializamos la clase con los valores x de los puntos, los valores y de los puntos, el número de grupos a usar, n_clusters y el límite del desplazamiento de los grupos a partir del cual consideraremos que podemos parar de iterar, limit.
Además, a partir del los valores introducidos, extraemos las ventana umbral donde se colocan los puntos (atributos x_min, x_max, y_min e y_max) que después usaremos para inicializar los centroides (mediante _init_centroids).

método _init_centroids

    def _init_centroids(self):
        self.x_centroids = []
        self.y_centroids = []
        self.colors = []
        for i in range(self.n_clusters):
            self.x_centroids.append(randint(self.x_min, self.x_max))
            self.y_centroids.append(randint(self.y_min, self.y_max))
            r = randint(0,255)
            g = randint(0,255)
            b = randint(0,255)
            color = 'rgb({0},{1},{2})'.format(r, g, b)
            self.colors.append(color)
        self._assign_centroids()

Mediante este método, que se usa al inicializar la clase, creamos los centroides iniciales a partir de valores aleatorios situados entre los valores de x_min, x_max, y_min e y_max. Además, asignamos unos colores aleatorios a cada centroide (que luego usaremos en la visualización). Pensándolo fríamente, ahora que estoy escribiendo esto, la verdad que colors podría estar fuera de esta clase pero lo vamos a dejar así.
Una vez que se han creado los centroides hacemos la asignación de cada punto del conjunto de puntos $x$ e $y$ a cada centroide mediante el método _assign_centroids.

método _assign_centroids

    def _assign_centroids(self):
        self.c = []
        # Maximum possible distance to a centroid
        dmax  = sqrt((self.x_min - self.x_max)**2 + 
                     (self.y_min - self.y_max)**2)
        for xi, yi in zip(self.x, self.y):
            cluster = 0
            d0 = dmax
            for i in range(self.n_clusters):
                d = sqrt((xi - self.x_centroids[i])**2 + 
                         (yi - self.y_centroids[i])**2)
                if d < d0:
                    cluster = i
                    d0 = d
            self.c.append(cluster)

en el atributo c (que es una lista) almacenamos el valor del grupo al que pertenece cada punto del conjunto de datos $x$ e $y$. Para ello, primero tenemos que calcular la distancia de cada punto a cada centroide y el que centroide que tenga menos distancia al punto será el asignado. Por tanto, en este paso, hemos de calcular $N \cdot K$ distancias.

método _recalculate_centroids

    def _recalculate_centroids(self):
        self._x_centroids = self.x_centroids[:]
        self._y_centroids = self.y_centroids[:]
        for n in range(self.n_clusters):
            x0 = 0
            y0 = 0
            cont = 0
            for i, c in enumerate(self.c):
                if c == n:
                    cont += 1
                    x0 += self.x[i]
                    y0 += self.y[i]
            self.x_centroids[n] = x0 / cont
            self.y_centroids[n] = y0 / cont
        self._assign_centroids()

En este paso, recalculamos los centroides. Cada nuevo centroide será el centroide de los puntos asignados a ese centroide. Los antiguos centroides los conservamos para poder compararlos con los nuevos y ver si han variado poco o mucho las nuevas posiciones de los centroides. Una vez que hemos calculado los nuevos centroides y que mantenemos los antiguos asignamos los puntos a los nuevos centroides mediante el método _assign_centroids explicado anteriormente.

método _check_stop

    def _check_stop(self):
        for i in range(self.n_clusters):
            d = sqrt(
                (self._x_centroids[i] - self.x_centroids[i])**2 +
                (self._y_centroids[i] - self.y_centroids[i])**2
                )
            if d > self.limit:
                return False
        return True

En este método calculamos si la diferencia entre la posición de los centroides antiguos y de los nuevos es superior o inferior al límite o umbral que hemos definido al instanciar la clase. Si cualquiera de los centroides se ha movido más del umbral definido seguiremos iterando (_check_stop devolverá False), si ninguno supera el umbral le diremos que pare de iterar (_check_stop devolverá True).

métodos __iter__ y __next__

    def __iter__(self):
        return self

    def __next__(self):
        self.iterations += 1
        self._recalculate_centroids()
        stop = self._check_stop()
        if stop == True:
            raise StopIteration
        return self

Si os habéis leído el enlace sobre iteradores que he dejado más arriba espero que esto sea sencillo de entender.

  • El método __iter__ no necesita mayor explicación.
  • El método __next__ incrementa el atributo iterations, que no vamos a usar pero que podríamos usar para limitar, por ejemplo, el número de iteraciones, os lo dejo como ejercicio :-D, cada vez que damos un nuevo paso recalculamos los centroides y chequeamos si hay que parar la iteración porque hemos cumplido las condiciones fijadas (sí, el stop == True es redundante pero he pretendido que sea lo más claro posible).

Visualización

El hecho de crear la clase como un iterador es porque he pensado que podríamos iterar en cada paso y hacer una visualización interactiva. Como la visualizazión quiero que funciones cuando el notebook está estático he recurrido a usar Brythonmagic.
Si queréis saber más sobre Brythonmagic podéis leer el README del enlace anterior o ver esta entrada con vídeo y todo que muestra el funcionamiento.
Como resumen, básicamente es una magic function para el notebook que nos permite usar brython (una implementación de Python 3 hecha en javascript que funciona en el navegador sin necesidad de ningún kernel detrás).
Si no lo tienes instalado lo puedes instalar mediante pip.

!pip install brythonmagic
Downloading/unpacking brythonmagic
  Downloading brythonmagic-0.1.1.tar.gz
  Running setup.py (path:/home/kiko/pyprojs/venv-scipy/build/brythonmagic/setup.py) egg_info for package brythonmagic
    
Requirement already satisfied (use --upgrade to upgrade): ipython>=1.0 in /home/kiko/pyprojs/venv-scipy/lib/python3.4/site-packages (from brythonmagic)
Installing collected packages: brythonmagic
  Running setup.py install for brythonmagic
    
Successfully installed brythonmagic
Cleaning up...
Para poder hacer uso de la extensión la hemos de cargar mediante:

%load_ext brythonmagic
El paso siguiente nos permite usar toda la maquinaria de brython en el navegador dentro del notebook y es el último paso para que todo funcione.

%%HTML
<script type="text/javascript" src="http://brython.info/src/brython_dist.js"></script>
Podemos comprobar si funciona con el siguiente ejemplo. Después de ejecutar la celda debrías de ver un mensaje en pantalla (esto seré un poco enojante cuando lo veamos en estático puesto que siempre saltará esta ventana...):

%%brython
from browser import alert
alert('it works!')
A continuación metemos el código de la clase KMeans que ya hemos detallado más arriba y la llamaremos desde otras celdas brython a partir del nombre que le hemos dado en esta celda (kmeans_class, ver primera línea de la celda)

%%brython -s kmeans_class
from math import sqrt
from random import randint

class KMeans:
    def __init__(self, x, y, n_clusters = 1, limit = 10):
        self.x = x
        self.x_min = min(x)
        self.x_max = max(x)
        self.y = y
        self.y_min = min(y)
        self.y_max = max(y)
        self.n_clusters = n_clusters
        self.limit = limit
        self._init_centroids()        
        self.iterations = 0
        
    def _init_centroids(self):
        self.x_centroids = []
        self.y_centroids = []
        self.colors = []
        for i in range(self.n_clusters):
            self.x_centroids.append(randint(self.x_min, self.x_max))
            self.y_centroids.append(randint(self.y_min, self.y_max))
            r = randint(0,255)
            g = randint(0,255)
            b = randint(0,255)
            color = 'rgb({0},{1},{2})'.format(r, g, b)
            self.colors.append(color)
        self._assign_centroids()
    
    def _assign_centroids(self):
        self.c = []
        # Maximum possible distance to a centroid
        dmax  = sqrt((self.x_min - self.x_max)**2 + 
                     (self.y_min - self.y_max)**2)
        for xi, yi in zip(self.x, self.y):
            cluster = 0
            d0 = dmax
            for i in range(self.n_clusters):
                d = sqrt((xi - self.x_centroids[i])**2 + 
                         (yi - self.y_centroids[i])**2)
                if d < d0:
                    cluster = i
                    d0 = d
            self.c.append(cluster)
    
    def _recalculate_centroids(self):
        self._x_centroids = self.x_centroids[:]
        self._y_centroids = self.y_centroids[:]
        for n in range(self.n_clusters):
            x0 = 0
            y0 = 0
            cont = 0
            for i, c in enumerate(self.c):
                if c == n:
                    cont += 1
                    x0 += self.x[i]
                    y0 += self.y[i]
            self.x_centroids[n] = x0 / cont
            self.y_centroids[n] = y0 / cont
        self._assign_centroids()
    
    def _check_stop(self):
        for i in range(self.n_clusters):
            d = sqrt(
                (self._x_centroids[i] - self.x_centroids[i])**2 +
                (self._y_centroids[i] - self.y_centroids[i])**2
                )
            if d > self.limit:
                return False
        return True
    
    def __iter__(self):
        return self
    
    def __next__(self):
        self.iterations += 1
        self._recalculate_centroids()
        stop = self._check_stop()
        if stop == True:
            raise StopIteration
        return self
El código que figura a continuación es parte de una librería que empecé hace un tiempo para hacer gráficos en el canvas del navegador de forma simple a partir de Brython. La funcionalidad básica está en el módulo base.py y lo que figura a continuación es parte de ese módulo modificado en algún sitio.
NO VOY A EXPLICAR ESTE CÓDIGO EN DETALLE PUESTO QUE NO ES PARTE DEL PROPÓSITO DE LA ENTRADA Y NO QUIERO DESVIAR LA ATENCIÓN. SI TENÉIS ALGUNA DUDA O INTERÉS PODÉIS USAR LOS COMENTARIOS DEL BLOG PARA ELLO.
El código a continuación permite dibujar sobre un canvas HTML5 diferentes formas. Solo vamos a definir formas para dibujar círculos, para los puntos y los centroides de los grupos, y líneas, para mostrar qué puntos se asignan a qué centroide en cada paso.

%%brython -s canvas_utils
from browser import document as doc
import math

## Base classes for higher level objects
class Figure:
    """
    Base class to create other elements.
    """
    def __init__(self, canvasid, 
                       facecolor = "white", 
                       edgecolor = "black", 
                       borderwidth = None):
        """        
        Parameters
        ----------
        *canvasid*: String
            String indicating the canvas id where the image should be 
            rendered.
        *facecolor*: String
            String value containing a valid HTML color
        *edgecolor*: String
            String value containing a valid HTML color
        *borderwidth*: Integer
            Value indicating the width of the border in pixels.
            If not provided it will 0 and the edgecolor will not be
            visible
        """

        if isinstance(canvasid, str):
            self.id = canvasid
        else:
            raise Exception("The canvasid parameter should be a string")
             
        try:
            self.canvas = doc[self.id]
        except:
            raise Exception("No HTML element with id=%s" %
                            self.id)
        
        try:
            self._W = self.canvas.width
            self._H = self.canvas.height
            self._ctx = self.canvas.getContext("2d")
        except:
            raise Exception("You must provide the ID of a <canvas> element")
        
        self.facecolor = facecolor
        self.borderwidth = borderwidth
        self.edgecolor = edgecolor
        self.clf()
    
    def clf(self):
        "clear the figure"
        self._ctx.save()
        
        # The following line should clear the canvas but I found a
        # problem when I use beginPath ¿¿¿???
        #self._ctx.clearRect(0, 0, self._W, self._H)
        # So I use the following line that is less performant but
        # this operation shouldn't be done very often...
        self.canvas.width = self.canvas.width
        
        self._ctx.fillStyle = self.facecolor
        self._ctx.fillRect(0, 0, self._W, self._H)
        self._ctx.fill()
        if self.borderwidth:
            self._ctx.lineWidth = self.borderwidth
            self._ctx.strokeStyle = self.edgecolor
            self._ctx.strokeRect(0, 0, self._W, self._H)
            self._ctx.stroke()
        self._ctx.restore()
        

class Shape:
    """
    Base class to create other elements.
    """
    def __init__(self, context, x, y,
                       facecolor = "black", 
                       edgecolor = "black",
                       #alpha = 1,
                       borderwidth = None):
        """        
        Parameters
        ----------
        *context*: a canvas context
            a valid canvas context where the text will be rendered
        *x*: int or float
            x value for location in pixels
        *y*: int or float
            y value for location in pixels
        *facecolor*: String
            String value containing a valid HTML color
        *edgecolor*: String
            String value containing a valid HTML color
        *alpha*: int or float
            Value between 0 (transparent) and 1 (opaque) to set the
            transparency of the text
        *borderwidth*: Integer
            Value indicating the width of the border in pixels.
            If not provided it will 0 and the edgecolor will not be
            visible
        """
        self._ctx = context
        self.x = x
        self.y = y
        self.facecolor = facecolor
        self.borderwidth = borderwidth
        self.edgecolor = edgecolor
        #self.alpha = alpha

class Circle(Shape):
    def __init__(self, *args, radius = 10, **kwargs):
        """
        Parameters
        ----------
        *radius*: int or float
            radius of the circle in pixels.
        """
        Shape.__init__(self, *args, **kwargs)
        self.r = radius
        self.draw()
    
    def draw(self):
        self._ctx.save()
        #self._ctx.globalAlpha = self.alpha
        self._ctx.beginPath()
        self._ctx.fillStyle = self.facecolor
        self._ctx.arc(self.x, self.y, self.r, 0, 2 * math.pi)
        self._ctx.fill()
        if self.borderwidth:
            self._ctx.lineWidth = self.borderwidth
            self._ctx.strokeStyle = self.edgecolor
            self._ctx.arc(self.x, self.y, self.r, 0, 2 * math.pi)
            self._ctx.stroke()
        self._ctx.closePath()
        self._ctx.restore()

class Line(Shape):
    def __init__(self, *args, polygon = False, borderwidth = 2, **kwargs):
        Shape.__init__(self, *args, **kwargs)
        self.borderwidth = borderwidth
        self.polygon = polygon
        self.draw()
    
    def draw(self):
        self._ctx.save()
        #self._ctx.globalAlpha = self.alpha
        self._ctx.beginPath()
        self._ctx.moveTo(self.x[0], self.y[0])
        for i in range(len(self.x)):
            self._ctx.lineTo(self.x[i], self.y[i])
        if self.polygon:
            self._ctx.closePath()
            if self.facecolor:
                self._ctx.fillStyle = self.facecolor
                self._ctx.fill()
        if self.borderwidth:
            self._ctx.lineWidth = self.borderwidth
            self._ctx.strokeStyle = self.edgecolor
            self._ctx.stroke()
        self._ctx.restore()
El siguiente código solo nos va a valer para establecer una mínima disposición de los elementos contenidos en la visualización.
Se incluye un canvas, donde se dibujarán las cosas, y un botón, para poder iterar el algoritmo.

html = """
<div id="main">
 <p>
  <canvas id="cnvs01" width=500 height=500></canvas>
 </p>
 <p>
  <button id="button" class="btn">Next step</button>
 </p>
</div>"""
Por último, este es el código que realiza todo a partir de los demás. Voy a intentar explicarlo un poco más en detalle:

fig = Figure('cnvs01', borderwidth = 2)

n_points = 50
x = [randint(10, fig._W - 10) for value in range(n_points)]
y = [randint(10, fig._H - 10) for value in range(n_points)]

kmeans = KMeans(x, y, n_clusters = 4, limit = 1)

def plot(obj):
    fig._ctx.save()
    fig._ctx.fillStyle= "#ffffff"
    fig._ctx.globalAlpha = 0.3
    fig._ctx.fillRect(2,2,fig._W-4,fig._H-4)
    fig._ctx.restore()
    x = obj.x
    y = obj.y
    npoints = len(x)
    colors = obj.colors
    xc = obj.x_centroids
    yc = obj.y_centroids
    c = obj.c
    for i in range(npoints):
        color = colors[c[i]]
        Line(fig._ctx, [x[i], xc[c[i]]], [y[i], yc[c[i]]],
             facecolor = color, edgecolor = color)
        Circle(fig._ctx, x[i], y[i], 
               facecolor = color, edgecolor = 'black',
               borderwidth = 1, radius = 4)
    for xci, yci, color in zip(xc, yc, colors):
        Circle(fig._ctx, xci, yci, 
               facecolor = color, edgecolor = 'black',
               borderwidth = 1, radius = 8)

def update(ev):
    plot(kmeans)
    try:
        next(kmeans)
    except:
        #doc['button'].disabled = True
        del doc['button']

doc['button'].bind('click', update)

  • fig = Figure('cnvs01', borderwidth = 2) inicializamos el canvas con un borde negro usando la clase Figure creada más arriba.
  • Definimos el número de puntos a usar y las posiciones de los puntos.
  • Inicializamos el objeto mediante kmeans = KMeans(x, y, n_clusters = 4, limit = 1). En este caso queremos que tenga 4 clusters (n_clusters) y que el límite (limit) para dejar de iterar sea cuando los centroides se muevan un pixel o menos.
  • La función plot hace varias cosas.
    1. Primero suaviza los colores de la imagen previa antes de la actual iteración (esto está más relacionado con el canvas HTML5 y con javascript y no hace falta entenderlo mucho más allá de lo comentado en esta línea)
      fig._ctx.save()
      fig._ctx.fillStyle= "#ffffff"
      fig._ctx.globalAlpha = 0.3
      fig._ctx.fillRect(2,2,fig._W-4,fig._H-4)
      fig._ctx.restore()
    2. Después extraemos todos los datos del objeto (kmeans) que vamos a usar dentro de la función.
      x = obj.x
      y = obj.y
      npoints = len(x)
      colors = obj.colors
      xc = obj.x_centroids
      yc = obj.y_centroids
      c = obj.c
    3. Dibujamos las líneas entre los puntos y los centroides y los puntos con colores asociados a cada grupo
      for i in range(npoints):
         color = colors[c[i]]
         Line(fig._ctx, [x[i], xc[c[i]]], [y[i], yc[c[i]]],
              facecolor = color, edgecolor = color)
         Circle(fig._ctx, x[i], y[i], 
                facecolor = color, edgecolor = 'black',
                borderwidth = 1, radius = 4)
    4. Y finalmente se dibujan los centroides de cada grupo con un círculo un poco más grande que los propios puntos
      for xci, yci, color in zip(xc, yc, colors):
         Circle(fig._ctx, xci, yci, 
                facecolor = color, edgecolor = 'black',
                borderwidth = 1, radius = 8)
  • Creamos, además, una función update que será la que llama a la función plot y la que llama a una nueva iteración. El código que figura en el bloque except, del doc['button'], es más de la parte de brython y sirve para que el botón desaparezca una vez que el iterador ha quedado exhausto (se han agotado las iteraciones).
  • La última línea de código, doc['button'].bind('click', update), asocia el evento click del botón a la función update que he comentado anteriormente.

Si ahora ejecutamos la siguiente celda de código deberíamos ver un canvas de 500px x 500px con un botón debajo. Si vamos pulsando al botón veremos como nueva iteración en acción, además de ver las anteriores iteraciones de forma difuminada. Una vez que hemos alcanzado la condición de que los centroides no se mueven más desaparecerá el botón (para no teneros ahí pulsando y que me digáis que eso no sigue funcionando...).

%%brython -S kmeans_class canvas_utils -h html

fig = Figure('cnvs01', borderwidth = 2)

n_points = 50

x = [randint(10, fig._W - 10) for value in range(n_points)]
y = [randint(10, fig._H - 10) for value in range(n_points)]

kmeans = KMeans(x, y, n_clusters = 4, limit = 1)

def plot(obj):
    fig._ctx.save()
    fig._ctx.fillStyle= "#ffffff"
    fig._ctx.globalAlpha = 0.3
    fig._ctx.fillRect(2,2,fig._W-4,fig._H-4)
    fig._ctx.restore()
    x = obj.x
    y = obj.y
    npoints = len(x)
    colors = obj.colors
    xc = obj.x_centroids
    yc = obj.y_centroids
    c = obj.c
    for i in range(npoints):
        color = colors[c[i]]
        Line(fig._ctx, [x[i], xc[c[i]]], [y[i], yc[c[i]]],
             facecolor = color, edgecolor = color)
        Circle(fig._ctx, x[i], y[i], 
               facecolor = color, edgecolor = 'black',
               borderwidth = 1, radius = 4)
    for xci, yci, color in zip(xc, yc, colors):
        Circle(fig._ctx, xci, yci, 
               facecolor = color, edgecolor = 'black',
               borderwidth = 1, radius = 8)

def update(ev):
    plot(kmeans)
    try:
        next(kmeans)
    except:
        #doc['button'].disabled = True
        del doc['button']
        
doc['button'].bind('click', update)
Podéis ver todo el código contenido en una página web aquí.

Conclusiones

Espero que haya quedado claro el funcionamiento básico del algoritmo K-Medias. También espero que si veis alguna errata en el código me aviséis o hagáis un Pull Request a nuestro repositorio de notebooks.
Podéis ver este notebook funcionando incluso en estático en el siguiente enlace.