किसी सूची में किसी आइटम का सूचकांक खोजना

3175

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

python  list  indexing 
— यूजीन एम
स्रोत
6
क्या आप वापस आ रहे हैं: [१] सबसे कम सूचकांक के कई उदाहरण हैं "bar", [२] सभी सूचकांकों के "bar"?
— 20g:56cểơửṩ
4
क) क्या यह गारंटी है कि आइटम सूची में है, या फिर हमें त्रुटि मामले को कैसे संभालना चाहिए? (वापसी कोई नहीं / ValueError बढ़ाएँ) b) क्या सूची प्रविष्टियाँ अद्वितीय होने की गारंटी हैं, और क्या हमें किसी मैच के पहले इंडेक्स, या सभी इंडेक्स को वापस करना चाहिए?
— एसएमसीआई
संख्यात्मक एकीकरण के साथ उत्तर देखें, अजगर सरणियों की तुलना में सुन्न सरणियां कहीं अधिक कुशल हैं। यदि सूची कम है, तो इसे पायथन सूची से कॉपी करने में कोई समस्या नहीं है, अगर ऐसा नहीं है, तो शायद आपको पहले स्थान पर तत्वों को संख्यात्मक सरणी में संग्रहीत करने पर विचार करना चाहिए।
— अथानासियोस

जवाबों:

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

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

कैविट्स फॉलो करते हैं

ध्यान दें कि जब यह पूछे गए सवाल का जवाब देने का सबसे साफ तरीका है , तो indexयह listएपीआई का एक कमज़ोर घटक है , और मुझे याद नहीं है कि पिछली बार मैंने इसे किस गुस्से में इस्तेमाल किया था। यह मेरे लिए टिप्पणियों में इंगित किया गया है क्योंकि यह उत्तर भारी संदर्भित है, इसे और अधिक पूर्ण बनाया जाना चाहिए। कुछ के बारे में 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(शायद तेज, कम से कम जब खोज करने के लिए सूची लंबी है, और आइटम आमतौर पर मौजूद है।)
— एलेक्स कोवेंट्री
स्रोत
20
सूचकांक पहला आइटम देता है जिसका मूल्य "बार" है। यदि "बार" सूची में दो बार मौजूद है, तो आपको दूसरे "बार" की कुंजी कभी नहीं मिलेगी। दस्तावेज़ीकरण देखें: docs.python.org/3/tutorial/datastructures.html
— mpoletto
2
यदि आप केवल एक तत्व (पहले) की खोज कर रहे हैं, तो मैंने पाया कि index()पूर्णांकों की सूचियों के मुकाबले सूची समझ से 90% तेज है।
— slybloty
यदि सूची बहुत लंबी है तो किस डेटा संरचना का उपयोग किया जाना चाहिए?
— izhang05
@izhang: कुछ सहायक सूचकांक, जैसे {तत्व -> list_index} तानाशाही, अगर तत्व हैज़ेबल हैं, और सूची में स्थिति मायने रखती है।
— एलेक्स कॉवेंट्री
898

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

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

class list(object)
 ...

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

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

— davidavr
स्रोत
2
बोचथॉन एक अच्छा उपयोगकर्ता-अनुकूल तरीका है जो डॉक्स को इंटरेक्टिव अंदाज में पढ़ता है।
— गोएट्ज़क
@davidavr हां, लेकिन फिर हम में से बाकी लोग जो सिर्फ डॉक्स की मदद से स्क्रॉल करने के बजाय इसे गूगल करना चाहते हैं, के पास यह अच्छा, केंद्रीय, विकल्पों का सेट नहीं होगा। :)
— होन्कोबॉय
555

अधिकांश उत्तर बताते हैं कि किसी एकल सूचकांक को कैसे खोजना है , लेकिन यदि आइटम कई बार सूची में होता है, तो उनके तरीके कई अनुक्रमित वापस नहीं करते हैं। उपयोग करें 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
— terrya
स्रोत
एन्यूमरेशन मेरे लिए इंडेक्स-आधारित विधियों की तुलना में बेहतर काम करता है, क्योंकि मैं 'स्टार्टस्विथ' का उपयोग करके स्ट्रिंग्स के सूचकांकों को इकट्ठा करना चाहता हूं, और मुझे कई घटनाओं को इकट्ठा करने की आवश्यकता है। या "इंड्सविथ" के साथ इंडेक्स का उपयोग करने का एक तरीका है कि मैं समझ में नहीं आ रहा है
— Tupelo Thistlehead
3
मेरे हाथों में, एनुमरेट संस्करण लगातार थोड़ा तेज है। हो सकता है कि ऊपर दिए गए माप के बाद से कुछ कार्यान्वयन विवरण बदल गए हों।
— एलेक्स कॉवेंट्री
2
यह पहले से ही '11: stackoverflow.com/questions/6294179/… 'के
— Cristik
132

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"])
— HongboZhu
स्रोत
2
और अगर सूची में मौजूद नहीं है?
— पीटर मोर्टेंसन
1
नहीं-मौजूद आइटम ValueError बढ़ाएगा
— Nam G VU
1
यह उत्तर यहां बेहतर होगा: stackoverflow.com/questions/6294179/…
— Cristik
86

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

# 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
— में tanzil
स्रोत
58

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

if 'your_element' in mylist:
    print mylist.index('your_element')
else:
    print None
— user3670684
स्रोत
1
यह हमें पकड़ने की कोशिश से बचने में मदद करता है!
— devssh
हालाँकि, यह जटिलता को दोगुना कर सकता है। क्या किसी ने जांच की?
— 15
@stefanct समय जटिलता अभी भी रैखिक है, लेकिन यह सूची के माध्यम से दो बार पुनरावृति करेगा।
— ApproachingDarknessFish
@ApproachingDarknessFish जाहिर है कि मेरा क्या मतलब था। भले ही पांडित्यिक रूप से यह जटिलता का एक ही क्रम है, दो बार पुनरावृति कई उपयोग मामलों में एक गंभीर नुकसान हो सकता है इस प्रकार मैंने इसे लाया। और हम अभी भी जवाब नहीं जानते ...
— stefanct
44

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

[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

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

— ग्राहम गिलर
स्रोत
9
तीसरी विधि सूची से दो बार पुनरावृत्त होती है, है ना?
— एरिक डुमिनील
पुन: "यहां सभी प्रस्तावित कार्य" : लेखन के समय शायद, लेकिन आपको यह देखने के लिए नए उत्तरों की जांच करनी चाहिए कि क्या यह अभी भी सच है।
— पीटर मोर्टेंसन
41

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

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

— rbrisuda
स्रोत
4
तार की सूची, गैर-संख्यात्मक वस्तुओं की सूची आदि के बारे में क्या ...?
— लैरीक्स डेसीडुआ
1
इस उत्तर को यहां बेहतर तरीके से पोस्ट किया जाना चाहिए: stackoverflow.com/questions/6294179/…
— क्रिस्चियन
1
यह सबसे अच्छा है जो मैंने पढ़ा है। सुन्न सरणियाँ पायथन सूचियों की तुलना में कहीं अधिक कुशल हैं। यदि सूची कम है, तो इसे पायथन सूची से कॉपी बनाने में कोई समस्या नहीं है, यदि ऐसा नहीं है, तो शायद डेवलपर को पहले स्थान पर तत्वों को संख्यात्मक सरणी में संग्रहीत करने पर विचार करना चाहिए।
— अथानासियोस
35

एक आइटम के सूचकांक को खोजने के लिए पायथन में एक सूची दी गई है

सूची में एक सूची ["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]

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

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

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

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

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

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

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

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

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

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

idlelibGUI और टेक्स्ट पार्सिंग के लिए इसमें कई, कई उपयोग हैं ।

keywordमॉड्यूल का उपयोग करता है तो यह स्वचालित रूप metaprogramming के माध्यम से इसे में कीवर्ड की सूची को पुनर्जीवित करने के मॉड्यूल में टिप्पणी मार्कर खोजने के लिए।

Lib / मेलबॉक्स थिंकपैड में यह एक आदेशित मानचित्रण की तरह उपयोग किया जा रहा है:

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 में:

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

Lib / पिकलेटूलसपी में:

numtopop = before.index(markobject)

इन उपयोगों के बारे में ऐसा प्रतीत होता है कि वे विवश आकारों की सूची में काम कर रहे हैं (क्योंकि ओ के लिए महत्वपूर्ण है) list.index कर रहे हैं, और वे अधिकतर पार्सिंग (और Idle के मामले में UI) में उपयोग किए जाते हैं।

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

— हारून हॉल
स्रोत
22

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')
— अर्नाल्डो पी। फिगुएरा फिग्यूइरा
स्रोत
1
इस उत्तर को यहां बेहतर तरीके से पोस्ट किया जाना चाहिए: stackoverflow.com/questions/6294179/…
— क्रिस्चियन
21

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

गणनाकर्ता (एलिस्ट) के साथ आप पहले तत्व (n) को स्टोर कर सकते हैं जो सूची का सूचकांक है जब तत्व 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
— जियोवन्नी जी। पी। वाई
स्रोत
1
: इस सवाल का जवाब बेहतर यहां पोस्ट किया जाना चाहिए stackoverflow.com/questions/6294179/...
— Cristik
16

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

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

res = [[x[0] for x in a].index(y) for y in b]
— kiriloff
स्रोत
16

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

>>> 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]
>>>
— Mathitis2Software
स्रोत
1
इस उत्तर को यहां बेहतर तरीके से पोस्ट किया जाना चाहिए: stackoverflow.com/questions/6294179/…
— क्रिस्चियन
15

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

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

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

और अब, इस सवाल और सभी उत्तरों की समीक्षा करने के बाद, मुझे एहसास हुआ कि एफएमसी ने अपने पहले के उत्तर में यही सुझाव दिया था । बार मैं मूल रूप से इस सवाल का जवाब में, मैं भी नहीं था देखना उत्तर दिया उस उत्तर को , क्योंकि मैं इसे समझ नहीं पाया था। मुझे उम्मीद है कि मेरे कुछ और क्रियात्मक उदाहरण समझने में सहायता करेंगे।

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

— MrWonderful
स्रोत
12

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

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

— bvanlew
स्रोत
1
: इस सवाल का जवाब बेहतर यहां पोस्ट किया जाना चाहिए stackoverflow.com/questions/6294179/...
— Cristik
10

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

def find_element(p,t):
    i = 0
    for e in p:
        if e == t:
            return i
        else:
            i +=1
    return -1
— dylankb
स्रोत
9

सूची L में आइटम x का सूचकांक खोजना:

idx = L.index(x) if (x in L) else -1
— केतन
स्रोत
4
यह सरणी को दो बार पुनरावृत्त करता है, इस प्रकार यह बड़े सरणियों के लिए प्रदर्शन के मुद्दों का परिणाम हो सकता है।
— क्रिस्टी
इस बात से सहमत। यदि सूचियां काफी लंबी हैं, तो मैं कुछ और करने जाऊंगा। हालांकि छोटे से मध्यम आकार की सूचियों के लिए एक बड़ी बात नहीं होनी चाहिए।
— केतन
5

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

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

जहाँ "हैस्टैक" प्रश्न में सूची है और "सुई" देखने के लिए आइटम है।

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

— जिहाद गैसमी
स्रोत
3
[i for i, j in enumerate (haystack) अगर j == 'सुई'] अधिक कॉम्पैक्ट और पठनीय है, तो मुझे लगता है।
— गियोवन्नी जी। PY
5 
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

— Coder123
स्रोत
4

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

try:
    index = array.index('search_keyword')
except ValueError:
    index = -1
— बामौर नाम दिया
स्रोत
5
हालाँकि, जावास्क्रिप्ट में दर्शन है कि अजीब परिणाम त्रुटियों से बेहतर हैं, इसलिए यह -1 को वापस करने के लिए समझ में आता है, लेकिन पायथन में, यह बग को ट्रैक करने के लिए एक कठिन बना सकता है, क्योंकि -1 सूची के अंत से एक आइटम लौटाता है।
— Sapphire_Brick
3

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

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))))))
— अंकित गुप्ता
स्रोत
1
यह उत्तर Scala/ कार्यात्मक-प्रोग्रामिंग के प्रति उत्साही लोगों के लिए घर पर महसूस होता है
— y2k-shubham
3

आइए 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

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

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

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

— mpoletto
स्रोत
2

यदि आप एक बार एक इंडेक्स खोजने जा रहे हैं तो "इंडेक्स" विधि का उपयोग करना ठीक है। हालाँकि, यदि आप अपने डेटा को एक से अधिक बार सर्च करने जा रहे हैं, तो मैं बाइसेक्ट मॉड्यूल का उपयोग करने की सलाह देता हूं । ध्यान रखें कि बाइसेक्ट मॉड्यूल डेटा का उपयोग करना चाहिए। तो आप एक बार डेटा सॉर्ट करें और फिर आप बाइसेक्ट का उपयोग कर सकते हैं। बाइसेक्ट का उपयोग करनामेरी मशीन पर मॉड्यूल इंडेक्स विधि का उपयोग करने से लगभग 20 गुना तेज है।

यहाँ पायथन 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
— व्लाद बेजेन
स्रोत
1

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

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

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

— pylang
स्रोत
0

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

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]
— sahasrara62
स्रोत
-1

मेरी राय में ["foo", "bar", "baz"].index("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

और अगर नाम गिरफ्तारी पर नहीं था, तो फंक्शन वापसी -1। उदाहरण के लिए:

प्रिंट (find_index (["foo", "bar", "baz"], "fooo")

-1

— NaabNuts
स्रोत
1
इसका उपयोग न करें क्योंकि l = [1, 2]; find_index(l, 3)वापस आ जाएगा -1और l[find_index(l, 3)]वापस आ जाएगा 2। -1 वापसी करने के लिए एक बुरी बात है, बस कोई नहीं लौटा।
— डैनियल स्ट्रैकोबोको
-1 एक ऐसा अनुबंध है जिसे आप कभी भी वापस कर सकते हैं, लेकिन अपने कार्यक्रमों में कोई भी उपयोग करने की कोशिश न करें क्योंकि आपके प्रोग्राम में कोई भी या कोई भी अन्य प्रोग्राम जैसे कि एंड्रॉइड और पीएचपी वेबसाइटों के साथ संचार नहीं करता है, उदाहरण के लिए प्रोग्राम ब्रेक का कारण हो सकता है कि आप JSON में वापस लौट सकते हैं और आपका वेबसाइट फोन एप्लिकेशन बंद हो जाएगा या त्रुटि 500 ​​(आंतरिक सर्वर त्रुटि) वापस कर देगा।
— नबंट्स
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.