[pyar] ¿Volvemos a empezar?

[Fernando Pelliccioni]

2014-04-30 21:08 GMT-03:00 Roberto Alsina <ralsina en netmanagers.com.ar>:

>  On 30/04/14 20:26, Fernando Pelliccioni wrote:
>
>
>
>
> 2014-04-30 19:53 GMT-03:00 Roberto Alsina <ralsina en netmanagers.com.ar>:
>
>>  On 30/04/14 19:46, Fernando Pelliccioni wrote:
>>
>>
>>
>>
>> 2014-04-30 19:40 GMT-03:00 Roberto Alsina <ralsina en netmanagers.com.ar>:
>>
>>>  On 30/04/14 19:28, Fernando Pelliccioni wrote:
>>>
>>>
>>>
>>>
>>> 2014-04-30 19:20 GMT-03:00 Cesar Ballardini <cesar en ballardini.com.ar>:
>>>
>>>> Me parece que Fernando preguntaba si se copiaban los elementos, no la
>>>> lista.
>>>>
>>>>
>>>  Veo dos opciones.
>>>
>>>  - Se crea una nueva lista, conteniendo punteros o referencias a la
>>> lista anterior  (shallow-copy)
>>> - Se crea una nueva lista, conteniendo copias de los elementos
>>> (deep-copy)
>>>
>>>  Según la respuesta de Pablo, creo que es DeepCopy, pero me hace dudar
>>> el CopyOnWrite...
>>> Soy muy desconfiado con estas cosas y me gusta probarlas por mi cuenta o
>>> leerlo bien en la especificación (cosa que no hice porque me dio vagancia
>>> leer toda la pagina, opté por el atajo de consultarles a ustedes)
>>>
>>>
>>>  No, no es ninguna de esas opciones :-)
>>>
>>> En Python la semántica de asignación es un poco distinta que en otros
>>> lenguajes, es simplemente binding de nombres.
>>>
>>> a = b lo unico que hace es bindear el nombre "b" al mismo objeto que
>>> estaba bindeado el nombre "a".
>>> En cierta forma en python todas las variables son punteros.
>>>
>>>
>>>
>>  Entiendo.
>> Pero mi pregunta esta enfocada en el caso del Slice. Como mostraste
>> antes, no podes hacer que B (que es un slice de A) referencia a A.
>> La respuesta de Facundo me deja sin certezas
>>
>>
>>
>>  No entiendo qué querés decir con "no podes hacer que B (que es un slice
>> de A) referencia a A". Podés explicar un poco?
>>
>>
>
>  Escribí cualquier cosa, pero estaba pensando en esto...
>
>  a = 'Python'
> b = a[:]
> id(a)
> id(b)
>
>  c = a[2:4]
> id(c)
>
>
>  Paso a paso, con una impresion burda de la memoria.
>
>  a = 'Python'
>
>  a
>  -------------
>  |P|y|t|h|o|n|
>  -------------
>  0 1 2 3 4 5
>
>  b = a[:]
>
>
>  b
>  a
>  -------------
>  |P|y|t|h|o|n|
>  -------------
>  0 1 2 3 4 5
>
>
> NO :-)
>
> No pienso hacer el diagramita en ASCII porque sería complicado, pero a y b
> son objetos distintos.
>
>
>
Sí, lo se, eso intenté en mi diagrama (no estoy mostrando las direcciones
de memoria de a y b, sino, a donde apuntan, o referencian)
a y b son dos objetos distintos, que apuntan a la misma direccion.


>
>  c = a[2:4]
>
>  b            c
> a
> --------------------------
>  |P|y|t|h|o|n|&a[2]|&a[3]|
> --------------------------
>  0 1 2 3 4 5   6     7
>
>
>  (Espero todos reciban lo anterior en Courier, sino no se va a entender
> un joraca)
>
>
>  Me refería a que no podés asegurar que Slice:
>  - "retorne" una referencia a la secuencia original,
>
>
> Primero: "Slice" no existe. Existe la sintaxis de slices. Un slice de un
> iterable puede ser cualquier cosa. Podés hacer un iterable que cualquier
> slice sea el número 42.
> Hay una convención acerca de qué deben hacer, nada más.
>

Slice es una forma de decir, es mas facil escribir "Slice" que "sintaxis de
slices".


>
>
>    - ni que cree una nueva lista con referencias a la secuencia original.
>
>
> Los slices no solo se aplican a listas. Se aplican a cualquier iterable.
> Algunos iterables son inmutables, y otros son mutables.
> En general en Python no podés nunca asegurar esa clase de cosas.
>
>
>
>  Listo, no le doy más vueltas al asunto... me quedo con que no podés
> asegurar la semantica de Slice, ni siquiera con distintas ejecuciones del
> mismo tipo (los dos ejemplos anteriores estoy usando String).
>
>
> Sospecho que seguís sin entender como funciona, pero lo mejor es que no
> necesitás saberlo, en general.
>
>
>    Todo esto (me fui por las ramas) esta relacionado al algoritmo de
> Palindromos :)
>
>  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.
Suponiendo el peor de los casos, que significa hacer? ( no solo
complejidad asintótica, sino, operaciones concretas )

s == s[::-1]


La respondo yo.

En el peor de los casos:
1.    Para s[::-1]
                   - Memory allocation para la nueva secuencia, ya que como
vimos antes, no podemos asegurar que id(s) == id(s[::-1])
                   - Cargar la nueva lista con las referencias de la lista
original

 2.  Para la comparacion de igualdad ==
              - Iterar sobre la secuencia, realizando...
              - N comparaciones

¿Es necesaria esta complejidad para un algoritmo de palindromos? (no perder
de vista que tengo en mente otra cosa)
¿Es el optimizer tan inteligente para darse cuenta de esto? ¿seguro? ¿como
lo podemos verificar?

(Para el mejor de los casos tendría que explorar la semántica de  s == s,
que me estimo que luego de ser optimizado es NO-OP.)


Ahora, realmente no quiero seguir rompiendo las bolas si estos temas no
interesan en la lista o piensan que no son importantes.
Podemos someterlo a votación o puedo seguir y cada cual es libre de leer u
omitir.




>
>
>    Y no lo hago para hinchar las pelotas y optimizar algo que tarda 3 ns
> llevarlo a 1ns, sino, porque hay algo más grande atrás, que aun no salio a
> la luz.
>  Sí, me gusta mantener el misterio :)
>
>
>
> _______________________________________________
> pyar mailing list pyar en python.org.ar
> http://listas.python.org.ar/listinfo/pyar
>
> PyAr - Python Argentina - Sitio web: http://www.python.org.ar/
>
> La lista de PyAr esta Hosteada en USLA - Usuarios de Software Libre de
> Argentina - http://www.usla.org.ar
>
------------ próxima parte ------------
Se ha borrado un adjunto en formato HTML...
URL: <http://listas.python.org.ar/pipermail/pyar/attachments/20140430/ac58f48c/attachment-0001.html>