Y at-il un moyen en Python d'indexer une liste de conteneurs (tuples, listes, dictionnaires) par un élément d'un conteneur?

Question

J'ai cherché une recette/exemple pour indexer une liste de tuples sans modifier l'approche de décorer, trier, sans décor.

Par exemple:

l=[(a,b,c),(x,c,b),(z,c,b),(z,c,d),(a,d,d),(x,d,c) . . .] 

L'approche que je l'ai utilisé est de construire un dictionnaire à l'aide defaultdict du second élément

from collections import defaultdict 

tdict=defaultdict(int) 

for myTuple in l: 
    tdict[myTuple[1]]+=1 

Ensuite, je dois construire une liste constituée de la deuxième élément dans le tuple pour chaque élément de la liste. Bien qu'il existe plusieurs façons d'y arriver une approche simple consiste à:

tempList=[myTuple[1] for myTuple in l] 

puis générer un index de chaque élément tdict

indexDict=defaultdict(dict) 
for key in tdict: 
    indexDict[key]['index']=tempList.index(key) 

Il est clair que cela ne semble pas très Pythonic. J'ai essayé de trouver des exemples ou des idées en pensant que je devrais être capable d'utiliser quelque chose de magique pour obtenir l'index directement. Pas de chance pour le moment. Notez, je comprends que je peux prendre mon approche un peu plus directement et ne pas générer tdict.

sortie pourrait être un dictionnaire avec l'index

indexDict={'b':{'index':0},'c':{'index':1},'d':{'index':4},. . .} 

Après avoir appris beaucoup de réponses de Nadia Je pense que la réponse est non.

Pendant que sa réponse fonctionne, je pense que c'est plus compliqué que nécessaire. Je voudrais simplement

def build_index(someList): 
    indexDict={} 
    for item in enumerate(someList): 
     if item[1][1] not in indexDict: 
      indexDict[item[1][1]]=item[0] 
    return indexDict 

Answer 1

Cela va générer le résultat que vous voulez

dict((myTuple[1], index) for index, myTuple in enumerate(l)) 

>>> l = [(1, 2, 3), (4, 5, 6), (1, 4, 6)] 
>>> dict((myTuple[1], index) for index, myTuple in enumerate(l)) 
{2: 0, 4: 2, 5: 1} 

Et si vous insistez sur l'utilisation d'un dictionnaire pour représenter l'index:

dict((myTuple[1], {'index': index}) for index, myTuple in enumerate(l)) 

Le résultat sera:

{2: {'index': 0}, 4: {'index': 2}, 5: {'index': 1}} 

---

EDIT Si vous voulez gérer la collision clé, vous devrez étendre la solution comme ceci:

def build_index(l): 
    indexes = [(myTuple[1], index) for index, myTuple in enumerate(l)] 
    d = {} 
    for e, index in indexes: 
     d[e] = min(index, d.get(e, index)) 
    return d 

>>> l = [(1, 2, 3), (4, 5, 6), (1, 4, 6), (2, 4, 6)] 
>>> build_index(l) 
{2: 0, 4: 2, 5: 1} 

---

EDIT 2

Et plus généralisé et compact solution (dans une définition similaire à sorted)

def index(l, key): 
    d = {} 
    for index, myTuple in enumerate(l): 
     d[key(myTuple)] = min(index, d.get(key(myTuple), index)) 
    return d 

>>> index(l, lambda a: a[1]) 
{2: 0, 4: 2, 5: 1} 

Donc la réponse à votre question est oui: Il existe un moyen en Python d'indexer une liste de conteneurs (tuples, listes, dictionnaires) par un élément d'un conteneur sans pré-traitement. Mais votre demande de stocker le résultat dans un dictionnaire rend impossible d'être un seul doublure. Mais il n'y a pas de pré-traitement ici. La liste n'est itérée qu'une seule fois.

Answer 2

Si je pense que c'est ce que vous demandez ...

l = ['asd', 'asdxzc'] 
d = {} 

for i, x in enumerate(l): 
    d[x] = {'index': i}