Gegeven een lijst ["foo", "bar", "baz"] en een item in de lijst "bar", hoe krijg ik de index ervan ( 1) in Python?

Antwoord 1, autoriteit 100%

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

Referentie: Datastructuren > Meer over lijsten

Voorbehoud volgen

Merk op dat, hoewel dit misschien de schoonste manier is om de vraag zoals gesteld te beantwoorden, index een nogal zwak onderdeel is van de list API , en ik kan me de laatste keer dat ik het uit woede heb gebruikt niet herinneren. Er is mij in de opmerkingen op gewezen dat, omdat er veel naar dit antwoord wordt verwezen, het completer moet worden gemaakt. Enkele kanttekeningen bij list.index volgen. Het is waarschijnlijk de moeite waard om eerst de documentatie ervoor te bekijken:

list.index(x[, start[, end]])
Retourneer een op nul gebaseerde index in de lijst van het eerste item waarvan de waarde gelijk is aan x. Verhoogt een ValueError als een dergelijk item niet bestaat.

De optionele argumenten start en end worden geïnterpreteerd zoals in de slice-notatie en worden gebruikt om het zoeken te beperken tot een bepaalde subreeks van de lijst. De geretourneerde index wordt berekend ten opzichte van het begin van de volledige reeks in plaats van het startargument.

Lineaire tijdcomplexiteit in lijstlengte

Een index-aanroep controleert elk element van de lijst op volgorde, totdat er een overeenkomst wordt gevonden. Als uw lijst lang is en u niet ongeveer weet waar in de lijst deze voorkomt, kan deze zoekopdracht een knelpunt worden. Overweeg dan een andere datastructuur. Merk op dat als je ongeveer weet waar je de overeenkomst kunt vinden, je index een hint kunt geven. In dit fragment is l.index(999_999, 999_990, 1_000_000) bijvoorbeeld ongeveer vijf ordes van grootte sneller dan gewoon l.index(999_999), omdat de eerste hoeft slechts 10 vermeldingen te doorzoeken, terwijl de laatste een miljoen zoekt:

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

Retourneert alleen de index van de eerste overeenkomst naar zijn argument

Een aanroep tot index doorzoekt de lijst op volgorde totdat er een overeenkomst wordt gevonden, en stopt daar. Als u verwacht indexen van meer overeenkomsten nodig te hebben, moet u een lijstbegrip of generatoruitdrukking.

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

Op de meeste plaatsen waar ik ooit index zou hebben gebruikt, gebruik ik nu een lijstbegrip of generator-expressie omdat ze meer generaliseerbaar zijn. Dus als je overweegt om naar index te gaan, kijk dan eens naar deze uitstekende Python-functies.

Gooit als element niet aanwezig is in lijst

Een aanroep van index resulteert in een ValueError als het item niet aanwezig is.

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

Als het item mogelijk niet in de lijst voorkomt, moet u ofwel

Controleer er eerst naar met item in my_list (schone, leesbare benadering), of
Wikkel de index-aanroep in een try/except-blok dat ValueError opvangt (waarschijnlijk sneller, tenminste als de te doorzoeken lijst lang is , en het item is meestal aanwezig.)

Antwoord 2, autoriteit 18%

Eén ding dat echt nuttig is bij het leren van Python is het gebruik van de interactieve helpfunctie:

>>> help(["foo", "bar", "baz"])
Help on list object:
class list(object)
 ...
 |
 |  index(...)
 |      L.index(value, [start, [stop]]) -> integer -- return first index of value
 |

die je vaak naar de methode leiden die je zoekt.

Antwoord 3, autoriteit 12%

De meeste antwoorden leggen uit hoe u een enkele index kunt vinden, maar hun methoden retourneren niet meerdere indexen als het item meerdere keren in de lijst voorkomt. Gebruik enumerate():

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

De functie index() retourneert alleen de eerste instantie, terwijl enumerate() alle instanties retourneert.

Als lijstbegrip:

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

Hier is ook nog een kleine oplossing met itertools.count() (wat ongeveer dezelfde benadering is als opsommen):

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

Dit is efficiënter voor grotere lijsten dan het gebruik van 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

Antwoord 4, autoriteit 4%

Alle indexen ophalen:

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

Antwoord 5, autoriteit 3%

index() retourneert de eerste index van waarde!

| index(…)
| L.index(waarde, [start, [stop]]) -> geheel getal — retourneer eerste index van waarde

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

Antwoord 6, autoriteit 2%

Er ontstaat een probleem als het element niet in de lijst staat. Deze functie lost het probleem op:

# 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

Antwoord 7, autoriteit 2%

a = ["foo","bar","baz",'bar','any','much']
indexes = [index for index in range(len(a)) if a[index] == 'bar']

Antwoord 8

U moet een voorwaarde instellen om te controleren of het element dat u zoekt in de lijst staat

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

Antwoord 9

Als u alle indexen wilt, kunt u NumPy:

gebruiken

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

Het is een duidelijke, leesbare oplossing.

Antwoord 10

Alle voorgestelde functies hier reproduceren inherent taalgedrag, maar verdoezelen wat er aan de hand is.

[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

Waarom een functie schrijven met uitzonderingsbehandeling als de taal de methoden biedt om te doen wat u zelf wilt?

Antwoord 11

De index van een item vinden met een lijst die het bevat in Python

Voor een lijst ["foo", "bar", "baz"] en een item in de lijst "bar", wat is het schoonst manier om de index (1) in Python te krijgen?

Natuurlijk, er is de indexmethode, die de index van het eerste exemplaar retourneert:

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

Er zijn een aantal problemen met deze methode:

als de waarde niet in de lijst staat, krijg je een ValueError
als er meer dan één van de waarden in de lijst staat, krijg je alleen de index voor de eerste

Geen waarden

Als de waarde zou kunnen ontbreken, moet u de ValueError opvangen.

Je kunt dit doen met een herbruikbare definitie zoals deze:

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

En gebruik het als volgt:

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

En het nadeel hiervan is dat u waarschijnlijk moet controleren of de geretourneerde waarde is of is not Geen:

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

Meer dan één waarde in de lijst

Als u meer exemplaren zou kunnen hebben, krijgt u geen volledige informatie met list.index:

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

U zou de indexen in een lijst kunnen opsommen:

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

Als je geen voorvallen hebt, kun je dat controleren met een booleaanse controle van het resultaat, of gewoon niets doen als je de resultaten doorloopt:

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

Betere gegevensuitwisseling met panda’s

Als je panda’s hebt, kun je deze informatie gemakkelijk krijgen met een Series-object:

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

Een vergelijkingscontrole levert een reeks booleans op:

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

Geef die reeks booleans door aan de reeks via subscriptnotatie, en u krijgt alleen de overeenkomende leden:

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

Als u alleen de indexen wilt, retourneert het indexkenmerk een reeks gehele getallen:

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

En als je ze in een lijst of tuple wilt, geef ze dan gewoon door aan de constructor:

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

Ja, je zou ook een lijstbegrip met enumerate kunnen gebruiken, maar dat is naar mijn mening niet zo elegant – je doet tests voor gelijkheid in Python, in plaats van de ingebouwde code die in C is geschreven het te laten verwerken:

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

Is dit een XY-probleem?

Het XY-probleem is vragen naar uw oplossingspoging in plaats van uw werkelijke probleem.

Waarom denk je dat je de index nodig hebt voor een element in een lijst?

Als u de waarde al kent, waarom maakt het u dan uit waar deze in een lijst staat?

Als de waarde er niet is, is het vangen van de ValueError nogal uitgebreid – en dat wil ik liever vermijden.

Ik herhaal de lijst toch meestal, dus ik houd meestal een verwijzing naar interessante informatie bij, waarbij ik de index krijg met opsommen.

Als je gegevens verprutst, zou je waarschijnlijk panda’s moeten gebruiken – die veel elegantere tools hebben dan de pure Python-oplossingen die ik heb laten zien.

Ik kan me niet herinneren dat ik zelf list.index nodig had. Ik heb echter de standaardbibliotheek van Python bekeken en ik zie er een aantal uitstekende toepassingen voor.

Er zijn vele, vele toepassingen voor in idlelib, voor GUI en tekstontleding.

De module keyword gebruikt het om commentaarmarkeringen in de module te vinden om automatisch de lijst met trefwoorden erin te regenereren via metaprogrammering.

In Lib/mailbox.py lijkt het te gebruiken als een geordende mapping:

key_list[key_list.index(old)] = new

del key_list[key_list.index(key)]

In Lib/http/cookiejar.py, lijkt te worden gebruikt om de volgende maand te krijgen:

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

In Lib/tarfile.py vergelijkbaar met distutils om een segment tot aan een item te krijgen:

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

In Lib/pickletools.py:

numtopop = before.index(markobject)

Wat deze gebruiken gemeen lijken te hebben, is dat ze lijken te werken op lijsten met beperkte afmetingen (belangrijk vanwege de O(n)-opzoektijd voor list.index), en ze zijn meestal gebruikt bij het ontleden (en UI in het geval van Idle).

Hoewel er use-cases voor zijn, zijn ze vrij ongebruikelijk. Als je merkt dat je op zoek bent naar dit antwoord, vraag jezelf dan af of wat je doet het meest directe gebruik is van de tools die door de taal worden geboden voor jouw use-case.

Antwoord 12

Alle exemplaren en de positie van een of meer (identieke) items in een lijst ophalen

Met enumerate(alist) kun je het eerste element (n) dat de index van de lijst is, opslaan als het element x gelijk is aan wat je zoekt.

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

Laten we onze functie findindex maken

Deze functie neemt het item en de lijst als argumenten en retourneert de positie van het item in de lijst, zoals we eerder zagen.

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

Uitvoer

[1, 3, 5, 7]

Eenvoudig

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

Uitvoer:

0
4

Antwoord 13

Alle indexen met de zip functie:

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

Antwoord 14

Je kunt gewoon mee gaan

a = [['hand', 'head'], ['phone', 'wallet'], ['lost', 'stock']]
b = ['phone', 'lost']
res = [[x[0] for x in a].index(y) for y in b]

Antwoord 15

Een andere optie

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

Antwoord 16

En nu, voor iets heel anders…

… zoals het bevestigen van het bestaan van het item voordat de index wordt opgehaald. Het leuke van deze aanpak is dat de functie altijd een lijst met indices retourneert — zelfs als het een lege lijst is. Het werkt ook met strings.

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

Wanneer geplakt in een interactief python-venster:

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

Bijwerken

Na nog een jaar van heads-down python-ontwikkeling, schaam ik me een beetje voor mijn oorspronkelijke antwoord, dus om alles recht te zetten, kan men zeker de bovenstaande code gebruiken; de veel meer idiomatische manier om hetzelfde gedrag te krijgen, zou echter zijn om lijstbegrip te gebruiken, samen met de functie enumerate().

Zoiets als dit:

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

Wat, wanneer geplakt in een interactief python-venster, oplevert:

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

En nu, na het bekijken van deze vraag en alle antwoorden, realiseer ik me dat dit precies is wat FMc suggereerde in zijn eerder antwoord . Op het moment dat ik deze vraag oorspronkelijk beantwoordde, zag ik dat antwoord niet eens, omdat ik het niet begreep. Ik hoop dat mijn wat meer uitgebreide voorbeeld het begrip zal helpen.

Als de enkele regel code hierboven nog steeds niet voor u klopt, raad ik u ten zeerste aan Google ‘pythonlijstbegrip’ te gebruiken en een paar minuten de tijd te nemen om uzelf vertrouwd te maken. Het is slechts een van de vele krachtige functies die het een plezier maken om Python te gebruiken om code te ontwikkelen.

Antwoord 17

Een variant op het antwoord van FMc en user7177 geeft een dictaat dat alle indices voor elke invoer kan retourneren:

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

U kunt dit ook gebruiken als een one-liner om alle indices voor een enkele invoer te krijgen. Er zijn geen garanties voor efficiëntie, hoewel ik set(a) wel heb gebruikt om het aantal keren dat de lambda wordt aangeroepen te verminderen.

Antwoord 18

Index zoeken van item x in lijst L:

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

Antwoord 19

Deze oplossing is niet zo krachtig als andere, maar als je een beginner bent en alleen kennis hebt van forloops, is het nog steeds mogelijk om de eerste index van een item te vinden zonder de ValueError:

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

Antwoord 20

De methode

Python index() genereert een fout als het item niet werd gevonden. Dus in plaats daarvan kun je het vergelijkbaar maken met de functie indexOf() van JavaScript die -1 retourneert als het item niet werd gevonden:

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

Antwoord 21

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)

Dit geldt als de tekenreeks ook niet in de lijst staat, als deze niet in de lijst staat, dan location = -1

Antwoord 22

Er is een kans dat die waarde niet aanwezig is, dus om deze ValueError te voorkomen, kunnen we controleren of die daadwerkelijk in de lijst voorkomt.

list =  ["foo", "bar", "baz"]
item_to_find = "foo"
if item_to_find in list:
      index = list.index(item_to_find)
      print("Index of the item is " + str(index))
else:
    print("That word does not exist")

Antwoord 23

Er is een functioneler antwoord hierop.

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

Meer algemene vorm:

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

Antwoord 24

Aangezien Python-lijsten op nul zijn gebaseerd, kunnen we de ingebouwde zip-functie als volgt gebruiken:

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

waarbij “hooiberg” de lijst in kwestie is en “naald” het item waarnaar moet worden gezocht.

(Opmerking: hier herhalen we i om de indexen te krijgen, maar als we ons liever op de items moeten concentreren, kunnen we overschakelen naar j.)

Antwoord 25

Voor een vergelijkbare

# Throws ValueError if nothing is found
some_list = ['foo', 'bar', 'baz'].index('baz')
# some_list == 2

Aangepast predikaat

some_list = [item1, item2, item3]
# Throws StopIteration if nothing is found
# *unless* you provide a second parameter to `next`
index_of_value_you_like = next(
    i for i, item in enumerate(some_list)
    if item.matches_your_criteria())

Index van alle items zoeken op predikaat

index_of_staff_members = [
    i for i, user in enumerate(users)
    if user.is_staff()]

Antwoord 26

Als je een index één keer gaat vinden, is het prima om de “index”-methode te gebruiken. Als u uw gegevens echter meer dan één keer gaat doorzoeken, raad ik u aan bisect-module. Houd er rekening mee dat het gebruik van bisect-modulegegevens moet worden gesorteerd. Dus je sorteert gegevens één keer en dan kun je bisect gebruiken.
Het gebruik van de module bisect op mijn computer is ongeveer 20 keer sneller dan het gebruik van de indexmethode.

Hier is een voorbeeld van code die de syntaxis van Python 3.8 en hoger gebruikt:

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

Uitvoer:

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

Antwoord 27

Voor degenen die uit een andere taal komen zoals ik, misschien is het met een eenvoudige lus gemakkelijker te begrijpen en te gebruiken:

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

Ik ben dankbaar voor Wat doet enumerate precies?. Dat hielp me het te begrijpen.

Antwoord 28

Laten we de naam lst geven aan de lijst die je hebt. Men kan de lijst lst converteren naar een numpy array. En gebruik dan numpy.where om de index van het gekozen item in de lijst te krijgen. Hieronder volgt de manier waarop u het gaat implementeren.

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

Antwoord 29

Als prestaties van belang zijn:

In talrijke antwoorden wordt vermeld dat de ingebouwde methode van de methode list.index(item) een O(n)-algoritme is. Het is prima als je dit een keer moet doen. Maar als u de indices van elementen een aantal keren moet openen, is het logischer om eerst een woordenboek (O(n)) van item-indexparen te maken en vervolgens de index op O(1) te openen elke keer dat u het.

Als u zeker weet dat de items in uw lijst nooit worden herhaald, kunt u eenvoudig:

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.

Als u dubbele elementen heeft en al hun indices moet retourneren:

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]

Antwoord 30

Het gebruikt gewoon de python-functie array.index() en met een simpele Try / Behalve het retourneert de positie van het record als het in de lijst wordt gevonden en retourneert -1 als dat niet het geval is gevonden in de lijst (zoals op JavaScript met de functie indexOf()).

fruits = ['apple', 'banana', 'cherry']
try:
  pos = fruits.index("mango")
except:
  pos = -1

In dit geval “mango” is niet aanwezig in de lijst fruits dus de pos variabele is -1, als ik had gezocht naar "cherry" de variabele pos zou 2 zijn.

De index van een item in een lijst zoeken