[Python 2.X] Nettoyage propre d'un tableau

Nettoyage propre d'un tableau

Bonjour

J'ai un souci existentiel à propos de la meilleure façon de nettoyer un tableau.
En effet, vaut-il mieux écrire del tab[:] ou plus simplement tab=autre_chose en laissant le gb se débrouiller tout seul...?

J'ai testé les deux façons de faire de cette façon
Code:

1 2 3 4 5 6 7 8 9 class toto(object): def __init__(self): print "init (%s)" % self def __del__(self): print "del (%s)" % self # class toto tab=[toto() for x in range(5)] print "tab créé" del tab[:] # Ou bien tab=None print "tab supprimé"
Mais je ne vois aucune différence. Si l'un d'entre vous avait des conseils à ce sujet...

Merci à tous :)

Bonjour,

Si je comprend bien la question, il y a bien une différence,

Code:

1
2
3
4
5
6
7
8
 
>>> a = [1, 2, 3]
>>> b = a
>>> a = []
>>> print(a)
[]
>>> print(b)
[1, 2, 3]

Code:

1
2
3
4
5
6
7
8
9
10
 
>>> a = [1, 2, 3]
>>> b = a
>>> del a[:]     
>>> print(a)
[]
>>> print(b)
[]
>>> a is b
True

Je vais quand même t'embêter encore un peu plus en te donnant une troisième solution.

Code:

1
2
3
4
5
6
7
8
9
10
 
 
# Comparaison de l=list(range(1000))" "b=l[:];del b[:] VS l=list(range(1000))" "b=l[:];b[:] = []
 
$ python -mtimeit "l=list(range(1000))" "b=l[:];del b[:]"
10000 loops, best of 3: 29.8 usec per loop
$ python -mtimeit "l=list(range(1000))" "b=l[:];b[:] = []"
10000 loops, best of 3: 28.7 usec per loop
 
(python 2.5, à tester avec votre python)

Salut,

La différence est entre déréférencer la liste et déréférencer les objets la liste. Et si on fait abstraction de l'objet (liste) supplémentaire, ici, le GC ne bosse pas vraiment: les objets sont détruits lorsque le nombre de références passe à 0.
Il bosse surtout lorsqu'il y a des cycles i.e. il n'y a plus vraiment de références qu'entre les objets eux-mêmes.

Après entre "del tab[:]" et "tab=autre_chose" est plutôt dans vider la liste plutôt qu'assigner à tab autre chose. Ce qui n'aura pas le même effet pour les autres variables associées au même objet (mais c'est plus un pb de GC).
Code:

1 2 3 4 5 6 >>> a = b = [1, 2, 3] >>> del a[:] >>> b [] >>> a []
on a "vidé" la liste associée à a et b.
Code:

1 2 3 4 5 6 7 >>> a = b = [1, 2, 3] >>> a = [] >>> a [] >>> b [1, 2, 3] >>>
on a assigné une nouvelle liste à a mais l'ancienne, côté b, est inchangée.

Dit autrement, les deux constructions adressant des problèmes différents, difficile de savoir laquelle est la meilleure: çà dépend du contexte.

- W

Bonsoir,

une autre méthode d'investigation est d'étudier la transformation du code en bytecode à l'aide de la librairie dis.

Un exemple ici : http://stackoverflow.com/a/12673195

Puisque timeit retourne pratiquement le même temps de traitement sur les deux méthodes, avec dis on saura exactement le nombre d'instructions que prennent les opérations.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import dis # Disassembler for Python bytecode
import sys
 
def f_del():
	l = list(range(1000))
	b=l[:]
	del b[:]
	return # Pour séparer les instructions de retour de fonction
 
def f_slice():
	l = list(range(1000))
	b=l[:]
	b[:] = []
	return # Pour séparer les instructions de retour de fonction
 
print("Python {} on {}".format(sys.version, sys.platform))
print("\nf_del")
dis.dis(f_del)
print("\nf_slice")
dis.dis(f_slice)

On obtient ceci :

Testé sur Windows 7 Home x64

Code:

1
2
3
4
5
6
7
8
9
10
Python 2.7.11 (v2.7.11:6d1b6a68f775, Dec  5 2015, 20:40:30) [MSC v.1500 64 bit (AMD64)] on win32
 
f_del
  7          25 LOAD_FAST                1 (b)
             28 DELETE_SLICE+0
 
f_slice
 13          25 BUILD_LIST               0
             28 LOAD_FAST                1 (b)
             31 STORE_SLICE+0

Code:

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
Python 3.5.1 (v3.5.1:37a07cee5969, Dec  6 2015, 01:54:25) [MSC v.1900 64 bit (AMD64)] on win32
 
f_del
  5           0 LOAD_GLOBAL              0 (list)
              3 LOAD_GLOBAL              1 (range)
              6 LOAD_CONST               1 (1000)
              9 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             12 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             15 STORE_FAST               0 (l)
 
  6          18 LOAD_FAST                0 (l)
             21 LOAD_CONST               0 (None)
             24 LOAD_CONST               0 (None)
             27 BUILD_SLICE              2
             30 BINARY_SUBSCR
             31 STORE_FAST               1 (b)
 
  7          34 LOAD_FAST                1 (b)
             37 LOAD_CONST               0 (None)
             40 LOAD_CONST               0 (None)
             43 BUILD_SLICE              2
             46 DELETE_SUBSCR
 
  8          47 LOAD_CONST               0 (None)
             50 RETURN_VALUE
 
f_slice
 11           0 LOAD_GLOBAL              0 (list)
              3 LOAD_GLOBAL              1 (range)
              6 LOAD_CONST               1 (1000)
              9 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             12 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             15 STORE_FAST               0 (l)
 
 12          18 LOAD_FAST                0 (l)
             21 LOAD_CONST               0 (None)
             24 LOAD_CONST               0 (None)
             27 BUILD_SLICE              2
             30 BINARY_SUBSCR
             31 STORE_FAST               1 (b)
 
 13          34 BUILD_LIST               0
             37 LOAD_FAST                1 (b)
             40 LOAD_CONST               0 (None)
             43 LOAD_CONST               0 (None)
             46 BUILD_SLICE              2
             49 STORE_SUBSCR
 
 14          50 LOAD_CONST               0 (None)
             53 RETURN_VALUE

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Python 3.5.1 (v3.5.1:37a07cee5969, Dec  6 2015, 01:54:25) [MSC v.1900 64 bit (AMD64)] on win32
 
f_del
  7          34 LOAD_FAST                1 (b)
             37 LOAD_CONST               0 (None)
             40 LOAD_CONST               0 (None)
             43 BUILD_SLICE              2
             46 DELETE_SUBSCR
 
f_slice
 13          34 BUILD_LIST               0
             37 LOAD_FAST                1 (b)
             40 LOAD_CONST               0 (None)
             43 LOAD_CONST               0 (None)
             46 BUILD_SLICE              2
             49 STORE_SUBSCR

Les numéros de la première colonne sont les lignes dans le code python.

Avec python 2.7.11 ce qui change :

f_del :

LOAD_FAST: b
DELETE_SLICE+0

f_slice:

BUILD_LIST
LOAD_FAST: b
STORE_SLICE+0

Avec python 3.5.1 :
f_del :

DELETE_SUBSCR

f_slice:

BUILD_LIST
STORE_SUBSCR

On a toujours une instruction en plus avec la méthode de de remplacement, mais le temps d'exécution reste quasiment identique.

Ce qui est intéressant c'est la différence entre python 2 et 3:

Code:

1
2
3
import timeit
timeit.timeit("f_del()", "from __main__ import f_del", number=int(1e5))
timeit.timeit("f_slice()", "from __main__ import f_slice", number=int(1e5))

Avec python 2.7.11 : On a 2 et 3 instructions
f_del: 1.346 s
f_slice: 1.346 s

Avec python 3.5.1 : On a 5 et 6 instructions et ça se ressent:
f_del: 1.745 s
f_slice: 1.776 s

Je ne sais pas à quoi servent les deux instructions LOAD_CONST, peut-être pour les paramètres du slicing start:end ?

Il y a sans doute une syntaxe plus efficace en python 3.

Exemple avec la méthode clear()

Code:

1
2
3
4
5
6
7
8
def f_clear():
	l = list(range(1000))
	b=l[:]
	b.clear()
	return # Pour séparer les instructions de retour de fonction
 
print("\nf_clear")
dis.dis(f_clear)

Code:

1
2
3
4
 19          34 LOAD_FAST                1 (b)
             37 LOAD_ATTR                2 (clear)
             40 CALL_FUNCTION            0 (0 positional, 0 keyword pair)
             43 POP_TOP

On gagne une instruction mais le temps n'est pas meilleur :

f_del: 1.757
f_slice: 1.759
f_clear: 1.769

Merci de vos avis.
Donc déjà je vais préciser quelques points: dans mon cas précis il n'y a aucune notion de recopie. J'ai retrouvé un de mes anciens codes de débutant où j'avais écrit une class style
Code:

1 2 3 4 5 6 7 8 9 10 11 class truc: def __init__(self): self.__tabID=[] def clear(self): del self.__tabId[:] def load(self): ... self.__tabId=[...] # class
Et c'est là que je me suis demandé si le del de mon clear() était vraiment pertinent vu qu'au chargement je réinitialisais totalement mon tableau ; d'où ma question.

Citation:

Envoyé par wiztricks

Dit autrement, les deux constructions adressant des problèmes différents, difficile de savoir laquelle est la meilleure: çà dépend du contexte.

Ok. Déjà là ça me rassure quand je pense que le del devient totalement inutile. 8-)

Citation:

Envoyé par IPreferCSharp

Bonjour,

J'aime bien ton pseudo. Enfin chacun ses choix ;)

Citation:

Envoyé par IPreferCSharp

Code:

$ python -mtimeit "l=list(range(1000))" "b=l[:];b[:] = []"

Ce ne devrait pas être plutôt

Code:

$ python -mtimeit "l=list(range(1000))" "b=l[:];b = []"

???

En tout cas chez-moi (python 2.7.11) voilà ce que ça donne...
Code:

1 2 3 4 5 $ python -mtimeit "l=list(range(10000));b=l[:];del b[:]" 10000 loops, best of 3: 122 usec per loop $ python -mtimeit "l=list(range(10000));b=l[:];b=None" 10000 loops, best of 3: 124 usec per loop
Très sensiblement pareil quoi. Et pareil pour le b[:]=[]...

Citation:

Envoyé par YCL-1

une autre méthode d'investigation est d'étudier la transformation du code en bytecode à l'aide de la librairie dis.

Super sympa :plusser:. Un nouveau truc à explorer :applo: