Jedną z rzeczy, która jest naprawdę pomocna w nauce Pythona, jest użycie interaktywnej funkcji pomocy:

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

class list(object)
 ...

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

Które często prowadzą cię do metody, której szukasz.

Większość odpowiedzi wyjaśnia, jak znaleźć pojedynczy indeks , ale ich metody nie zwracają wielu indeksów, jeśli element znajduje się na liście wiele razy. Użycie enumerate():

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

Funkcja index() zwraca tylko pierwsze wystąpienie, podczas gdy enumerate() zwraca wszystkie wystąpienia.

Jako spis treści:

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

Oto jeszcze jedno małe rozwiązanie z itertools.count() (które jest prawie takie samo podejście jak "enumerate"): {]}

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

Jest to bardziej efektywne dla większych list niż użycie 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

Aby uzyskać wszystkie indeksy:

 indexes = [i for i,x in enumerate(xs) if x == 'foo']

index() zwraca pierwszy indeks wartości!

| index(...)
| L. index (value, [start, [stop]]) -> integer -- return pierwszy indeks wartości

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

Problem pojawi się, jeśli element nie znajduje się na liście. Ta funkcja rozwiązuje problem:

# 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

a = ["foo","bar","baz",'bar','any','much']

indexes = [index for index in range(len(a)) if a[index] == 'bar']

Musisz ustawić warunek, aby sprawdzić, czy element, którego szukasz, znajduje się na liście

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

Wszystkie proponowane tutaj funkcje odtwarzają nieodłączne zachowania językowe, ale zaciemniają, co się dzieje.

[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

Po co pisać funkcję z obsługą WYJĄTKÓW, jeśli język sam zapewnia metody do tego, co chcesz?

Jeśli chcesz wszystkie indeksy, możesz użyć 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),)

Jest to jasne, czytelne rozwiązanie.

Znalezienie indeksu elementu podanego listy zawierającej go w Pythonie

Dla listy ["foo", "bar", "baz"] i elementu na liście "bar", jaki jest najczystszy sposób na uzyskanie indeksu (1) w Pythonie?

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

Istnieje kilka problemów z tą metodą:

• jeśli wartość nie znajduje się na liście, otrzymasz ValueError
• jeśli więcej niż jedna z wartości jest na liście znajdziesz indeks tylko dla pierwszego

Brak wartości

Jeśli wartość może brakować, musisz złapać ValueError.

Możesz to zrobić za pomocą definicji wielokrotnego użytku, takiej jak ta:

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

I użyj go tak:

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

A minusem tego jest to, że prawdopodobnie będziesz miał sprawdzanie, czy zwrócona wartość is lub is not None:

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

Więcej niż jedna wartość na liście

Jeśli mógłbyś mieć więcej zdarzeń, będziesz Nie uzyskać pełne informacje z list.index:

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

Możesz wyliczyć do listy indeksy:

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

Jeśli nie masz żadnych wystąpień, możesz to sprawdzić za pomocą boolean check wyniku, lub po prostu nie rób nic, jeśli zapętlisz wyniki:

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

Lepsze dane z pand

Jeśli masz pandy, możesz łatwo uzyskać te informacje za pomocą obiektu szeregowego:

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

Kontrola porównawcza zwróci serię of booleans:

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

Przekaż tę serię booleanów do serii za pomocą notacji dolnej, a otrzymasz tylko pasujące elementy:

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

Jeśli chcesz tylko indeksy, atrybut index zwraca serię liczb całkowitych:

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

I jeśli chcesz je umieścić w liście lub krotce, po prostu przekaż je do konstruktora:

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

Tak, przydałaby się też lista z enumerate, ale to nie jest tak eleganckie, moim zdaniem-robisz testy na równość w Pythonie, zamiast pozwalać wbudowanemu kodowi napisanemu w C, zajmijcie się nim:

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

Problem XY polega na pytaniu o próbę rozwiązania, a nie o faktyczny problem.

Dlaczego uważasz, że potrzebujesz indeksu podanego jako element listy?

Jeśli znasz już wartość, dlaczego obchodzi cię, gdzie jest ona na liście?

Jeśli nie ma wartości, łapanie ValueError jest raczej gadatliwe - i wolę unikaj tego.

Zazwyczaj iteruję nad listą, więc zazwyczaj zachowam wskaźnik do interesujących informacji, uzyskując indeks z enumerate.

Jeśli gromadzisz dane, prawdopodobnie powinieneś używać pand-które mają o wiele bardziej eleganckie narzędzia niż czyste obejścia w Pythonie, które pokazałem.

Jest wiele, wiele zastosowań dla niego w idlelib, do analizy GUI i tekstu.

Moduł keyword używa go do znajdowania znaczników komentarzy w module, aby automatycznie regenerować listę słów kluczowych w nim za pomocą metaprogramowania.

W Lib/mailbox.py wygląda na to, że używa go jak uporządkowanego mapowania: {]}

key_list[key_list.index(old)] = new

I

del key_list[key_list.index(key)]

W Lib/http/cookiejar.py, wydaje się być używany do zdobycia następnego miesiąca:

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

W Lib/tarfile.py podobne do distutils, aby uzyskać pokrój do elementu:

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

W Lib/pickletools.py:

numtopop = before.index(markobject)

To, co te zwyczaje wydają się mieć wspólnego jest to, że wydają się działać na listach ograniczonych rozmiarów (ważne ze względu na O(n) lookup time for list.index), i są one używane głównie w parsingu (i UI w przypadku Idle).

Wszystkie indeksy z zip Funkcja:

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

Po prostu możesz wybrać

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

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

Inna opcja

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

Wariant odpowiedzi z FMc i user7177 da dict, który może zwrócić wszystkie indeksy dla dowolnego wpisu:

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

Możesz również użyć tego jako jednego linera, aby uzyskać wszystkie indeksy dla jednego wpisu. Nie ma gwarancji skuteczności, chociaż użyłem set(a), aby zmniejszyć liczbę wywołań lambda.

A teraz coś zupełnie innego...

... na przykład potwierdzenie istnienia elementu przed uzyskaniem indeksu. Zaletą tego podejścia jest to, że funkcja zawsze zwraca listę indeksów - nawet jeśli jest to pusta lista. Działa również ze strunami.

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

Po wklejeniu do interaktywnego okna Pythona:

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

Update

Po kolejnym roku rozwoju Pythona heads-down, jestem trochę zażenowany moją oryginalną odpowiedzią, więc aby ustawić zapis prosty, z pewnością można użyć powyższego kodu; jednak znacznie bardziej idiomatycznym sposobem uzyskania tego samego zachowania byłoby użycie rozumienia list, wraz z funkcją enumerate ().

Coś takiego:

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

Które po wklejeniu do interaktywnego okna Pythona daje:

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

A teraz, po przejrzeniu tego pytania i wszystkich odpowiedzi, zdaję sobie sprawę, że to jest dokładnie to, co FMC zasugerował w swojej wcześniejszej odpowiedzi . Kiedy odpowiedziałem na to pytanie, nawet nie widziałem tej odpowiedzi, ponieważ jej nie rozumiałem. Mam nadzieję, że mój nieco bardziej gadatliwy przykład pomoże zrozumieć.

Jeśli pojedyncza linijka kodu powyżej nadal nie ma sensu dla Ciebie, Gorąco polecam Ci Google "Python list comprehension" i poświęć kilka minut na zapoznanie się. To tylko jedna z wielu zaawansowanych funkcji, które sprawiają, że korzystanie z Pythona do tworzenia kodu jest przyjemnością.

Uzyskanie wszystkich wystąpień i pozycji jednego lub więcej (identycznych) elementów na liście

Za pomocą enumerate (alist) możesz zapisać pierwszy element (n), który jest indeksem listy, gdy element x jest równy temu, czego szukasz.

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

Niech nasza funkcja findindex

Ta funkcja przyjmuje element i listę jako argumenty i zwraca pozycję elementu na liście, tak jak widzieliśmy wcześniej.

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

Wyjście

[1, 3, 5, 7]

Proste

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

Wyjście:

0
4

To rozwiązanie nie jest tak potężne jak inne, ale jeśli jesteś początkujący i znasz tylko pętle for, nadal możesz znaleźć pierwszy indeks elementu, unikając ValueError:

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

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)

Oznacza to, że jeśli łańcuch nie znajduje się na liście, jeśli nie znajduje się na liście, to location = -1

Ponieważ listy Pythona są oparte na 0, możemy użyć wbudowanej funkcji zip w następujący sposób:

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

Gdzie "stóg siana" to lista, o której mowa, a "igła" to przedmiot, którego należy szukać.

(Uwaga: tutaj iterujemy używając i, aby uzyskać indeksy, ale jeśli chcemy skupić się na elementach, możemy przełączyć się na j.)

Istnieje bardziej funkcjonalna odpowiedź na to pytanie.

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

Bardziej ogólna forma:

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

Metoda Python index() wyświetla błąd, jeśli element nie został znaleziony, co jest do bani!

Więc zamiast tego możesz uczynić go podobnym do indexOf() funkcji JavaScript, która zwraca -1 Jeśli element nie został znaleziony:

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

Znalezienie indeksu pozycji x na liście L :

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

Dla tych, którzy pochodzą z innego języka jak ja, może dzięki prostej pętli łatwiej jest go zrozumieć i używać:

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

Jestem wdzięczny za co dokładnie robi enumerate?. To pomogło mi zrozumieć.

Jeśli wydajność jest niepokojąca:

W licznych odpowiedziach mówi się, że wbudowana metoda metody {[2] } jest algorytmem O (n). To jest w porządku, jeśli trzeba wykonać to raz. Ale jeśli chcesz uzyskać dostęp do indeksów elementów kilka razy, bardziej sensowne jest najpierw utworzenie słownika(O(n)) par element-indeks, a następnie dostęp do indeksu w O (1) za każdym razem, gdy go potrzebujesz.

Jeśli masz pewność, że pozycje na liście nigdy się nie powtórzą, możesz łatwo:

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.

Jeśli możesz mieć zduplikowane elementy i musisz zwrócić wszystkie ich indeksy:

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]

Są dwie możliwości, jeśli lista nie zawiera powtarzających się elementów, które należy sprawdzić w indeksie

 eg: li=[10,20,30] # here need to get index of 20 means
     li.index(20) # will work properly because 20 is not repeated

Jeśli jego powtórzenie oznacza, że da Ci tylko pierwszy indeks

Jeśli chcesz uzyskać cały indeks, w którym element jest obecny oznacza

eg: li=[10,20,30,20,40, 50, 10] # here need to get index of 20 means its have 2 index (1,3) 

Aby to osiągnąć musisz to zrobić jak

 li=[10,20,30,20,40, 50, 10]
 [i for i, e in enumerate(li) if e == 20]

Następnie otrzymasz listę indeksu jako o / p jak [1,3]

Jak wskazał @TerryA, wiele odpowiedzi mówi o tym, jak znaleźć Jeden indeks.

more_itertools jest biblioteką innej firmy z narzędziami do lokalizowania wielu indeksów wewnątrz iterowalnego.

Given

import more_itertools as mit


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

Kod

Znajdź wskaźniki wielu obserwacji:

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

Przetestuj wiele elementów:

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

Zobacz także więcej opcji z more_itertools.locate. Install via > pip install more_itertools.