Sélectionner explicitement des éléments dans une liste ou un tuple

J'ai la liste Python suivante (peut également être un tuple):

myList = ['foo', 'bar', 'baz', 'quux']

je peux dire

>>> myList[0:3]
['foo', 'bar', 'baz']
>>> myList[::2]
['foo', 'baz']
>>> myList[1::2]
['bar', 'quux']

Comment sélectionner explicitement des éléments dont les index n'ont pas de modèles spécifiques? Par exemple, je veux sélectionner [0,2,3]. Ou parmi une très grande liste de 1000 articles, je veux sélectionner [87, 342, 217, 998, 500]. Y a-t-il une syntaxe Python qui fait cela? Quelque chose qui ressemble à:

>>> myBigList[87, 342, 217, 998, 500]

list( myBigList[i] for i in [87, 342, 217, 998, 500] )

J'ai comparé les réponses avec python 2.5.2:

• 19,7 usec: [ myBigList[i] for i in [87, 342, 217, 998, 500] ]

• 20,6 usec: map(myBigList.__getitem__, (87, 342, 217, 998, 500))

• 22,7 usec: itemgetter(87, 342, 217, 998, 500)(myBigList)

• 24,6 usec: list( myBigList[i] for i in [87, 342, 217, 998, 500] )

Notez que dans Python 3, le 1er a été changé pour être le même que le 4ème.

Une autre option serait de commencer par un numpy.arrayqui permet l'indexation via une liste ou un numpy.array:

>>> import numpy
>>> myBigList = numpy.array(range(1000))
>>> myBigList[(87, 342, 217, 998, 500)]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: invalid index
>>> myBigList[[87, 342, 217, 998, 500]]
array([ 87, 342, 217, 998, 500])
>>> myBigList[numpy.array([87, 342, 217, 998, 500])]
array([ 87, 342, 217, 998, 500])

Le tuplene fonctionne pas de la même manière que ce sont des tranches.

Et ça:

from operator import itemgetter
itemgetter(0,2,3)(myList)
('foo', 'baz', 'quux')

Ce n'est pas intégré, mais vous pouvez créer une sous-classe de liste qui prend les tuples comme "index" si vous le souhaitez:

class MyList(list):

    def __getitem__(self, index):
        if isinstance(index, tuple):
            return [self[i] for i in index]
        return super(MyList, self).__getitem__(index)


seq = MyList("foo bar baaz quux mumble".split())
print seq[0]
print seq[2,4]
print seq[1::2]

impression

foo
['baaz', 'mumble']
['bar', 'quux']

Peut-être qu'une liste de compréhension est dans l'ordre:

L = ['a', 'b', 'c', 'd', 'e', 'f']
print [ L[index] for index in [1,3,5] ]

Produit:

['b', 'd', 'f']

Est-ce ce que vous recherchez?

>>> map(myList.__getitem__, (2,2,1,3))
('baz', 'baz', 'bar', 'quux')

Vous pouvez également créer votre propre Listclasse qui prend en charge les tuples comme arguments __getitem__si vous voulez pouvoir le faire myList[(2,2,1,3)].

Je veux juste souligner que même la syntaxe d'itemgetter semble vraiment soignée, mais elle est un peu lente lorsqu'elle est exécutée sur une grande liste.

import timeit
from operator import itemgetter
start=timeit.default_timer()
for i in range(1000000):
    itemgetter(0,2,3)(myList)
print ("Itemgetter took ", (timeit.default_timer()-start))

Itemgetter a pris 1.065209062149279

start=timeit.default_timer()
for i in range(1000000):
    myList[0],myList[2],myList[3]
print ("Multiple slice took ", (timeit.default_timer()-start))

La tranche multiple a pris 0,6225321444745759

Une autre solution possible:

sek=[]
L=[1,2,3,4,5,6,7,8,9,0]
for i in [2, 4, 7, 0, 3]:
   a=[L[i]]
   sek=sek+a
print (sek)

comme souvent quand vous avez un tableau numpy booléen comme mask

[mylist[i] for i in np.arange(len(mask), dtype=int)[mask]]

Un lambda qui fonctionne pour n'importe quelle séquence ou np.array:

subseq = lambda myseq, mask : [myseq[i] for i in np.arange(len(mask), dtype=int)[mask]]

newseq = subseq(myseq, mask)