Python moyen le plus Rapide pour trouver les Index de l'élément dans la liste

Si l'on devait tenter de trouver l'index d'un élément dans une liste, on pourrait faire un couple de différentes manières, voici ce que je sais être le plus rapide

aList = [123, 'xyz', 'zara','xyz', 'abc']; 
indices = [i for i, x in enumerate(aList) if x == "xyz"]
print(indices)

Un autre moyen de ne pas pythonic et le ralentissement de la

count = 0
indices = []
aList = [123, 'xyz', 'zara','xyz', 'abc'];
for i in range(0,len(aList):
    if 'xyz' == aList[i]:
        indices.append(i)
print(indices)

la première méthode est sans doute plus rapide cependant que faire si vous voulez aller plus vite est-il un moyen? pour le premier index de l'aide de la méthode

aList = [123, 'xyz', 'zara','xyz', 'abc'];             
print "Index for xyz : ", aList.index( 'xyz' )

est très rapide, mais ne peux pas gérer de multiples indices Comment peut-on aller sur les excès de vitesse les choses?

InformationsquelleAutor Tyler Cowan | 2016-02-25

5
```
    def find(target, myList):
        for i in range(len(myList)):
            if myList[i] == target:
                yield i

    def find_with_list(myList, target):
         inds = []
         for i in range(len(myList)):
             if myList[i] == target:
                 inds += i,
         return inds


In [8]: x = range(50)*200
In [9]: %timeit [i for i,j in enumerate(x) if j == 3]
1000 loops, best of 3: 598 us per loop

In [10]: %timeit list(find(3,x))
1000 loops, best of 3: 607 us per loop
In [11]: %timeit find(3,x)
1000000 loops, best of 3: 375 ns per loop

In [55]: %timeit find_with_list(x,3)
1000 loops, best of 3: 618 us per loop
```
En supposant que vous voulez une liste de vos sorties:
Toutes les options semblait qu'ils présentent les mêmes performances en temps pour mon test avec la compréhension de liste étant le plus rapide (à peine).

Et si vous êtes cool avec le retour d'un générateur, c'est beaucoup plus rapide que les autres approches. Pensé qu'il ne tient pas compte de l'itération sur les indices, ni de les stocker, de sorte que le nmr ne peut pas être répété plus d'une seconde de temps.
- donc, ce que vous dites est une itération sur chaque index et de faire une comparaison directe est le moyen le plus rapide pour obtenir tous les emplacements d'index de la correspondance des éléments dans une liste?
- c'est le moyen le plus rapide, je sais comment en supposant une série de calcul. Si c'était un géant de la liste et vous pourriez diviser et traiter les parties en parallèle, qui serait susceptible d'être plus rapide
- [i for i,j in enumerate(x) if x == 3], deuxième x devrait être j.
- Je pensais parallèle pourrait être le chemin à parcourir comme diviser et conquérir Malade d'avoir à le regarder. il y a obtenu d'être une meilleure façon.
- whoa! c'était une énorme erreur et fait beaucoup de sens, pourquoi il a été lent. J'ai corrigé le code et les résultats. Merci!
- Vos 2 derniers exemples sont plus rapides parce que vous êtes de ne pas consommer les générateurs...
InformationsquelleAutor Garrett R

Utilisation list.index(elem, start)! Qui utilise une boucle for en C (voir la mise en oeuvre list_index_impl fonction de la source de Disponible de listobject.c).
Éviter de passer en boucle sur tous les éléments en Python, il est plus lent que chez C.

def index_finder(lst, item):
    """A generator function, if you might not need all the indices"""
    start = 0
    while True:
        try:
            start = lst.index(item, start)
            yield start
            start += 1
        except ValueError:
            break

import array
def index_find_all(lst, item, results=None):
    """If you want all the indices.
    Pass results=[] if you explicitly need a list,
    or anything that can .append(..)"""
    if results is None:
        length = len(lst)
        results = array.array('B') if length <= 2**8 else array.array('H') if length <= 2**16 else array.array('L') if length <= 2**32 else array.array('Q')
    start = 0
    while True:
        try:
            start = lst.index(item, start)
            results.append(start)
            start += 1
        except ValueError:
            return results

# Usage example
l = [1, 2, 3, 4, 5, 6, 7, 8] * 32

print(*index_finder(l, 1))
print(*index_find_all(l, 1))

InformationsquelleAutor poke53280

0
```
D=dict()
for i, item in enumerate(l):
    if item not in D:
        D[item] = [i]
    else:
        D[item].append(i)
```
Puis il suffit d'appeler D[item] pour obtenir les indices qui correspondent. Vous allez donner de départ temps de calcul mais de le gagner lors de l'appel.

InformationsquelleAutor John

Pour obtenir l'index de l'élément, vous pouvez utiliser le dictionnaire.

aList = [123, 'xyz', 'zara','xyz', 'abc'];
#The following apporach works only on lists with unique values
aList = list(np.unique(aList)); 
dict = enumerate(aList);
# get inverse mapping of above dictionary, replace key with values
inv_dict = dict(zip(dict.values(),dict.keys()))
# to get index of item by value, use 'inv_dict' and to get value by index, use 'dict'
valueofItemAtIndex0 = dict[0]; # value = 123
indexofItemWithValue123 = inv_dict[123]; # index = 0

InformationsquelleAutor Harish Mashetty

0

J'ai utilisé un autre moyen pour trouver l'indice d'un élément dans une liste en Python 3:
```
def index_of(elem, a):
    a_e = enumerate(a)
    a_f = list(filter(lambda x: x[1] == elem, a_e))
    if a_f:
        return a_f[0][0]
    else:
        return -1
```
Quelques tests:
```
a=[1,2,3,4,2]
index_of(2,a)
```
Cette fonction retourne toujours la première occurrence de l'élément. Si un élément ins pas dans la liste, renvoie -1. Pour mes objectifs, que la solution a bien fonctionné.

InformationsquelleAutor Ângelo Polotto
0

Il suffit de créer un dictionnaire de l'article->index à partir de la liste des éléments à l'aide de zip comme suit:
```
items_as_dict = dict(zip(list_of_items,range(0,len(list_of_items))))
index = items_as_dict(item)
```
InformationsquelleAutor Ahmedov

Vous devez vous connecter pour publier un commentaire.