Mit Python Listenindex () -Methode auf einer Liste von Tupeln oder Objekten?

Question

Python Listentyp hat einen Index () Methode, die einen Parameter und gibt den Index des ersten Elements in der Liste Anpassung der Parameter. Zum Beispiel:

>>> some_list = ["apple", "pear", "banana", "grape"]
>>> some_list.index("pear")
1
>>> some_list.index("grape")
3

Gibt es einen anmutigen (idiomatischen) Weg, dies zu Listen von komplexen Objekten zu erweitern, wie Tupeln? Im Idealfall würde Ich mag Lage sein, so etwas zu tun:

>>> tuple_list = [("pineapple", 5), ("cherry", 7), ("kumquat", 3), ("plum", 11)]
>>> some_list.getIndexOfTuple(1, 7)
1
>>> some_list.getIndexOfTuple(0, "kumquat")
2

getIndexOfTuple () ist nur eine hypothetische Methode, die einen Subindex und einen Wert annimmt, und dann gibt den Index des Listenelementes mit dem angegebenen Wert an diesem Subindex. Ich hoffe,

Gibt es eine Möglichkeit, dass die allgemeine Ergebnis zu erzielen, Listenkomprehensionen mit oder lambas oder etwas „in-line“ wie das? Ich glaube, ich könnte meine eigene Klasse und Methode schreiben, aber ich will nicht das Rad neu erfinden, wenn Python bereits einen Weg, es zu tun hat.

Answer 1

Wie wäre das?

>>> tuple_list = [("pineapple", 5), ("cherry", 7), ("kumquat", 3), ("plum", 11)]
>>> [x for x, y in enumerate(tuple_list) if y[1] == 7]
[1]
>>> [x for x, y in enumerate(tuple_list) if y[0] == 'kumquat']
[2]

Wie in den Kommentaren darauf hingewiesen, dies würde alle Spiele bekommen. Um nur den ersten zu bekommen, die Sie tun können:

>>> [y[0] for y in tuple_list].index('kumquat')
2

Es gibt eine gute Diskussion in den Kommentaren in Bezug auf die Geschwindigkeitsdifferenz zwischen allen Lösungen gebucht. Ich kann ein wenig voreingenommen sein, aber ich persönlich würde zu einem Einzeiler haften, wenn die Geschwindigkeit wir reden ziemlich unbedeutend ist Funktionen im Vergleich zu erstellen und Module für dieses Problem zu importieren, aber wenn Sie auf tut dies auf eine sehr große Menge planen von Elementen Sie können an den anderen Antworten zur Verfügung gestellt aussehen wollen, wie sie schneller sind als das, was ich zur Verfügung gestellt.

Answer 2

Diese Liste Comprehensions sind chaotisch nach einer Weile.

Ich mag diesen Pythonic Ansatz:

from operator import itemgetter

def collect(l, index):
   return map(itemgetter(index), l)

# And now you can write this:
collect(tuple_list,0).index("cherry")   # = 1
collect(tuple_list,1).index("3")        # = 2

Wenn Sie Ihren Code müssen alle sein Super-performante:

# Stops iterating through the list as soon as it finds the value
def getIndexOfTuple(l, index, value):
    for pos,t in enumerate(l):
        if t[index] == value:
            return pos

    # Matches behavior of list.index
    raise ValueError("list.index(x): x not in list")

getIndexOfTuple(tuple_list, 0, "cherry")   # = 1

Answer 3

Eine Möglichkeit ist die itemgetter Funktion aus dem operator Modul zu verwenden :

import operator

f = operator.itemgetter(0)
print map(f, tuple_list).index("cherry") # yields 1

Der Aufruf von itemgetter gibt eine Funktion, die das Äquivalent von foo[0] für alles, was an sie übergeben wird tun. Mit map Sie dann anwenden, um diese Funktion jedes Tupel, die Informationen in eine neue Liste zu extrahieren, auf das Sie dann index als normal bezeichnen.

map(f, tuple_list)

entspricht:

[f(tuple_list[0]), f(tuple_list[1]), ...etc]

was wiederum äquivalent zu:

[tuple_list[0][0], tuple_list[1][0], tuple_list[2][0]]

das gibt:

["pineapple", "cherry", ...etc]

Answer 4

Sie können dies tun mit einer Liste Verständnis und index ()

tuple_list = [("pineapple", 5), ("cherry", 7), ("kumquat", 3), ("plum", 11)]
[x[0] for x in tuple_list].index("kumquat")
2
[x[1] for x in tuple_list].index(7)
1

Answer 5

Ich würde setzt diese als Kommentar zu Triptychon, aber ich kann noch nicht kommentieren mangels Bewertung:

Mit der enumerator Methode auf Subindizes in einer Liste von Tupeln entsprechen. z.

li = [(1,2,3,4), (11,22,33,44), (111,222,333,444), ('a','b','c','d'),
        ('aa','bb','cc','dd'), ('aaa','bbb','ccc','ddd')]

# want pos of item having [22,44] in positions 1 and 3:

def getIndexOfTupleWithIndices(li, indices, vals):

    # if index is a tuple of subindices to match against:
    for pos,k in enumerate(li):
        match = True
        for i in indices:
            if k[i] != vals[i]:
                match = False
                break;
        if (match):
            return pos

    # Matches behavior of list.index
    raise ValueError("list.index(x): x not in list")

idx = [1,3]
vals = [22,44]
print getIndexOfTupleWithIndices(li,idx,vals)    # = 1
idx = [0,1]
vals = ['a','b']
print getIndexOfTupleWithIndices(li,idx,vals)    # = 3
idx = [2,1]
vals = ['cc','bb']
print getIndexOfTupleWithIndices(li,idx,vals)    # = 4

Answer 6

Inspiriert von diese Frage , fand ich das ganz elegant:

>>> tuple_list = [("pineapple", 5), ("cherry", 7), ("kumquat", 3), ("plum", 11)]
>>> next(i for i, t in enumerate(tuple_list) if t[1] == 7)
1
>>> next(i for i, t in enumerate(tuple_list) if t[0] == "kumquat")
2

Answer 7

ok, es könnte ein Fehler in vals(j) sein, die Korrektur ist:

def getIndex(li,indices,vals):
for pos,k in enumerate(lista):
    match = True
    for i in indices:
        if k[i] != vals[indices.index(i)]:
            match = False
            break
    if(match):
        return pos

Answer 8

tuple_list = [("pineapple", 5), ("cherry", 7), ("kumquat", 3), ("plum", 11)]

def eachtuple(tupple, pos1, val):
    for e in tupple:
        if e == val:
            return True

for e in tuple_list:
    if eachtuple(e, 1, 7) is True:
        print tuple_list.index(e)

for e in tuple_list:
    if eachtuple(e, 0, "kumquat") is True:
        print tuple_list.index(e)

Answer 9

z = list(zip(*tuple_list))
z[1][z[0].index('persimon')]

Answer 10

Kein Körper lambda vorschlagen?

Y dies und Werke versuchen. Ich komme zu diesem Beitrag Such Antwort. Ich habe nicht festgestellt, dass Ich mag, aber ich fühle mich ein insingth: P

    l #[['rana', 1, 1], ['pato', 1, 1], ['perro', 1, 1]]

    map(lambda x:x[0], l).index("pato") #1 

Bearbeiten hinzuzufügen Beispiele:

   l=[['rana', 1, 1], ['pato', 2, 1], ['perro', 1, 1], ['pato', 2, 2], ['pato', 2, 2]]

extrahieren alle Artikel von Bedingung:         Filter (lambda x: x [0] == "pato", l) # [[ 'pato', 2, 1], [ 'pato', 2, 2], [ 'pato', 2, 2]]

extrahiert alle Artikel von Zustand mit Index:

    >>> filter(lambda x:x[1][0]=="pato", enumerate(l))
    [(1, ['pato', 2, 1]), (3, ['pato', 2, 2]), (4, ['pato', 2, 2])]
    >>> map(lambda x:x[1],_)
    [['pato', 2, 1], ['pato', 2, 2], ['pato', 2, 2]]

Hinweis: _ Variable funktioniert nur im interaktiven Interpreter y normale Textdatei _ muß explicti zuweisen, dh _ = Filter (lambda x: x [1] [0] == "Pato", aufzählen (l))

Answer 11

Pythons list.index (x) liefert Index des ersten Auftretens von x in der Liste. So können wir Objekte vorbei Liste Kompression zurück ihren Index zu erhalten.

>>> tuple_list = [("pineapple", 5), ("cherry", 7), ("kumquat", 3), ("plum", 11)]
>>> [tuple_list.index(t) for t in tuple_list if t[1] == 7]
[1]
>>> [tuple_list.index(t) for t in tuple_list if t[0] == 'kumquat']
[2]

Mit der gleichen Linie, können wir auch die Liste des Index für den Fall bekommen es mehr abgestimmte Elemente.

>>> tuple_list = [("pineapple", 5), ("cherry", 7), ("kumquat", 3), ("plum", 11), ("banana", 7)]
>>> [tuple_list.index(t) for t in tuple_list if t[1] == 7]
[1, 4]

Answer 12

Ich denke, die folgende ist nicht der beste Weg, um es (Geschwindigkeit und Eleganz betrifft) zu tun, aber gut, es könnte helfen:

from collections import OrderedDict as od
t = [('pineapple', 5), ('cherry', 7), ('kumquat', 3), ('plum', 11)]
list(od(t).keys()).index('kumquat')
2
list(od(t).values()).index(7)
7
# bonus :
od(t)['kumquat']
3

Liste von Tupeln mit 2 Mitgliedern kann gleich direkt, Datenstrukturen sind tatsächlich bestellt dict umgewandelt werden, so können wir dict Methode on the fly verwenden.