[pyar] ¿Volvemos a empezar?

[Fernando Pelliccioni]

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


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,
- ni que cree una nueva lista con referencias a la secuencia original.


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).

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").

Por las dudas claro:
Se la respuesta, lo pregunto para que veamos si podemos mejorar el
algoritmo)
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 :)


Saludos,





> _______________________________________________
> 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/9ec22791/attachment.html>