एक चीज जो वास्तव में पायथन सीखने में मददगार है, वह है इंटरएक्टिव हेल्प फंक्शन का उपयोग करना:

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

class list(object)
 ...

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

जो अक्सर आपको उस विधि तक ले जाएगा जिसकी आप तलाश कर रहे हैं।

अधिकांश उत्तर समझाते हैं कि एक एकल अनुक्रमणिका को कैसे खोजा जाए, लेकिन यदि आइटम कई बार सूची में है तो उनके तरीके एकाधिक अनुक्रमणिका नहीं लौटाते हैं। 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

सभी अनुक्रमणिका प्राप्त करने के लिए:

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

index() मान की पहली अनुक्रमणिका लौटाता है!

| अनुक्रमणिका(...)
| L.index(मान, [शुरू, [रोकें]]) -> पूर्णांक -- मान का पहला सूचकांक लौटाएं

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

यदि तत्व सूची में नहीं है तो समस्या उत्पन्न होगी। यह फ़ंक्शन समस्या को संभालता है:

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

आपको यह जांचने के लिए एक शर्त सेट करनी होगी कि आप जो तत्व खोज रहे हैं वह सूची में है या नहीं

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

यहां प्रस्तावित सभी कार्य अंतर्निहित भाषा व्यवहार को पुन: उत्पन्न करते हैं लेकिन अस्पष्ट है कि क्या हो रहा है।

[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

अपवाद हैंडलिंग के साथ एक फ़ंक्शन क्यों लिखें यदि भाषा आपको वह करने के तरीके प्रदान करती है जो आप स्वयं चाहते हैं?

यदि आप सभी अनुक्रमणिका चाहते हैं, तो आप 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),)

यह स्पष्ट, पठनीय समाधान है।

किसी आइटम की अनुक्रमणिका ढूँढना एक सूची दी गई है जिसमें इसे पायथन में शामिल किया गया है

सूची ["foo", "bar", "baz"] और सूची में एक आइटम "bar" के लिए, पायथन में इसकी अनुक्रमणिका (1) प्राप्त करने का सबसे साफ तरीका क्या है?

ठीक है, निश्चित रूप से, वहाँ सूचकांक विधि है, जो पहली घटना का सूचकांक लौटाती है:

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

पंडों के साथ बेहतर डेटा मंग

यदि आपके पास पांडा हैं, तो आप श्रृंखला वस्तु के साथ यह जानकारी आसानी से प्राप्त कर सकते हैं:

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

यदि आप केवल अनुक्रमणिका चाहते हैं, तो अनुक्रमणिका विशेषता पूर्णांकों की एक श्रृंखला लौटाती है:

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

और यदि आप उन्हें किसी सूची या टपल में चाहते हैं, तो बस उन्हें कंस्ट्रक्टर के पास भेज दें:

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

हां, आप एन्यूमरेट के साथ एक सूची समझ का भी उपयोग कर सकते हैं, लेकिन यह मेरी राय में उतना ही सुरुचिपूर्ण नहीं है - आप सी में लिखे गए बिल्टिन कोड को संभालने के बजाय पायथन में समानता के लिए परीक्षण कर रहे हैं:

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

क्या यह एक XY समस्या है?

XY समस्या आपकी वास्तविक समस्या के बजाय आपके प्रयास किए गए समाधान के बारे में पूछ रही है।

आपको क्या लगता है कि आपको सूची में एक तत्व दिए गए सूचकांक की आवश्यकता क्यों है?

यदि आप पहले से ही मूल्य जानते हैं, तो आप इसकी परवाह क्यों करते हैं कि यह सूची में कहां है?

यदि मान नहीं है, तो ValueError को पकड़ना वर्बोज़ है - और मैं इससे बचना पसंद करता हूं।

मैं आमतौर पर वैसे भी सूची में पुनरावृति कर रहा हूं, इसलिए मैं आमतौर पर किसी भी दिलचस्प जानकारी के लिए एक सूचक रखूंगा, एन्यूमरेट के साथ अनुक्रमणिका प्राप्त कर रहा हूं।< /ए>

key_list[key_list.index(old)] = new

del key_list[key_list.index(key)]

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

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

numtopop = before.index(markobject)

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

एक सूची में सभी घटनाओं और एक या अधिक (समान) वस्तुओं की स्थिति प्राप्त करना

एन्यूमरेट (एलीस्ट) के साथ आप पहले तत्व (एन) को स्टोर कर सकते हैं जो सूची की अनुक्रमणिका है जब तत्व x आपके द्वारा खोजे जाने के बराबर होता है।

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

आइए अपने फंक्शन को फाइंडइंडेक्स बनाते हैं

यह फ़ंक्शन आइटम और सूची को तर्क के रूप में लेता है और सूची में आइटम की स्थिति लौटाता है, जैसा कि हमने पहले देखा था।

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

बस आप साथ जा सकते हैं

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

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

एक अन्य विकल्प

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

और अब पूरी तरह से अलग कुछ करने के लिए...

... जैसे सूचकांक प्राप्त करने से पहले वस्तु के अस्तित्व की पुष्टि करना। इस दृष्टिकोण के बारे में अच्छी बात यह है कि फ़ंक्शन हमेशा सूचकांकों की एक सूची देता है - भले ही यह एक खाली सूची हो। यह स्ट्रिंग्स के साथ भी काम करता है।

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

अद्यतन

हेड-डाउन पायथन विकास के एक और वर्ष के बाद, मैं अपने मूल उत्तर से थोड़ा शर्मिंदा हूं, इसलिए रिकॉर्ड को सीधे सेट करने के लिए, कोई निश्चित रूप से उपरोक्त कोड का उपयोग कर सकता है; हालांकि, समान व्यवहार प्राप्त करने के लिए अधिक अधिक मुहावरेदार तरीका सूची समझ का उपयोग करना होगा, साथ में गणना () फ़ंक्शन।

कुछ इस तरह:

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 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 ने अपने पहले का जवाब. जिस समय मैंने मूल रूप से इस प्रश्न का उत्तर दिया था, उस समय मैंने उस उत्तर को देख भी नहीं देखा था, क्योंकि मैं इसे समझ नहीं पाया था। मुझे आशा है कि मेरा कुछ और वर्बोज़ उदाहरण समझने में सहायता करेगा।

यदि उपरोक्त कोड की एक पंक्ति अभी भी आपको नहीं समझ में आती है, तो मैं आपको Google 'पायथन सूची समझ' की अत्यधिक अनुशंसा करता हूं और स्वयं को परिचित करने के लिए कुछ मिनट दें। यह कई शक्तिशाली विशेषताओं में से एक है जो कोड विकसित करने के लिए पायथन का उपयोग करने में खुशी देता है।

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

एकल प्रविष्टि के लिए सभी सूचकांक प्राप्त करने के लिए आप इसे एक लाइनर के रूप में भी उपयोग कर सकते हैं। दक्षता के लिए कोई गारंटी नहीं है, हालांकि मैंने लैम्ब्डा को कॉल करने की संख्या को कम करने के लिए सेट (ए) का उपयोग किया था।

यह समाधान दूसरों की तरह शक्तिशाली नहीं है, लेकिन यदि आप एक नौसिखिया हैं और केवल for लूप के बारे में जानते हैं तो ValueError से बचते हुए किसी आइटम की पहली अनुक्रमणिका ढूंढना अभी भी संभव है:

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

सूची एल में आइटम एक्स की अनुक्रमणिका ढूँढना:

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

चूंकि पायथन सूचियां शून्य-आधारित हैं, इसलिए हम ज़िप बिल्ट-इन फ़ंक्शन का उपयोग निम्नानुसार कर सकते हैं:

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

जहां "घास का ढेर" प्रश्न में सूची है और "सुई" देखने के लिए वस्तु है।

(नोट: यहां हम अनुक्रमणिका प्राप्त करने के लिए i का उपयोग करके पुनरावृति कर रहे हैं, लेकिन अगर हमें उन वस्तुओं पर ध्यान केंद्रित करने की आवश्यकता है जिन्हें हम j पर स्विच कर सकते हैं।)

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

यदि आइटम नहीं मिला तो पायथन index() विधि एक त्रुटि फेंकता है। तो इसके बजाय आप इसे जावास्क्रिप्ट के indexOf() फ़ंक्शन के समान बना सकते हैं जो आइटम नहीं मिलने पर -1 लौटाता है:

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

इसका एक अधिक कार्यात्मक उत्तर है।

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

आपके पास जो सूची है, उसे 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

मेरे जैसी दूसरी भाषा से आने वालों के लिए, शायद एक साधारण लूप के साथ इसे समझना और इसका उपयोग करना आसान है:

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

मैं के लिए आभारी हूं, तो एन्यूमरेट वास्तव में क्या करता है? . इससे मुझे समझने में मदद मिली।

यदि प्रदर्शन चिंता का विषय है:

कई उत्तरों में यह उल्लेख किया गया है कि list.index(item) विधि की अंतर्निहित विधि एक O(n) एल्गोरिथम है। यह ठीक है अगर आपको इसे एक बार करने की ज़रूरत है। लेकिन अगर आपको तत्वों के सूचकांकों को कई बार एक्सेस करने की आवश्यकता है, तो पहले आइटम-इंडेक्स जोड़े का एक शब्दकोश (ओ (एन)) बनाने के लिए और अधिक समझ में आता है, और फिर इंडेक्स को ओ (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]

जैसा कि @TerryA द्वारा इंगित किया गया है, कई उत्तर चर्चा करते हैं कि एक अनुक्रमणिका कैसे खोजें।

more_itertools एकाधिक< का पता लगाने के लिए टूल के साथ एक तृतीय-पक्ष लाइब्रेरी है /em> एक पुनरावर्तनीय के भीतर सूचकांक।

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]