Подтвердить что ты не робот

Использование метода index() списка Python в списке кортежей или объектов?

Тип списка Python имеет метод index(), который принимает один параметр и возвращает индекс первого элемента в списке, соответствующем параметру. Например:

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

Есть ли изящный (идиоматический) способ распространить его на списки сложных объектов, например кортежи? В идеале я хотел бы сделать что-то вроде этого:

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

getIndexOfTuple() - это всего лишь гипотетический метод, который принимает подиндекс и значение, а затем возвращает индекс элемента списка с заданным значением в этом подиндексе. Я надеюсь, что

Есть ли какой-то способ достичь этого общего результата, используя списки или lambas или что-то вроде "in-line"? Я думаю, что я мог бы написать свой собственный класс и метод, но я не хочу изобретать колесо, если у Python уже есть способ сделать это.

4b9b3361

ОТВЕТЫ

Ответ 1

Как насчет этого?

>>> 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]

Как указано в комментариях, это приведет к получению всех совпадений. Чтобы получить первый, вы можете:

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

В комментариях есть хорошая дискуссия относительно разницы в скорости между всеми опубликованными решениями. Я могу быть немного предвзятым, но я лично буду придерживаться однострочного интерфейса, поскольку скорость, о которой мы говорим, довольно незначительна по сравнению с созданием функций и импортом модулей для этой проблемы, но если вы планируете сделать это в очень большой сумме элементов, которые вы, возможно, захотите посмотреть на другие предоставленные ответы, поскольку они быстрее, чем я предоставлял.

Ответ 2

Эти перечни сообщений беспорядочны через некоторое время.

Мне нравится этот подход Pythonic:

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

Если вам нужно, чтобы ваш код был суперэффективным:

# 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

Ответ 3

Одна из возможностей заключается в использовании функции itemgetter из модуля operator:

import operator

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

Вызов itemgetter возвращает функцию, которая будет выполнять эквивалент foo[0] для всех переданных ей. Используя map, вы затем применяете эту функцию к каждому кортежу, извлекая информацию в новый список, после чего вы вызываете index как обычно.

map(f, tuple_list)

эквивалентно:

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

что в свою очередь эквивалентно:

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

который дает:

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

Ответ 4

Вы можете сделать это со списком и индексом()

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

Ответ 5

Я бы разместил это как комментарий к Triptych, но я не могу комментировать пока из-за отсутствия рейтинга:

Использование метода перечисления для сопоставления по подиндексам в списке кортежей. например.

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

Ответ 6

Вдохновленный этот вопрос, я нашел это довольно элегантным:

>>> 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

Ответ 7

ok, это может быть ошибкой в ​​ vals(j), поправка:

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

Ответ 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)

Ответ 9

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

Ответ 10

Никакое тело не предлагает лямбда?

Попробуйте это и работаем. Я прихожу к ответу на этот пост. Я не нашел, что мне нравится, но я чувствую себя вдавленным: P

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

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

Изменить для добавления примеров:

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

извлечь все элементы по условию:       фильтр (lambda x: x [0] == "pato", l) # [['pato', 2, 1], ['pato', 2, 2], ['pato', 2, 2]]

извлечь все элементы по условию с индексом:

    >>> 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]]

Примечание: переменная _ работает только в интерактивном интерпретаторе y нормальный текстовый файл _ требуется explicti assign, то есть _ = filter (lambda x: x [1] [0] == "pato", enumerate (l))

Ответ 11

Python list.index(x) возвращает индекс первого вхождения x в список. Таким образом, мы можем передавать объекты, возвращаемые сжатием списка, для получения их индекса.

>>> 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]

С той же строкой мы также можем получить список индексов в случае, если имеется несколько согласованных элементов.

>>> 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]