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

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

7.10.2008 01:39:38
Вы возвращаете: [1] Самый низкий индекс, если есть несколько экземпляров "bar", [2] Все индексы "bar"?
Ṃųỻịgǻňạcểơửṩ 12.05.2018 20:56:39
а) Гарантируется ли, что элемент находится в списке, или как мы должны обработать ошибку? (вернуть None / повысить ValueError) б) Гарантируется ли уникальность записей в списке, и должны ли мы возвращать первый индекс совпадения или все индексы?
smci 21.05.2018 06:20:46
Посмотрите ответы с интеграцией NumPy, массивы NUMPY гораздо более эффективны, чем списки Python. Если список короткий, то нетрудно скопировать его из списка Python, если нет, то, возможно, вам стоит сначала сохранить элементы в массиве numpy.
Athanassios 28.01.2020 12:21:33
30 ОТВЕТОВ
РЕШЕНИЕ
>>> ["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(возможно, быстрее, по крайней мере, когда список для поиска длинный, а элемент обычно присутствует).
4380
21.01.2020 13:12:18
index возвращает первый элемент, значение которого равно «bar». Если в списке дважды присутствует «бар», вы никогда не найдете ключ для второго «бара». См. Документацию: docs.python.org/3/tutorial/datastructures.html
mpoletto 30.01.2018 04:51:44
Если вы ищете только один элемент (первый), я обнаружил, что index()он чуть менее чем на 90% быстрее, чем списки со списками целых чисел.
slybloty 19.09.2019 20:13:53
Какую структуру данных следует использовать, если список очень длинный?
izhang 22.02.2020 20:36:31
@izhang: некоторый вспомогательный индекс, такой как dict {element -> list_index}, если элементы являются хешируемыми, и позиция в списке имеет значение.
Alex Coventry 24.02.2020 04:30:03

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

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

class list(object)
 ...

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

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

892
7.10.2008 13:19:56
bpython - это удобный и удобный способ читать документы в интерактивном режиме.
goetzc 22.09.2019 18:09:57
@davidavr да, но у остальных из нас, кто просто хочет погуглить, вместо того, чтобы просматривать справочные документы, не было бы этого замечательного, центрального, ранжированного набора параметров. :)
honkaboy 6.04.2020 23:42:20

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"])
132
9.03.2012 10:38:09
А если не существует в списке?
Peter Mortensen 4.06.2018 20:16:56
Несуществующий элемент вызовет ValueError
Nam G VU 13.08.2018 05:29:28
Этот ответ будет лучше здесь: stackoverflow.com/questions/6294179/…
Cristik 10.02.2019 10:56:42
a = ["foo","bar","baz",'bar','any','much']

indexes = [index for index in range(len(a)) if a[index] == 'bar']
77
31.10.2017 07:45:46
Этот ответ лучше опубликовать здесь: stackoverflow.com/questions/6294179/…
Cristik 10.02.2019 10:57:26

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

# 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
86
24.04.2017 10:00:10

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

[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

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

44
24.12.2016 14:24:33
Третий метод повторяется дважды по списку, верно?
Eric Duminil 5.02.2017 13:59:54
Re: «Все предложенные функции здесь» : Возможно, на момент написания, но вы должны проверить новые ответы, чтобы увидеть, если это все еще верно.
Peter Mortensen 4.06.2018 20:19:50

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

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

res = [[x[0] for x in a].index(y) for y in b]
16
29.05.2013 07:17:15

Другой вариант

>>> a = ['red', 'blue', 'green', 'red']
>>> b = 'red'
>>> offset = 0;
>>> indices = list()
>>> for i in range(a.count(b)):
...     indices.append(a.index(b,offset))
...     offset = indices[-1]+1
... 
>>> indices
[0, 3]
>>> 
16
29.05.2013 19:17:21
Этот ответ лучше опубликовать здесь: stackoverflow.com/questions/6294179/…
Cristik 10.02.2019 10:58:53

Большинство ответов объясняют, как найти один индекс , но их методы не возвращают несколько индексов, если элемент находится в списке несколько раз. Используйте 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
540
21.01.2020 13:04:01
Перечисление работает лучше, чем методы на основе индексов, так как я собираю индексы строк, используя «старты с», и мне нужно собрать несколько вхождений. Или есть способ использовать индекс с «запускается с», который я не мог понять
Tupelo Thistlehead 26.10.2017 19:15:53
В моих руках перечислимая версия последовательно немного быстрее. Некоторые подробности реализации могли измениться с момента публикации вышеуказанного измерения.
Alex Coventry 17.11.2017 18:43:32
На этот вопрос уже ответили с '11: stackoverflow.com/questions/6294179/…
Cristik 10.02.2019 10:55:37

Чтобы получить все индексы:

indexes = [i for i,x in enumerate(xs) if x == 'foo']
171
30.07.2019 11:17:35
Уже есть еще один вопрос для этого, добавленный в '11: stackoverflow.com/questions/6294179/…
Cristik 10.02.2019 10:56:16

Вариант ответа от 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), чтобы уменьшить количество вызовов лямбды.

12
28.03.2014 09:11:57
Этот ответ лучше опубликовать здесь: stackoverflow.com/questions/6294179/…
Cristik 10.02.2019 10:59:16

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

if 'your_element' in mylist:
    print mylist.index('your_element')
else:
    print None
58
26.05.2014 04:26:52
Это помогает нам избежать попытки поймать!
devssh 10.09.2018 07:45:39
Однако это может удвоить сложность. Кто-нибудь проверял?
stefanct 6.09.2019 15:58:35
@stefanct Временная сложность все еще линейна, но она будет повторять список дважды.
ApproachingDarknessFish 28.01.2020 20:55:03
@ApproachingDarknessFish Это, очевидно, то, что я имел в виду. Даже если педантично это тот же порядок сложности, итерация два раза может быть серьезным недостатком во многих случаях применения , таким образом , я привел его. И мы до сих пор не знаем ответа ...
stefanct 29.01.2020 01:50:05

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

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

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 для разработки кода.

15
18.07.2018 10:01:05

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

def find_element(p,t):
    i = 0
    for e in p:
        if e == t:
            return i
        else:
            i +=1
    return -1
10
12.11.2017 06:07:52
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
13.02.2020 13:06:51

Все индексы с zipфункцией:

get_indexes = lambda x, xs: [i for (y, i) in zip(xs, range(len(xs))) if x == y]

print get_indexes(2, [1, 2, 3, 4, 5, 6, 3, 2, 3, 2])
print get_indexes('f', 'xsfhhttytffsafweef')
22
4.06.2018 20:50:20
Этот ответ лучше опубликовать здесь: stackoverflow.com/questions/6294179/…
Cristik 10.02.2019 10:58:40

Если вы хотите все индексы, то вы можете использовать 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),)

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

41
4.06.2018 20:26:33
А как насчет списков строк, списков нечисловых объектов и т. Д ...?
Laryx Decidua 12.10.2016 14:55:58
Этот ответ лучше опубликовать здесь: stackoverflow.com/questions/6294179/…
Cristik 10.02.2019 10:58:13
Это лучшее, что я прочитал. Числовые массивы намного эффективнее, чем списки Python. Если список короткий, то нет проблем с его копированием из списка Python, если нет, то, возможно, разработчик должен в первую очередь подумать о сохранении элементов в массиве numpy.
Athanassios 28.01.2020 12:23:12

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

С помощью 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
21
5.11.2018 12:18:25
Этот ответ лучше опубликовать здесь: stackoverflow.com/questions/6294179/…
Cristik 10.02.2019 10:59:07

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

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

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

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

5
4.06.2018 20:56:33
[i для i, j в перечислении (стоге сена), если j == 'needle'], я думаю, более компактно и читабельно.
Giovanni G. PY 27.12.2017 07:23:34

Нахождение индекса элемента по списку, содержащему его в 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), и они в основном используются при разборе (и пользовательском интерфейсе в случае ожидания).

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

34
2.09.2017 23:56:20

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

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

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

2
4.06.2018 20:55:15

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

try:
    index = array.index('search_keyword')
except ValueError:
    index = -1
4
30.07.2019 11:19:11
тем не менее, JavaScript придерживается философии, согласно которой странные результаты лучше ошибок, поэтому имеет смысл возвращать -1, но в Python может быть сложно отследить ошибку, поскольку -1 возвращает элемент из конца списка.
Sapphire_Brick 29.10.2019 22:44:21

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

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))))))
3
4.06.2018 20:53:01
Этот ответ чувствует себя как дома для Scala/ функционально-программирование энтузиастов
y2k-shubham 21.08.2018 05:13:12

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

idx = L.index(x) if (x in L) else -1
7
30.01.2019 17:36:11
Это повторяет массив дважды, что может привести к проблемам с производительностью больших массивов.
Cristik 10.02.2019 11:00:50
Согласен. Если списки очень длинные, я бы пошел на что-то еще. Не должно быть большой проблемой для небольших и средних списков.
Ketan 25.02.2019 08:13:33

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

В многочисленных ответах упоминается, что встроенный метод 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
10.09.2018 18:51:04

Как указывает @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.

1
25.09.2018 15:47:56

Давайте дадим название 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
3
28.11.2018 06:42:23

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

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]
0
18.03.2019 09:32:09

на мой взгляд, ["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
8.03.2020 09:23:19
Не используйте это, потому l = [1, 2]; find_index(l, 3)что вернется -1и l[find_index(l, 3)]вернется 2. -1 плохо возвращать, просто вернуть нет.
Daniel 12.03.2020 08:22:09
-1 - это контракт, который вы можете вернуть, когда захотите, но попробуйте использовать меньшее значение None в своих программах, потому что None или Null при взаимодействии вашей программы с другими программами, такими как сайты Android и PHP, могут вызвать разрыв программы, например, вы можете вернуть null в JSON и приложение телефона вашего веб-сайта закроется или вернет ошибку 500 (внутренняя ошибка сервера).
Pouria 13.03.2020 19:21:14
Это не php или android, это python. И вы используете «контракт» вы узнали из c. Избегайте этого или не понесите затрат.
Daniel 15.03.2020 06:37:25

Если вы собираетесь найти индекс один раз, тогда лучше использовать метод «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
0
3.04.2020 16:50:22