[pyar] ¿Volvemos a empezar?

[Roberto Alsina]

On 30/04/14 22:47, Fernando Pelliccioni wrote:
>
>
>
> 2014-04-30 22:43 GMT-03:00 Roberto Alsina <ralsina en netmanagers.com.ar 
> <mailto:ralsina en netmanagers.com.ar>>:
>
>     On 30/04/14 22:37, Fernando Pelliccioni wrote:
>>
>>
>>
>>     2014-04-30 21:45 GMT-03:00 Roberto Alsina
>>     <ralsina en netmanagers.com.ar <mailto:ralsina en netmanagers.com.ar>>:
>>
>>         On 30/04/14 21:37, Fernando Pelliccioni wrote:
>>>
>>>>             Ahora, que "conozco" algo sobre la semantica de Slice.
>>>>             ¿Que implica, a nivel complejidad, hacer lo siguiente?
>>>>
>>>>             s == s[::-1]
>>>>
>>>>             Donde s es una secuencia (o un tipo "Slice-able").
>>>>
>>>
>>>             Depende.
>>>
>>>
>>>>             Por las dudas claro:
>>>>             Se la respuesta, lo pregunto para que veamos si podemos
>>>>             mejorar el algoritmo)
>>>
>>>             No, no creo que la sepas :-)
>>>             La complejidad es la que sea que tenga s.__getitem__
>>>
>>>
>>>         Tengo que leer todavia el link que me pasaste acerca de
>>>         s.__getitem__
>>>         Bueno, en realidad me refería a suponer el peor de los casos.
>>
>>         Infinita.
>>
>>         class X(object):
>>             def __getitem__(self, *a, **kw):
>>                 while True:
>>                     pass
>>
>>
>>     Vos podés calcular la complejidad del algoritmo a pesar de casos
>>     con side-effects como estos.
>>     Para no concentrarnos en estas cosas por ahora, entonces, digamos
>>     que vamos a operar con las secuencias built-in de Python.
>
>     No, no podés. Pero bueno, como decís vamos a las secuencias
>     built-in. ¿Cual? Porque no es lo mismo una lista que un string.
>
>
>>
>>
>>         ¿En el mejor de los casos? Constante:
>>
>>         >>> class X(object):
>>         ...     def __getitem__(self, *a, **kw):
>>         ...          return 42
>>         ...
>>         >>> x=X()
>>         >>> x[1:34]
>>         42
>>
>>
>>     Por mas que __getitem__ sea constant-time no modifica la
>>     complejidad de mi algoritmo, ejemplo
>>
>>     # Pseudo-Codigo, no se exasperen, se que no es el estilo de
>>     programacion usado en python, es un ejemplo
>>             sum = 0
>>             x = X()            # x es del tipo X
>>             for ( i  from 0 to size(x) )
>>                  sum = sum + x[i]          # x[i] es constant time, y
>>     retorna siempre 42
>>
>>     Cual es la complejidad de mi algoritmo?
>>
>
>     Es que ahí estás calculando la complejidad de ese loop, no de lo
>     que hace __getitem__ que es lo que hacía tu ejemplo anterior.
>     Cuando haces un slice, lo que hacés es una simple llamada a
>     __getitem__. La complejidad de __getitem__ es arbitraria, depende
>     de la clase.
>
>
>
> Lei hasta aca nada mas, me tengo que ir.
>
> Creo que alguno de los dos no entiende cual es la relacion entre Slice 
> y GetItem. Lo mas probable es que sea yo :)
> Concentrandonos solo en Secuencias (dejando de lado mapping types) 
> asumo que GetItem sirve para acceder a un indice dado por una secuencia.
> Como implementarias Slice con GetItem? (Suponiendo que Slice sea una 
> funcion)
>

Y bueno, si no leés la documentación que te pasan no se puede :-)

Te la paso de nuevo:

https://docs.python.org/2/reference/datamodel.html#object.__getitem__

Y te doy un ejemplo:

 >>> 'casa'.__getitem__(slice(None,None,-1))
'asac'

iterable[a:b:c] es *exactamente* iterable.__getitem__(slice(a,b,c))

Eso es lo que es, y es todo lo que es. No es otra cosa. No hay nada más. 
Eso es todo. Ahí se terminan los slices. Eso es to, eso es to, eso es 
todo amigos. Es un ex-loro. ha cesado de existir.


------------ próxima parte ------------
Se ha borrado un adjunto en formato HTML...
URL: <http://listas.python.org.ar/pipermail/pyar/attachments/20140430/90fd9151/attachment.html>