Différentes façons de compensation des listes

Est-il une raison pour faire quelque chose de plus compliqué que l'une de ces deux lignes lorsque vous souhaitez effacer une liste en Python?

old_list = []
old_list = list()

La raison pour laquelle je demande, c'est que je viens de voir cela dans certains cours d'exécution de code:

del old_list[ 0:len(old_list) ]

Pourquoi faites-vous cela? La Collecte des ordures œuvres. Pourquoi ne pas tout simplement ignorer l'ancienne valeur de la liste et laissez Python nettoyer automatiquement?
L'affiche n'a pas écrit le code, et est de se demander pourquoi l'écrivain original peut l'avoir fait.
Vous pouvez aussi faire: alors que l: l.pop()
LOL. Je suis sûr que c'est efficace.
Personne n'a rien dit asbout qu'il soit efficace...
Pas liés à votre question, mais vous ne devriez pas utiliser len lors de la spécification d'une tranche. a[:x] signifie en commençant à x et a[x:] signifie x à la fin. a[ 0:len(a) ] peut être écrite comme a[:]. Vous pouvez également utiliser des négatifs à partir de la fin (a[-1] est le dernier élément).

InformationsquelleAutor johannix | 2009-05-12

list python

344

La compensation d'une liste à la place affectera tous les autres références de la même liste.

Par exemple, cette méthode n'affecte pas les autres références:
```
>>> a = [1, 2, 3]
>>> b = a
>>> a = []
>>> print(a)
[]
>>> print(b)
[1, 2, 3]
```
Mais celui-ci n':
```
>>> a = [1, 2, 3]
>>> b = a
>>> del a[:]      # equivalent to   del a[0:len(a)]
>>> print(a)
[]
>>> print(b)
[]
>>> a is b
True
```
Vous pouvez aussi faire:
```
>>> a[:] = []
```
- Hmm, vous apprenez quelque chose de nouveau chaque jour.
- Vous pouvez également faire de del a[:]
- Pourquoi le premier n'affecte a? J'ai pensé a et b référence au même objet... veux Juste savoir pourquoi. Merci.
- Avec python 3.3 et, plus tard, vous pouvez aller avec a.clear(), pas de problème!
- parce que dans le début, vous êtes la modification d'une référence de " a " à un point de tableau, pas de compensation de l'un, et b des points encore une ancienne
- Ce serait super si quelqu'un peut montrer la différence de performance entre ces méthodes!
InformationsquelleAutor Koba
35

Il y a un moyen très simple pour effacer une liste python. Utilisation del list_name[:].

Par exemple:
```
>>> a = [1, 2, 3]
>>> b = a
>>> del a[:]
>>> print a, b
[] []
```
InformationsquelleAutor NixMan
14

Faire alist = [] ne pas effacer la liste, il suffit de crée une liste vide et le lie à la variable alist. L'ancienne liste continuera d'exister, si elle avait d'autres variables liaisons.

Pour vider une liste en place, vous pouvez utiliser l'une de ces façons:
1. alist.clear() # Python 3.3+, most obvious
2. del alist[:]
3. alist[:] = []
4. alist *= 0 # fastest
Voir le Mutable Types De Séquence page de documentation pour plus de détails.

InformationsquelleAutor Eugene Yarmash
13

~~Il me semble que la del va vous donner les secours de la mémoire, tandis que l'attribution d'une nouvelle liste fera l'ancien être supprimé que lorsque le gc s'exécute.de la matière.~~

Cela peut être utile pour les grandes listes, mais pour une petite liste de elle devrait être négligeable.

Modifier: Comme Algorias, il n'a pas d'importance.

Noter que
```
del old_list[ 0:len(old_list) ]
```
est équivalent à
```
del old_list[:]
```
- gc n'est pas exécuté dans les cycles. La liste est libéré dès que sa dernière référence est supprimée.
- Algorias: c'est vrai pour Disponible, mais peut-être pas pour d'autres implémentations.
- del old_list[ 0:len(old_list) ] et del old_list[:] ont un même résultat, mais le dernier est plus rapide (vérifié dans la version 2.6 de Python)
InformationsquelleAutor besen
5

Il y a deux cas dans lesquels vous pouvez effacer une liste:
1. Vous souhaitez utiliser le nom old_list plus loin dans votre code;
2. Vous voulez l'ancien liste à être nettoyés dès que possible afin de libérer de la mémoire;
Dans le cas 1 vous suffit d'aller sur la mission:
```
    old_list = []    # or whatever you want it to be equal to
```
Dans le cas 2 la del déclaration permettrait de réduire le nombre de références à l'objet de la liste le nom old list points. Si l'objet de la liste est seulement signalé par le nom old_list à, le compteur de référence de 0, et l'objet sera libéré pour la collecte des ordures.
```
    del old_list
```
InformationsquelleAutor Alex
4
```
del list[:] 
```
Va supprimer les valeurs de la variable de liste
```
del list
```
Va supprimer la variable elle-même à partir de la mémoire

InformationsquelleAutor ytpillai
3

Si vous êtes à la suppression de la liste, vous, de toute évidence, n'ont pas besoin de la liste. Si oui, vous pouvez simplement supprimer la totalité de la liste par simple del méthode.
```
a = [1, 3, 5, 6]
del a # This will entirely delete a(the list).
```
Mais dans ce cas, vous en aurez besoin, vous pouvez la réinitialiser elle. Ou, simplement, clairement l'un de ses éléments par
```
del a[:]
```
InformationsquelleAutor lavee_singh
-4

une autre solution qui fonctionne bien est de créer la liste vide comme référence la liste est vide.
```
empt_list = []
```
par exemple vous avez une liste de a_list = [1,2,3]. Pour effacer, il suffit de rendre le suivant:
```
a_list = list(empt_list)
```
cela fera a_list une liste vide tout comme le empt_list.
- Pas de raison de créer empt_list. Utilisez simplement a_list = list().
InformationsquelleAutor Mounir Ben

Vous devez vous connecter pour publier un commentaire.