List Manipulation en Python avec pop ()

En bref, j'ai besoin de supprimer plusieurs éléments d'une liste en fonction de leur index. Cependant, je ne peux pas utiliser de la pop, car il met l'index (sans quelques maladroit de compensation du système). Est-il un moyen de supprimer plusieurs éléments en même temps?

J'ai un algorithme qui parcourt la liste, et si les conditions sont réunies supprime cet élément via le menu de la méthode. Un problème se pose vu que c'est fait dans une boucle. Une fois que pop est en fait la liste est raccourcie par un, le déplacement de toutes les valeurs de un. Donc la boucle va sortir de la plage. Il est possible de supprimer plusieurs éléments simultanément, ou une autre solution?

Un exemple de mon problème:

L = ['a', 'b', 'c', 'd']

for i in range(len(L)):
    print L
    if L[i] == 'a' or L[i] == 'c':
        L.pop(i)

source d'informationauteur rectangletangle

list python

17

Sont vos listes? Si oui, utiliser ifilter de itertools pour filtrer les éléments que vous ne voulez pas paresseusement (pas de coût d'achat).

Listes pas si grand? Il suffit d'utiliser une compréhension de liste:
```
 newlist = [x for x in oldlist if x not in ['a', 'c'] ]
```
Cela va créer une nouvelle copie de la liste. Ce n'est généralement pas un problème pour l'efficacité, à moins que vous vous souciez vraiment de la consommation de mémoire.

Comme un heureux moyen de la syntaxe de la commodité et de la paresse ( = efficacité pour les grandes listes), vous pouvez construire un générateur plutôt que d'une liste à l'aide de ( ) au lieu de [ ]:
```
interestingelts = (x for x in oldlist if x not in ['a', 'c'])
```
Après cela, vous pouvez effectuer une itération sur interestingeltsmais vous ne pouvez pas l'index:
```
 for y in interestingelts:    # ok
    print y

 print interestingelts[0]     # not ok: generator allows sequential access only
```
15

Vous voulez une compréhension de liste:
```
L = [c for c in L if c not in ['a', 'c']]
```
Ou, si vous ne voulez vraiment pas à créer une copie, revenir en arrière:
```
for i in reversed(range(len(L))):
    if L[i] in ['a', 'c']:
        L.pop(i)    # del L[i] is more efficient
```
Grâce à ncoghlan pour reversed() & phooji pour del L[i] suggestions. (J'ai décidé de la laisser L.pop(i)puisque c'est la façon dont la question a été initialement formulée.)

Aussi, comme J. S. Sébastien justement, en allant vers l'arrière est efficace de l'espace mais le temps inefficace; la plupart du temps une compréhension de liste ou d'un générateur (L = (...) au lieu de L = [...]) est le meilleur.

Edit:

Ok, donc, puisque les gens semblent vouloir quelque chose de moins ridiculement lent que l'inversion de la méthode ci-dessus (je ne peux pas imaginer pourquoi... 🙂 voici un ordre de préservation de la, en place un filtre qui doit différer de la vitesse à partir d'une compréhension de liste uniquement par une constante. (Cela rejoint ce que je ferais si je le voulais pour filtrer une chaîne de caractères en c.)
```
write_i = 0
for read_i in range(len(L)):
    L[write_i] = L[read_i]
    if L[read_i] not in ['a', 'c']:
         write_i += 1

del L[write_i:]
print L
# output: ['b', 'd']
```

Sommaire

utiliser compréhension de liste (ou genexpr) pour supprimer plusieurs éléments d'une liste
si votre entrée est un grand octet string puis utilisez str.translate() pour supprimer des caractères
de la suppression d'un élément à la fois del L[i] est lente pour les grandes listes

Si des éléments sont octets comme dans votre exemple, vous pourriez utiliser str.translate():

def remove_bytes(bytestr, delbytes):
    """
    >>> remove_bytes(b'abcd', b'ac') == b'bd'
    True
    """
    return bytestr.translate(None, delbytes)

En général plusieurs éléments pourraient être supprimés à l'aide de découpage:

def remove_inplace_without_order(L, delitems):
    """Remove all items from `L` that are in `delitems` (not preserving order).

    >>> L = list(range(4)); remove_inplace_without_order(L, [0,2]); L
    [3, 1]
    """
    idel = len(L) # items idel.. to be removed
    for i in reversed(range(len(L))):
        if L[i] in delitems:
            idel -= 1
            L[i] = L[idel] # save `idel`-th item
    del L[idel:] # remove items all at once
    #NOTE: the function returns `None` (it means it modifies `L` inplace)

Comme @phooji et @senderle déjà mentionné compréhension de liste (ou générateur d'expression) est préférable dans votre cas:

def remove_listcomp(L, delitems):
    return [x for x in L if x not in delitems]

Voici une comparaison des performances pour les L=list("abcd"*10**5); delitems="ac":

| function                     | time, msec |  ratio |
|------------------------------+------------+--------|
| list                         |       4.42 |    0.9 |
| remove_bytes                 |       4.88 |    1.0 |
| remove                       |       27.3 |    5.6 |
| remove_listcomp              |       36.8 |    7.5 |
| remove_inplace_without_order |       71.2 |   14.6 |
| remove_inplace_senderle2     |       83.8 |   17.2 |
| remove_inplace_senderle      |      15000 | 3073.8 |
#+TBLFM: $3=$2/@3$2;%.1f

Où

try:
    from itertools import ifilterfalse as filterfalse
except ImportError:
    from itertools import filterfalse # py3k

def remove(L, delitems):
    return filterfalse(delitems.__contains__, L)

def remove_inplace_senderle(L, delitems):
    for i in reversed(range(len(L))):
        if L[i] in delitems:
            del L[i]

def remove_inplace_senderle2(L, delitems):
    write_i = 0
    for read_i in range(len(L)):
        L[write_i] = L[read_i]
        if L[read_i] not in delitems:
             write_i += 1
    del L[write_i:]

remove_inplace_senderle() est lente à cause qu'il utilise O(N**2) algorithme. Chaque del L[i] pourrait causer tous les éléments à droite à être déplacé de gauche à combler l'écart.

Le temps de colonne dans le tableau ci-dessus inclut le temps qu'il faut pour créer une nouvelle liste d'entrée (la première ligne) en raison de certains algorithmes de modifier une entrée directe.

Voici les horaires pour la même entrée, mais sans créer une nouvelle liste à chaque itération:

 | function        | time, msec | ratio |
 |-----------------+------------+-------|
 | remove_bytes    |      0.391 |     1 |
 | remove          |       24.3 |    62 |
 | remove_listcomp |       33.4 |    85 |
 #+TBLFM: $3=$2/@2$2;%d

Le tableau montre que itertools.ifilterfalse() ne pas fournir une amélioration significative de plus de listcomp.

En général, il n'est pas la peine, ou même nuisible à réfléchir sur la performance pour de telles tâches, à moins d'un profileur prouvé que ce code est un goulot d'étranglement, et il est important pour votre programme. Mais il pourrait être utile d'être au courant des solutions de rechange qui pourraient fournir de plus d'un ordre de grandeur amélioration de la vitesse.

Vous devez vous connecter pour publier un commentaire.