[Python-es] Eficiencia de las listas

[Kiko]

pandas está muy 'cythonizado' por lo que para muchas operaciones
debería ser muy buena opción. Su funcionamiento pretende emular parte
de la funcionalidad de R (dataframes).

Si trabajas con información muy 'grande' que no entra en memoria una
buena opción es pytables ya que el acceso a los datos es muy rápido.
Si te entra todo en memoria quizá no es necesario que lo pruebes
ahora.

Gente que andaba desarrollando numexpr (Francesc) ahora están metidos
en continuum que son los desarrolladores de numba, blaze,... Numexpr
es un jit de un subconjunto limitado de operaciones. Numba quizá sea
algo más generalista y es realmente brillante cuando hay que meterse
en bucles y la vectorización de numpy no ayuda del todo
(http://jakevdp.github.io/blog/2013/06/15/numba-vs-cython-take-2/).

Saludos.

El 07/08/13, Chema Cortes <pych3m4 en gmail.com> escribió:
> El día 7 de agosto de 2013 14:30, Kiko <kikocorreoso en gmail.com> escribió:
>
>> mira también rot90, fliplr, flipud...
>>
>> http://docs.scipy.org/doc/numpy/reference/routines.array-manipulation.html#rearranging-elements
>
> Los había mirado, pero son funciones para  >= 2-d. No veo cómo usarlas
> con listas unidimensionales.
>
>
>>
>> El 07/08/13, Chema Cortes <pych3m4 en gmail.com> escribió:
>>> El día 6 de agosto de 2013 16:38, Daπid <davidmenhur en gmail.com> escribió:
>>>> 2013/8/6 Chema Cortes <pych3m4 en gmail.com>:
>>>
>>>> Por otro lado, si la operación de inversión no se hace sobre el array,
>>>> sino sobre una copia, se gana tiempo:
>>>>
>>>> In [31]: l2 = l.copy()
>>>>
>>>> In [32]: %timeit l[i+1:j+1]=l2[j:i:-1]
>>>> 10000 loops, best of 3: 101 us per loop
>>>
>>> He mirado un poco mejor el funcionamiento de los arrays en numpy. Los
>>> troceos no crean nuevos arrays, sino lo que llama "vistas" ("views")
>>> (a excepción de los "fancy indexing" de numpy). Como las vistas están
>>> enlazadas con el objeto original, los cambios en una vista se efectúan
>>> directamente sobre el objeto original de forma eficiente.
>>>
>>> Creo que usaré los arrays de numpy para operaciones con listas
>>> grandes. También necesitaba hacer rotar la lista, cosa que veo que
>>> puede hacer con np.roll, aunque no es tan eficiente como deque
>>> .rotate() que realiza la operación "in-place".
>>>
>>> Como curiosidad, había descartado algunas pruebas bizarras con deque,
>>> pero muestra lo increiblemente rápido que puede llegar a ser:
>>>
>>> d=deque(l)
>>>
>>> %timeit d.rotate(-i-1);d.extendleft([d.popleft() for _ in
>>> range(j-i)]);d.rotate(i+1)
>>> 10 loops, best of 3: 29.8 ms per loop
>>>
>>> Es la misma operación que l[i+1:j+1]=l2[j:i:-1], primero rotando la
>>> lista hacia la izquierda, añadiendo la lista invertida al principio y
>>> volviendo a rotar hacia la derecha para mantener el mismo orden.
>>>
>>>
>>> --
>>> Hyperreals *R  "Quarks, bits y otras criaturas infinitesimales":
>>> http://ch3m4.org/blog
>>> Buscador Python Hispano: http://ch3m4.org/python-es
>>> _______________________________________________
>>> Python-es mailing list
>>> Python-es en python.org
>>> http://mail.python.org/mailman/listinfo/python-es
>>> FAQ: http://python-es-faq.wikidot.com/
>>>
>> _______________________________________________
>> Python-es mailing list
>> Python-es en python.org
>> http://mail.python.org/mailman/listinfo/python-es
>> FAQ: http://python-es-faq.wikidot.com/
>
>
>
> --
> Hyperreals *R  "Quarks, bits y otras criaturas infinitesimales":
> http://ch3m4.org/blog
> Buscador Python Hispano: http://ch3m4.org/python-es
> _______________________________________________
> Python-es mailing list
> Python-es en python.org
> http://mail.python.org/mailman/listinfo/python-es
> FAQ: http://python-es-faq.wikidot.com/
>