Discussion :

[sopsag]

Bonjour à tous (et à toutes),

je me suis fais une petite classe dérivée de list comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
class Stack ( list ) :
 
    def pops(self,n):
        '''pops the n first elements'''
        res = self[:n]
        self = self[n:]
        print self
        return res
 
    def push (self,vals):
        '''pushes vals at the head (vals must be a list)'''
        self = vals + self
        print self

et pour une raison que je ne m'explique pas, les méthodes sont sans effet (self reste inchangé en sortie de méthode) alors que les print affichent bien ce que j'attends...
Comme si self était restauré à la sortie.

Quelqu'un y comprend quelque chose ?
Comment obtenir une classe qui fait ce que je veux ?

Merci d'avance

[kango]

bonsoir,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
class Stack(list):
   def push(self, vals):
      for val in vals:
         self.insert(0,val)
   def pops(self, n):
         return [self.pop(0) for i in xrange(n)]

c'est quelque chose comme ça que tu souhaite obtenir ?

(on ne peut pas réaffecter self)

[sopsag]

Génial !!

c'est ça !
à un reversed près :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
    def push(self, vals):
        for val in reversed( vals ):
            self.insert(0,val)

Ça me rappelle le this du c++...

Merci

[kango]

je crois que c'est exactement la même chose que le this du c++

attention cependant, les insert(0,...) et pop(0) d'une liste sont O(n) alors que le append(...) et le pop() sont en O(1). je ne sais pas si c'est gênant pour toi

[eyquem]

C’est bien aussi de comprendre la cause des problèmes. Comparer:


Ton code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class Stack ( list ) :
 
    def pops(self,n):
        '''pops the n first elements'''
        res = self[:n]
        self = self[n:]
        print '  res   ',id(res),res
        print '  self  ',id(self),self
        return res
 
    def push (self,vals):
        print '  self  ',id(self),self
        '''pushes vals at the head (vals must be a list)'''
        self = vals + self
        print '  self  ',id(self),self
 
 
a = Stack()
print 'new a ',id(a),a
 
print '\na.push([2,3])'
a.push([2,3])
print 'a       ',id(a),a
 
print '\na.push([7,8,34,56])'
a.push([7,8,34,56])
print 'a       ',id(a),a
 
print '\na.pops(3)'
a.pops(3)
print 'a       ',id(a),a

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
new a  17505136 []
 
a.push([2,3])
  self   17505136 []
  self   17540880 [2, 3]
a        17505136 []
 
a.push([7,8,34,56])
  self   17505136 []
  self   9917144 [7, 8, 34, 56]
a        17505136 []
 
a.pops(3)
  res    17541800 []
  self   9917144 []
a        17505136 []

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Stack ( list ) :
 
    def pops(self,n):
        '''pops the n first elements'''
        res = self[0:n]
        self[0:n] = []
        print '  res   ',id(res),res
        print '  self  ',id(self),self
        return res
 
    def push (self,vals):
        print '  self  ',id(self),self
        '''pushes vals at the head (vals must be a list)'''
        self[0:0] = vals
        print '  self  ',id(self),self
 
 
 
a = Stack()
print 'new a =',id(a),a
 
print '\na.push([2,3])'
a.push([2,3])
print 'a       ',id(a),a
 
print '\na.push([7,8,34,56])'
a.push([7,8,34,56])
print 'a       ',id(a),a
 
print '\na.pops(3)'
a.pops(3)
print 'a       ',id(a),a

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
new a = 17505136 []
 
a.push([2,3])
  self   17505136 []
  self   17505136 [2, 3]
a        17505136 [2, 3]
 
a.push([7,8,34,56])
  self   17505136 [2, 3]
  self   17505136 [7, 8, 34, 56, 2, 3]
a        17505136 [7, 8, 34, 56, 2, 3]
 
a.pops(3)
  res    17514744 [7, 8, 34]
  self   17505136 [56, 2, 3]
a        17505136 [56, 2, 3]

self[n:] crée un nouvel objet, c’est à dire à un emplacement mémoire différent

self = self[n:] déplace l’étiquette self de l’objet local self (c’est à dire l’objet de type Stack traité) sur ce nouvel objet: l’objet de type Stack n’est absolument pas touché





de même vals + self n’est pas une modification en place, cela crée un nouvel objet, à une adresse différente

self = vals + self déplace l’étiquette self de l’objet de type Stack traité sur le nouvel objet





Par contre ,
self[0:n] = [] et self[0:0] = vals sont des opérations en place,c’est à dire qui changent les éléments de la liste sans toucher à sa localisation.

[sopsag]

Merci de toutes ces explications !

Je me doutais un peu que c'était ce genre de problème liés à l'implémentation même de python.

--> C'est justement ce qui me gène un peu avec les langages évolués qui mâchent tout le boulot : on a l'impression d'être détaché des détails d'implémentation mais de temps en temps on tombe sur ce genre d'os qui obligent à savoir ce qui se passe dans les tripes de l'interpréteur.

Rien n'empêche une autre implémentation (sous un autre OS/plateforme/matériel) d'avoir un comportement différent.
--> Y aurait-il une norme au niveau des choix d'implémentation ?

Au moins en C++, this est const et on sait tout de suite qu'on ne peut pas y toucher.

Mais bon... ça reste un langage très agréable !