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

3891
Eugene M 7 अक्टूबर 2008, 05:39
7
क्या आप लौट रहे हैं: [1] "bar" के कई उदाहरण होने पर सबसे कम सूचकांक, [2] "bar" के सभी सूचकांक?
 – 
Ṃųỻịgǻňạcểơửṩ
12 मई 2018, 23:56
5
ए) क्या यह गारंटी है कि आइटम सूची में है, या फिर हमें त्रुटि मामले को कैसे संभालना चाहिए? (वापसी कोई नहीं/मूल्य त्रुटि बढ़ाएं) बी) क्या सूची प्रविष्टियां अद्वितीय होने की गारंटी है, और क्या हमें किसी मैच की पहली अनुक्रमणिका, या सभी अनुक्रमणिका वापस करनी चाहिए?
 – 
smci
21 मई 2018, 09:20
1
संख्यात्मक एकीकरण के साथ उत्तर देखें, पायथन सूचियों की तुलना में सुन्न सरणियाँ कहीं अधिक कुशल हैं। यदि सूची छोटी है तो इसे पायथन सूची से कॉपी करने में कोई समस्या नहीं है, यदि ऐसा नहीं है तो शायद आपको तत्वों को पहले स्थान पर numpy array में संग्रहीत करने पर विचार करना चाहिए।
 – 
Athanassios
28 जिंदा 2020, 15:21

32 जवाब

सबसे बढ़िया उत्तर
>>> ["foo", "bar", "baz"].index("bar")
1

संदर्भ: डेटा संरचनाएं > सूचियों पर अधिक

चेतावनी का पालन करें

ध्यान दें कि जैसा पूछा गया प्रश्न का उत्तर देने का यह शायद सबसे साफ तरीका है, index list API का एक कमजोर घटक है, और मुझे अंतिम याद नहीं है समय मैंने इसे गुस्से में इस्तेमाल किया। टिप्पणियों में मुझे यह बताया गया है कि क्योंकि यह उत्तर भारी संदर्भित है, इसे और अधिक पूर्ण बनाया जाना चाहिए। list.index के बारे में कुछ चेतावनियां अनुसरण करती हैं। संभवतः इसके लिए दस्तावेज़ीकरण पर एक नज़र डालने लायक है:

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

पहले आइटम की सूची में शून्य-आधारित अनुक्रमणिका लौटाएं जिसका मान x के बराबर है। अगर ऐसा कोई आइटम नहीं है, तो ValueError उठाता है।

वैकल्पिक तर्क प्रारंभ और अंत की व्याख्या स्लाइस नोटेशन और खोज को सूची के किसी विशेष अनुवर्ती तक सीमित करने के लिए उपयोग किया जाता है। लौटाए गए सूचकांक की गणना प्रारंभ तर्क के बजाय पूर्ण अनुक्रम की शुरुआत के सापेक्ष की जाती है।

सूची की लंबाई में रैखिक समय-जटिलता

एक 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 तक पहुंचने पर विचार कर रहे हैं, तो इन उत्कृष्ट पायथन विशेषताओं पर एक नज़र डालें।

यदि तत्व सूची में मौजूद नहीं है तो फेंकता है

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 को पकड़ता है (शायद तेज़, कम से कम जब खोज करने के लिए सूची लंबी हो, और आइटम आमतौर पर मौजूद हो।)
5343
Community 20 जून 2020, 12:12
34
इंडेक्स पहला आइटम देता है जिसका मान "बार" है। यदि "बार" सूची में दो बार मौजूद है, तो आपको दूसरे "बार" की कुंजी कभी नहीं मिलेगी। दस्तावेज़ देखें: docs.python.org/3/tutorial/datastructures.html
 – 
mpoletto
30 जिंदा 2018, 07:51
6
यदि आप केवल एक तत्व (पहला) की खोज कर रहे हैं, तो मैंने पाया कि index() पूर्णांकों की सूचियों की तुलना में सूची बोध की तुलना में 90% से कम तेज़ है।
 – 
slybloty
19 सितंबर 2019, 23:13
यदि सूची बहुत लंबी है तो किस डेटा संरचना का उपयोग किया जाना चाहिए?
 – 
izhang05
22 फरवरी 2020, 23:36
@izhang: कुछ सहायक सूचकांक, जैसे {element -> list_index} dict, यदि तत्व धोने योग्य हैं, और सूची में स्थिति मायने रखती है।
 – 
Alex Coventry
24 फरवरी 2020, 07:30
अनुक्रम 1 = क्रमबद्ध (अनुक्रम 2, कुंजी = अनुक्रम 3. अनुक्रमणिका) एक बहुत ही आसान मुहावरा है। यदि आपके प्रदर्शनों की सूची में है तो आप अधिक बार अनुक्रमणिका का उपयोग कर सकते हैं।
 – 
Dvd Avins
24 फरवरी 2021, 09:42

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

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

class list(object)
 ...

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

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

961
davidavr 7 अक्टूबर 2008, 17:19
7
bpython दस्तावेज़ों को इंटरैक्टिव तरीके से पढ़ने का एक अच्छा उपयोगकर्ता-अनुकूल तरीका है।
 – 
goetzc
22 सितंबर 2019, 21:09
10
हां, लेकिन फिर हममें से बाकी जो मदद दस्तावेज़ों के माध्यम से स्क्रॉल करने के बजाय इसे Google करना चाहते हैं, उनके पास विकल्पों का यह अच्छा, केंद्रीय, रैंक वाला सेट नहीं होगा। :)
 – 
cydonian
7 अप्रैल 2020, 02:42

अधिकांश उत्तर समझाते हैं कि एक एकल अनुक्रमणिका को कैसे खोजा जाए, लेकिन यदि आइटम कई बार सूची में है तो उनके तरीके एकाधिक अनुक्रमणिका नहीं लौटाते हैं। 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
642
Boris 21 जिंदा 2020, 16:04
1
एन्यूमरेशन मेरे लिए इंडेक्स-आधारित विधियों की तुलना में बेहतर काम करता है, क्योंकि मैं 'स्टार्टविथ' का उपयोग करके स्ट्रिंग्स के इंडेक्स को इकट्ठा करना चाहता हूं, और मुझे कई घटनाओं को इकट्ठा करने की आवश्यकता है। या "स्टार्टविथ" के साथ इंडेक्स का उपयोग करने का कोई तरीका है कि मैं पता नहीं चल सका
 – 
Tupelo Thistlehead
26 अक्टूबर 2017, 22:15
5
मेरे हाथों में, एन्यूमरेट संस्करण लगातार थोड़ा तेज है। उपरोक्त माप पोस्ट किए जाने के बाद से कुछ कार्यान्वयन विवरण बदल गए होंगे।
 – 
Alex Coventry
17 नवम्बर 2017, 21:43
4
इसका उत्तर '11 से पहले ही दिया जा चुका है: stackoverflow.com/questions/6294179/…
 – 
Cristik
10 फरवरी 2019, 13:55
1
उत्तर का इतना बचतकर्ता! धन्यवाद !! .. मैंने समझने से पहले नेस्टेड शब्दकोश की अनुक्रमणिका प्राप्त करने के लिए 2 दिनों की कोशिश की, हम गणना का उपयोग कर सकते हैं
 – 
Viv
31 जुलाई 2020, 19:48

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

indexes = [i for i,x in enumerate(xs) if x == 'foo']
205
Arkistarvh Kltzuonstev 30 जुलाई 2019, 14:17
6
इसके लिए पहले से ही एक और प्रश्न है, जिसे '11: stackoverflow.com/questions/6294179/…
 – 
Cristik
10 फरवरी 2019, 13:56

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"])
146
HongboZhu 9 मार्च 2012, 14:38
2
और अगर सूची में मौजूद नहीं है?
 – 
Peter Mortensen
4 जून 2018, 23:16
1
अस्तित्वहीन वस्तु ValueError बढ़ाएगी
 – 
Nam G VU
13 अगस्त 2018, 08:29
1
यह उत्तर यहां बेहतर होगा: stackoverflow.com/questions/6294179/…
 – 
Cristik
10 फरवरी 2019, 13:56

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

# 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
96
tanzil 24 अप्रैल 2017, 13:00
a = ["foo","bar","baz",'bar','any','much']

indexes = [index for index in range(len(a)) if a[index] == 'bar']
95
savinson 31 अक्टूबर 2017, 10:45
2
यह उत्तर यहां बेहतर ढंग से पोस्ट किया जाना चाहिए: stackoverflow.com/questions/6294179/…
 – 
Cristik
10 फरवरी 2019, 13:57

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

if 'your_element' in mylist:
    print mylist.index('your_element')
else:
    print None
65
user3670684 26 मई 2014, 08:26
1
यह हमें ट्राइ कैच से बचने में मदद करता है!
 – 
devssh
10 सितंबर 2018, 10:45
2
हालाँकि, यह जटिलता को दोगुना कर सकता है। क्या किसी ने चेक किया?
 – 
stefanct
6 सितंबर 2019, 18:58
1
समय जटिलता अभी भी रैखिक है लेकिन यह सूची के माध्यम से दो बार पुनरावृत्त होगी।
 – 
ApproachingDarknessFish
28 जिंदा 2020, 23:55
जाहिर तौर पर मेरा यही मतलब था। यहां तक ​​​​कि अगर पैडेंटिक रूप से यह जटिलता का एक ही ऑर्डर है, तो कई बार उपयोग के मामलों में दो बार पुनरावृत्ति करना एक गंभीर नुकसान हो सकता है, इसलिए मैंने इसे लाया। और हम अभी भी जवाब नहीं जानते हैं ...
 – 
stefanct
29 जिंदा 2020, 04:50
यह संभवतः जटिलता को दोगुना करता है, मेरा मानना ​​​​है कि in सूची में ऑपरेटर के पास रैखिक रनटाइम है। @ApproachingDarknessFish ने कहा कि यह दो बार पुनरावृति करेगा जो आपके प्रश्न का उत्तर देता है, और यह कहना सही है कि रैखिक जटिलता को दोगुना करना कोई बड़ी बात नहीं है। मैं कई उपयोग मामलों में दो बार एक गंभीर नुकसान की सूची में पुनरावृत्ति नहीं कहूंगा, क्योंकि जटिलता सिद्धांत हमें बताता है कि ओ (एन) + ओ (एन) -> ओ (2 * एन) -> ओ (एन), यानी- परिवर्तन आमतौर पर नगण्य है।
 – 
Matthew Strasiotto
27 जून 2021, 09:48

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

[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

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

49
Peter Badida 24 पद 2016, 17:24
10
तीसरी विधि सूची में दो बार पुनरावृत्त होती है, है ना?
 – 
Eric Duminil
5 फरवरी 2017, 16:59
पुन: "यहां सभी प्रस्तावित कार्य": लेखन के समय शायद, लेकिन आपको यह देखने के लिए नए उत्तरों की जांच करनी चाहिए कि क्या यह अभी भी सत्य है।
 – 
Peter Mortensen
4 जून 2018, 23:19

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

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

53
Peter Mortensen 4 जून 2018, 23:26
5
स्ट्रिंग्स की सूचियों, गैर-संख्यात्मक वस्तुओं की सूची आदि के बारे में क्या ...?
 – 
Laryx Decidua
12 अक्टूबर 2016, 17:55
2
यह उत्तर यहां बेहतर ढंग से पोस्ट किया जाना चाहिए: stackoverflow.com/questions/6294179/…
 – 
Cristik
10 फरवरी 2019, 13:58
1
यह सबसे अच्छा मैंने पढ़ा है। numpy arrays Python सूचियों की तुलना में कहीं अधिक कुशल हैं। यदि सूची छोटी है तो इसे पायथन सूची से कॉपी करने में कोई समस्या नहीं है, यदि ऐसा नहीं है तो शायद डेवलपर को तत्वों को पहले स्थान पर numpy array में संग्रहीत करने पर विचार करना चाहिए।
 – 
Athanassios
28 जिंदा 2020, 15:23

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

सूची ["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 को पकड़ना वर्बोज़ है - और मैं इससे बचना पसंद करता हूं।

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

यदि आप डेटा मंग रहे हैं, तो आपको शायद पांडा का उपयोग करना चाहिए - जिसमें मेरे द्वारा दिखाए गए शुद्ध पायथन वर्कअराउंड की तुलना में कहीं अधिक सुरुचिपूर्ण उपकरण हैं।

मुझे याद नहीं है कि मुझे स्वयं list.index की आवश्यकता है। हालांकि, मैंने पायथन मानक पुस्तकालय को देखा है, और मुझे इसके लिए कुछ उत्कृष्ट उपयोग दिखाई देते हैं।

GUI और टेक्स्ट पार्सिंग के लिए 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)

इन उपयोगों में जो समानता प्रतीत होती है, वह यह है कि वे विवश आकारों की सूचियों पर काम करते प्रतीत होते हैं (list.index के लिए O(n) लुकअप समय के कारण महत्वपूर्ण), और वे ज्यादातर पार्सिंग (और UI में) में उपयोग किए जाते हैं निष्क्रिय का मामला)।

जबकि इसके लिए उपयोग के मामले हैं, वे काफी असामान्य हैं। यदि आप स्वयं को इस उत्तर की तलाश में पाते हैं, तो अपने आप से पूछें कि क्या आप जो कर रहे हैं वह आपके उपयोग-मामले के लिए भाषा द्वारा प्रदान किए गए टूल का सबसे प्रत्यक्ष उपयोग है।

46
Community 20 जून 2020, 12:12

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')
24
Peter Mortensen 4 जून 2018, 23:50
2
यह उत्तर यहां बेहतर ढंग से पोस्ट किया जाना चाहिए: stackoverflow.com/questions/6294179/…
 – 
Cristik
10 फरवरी 2019, 13:58

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

एन्यूमरेट (एलीस्ट) के साथ आप पहले तत्व (एन) को स्टोर कर सकते हैं जो सूची की अनुक्रमणिका है जब तत्व 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
28
Sociopath 5 नवम्बर 2018, 15:18
2
यह उत्तर यहां बेहतर ढंग से पोस्ट किया जाना चाहिए: stackoverflow.com/questions/6294179/…
 – 
Cristik
10 फरवरी 2019, 13:59

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

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

res = [[x[0] for x in a].index(y) for y in b]
20
kiriloff 29 मई 2013, 11:17

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

>>> 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]
>>> 
18
Mathitis2Software 29 मई 2013, 23:17
2
यह उत्तर यहां बेहतर ढंग से पोस्ट किया जाना चाहिए: stackoverflow.com/questions/6294179/…
 – 
Cristik
10 फरवरी 2019, 13:58

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

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

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 'पायथन सूची समझ' की अत्यधिक अनुशंसा करता हूं और स्वयं को परिचित करने के लिए कुछ मिनट दें। यह कई शक्तिशाली विशेषताओं में से एक है जो कोड विकसित करने के लिए पायथन का उपयोग करने में खुशी देता है।

16
MrWonderful 18 जुलाई 2018, 13:01

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

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

15
bvanlew 28 मार्च 2014, 13:11
1
यह उत्तर यहां बेहतर ढंग से पोस्ट किया जाना चाहिए: stackoverflow.com/questions/6294179/…
 – 
Cristik
10 फरवरी 2019, 13:59

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

def find_element(p,t):
    i = 0
    for e in p:
        if e == t:
            return i
        else:
            i +=1
    return -1
10
totallyhuman 12 नवम्बर 2017, 09:07

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

idx = L.index(x) if (x in L) else -1
12
Ketan 30 जिंदा 2019, 20:36
5
यह सरणी को दो बार पुनरावृत्त करता है, इस प्रकार यह बड़े सरणियों के लिए प्रदर्शन समस्याओं का परिणाम हो सकता है।
 – 
Cristik
10 फरवरी 2019, 14:00

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

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

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

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

4
Peter Mortensen 4 जून 2018, 23:56
4
[i for i, j in enumerate(haystack) if j=='needle'] अधिक कॉम्पैक्ट और पठनीय है, मुझे लगता है।
 – 
PythonProgrammi
27 पद 2017, 10:23
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

6
Sociopath 13 फरवरी 2020, 16:06

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

try:
    index = array.index('search_keyword')
except ValueError:
    index = -1
6
Arkistarvh Kltzuonstev 30 जुलाई 2019, 14:19
7
हालांकि, जावास्क्रिप्ट का दर्शन है कि अजीब परिणाम त्रुटियों से बेहतर होते हैं, इसलिए यह -1 वापस करने के लिए समझ में आता है, लेकिन पायथन में, यह बग को ट्रैक करना कठिन बना सकता है, क्योंकि -1 एक आइटम देता है सूची के अंत से।
 – 
Sapphire_Brick
30 अक्टूबर 2019, 01:44

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

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))))))
4
Peter Mortensen 4 जून 2018, 23:53
1
यह उत्तर Scala / कार्यात्मक-प्रोग्रामिंग उत्साही लोगों के लिए घर जैसा लगता है
 – 
y2k-shubham
21 अगस्त 2018, 08:13
जब किसी सूची में केवल एक मान की आवश्यकता होती है जिसमें कई मिलान होते हैं तो इसमें लंबा समय लगता है।
 – 
Caveman
22 जून 2020, 19:12

आपके पास जो सूची है, उसे 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
Siddharth Satpathy 28 नवम्बर 2018, 09:42
काम नहीं करता है अगर आइटम एक वर्ग का उदाहरण है
 – 
Caveman
22 जून 2020, 19:11

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

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

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

2
Peter Mortensen 4 जून 2018, 23:55

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

कई उत्तरों में यह उल्लेख किया गया है कि 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]
1
FatihAkici 10 सितंबर 2018, 21:51

जैसा कि @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]

more_itertools.locate के साथ और विकल्प भी देखें . > pip install more_itertools के ज़रिए इंस्टॉल करें।

0
pylang 25 सितंबर 2018, 18:47

ValueError को रोकने के लिए, आप इसे करने के लिए एक फ़ंक्शन बना सकते हैं, हालांकि एक वर्ग भी काम करेगा।

def findInList(List, item):
   try:
      return List.index(item)
   except ValueError:
      return -1

एकमात्र समस्या यह है कि इससे बग को ट्रैक करना मुश्किल हो सकता है; वही अन्य नंबरों पर लागू होगा।
हालांकि, अगर यह किसी संख्या के अलावा कुछ भी लौटाता है, तो संभवतः इसका उपयोग सूची अनुक्रमणिका के रूप में किया जाएगा, और किसी भी तरह से अनिवार्य रूप से एक त्रुटि होगी।

मेरी राय में, यह मानते हुए कि आइटम नहीं मिलने पर कुछ गलत हो गया है, try-except का उपयोग करना बेहतर है, लेकिन एक कस्टम त्रुटि संदेश के साथ, और इस प्रकार यह डिबगिंग को कठिन नहीं बनाएगा, न ही वापसी मूल्य मायने रखेगा:

# python 3.x

class itemNotFoundInListError(Exception): 
    pass

def findInList(List, item):
   try:
      return List.index(item)
   except ValueError:
      raise itemNotFoundInListError(f"List `{List}` does not contain `{item}.`")
1
Sapphire_Brick 30 अक्टूबर 2019, 01:27

शब्दकोश का उपयोग करते हुए, जहां पहले सूची को संसाधित करें और फिर उसमें अनुक्रमणिका जोड़ें

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
sahasrara62 18 मार्च 2019, 12:32

एक मौका है कि वह मान मौजूद नहीं हो सकता है इसलिए इस ValueError से बचने के लिए, हम जांच सकते हैं कि क्या वह वास्तव में सूची में मौजूद है।

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") 
6
Badri Paudel 28 अगस्त 2020, 12:35

एक तुलनीय के लिए

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

कस्टम विधेय

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_of_staff_members = [
    i for i, user in enumerate(users)
    if user.is_staff()]
4
Caveman 10 पद 2020, 14:48
idx = next((i for i, v in enumerate(ls) if v == chk), -1) str.index(chk) के समान व्यवहार प्राप्त करने के लिए।
 – 
tejasvi88
10 पद 2020, 13:42
जवाब में कुछ अतिरिक्त काम करने का फैसला किया
 – 
Caveman
10 पद 2020, 14:45

यह सिर्फ पायथन फ़ंक्शन array.index() का उपयोग करता है और एक साधारण कोशिश के साथ / यह सूची में पाए जाने पर रिकॉर्ड की स्थिति देता है और यदि यह सूची में नहीं मिलता है तो वापसी -1 (जैसे जावास्क्रिप्ट के साथ फ़ंक्शन indexOf())।

fruits = ['apple', 'banana', 'cherry']

try:
  pos = fruits.index("mango")
except:
  pos = -1

इस मामले में "आम" सूची में मौजूद नहीं है fruits इसलिए pos चर -1 है, अगर मैंने "चेरी" की खोज की थी तो pos चर 2 होगा।

4
Giacomo Casadei 10 अप्रैल 2021, 22:26