Нахождение индекса элемента в списке


3189

Учитывая список ["foo", "bar", "baz"]и элемент в списке "bar", как мне получить его index ( 1) в Python?


6
Вы возвращаете: [1] Самый низкий индекс, если есть несколько экземпляров "bar", [2] Все индексы "bar"?
Ṃųỻịgǻňạcểơửṩ

4
а) Гарантируется ли, что элемент находится в списке, или как мы должны обработать ошибку? (вернуть None / повысить ValueError) б) Гарантируется ли уникальность записей в списке, и должны ли мы возвращать первый индекс совпадения или все индексы?
smci

Просматривайте ответы с помощью numpy-интеграции, numy-массивы гораздо более эффективны, чем списки Python. Если список короткий, то нет проблем с его копированием из списка Python, если нет, то, возможно, вам стоит сначала сохранить элементы в массиве numpy.
Атанассиос

Ответы:


4493
>>> ["foo", "bar", "baz"].index("bar")
1

Справка: Структуры данных> Подробнее о списках

Предостережения следуют

Обратите внимание, что, хотя это, пожалуй, самый простой способ ответить на заданный вопрос , indexэто довольно слабый компонент listAPI, и я не могу вспомнить, когда в последний раз я использовал его в гневе. Мне было отмечено в комментариях, что, поскольку на этот ответ часто ссылаются, его следует сделать более полным. Некоторые предостережения о list.indexследовании. Вероятно, стоит сначала взглянуть на документацию:

list.index(x[, start[, end]])

Вернуть нулевой индекс в списке первого элемента, значение которого равно x . Поднимает, ValueErrorесли такого предмета нет.

Необязательные аргументы start и end интерпретируются так же, как в нотации слайса, и используются для ограничения поиска определенной подпоследовательностью списка. Возвращенный индекс вычисляется относительно начала полной последовательности, а не аргумента начала.

Линейная сложность по времени в длине списка

indexВызов проверяет каждый элемент списка в порядке, пока не найдет совпадения. Если ваш список длинный и вы не знаете, где именно он находится, этот поиск может стать узким местом. В этом случае вы должны рассмотреть другую структуру данных. Обратите внимание, что если вы точно знаете, где найти совпадение, вы можете дать indexподсказку. Например, в этом фрагменте l.index(999_999, 999_990, 1_000_000)примерно на пять порядков быстрее, чем прямой l.index(999_999), потому что первый должен искать только 10 записей, а второй ищет миллион:

>>> import timeit
>>> timeit.timeit('l.index(999_999)', setup='l = list(range(0, 1_000_000))', number=1000)
9.356267921015387
>>> timeit.timeit('l.index(999_999, 999_990, 1_000_000)', setup='l = list(range(0, 1_000_000))', number=1000)
0.0004404920036904514

Возвращает только индекс первого соответствия своему аргументу

Вызов indexвыполняет поиск по списку по порядку, пока не найдет совпадение и не остановится там. Если вы ожидаете, что вам понадобятся индексы большего числа совпадений, вы должны использовать понимание списка или выражение генератора.

>>> [1, 1].index(1)
0
>>> [i for i, e in enumerate([1, 2, 1]) if e == 1]
[0, 2]
>>> g = (i for i, e in enumerate([1, 2, 1]) if e == 1)
>>> next(g)
0
>>> next(g)
2

В большинстве мест, где я когда-то пользовался index, теперь я использую списочное понимание или генераторное выражение, потому что они более обобщаемы. Так что, если вы хотите достичь index, взгляните на эти отличные возможности Python.

Выдает, если элемент отсутствует в списке

Вызов indexприводит к, ValueErrorесли элемент отсутствует.

>>> [1, 1].index(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 2 is not in list

Если элемент может отсутствовать в списке, вы должны либо

  1. Сначала проверьте это с помощью item in my_list(чистого, читабельного подхода) или
  2. Оберните indexвызов в try/exceptблок, который перехватывает ValueError(возможно, быстрее, по крайней мере, когда список для поиска длинный, а элемент обычно присутствует).

20
index возвращает первый элемент, значение которого равно «bar». Если в списке дважды присутствует «бар», вы никогда не найдете ключ для второго «бара». См. Документацию: docs.python.org/3/tutorial/datastructures.html
mpoletto

2
Если вы ищете только один элемент (первый), я обнаружил, что index()он чуть менее чем на 90% быстрее, чем списки со списками целых чисел.
Слыблоты

Какую структуру данных следует использовать, если список очень длинный?
izhang05

@izhang: некоторый вспомогательный индекс, такой как диктант {element -> list_index}, если элементы являются хешируемыми, и позиция в списке имеет значение.
Алекс Ковентри

899

Одна вещь, которая действительно полезна при изучении Python - это использовать функцию интерактивной справки:

>>> help(["foo", "bar", "baz"])
Help on list object:

class list(object)
 ...

 |
 |  index(...)
 |      L.index(value, [start, [stop]]) -> integer -- return first index of value
 |

который часто приведет вас к методу, который вы ищете.


2
bpython - это удобный и удобный способ читать документы в интерактивном режиме.
goetzc

@davidavr да, но у остальных из нас, кто просто хочет погуглить, вместо того, чтобы просматривать справочные документы, не было бы этого замечательного, центрального, ранжированного набора параметров. :)
хонкабой

557

Большинство ответов объясняют, как найти один индекс , но их методы не возвращают несколько индексов, если элемент находится в списке несколько раз. Используйте enumerate():

for i, j in enumerate(['foo', 'bar', 'baz']):
    if j == 'bar':
        print(i)

index()Функция возвращает только первое вхождение, а enumerate()возвращает все вхождения.

Как понимание списка:

[i for i, j in enumerate(['foo', 'bar', 'baz']) if j == 'bar']

Вот еще одно небольшое решение с itertools.count()(которое в значительной степени совпадает с подходом перечисления):

from itertools import izip as zip, count # izip for maximum efficiency
[i for i, j in zip(count(), ['foo', 'bar', 'baz']) if j == 'bar']

Это более эффективно для больших списков, чем использование enumerate():

$ python -m timeit -s "from itertools import izip as zip, count" "[i for i, j in zip(count(), ['foo', 'bar', 'baz']*500) if j == 'bar']"
10000 loops, best of 3: 174 usec per loop
$ python -m timeit "[i for i, j in enumerate(['foo', 'bar', 'baz']*500) if j == 'bar']"
10000 loops, best of 3: 196 usec per loop

Для меня перечисление работает лучше, чем методы на основе индексов, так как я собираю индексы строк, используя 'setswith ", и мне нужно собрать несколько вхождений. Или есть ли способ использовать индекс с" setswith ", который я не мог понять
Тупело Тистлхед

3
В моих руках перечислимая версия последовательно немного быстрее. Некоторые подробности реализации могли измениться с момента публикации вышеуказанного измерения.
Алекс Ковентри

2
На этот вопрос уже ответили с '11: stackoverflow.com/questions/6294179/…
Cristik


132

index()возвращает первый индекс значения!

| индекс (...)
| L.index (value, [start, [stop]]) -> integer - вернуть первый индекс значения

def all_indices(value, qlist):
    indices = []
    idx = -1
    while True:
        try:
            idx = qlist.index(value, idx+1)
            indices.append(idx)
        except ValueError:
            break
    return indices

all_indices("foo", ["foo","bar","baz","foo"])

2
А если не существует в списке?
Питер Мортенсен

1
Несуществующий элемент вызовет ValueError
Nam G VU

1
Этот ответ подойдет лучше здесь: stackoverflow.com/questions/6294179/…
Cristik

87

Проблема возникнет, если элемента нет в списке. Эта функция обрабатывает проблему:

# if element is found it returns index of element else returns None

def find_element_in_list(element, list_element):
    try:
        index_element = list_element.index(element)
        return index_element
    except ValueError:
        return None


59

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

if 'your_element' in mylist:
    print mylist.index('your_element')
else:
    print None

1
Это помогает нам избежать попытки поймать!
Devssh

Однако это может удвоить сложность. Кто-нибудь проверял?
Stefanct

@stefanct Временная сложность все еще линейна, но она будет повторять список дважды.
Приближается к

@ApproachingDarknessFish Это, очевидно, то, что я имел в виду. Даже если педантично это тот же порядок сложности, повторение дважды может быть серьезным недостатком во многих случаях использования, поэтому я поднял его. И мы до сих пор не знаем ответа ...
Stefanct

44

Все предлагаемые здесь функции воспроизводят внутреннее поведение языка, но затеняют происходящее.

[i for i in range(len(mylist)) if mylist[i]==myterm]  # get the indices

[each for each in mylist if each==myterm]             # get the items

mylist.index(myterm) if myterm in mylist else None    # get the first index and fail quietly

Зачем писать функцию с обработкой исключений, если язык предоставляет методы для того, что вы сами хотите?


9
Третий метод повторяется дважды по списку, верно?
Эрик

Re: «Все предложенные функции здесь» : Возможно, на момент написания, но вы должны проверить новые ответы, чтобы увидеть, если это все еще верно.
Питер Мортенсен

42

Если вы хотите все индексы, то вы можете использовать NumPy :

import numpy as np

array = [1, 2, 1, 3, 4, 5, 1]
item = 1
np_array = np.array(array)
item_index = np.where(np_array==item)
print item_index
# Out: (array([0, 2, 6], dtype=int64),)

Это понятное, читаемое решение.


4
А как насчет списков строк, списков нечисловых объектов и т. Д ...?
Ларикс Децидуа

1
Этот ответ лучше опубликовать здесь: stackoverflow.com/questions/6294179/…
Cristik

1
Это лучший, который я прочитал. Числовые массивы намного эффективнее, чем списки Python. Если список короткий, то нет проблем с его копированием из списка Python, а если нет, то, возможно, разработчик должен в первую очередь подумать о сохранении элементов в массиве numpy.
Атанассиос

36

Нахождение индекса элемента по списку, содержащему его в Python

Для списка ["foo", "bar", "baz"]и элемента в списке "bar", каков самый чистый способ получить его индекс (1) в Python?

Ну, конечно, есть метод index, который возвращает индекс первого вхождения:

>>> l = ["foo", "bar", "baz"]
>>> l.index('bar')
1

Есть несколько проблем с этим методом:

  • если значение отсутствует в списке, вы получите ValueError
  • если в списке более одного значения, вы получите индекс только для первого

Нет значений

Если значение может отсутствовать, вам нужно поймать ValueError.

Вы можете сделать это с помощью многоразового определения следующим образом:

def index(a_list, value):
    try:
        return a_list.index(value)
    except ValueError:
        return None

И используйте это так:

>>> print(index(l, 'quux'))
None
>>> print(index(l, 'bar'))
1

И недостатком этого является то, что вы, вероятно, будете проверять, возвращаемое значение isили is notнет:

result = index(a_list, value)
if result is not None:
    do_something(result)

Более одного значения в списке

Если бы вы могли иметь больше случаев, вы не получите полную информацию с list.index:

>>> l.append('bar')
>>> l
['foo', 'bar', 'baz', 'bar']
>>> l.index('bar')              # nothing at index 3?
1

Вы можете перечислить в список, понимающий индексы:

>>> [index for index, v in enumerate(l) if v == 'bar']
[1, 3]
>>> [index for index, v in enumerate(l) if v == 'boink']
[]

Если у вас нет вхождений, вы можете проверить это с помощью логической проверки результата или просто ничего не делать, если вы просматриваете результаты:

indexes = [index for index, v in enumerate(l) if v == 'boink']
for index in indexes:
    do_something(index)

Лучшее копание данных с пандами

Если у вас есть панды, вы можете легко получить эту информацию с помощью объекта Series:

>>> import pandas as pd
>>> series = pd.Series(l)
>>> series
0    foo
1    bar
2    baz
3    bar
dtype: object

Проверка сравнения вернет серию логических значений:

>>> series == 'bar'
0    False
1     True
2    False
3     True
dtype: bool

Передайте эту серию логических значений в серию через индексную запись, и вы получите только подходящие члены:

>>> series[series == 'bar']
1    bar
3    bar
dtype: object

Если вам нужны только индексы, атрибут index возвращает последовательность целых чисел:

>>> series[series == 'bar'].index
Int64Index([1, 3], dtype='int64')

И если вы хотите, чтобы они были в списке или кортеже, просто передайте их конструктору:

>>> list(series[series == 'bar'].index)
[1, 3]

Да, вы могли бы использовать списочное понимание и с enumerate, но, на мой взгляд, это не так элегантно - вы делаете тесты на равенство в Python вместо того, чтобы позволить встроенному коду, написанному на C, обрабатывать его:

>>> [i for i, value in enumerate(l) if value == 'bar']
[1, 3]

Это проблема XY ?

Проблема XY спрашивает о вашей попытке решения, а не о вашей реальной проблеме.

Как вы думаете, зачем нужен индекс, заданный элементом в списке?

Если вы уже знаете значение, почему вас волнует, где оно находится в списке?

Если значения нет, то выловление ValueErrorдовольно многословно - и я предпочитаю избегать этого.

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

Если вы манипулируете данными, вам, вероятно, следует использовать панд - в которых есть гораздо более элегантные инструменты, чем те чисто обходные пути Python, которые я показал.

Я не вспоминаю о необходимости list.index, сам. Тем не менее, я просмотрел стандартную библиотеку Python и нашел отличные варианты ее использования.

Есть много, много применений для этого idlelib, для графического интерфейса и синтаксического анализа текста.

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

В lib / mailbox.py кажется, что он используется как упорядоченное отображение:

key_list[key_list.index(old)] = new

а также

del key_list[key_list.index(key)]

В Lib / http / cookiejar.py, похоже, используется для получения следующего месяца:

mon = MONTHS_LOWER.index(mon.lower())+1

В lib / tarfile.py аналогично distutils для получения среза до элемента:

members = members[:members.index(tarinfo)]

В Lib / pickletools.py:

numtopop = before.index(markobject)

Похоже, что эти обычаи объединяют то, что они работают со списками ограниченных размеров (важно из-за времени поиска O (n) list.index), и они в основном используются при разборе (и пользовательском интерфейсе в случае ожидания).

Хотя для этого есть варианты использования, они довольно редки. Если вы ищете этот ответ, спросите себя, является ли то, что вы делаете, наиболее прямым использованием инструментов, предоставляемых языком для вашего варианта использования.



22

Получение всех вхождений и положения одного или нескольких (идентичных) элементов в списке

С помощью enumerate (alist) вы можете сохранить первый элемент (n), который является индексом списка, когда элемент x равен тому, что вы ищете.

>>> alist = ['foo', 'spam', 'egg', 'foo']
>>> foo_indexes = [n for n,x in enumerate(alist) if x=='foo']
>>> foo_indexes
[0, 3]
>>>

Давайте сделаем нашу функцию findindex

Эта функция принимает элемент и список в качестве аргументов и возвращает позицию элемента в списке, как мы видели ранее.

def indexlist(item2find, list_or_string):
  "Returns all indexes of an item in a list or a string"
  return [n for n,item in enumerate(list_or_string) if item==item2find]

print(indexlist("1", "010101010"))

Вывод


[1, 3, 5, 7]

просто

for n, i in enumerate([1, 2, 3, 4, 1]):
    if i == 1:
        print(n)

Вывод:

0
4

1
Этот ответ лучше опубликовать здесь: stackoverflow.com/questions/6294179/…
Cristik

17

Просто вы можете пойти с

a = [['hand', 'head'], ['phone', 'wallet'], ['lost', 'stock']]
b = ['phone', 'lost']

res = [[x[0] for x in a].index(y) for y in b]


16

А сейчас нечто соверешнно другое...

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

def indices(l, val):
    """Always returns a list containing the indices of val in the_list"""
    retval = []
    last = 0
    while val in l[last:]:
            i = l[last:].index(val)
            retval.append(last + i)
            last += i + 1   
    return retval

l = ['bar','foo','bar','baz','bar','bar']
q = 'bar'
print indices(l,q)
print indices(l,'bat')
print indices('abcdaababb','a')

Когда вставлено в интерактивное окно Python:

Python 2.7.6 (v2.7.6:3a1db0d2747e, Nov 10 2013, 00:42:54) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> def indices(the_list, val):
...     """Always returns a list containing the indices of val in the_list"""
...     retval = []
...     last = 0
...     while val in the_list[last:]:
...             i = the_list[last:].index(val)
...             retval.append(last + i)
...             last += i + 1   
...     return retval
... 
>>> l = ['bar','foo','bar','baz','bar','bar']
>>> q = 'bar'
>>> print indices(l,q)
[0, 2, 4, 5]
>>> print indices(l,'bat')
[]
>>> print indices('abcdaababb','a')
[0, 4, 5, 7]
>>> 

Обновить

После еще одного года бездумной разработки Python я немного смутился из-за своего первоначального ответа, так что для ясности можно использовать приведенный выше код; тем не менее, гораздо более идиоматический способ получить такое же поведение - использовать понимание списка вместе с функцией enumerate ().

Что-то вроде этого:

def indices(l, val):
    """Always returns a list containing the indices of val in the_list"""
    return [index for index, value in enumerate(l) if value == val]

l = ['bar','foo','bar','baz','bar','bar']
q = 'bar'
print indices(l,q)
print indices(l,'bat')
print indices('abcdaababb','a')

Который при вставке в интерактивное окно Python дает:

Python 2.7.14 |Anaconda, Inc.| (default, Dec  7 2017, 11:07:58) 
[GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> def indices(l, val):
...     """Always returns a list containing the indices of val in the_list"""
...     return [index for index, value in enumerate(l) if value == val]
... 
>>> l = ['bar','foo','bar','baz','bar','bar']
>>> q = 'bar'
>>> print indices(l,q)
[0, 2, 4, 5]
>>> print indices(l,'bat')
[]
>>> print indices('abcdaababb','a')
[0, 4, 5, 7]
>>> 

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

Если приведенная выше строка кода по-прежнему не имеет смысла для вас, я настоятельно рекомендую вам «понимание списков Python» в Google и потратьте несколько минут на ознакомление. Это всего лишь одна из многих мощных функций, которые позволяют использовать Python для разработки кода.


13

Вариант ответа от FMc и user7177 даст указание, которое может вернуть все индексы для любой записи:

>>> a = ['foo','bar','baz','bar','any', 'foo', 'much']
>>> l = dict(zip(set(a), map(lambda y: [i for i,z in enumerate(a) if z is y ], set(a))))
>>> l['foo']
[0, 5]
>>> l ['much']
[6]
>>> l
{'baz': [2], 'foo': [0, 5], 'bar': [1, 3], 'any': [4], 'much': [6]}
>>> 

Вы также можете использовать это как один вкладыш, чтобы получить все индексы для одной записи. Гарантий эффективности нет, хотя я использовал set (a), чтобы уменьшить количество вызовов лямбды.


1
Этот ответ лучше опубликовать здесь: stackoverflow.com/questions/6294179/…
Cristik

10

Это решение не такое мощное, как другие, но если вы новичок и знаете только о forциклах, все же возможно найти первый индекс элемента, избегая при этом ValueError:

def find_element(p,t):
    i = 0
    for e in p:
        if e == t:
            return i
        else:
            i +=1
    return -1

10

Нахождение индекса элемента x в списке L:

idx = L.index(x) if (x in L) else -1

4
Это повторяет массив дважды, что может привести к проблемам с производительностью больших массивов.
Cristik

Согласен. Если списки очень длинные, я бы пошел на что-то еще. Не должно быть большой проблемой для небольших и средних списков.
Ketan

6
name ="bar"
list = [["foo", 1], ["bar", 2], ["baz", 3]]
new_list=[]
for item in list:
    new_list.append(item[0])
print(new_list)
try:
    location= new_list.index(name)
except:
    location=-1
print (location)

Это учитывает, если строка не находится в списке тоже, если ее нет в списке, то location = -1


5

Поскольку списки Python начинаются с нуля, мы можем использовать встроенную функцию zip следующим образом:

>>> [i for i,j in zip(range(len(haystack)), haystack) if j == 'needle' ]

где «стог сена» - это рассматриваемый список, а «игла» - это элемент, который нужно искать.

(Примечание: здесь мы повторяем, используя i для получения индексов, но если нам нужно сосредоточиться на элементах, мы можем переключиться на j.)


3
[i для i, j в перечислении (стоге сена), если j == 'needle'], я думаю, более компактно и читабельно.
Джованни Г.

5

index()Метод Python выдает ошибку, если элемент не был найден. Таким образом, вместо этого вы можете сделать его похожим на indexOf()функцию JavaScript, которая возвращает, -1если элемент не был найден:

try:
    index = array.index('search_keyword')
except ValueError:
    index = -1

5
тем не менее, JavaScript придерживается философии, согласно которой странные результаты лучше, чем ошибки, поэтому имеет смысл возвращать -1, но в Python может быть сложно отследить ошибку, поскольку -1 возвращает элемент из конца списка.
Sapphire_Brick

3

Есть более функциональный ответ на это.

list(filter(lambda x: x[1]=="bar",enumerate(["foo", "bar", "baz", "bar", "baz", "bar", "a", "b", "c"])))

Более общая форма:

def get_index_of(lst, element):
    return list(map(lambda x: x[0],\
       (list(filter(lambda x: x[1]==element, enumerate(lst))))))

1
Этот ответ чувствует себя как дома для Scala/ функционально-программирование энтузиастов
Y2K-Shubham

3

Давайте дадим название lstсписку, который у вас есть. Можно преобразовать список lstв numpy array. А затем используйте numpy.where, чтобы получить индекс выбранного элемента в списке. Следующее - способ, которым вы будете это реализовывать.

import numpy as np

lst = ["foo", "bar", "baz"]  #lst: : 'list' data type
print np.where( np.array(lst) == 'bar')[0][0]

>>> 1

2

Для тех, кто приходит с другого языка, как я, может быть, с простым циклом это легче понять и использовать:

mylist = ["foo", "bar", "baz", "bar"]
newlist = enumerate(mylist)
for index, item in newlist:
  if item == "bar":
    print(index, item)

Я благодарен за то, что именно перечисляет делать? , Это помогло мне понять.


2

Если вы собираетесь найти индекс один раз, тогда лучше использовать метод «index». Однако, если вы собираетесь искать данные более одного раза, я рекомендую использовать модуль bisect . Имейте в виду, что при использовании модуля bisect данные должны быть отсортированы. Таким образом, вы сортируете данные один раз, а затем можете использовать bisect. Использование модуля bisect на моей машине примерно в 20 раз быстрее, чем с помощью метода index.

Вот пример кода с использованием синтаксиса Python 3.8 и выше:

import bisect
from timeit import timeit

def bisect_search(container, value):
    return (
      index 
      if (index := bisect.bisect_left(container, value)) < len(container) 
      and container[index] == value else -1
    )

data = list(range(1000))
# value to search
value = 666

# times to test
ttt = 1000

t1 = timeit(lambda: data.index(value), number=ttt)
t2 = timeit(lambda: bisect_search(data, value), number=ttt)

print(f"{t1=:.4f}, {t2=:.4f}, diffs {t1/t2=:.2f}")

Вывод:

t1=0.0400, t2=0.0020, diffs t1/t2=19.60

1

Если производительность вызывает беспокойство:

В многочисленных ответах упоминается, что встроенный метод list.index(item)метода является алгоритмом O (n). Это хорошо, если вам нужно выполнить это один раз. Но если вам нужно получить доступ к индексам элементов несколько раз, имеет смысл сначала создать словарь (O (n)) пар элементов-индексов, а затем обращаться к индексу в O (1) каждый раз, когда вам нужно Это.

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

myList = ["foo", "bar", "baz"]

# Create the dictionary
myDict = dict((e,i) for i,e in enumerate(myList))

# Lookup
myDict["bar"] # Returns 1
# myDict.get("blah") if you don't want an error to be raised if element not found.

Если у вас могут быть повторяющиеся элементы, и вам необходимо вернуть все их индексы:

from collections import defaultdict as dd
myList = ["foo", "bar", "bar", "baz", "foo"]

# Create the dictionary
myDict = dd(list)
for i,e in enumerate(myList):
    myDict[e].append(i)

# Lookup
myDict["foo"] # Returns [0, 4]

1

Как указывает @TerryA, многие ответы обсуждают, как найти один индекс.

more_itertoolsсторонняя библиотека с инструментами для поиска нескольких индексов внутри итерируемого

Данный

import more_itertools as mit


iterable = ["foo", "bar", "baz", "ham", "foo", "bar", "baz"]

Код

Найти индексы множественных наблюдений:

list(mit.locate(iterable, lambda x: x == "bar"))
# [1, 5]

Протестируйте несколько предметов:

list(mit.locate(iterable, lambda x: x in {"bar", "ham"}))
# [1, 3, 5]

Смотрите также больше вариантов с more_itertools.locate. Установить через > pip install more_itertools.


0

используя словарь, где сначала обработать список, а затем добавить к нему индекс

from collections import defaultdict

index_dict = defaultdict(list)    
word_list =  ['foo','bar','baz','bar','any', 'foo', 'much']

for word_index in range(len(word_list)) :
    index_dict[word_list[word_index]].append(word_index)

word_index_to_find = 'foo'       
print(index_dict[word_index_to_find])

# output :  [0, 5]

-1

на мой взгляд, ["foo", "bar", "baz"].index("bar")это хорошо, но этого не достаточно! потому что, если «bar» нет в словаре, то ValueErrorвозникает. Так что вы можете использовать эту функцию:

def find_index(arr, name):
    try:
        return arr.index(name)
    except ValueError:
        return -1

if __name__ == '__main__':
    print(find_index(["foo", "bar", "baz"], "bar"))

и результат:

1

и если name не было в arr, функция возвращает -1. Например:

print (find_index (["foo", "bar", "baz"], "fooo"))

-1


1
Не используйте это, потому l = [1, 2]; find_index(l, 3)что вернется -1и l[find_index(l, 3)]вернется 2. -1 плохо возвращать, просто вернуть нет.
Даниэль Стракабошко

-1 - это контракт, который вы можете вернуть, когда захотите, но старайтесь использовать меньшее значение None в своих программах, потому что None или Null при взаимодействии вашей программы с другими программами, такими как сайты Android и PHP, могут вызвать разрыв программы, например, вы можете вернуть null в JSON и приложение телефона вашего веб-сайта закроется или вернет ошибку 500 (внутренняя ошибка сервера).
NaabNuts
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.