[PYTHON] metaclasse e deep copy con classe list

[postgres]

Qualcuno ha idea di come si possa implementare una metaclasse affinchè ridefinisca la copia di una lista in python?
Normalmente la copia in python fra list è una shallow copy come dice qua: http://docs.python.org/library/copy.html.

Il main è questo:

l=list()
l.append(1)
l.append(2)
l.append(3)
# l viene copiata in l1
l1=l
# il contenuto di l1 viene modificato
l1[2] = ’B’
l1
[1, 2, ’B’]
# ma il contenuto di l rimane invariato
l
[1, 2, 3]



Io avevo pensato a questo come soluzione:


def funz(obj):
import copy
print('entro')
return str(copy.deepcopy(obj))

class metacl(type):
def __new__(meta,classname,supers,classdict):
classdict['__boh__'] = funz
return type.__new__(meta,classname,supers,classdict)

class list(list,metaclass=metacl): pass




ma = non è un operatore che si può ridefnirire come + (attraverso __add__)
avevo pensato a __getattr__ a __copy__ ma non mi ridefinisce niente!

[cdimauro]

Hai 2 problemi. Il primo è che una lista la puoi creare anche così:
MiaLista = [1, 2, 3]
Per cui anche ridefinendo l'oggetto (funzione) built-in list, non risolveresti il problema in generale.

Il secondo è che la copia puoi farla anche così:
NuovaLista = MiaLista[ : ]

Quindi non è molto chiaro l'obiettivo che vuoi raggiungere. Potresti essere più preciso?

[postgres]

L'obiettivo è definire una metaclasse che implementi deep copy sull'operatore di assegnamento affinchè la classe list copi con deep copy..

[cdimauro]

Ti anticipo subito che è impossibile, perché in Python non esiste l'operatore di assegnamento, ma l'istruzione di assegnamento, che non è soggetta a overloading.

In buona sostanza, se scrivi:
Lista = [1, 2, 3]
AltraLista = Lista
Sia Lista che AltraLista puntano allo stesso oggetto, e non c'è verso di intercettare l'azione di assegnazione della seconda istruzione per fargli fare qualcos'altro.

Ti riporto cosa succede a basso livello con Python con quel codice:
Python 2.6.6 (r266:84297, Aug 24 2010, 18:46:32) [MSC v.1500 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import dis
>>> def f():
... Lista = [1, 2, 3]
... AltraLista = Lista
...
>>> dis.dis(f)
2 0 LOAD_CONST 1 (1)
3 LOAD_CONST 2 (2)
6 LOAD_CONST 3 (3)
9 BUILD_LIST 3
12 STORE_FAST 0 (Lista)

3 15 LOAD_FAST 0 (Lista)
18 STORE_FAST 1 (AltraLista)
21 LOAD_CONST 0 (None)
24 RETURN_VALUE
Questo è il disassemblato di quelle 2 istruzioni presenti nella funzione f.

Dall'offset 0 a 9 viene costruita la lista.
12 la memorizza nella variabile Lista (da notare l'istruzione usata: STORE_FAST).

Questo rappresenta la prima istruzione.

15 e 18 rappresentano, invece, la seconda istruzione, che si occupano rispettivamente di prelevare il valore da Lista e memorizzarlo in AltraLista.

E' un meccanismo di basso livello (una banale copia, alla fine) che Python utilizza per QUALUNQUE oggetto (valore) manipoli, siano esse lista, tuple, numeri, o quant'altro.

Ed è un meccanismo che, come puoi capire, non fa scattare alcun metodo speciale (tipo __getattr__, __setattr__, ecc. per intenderci) che sia eventualmente possibile intercettare.

Spero sia chiaro. Se hai ancora dubbi, chiedi pure.

P.S. 21 e 24 sono istruzioni di chiusura della funzione, perché Python restituisce sempre un valore, anche se non lo specifichi appositamente. Ignorale.

[snowx]

se provassi a ridefinire copy, si potrebbe riuscire a farlo?

[cdimauro]

Non risolverebbe il problema, che nel suo caso riguarda l'assegnazione.

L'assegnazione, per quanto detto prima, non fa uso della copy.

[snowx]

non si riesce ad intercettare STORE_FAST?
mi sembra strano che diano un esercizio d'esame impossibile da risolvere

[cdimauro]

non si riesce ad intercettare STORE_FAST?
Decisamente no. :D
mi sembra strano che diano un esercizio d'esame impossibile da risolvere
Può darsi che il testo dica un'altra cosa.

[postgres]

Ecco il testo:
Traditionally object-oriented programming provides two different modes for cloning an instance or a structured data type: shallow and deep copy. The former has the effect to clone exclusively the external shell and not its content originating a quite fastidious aliasing effect. The latter, instead, copies the shell and its content recursively creating two completely separate copies of the instance.

As you know, Python's programs suffer of the aliasing effect when you copy an instance of a class or a structured type (e.g., a list) with the = operator. As showed in the following example:


>>> l=[1,2,3]
>>> l1=l
>>> l1[2] = ’B’
>>> l1
[1, 2, ’B’]
>>> l
[1, 2, ’B’]


The exercise consists of defining a meta-class which implements the deep copy on the assignment operator and binding this to the standard class list. Such that the following behavior can be yielded

>>>
l=list()
>>> l.append(1)
>>> l.append(2)
>>> l.append(3)
>>> l1=l
>>> l1[2] = ’B’
>>> l1
[1, 2, ’B’]
>>> l
[1, 2, 3]

[cdimauro]

Letto tutto, ma rimane il problema: non esiste alcun operatore di assegnazione in Python, per cui l ed l1 contengono esattamente lo stesso oggetto.

Si può intercettare quest'operazione:
l1[2] = 'B'
Ma anche la variabile l conterrebbe [1, 2, ’B’] subito dopo.

[snowx]

Letto tutto, ma rimane il problema: non esiste alcun operatore di assegnazione in Python, per cui l ed l1 contengono esattamente lo stesso oggetto.

Si può intercettare quest'operazione:
l1[2] = 'B'
Ma anche la variabile l conterrebbe [1, 2, ’B’] subito dopo.

come la intercetti?

[cdimauro]

Col metodo speciale __setitem__ (http://docs.python.org/reference/datamodel.html#object.__setitem__).

[snowx]

ho provato cosi:

import copy

def setItemNostro(obj,q,b):
print('chiamo il 1')
a = copy.deepcopy(obj)
a.pop(q)
a.insert(q,b)
print('eccola',a)
return a

class metacl(type):
def __new__(meta,classname,supers,classdict):
classdict['__setitem__'] = setItemNostro
return type.__new__(meta,classname,supers,classdict)

class list(list,metaclass=metacl): pass


con questo main:

if __name__ == "__main__":
l=list()
l.append(1)
l.append(2)
l.append(3)
l1=l
l1[2] = 'B'
print(l1)
print(l)


ho il seguente output:


chiamo il 1
eccola [1, 2, 'B']
[1, 2, 3]
[1, 2, 3]


quindi in a ho il mio comportamento, come poteri fare per assegnarlo ad l1?

[cdimauro]

Come dicevo prima, non puoi farlo, perché dal testo di cui sopra dovresti riuscire a intercettare l'operazione di assegnazione fra variabili, mentre quella che hai intercettato è soltanto l'operazione di assegnazione di un elemento a un oggetto in grado di rispondere a quest'interfaccia.

__setitem_ sei riuscito a intercettarlo, ma non te ne fai niente. In pratica hai creato una copia di obj, l'hai modificata, ma quando esci dalla funzione "manipolatrice" tutto il lavoro che hai fatto viene buttato via.

Per renderlo "persistente", dovresti modificare direttamente obj, ma se lo fai anche la variabile l verrà modificata di conseguenza.

Non puoi nemmeno scrivere obj = a all'interno di quella funzione, perché ovviamente non funzionerebbe (semplicemente la variabile obj conterrebbe il nuovo valore, ma la lista originale rimarrebbe immutata).

[postgres]

su un sito ho letto questo:
If you really want to override assignment, one way would be to define
a property. Instead of 'var = value' you would then write
'var.propertyname = value'. Using a property, assignments are
translated into calls to getter or setter methods, which can be
overridden fairly easily, and which can modify the object 'in place'.

Quindi si potrebbe integrare una metaclass con una proprierty con getter e setter per modificare l'oggetto? con la metaclasse invece di intercettare = che è impossibile intercettiamo la classe lista aggiungendogli questa proprietà (nstead of 'var = value' you would then write 'var.propertyname = value').

può essere fattibile?

[cdimauro]

Certamente, e lo fai coi metodi speciali __getattr__ e __setattr__ che servono proprio allo scopo.

Però è una cosa diversa da quella di cui abbiamo discusso finora.

[postgres]

ma cosa ci metto dentro al setitem? come la uso deepcopy la dentro? setitem mi intercetta [1,2,3].

Io ho provato così, ma mi da l'effetto opposto, ovvero stampa sempre [1,2,3]!!!
E se gli dico di mettere b senza usare la deepcopy mi ritroverei sempre con due [1,2,B].

Comef accio a fargli stampare due liste diverse ridefinendo setitem?


Modificando setitem però alla fine invece di ottenere sempre [1, 2, 3]


import copy
stack = ()

def psetItem(obj,q,b): #[], posti 2, valore B
global stack
stack = copy.deepcopy(obj)
return obj

class metacl(type):
def __new__(meta,classname,supers,classdict):
classdict['__setitem__'] = psetItem
return type.__new__(meta,classname,supers,classdict)

class list(list, metaclass = metacl): pass

if __name__ == "__main__":

l=list()
l.append(1)
l.append(2)
l.append(3)
#print("llllll",l)
l1=l
l1[2] = 'B'

print("lll",l)
print("l1l1l1",l1)
print("lll",l)