python किसी आइटम की अनुक्रमणिका को पाइथन में एक सूची दी गई है




list (19)

किसी आइटम की अनुक्रमणिका को पाइथन में एक सूची दी गई है

एक सूची ["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 is तो आपके पास शायद एक जांच होगी:

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

सूची में एक से अधिक मूल्य

यदि आपके पास अधिक घटनाएं हो सकती हैं, तो आपको list.index साथ पूरी जानकारी नहीं 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]

क्या यह एक एक्सवाई समस्या है ?

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

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

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

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

मैं आमतौर पर सूची में फिर से चल रहा हूं, इसलिए मैं आमतौर पर किसी भी रोचक जानकारी के लिए पॉइंटर रखूंगा, सूचकांक को अंक के साथ प्राप्त कर रहा हूं ।

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

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

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

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

लिब / मेलबॉक्स.py में ऐसा लगता है कि यह एक आदेशित मैपिंग की तरह उपयोग कर रहा है:

key_list[key_list.index(old)] = new

तथा

del key_list[key_list.index(key)]

लिब / http / cookiejar.py में, अगले महीने प्राप्त करने के लिए उपयोग किया जाता है:

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

किसी आइटम पर एक टुकड़ा पाने के लिए distutils के समान Lib / tarfile.py में:

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

लिब / pickletools.py में:

numtopop = before.index(markobject)

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

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

https://code.i-harness.com

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


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

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

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


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

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

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

चलिए अपने फ़ंक्शन findindex बनाते हैं

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

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

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

इसके लिए एक और अधिक कार्यात्मक जवाब है।

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

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

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

एफएमसी और उपयोगकर्ता 7177 के उत्तर पर एक संस्करण एक ऐसा निर्देश देगा जो किसी भी प्रविष्टि के लिए सभी सूचकांक वापस कर सकता है:

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

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


चलो नाम सूची में आपके पास नाम दें। कोई सूची सूची को एक numpy array परिवर्तित कर सकते हैं। और, सूची में चुने गए आइटम की अनुक्रमणिका प्राप्त करने के लिए numpy.where का उपयोग करें। निम्नलिखित तरीका है जिसमें आप इसे लागू करेंगे।

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

जैसा कि @ टेरीए द्वारा इंगित किया गया है, कई उत्तरों पर चर्चा होती है कि एक सूचकांक कैसे ढूंढें।

more_itertools एक तीसरे पक्ष की लाइब्रेरी है जिसमें कई सूचकांक को 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 साथ और भी विकल्प देखें। more_itertools माध्यम से स्थापित करें।


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

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

यदि इसका दोहराया गया मतलब है तो यह आपको केवल पहली अनुक्रमणिका देगा

यदि आपको सभी इंडेक्स प्राप्त करने की आवश्यकता है जहां आइटम मौजूद है

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

यह पाने के लिए कि आपको ऐसा करने की ज़रूरत है

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

तो आपको इंडेक्स की सूची ओ / पी की तरह मिल जाएगी [1,3]


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

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

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

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

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

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


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

# 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

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

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

सभी इंडेक्स प्राप्त करने के लिए:

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

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

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

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

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

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

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

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

>>> print(list.index.__doc__)
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.

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

एक index कॉल index हर तत्व को क्रम में जांचता है, जब तक कि यह एक मैच न मिल जाए। यदि आपकी सूची लंबी है, और आप यह नहीं जानते कि सूची में कहां होता है, तो यह खोज एक बाधा बन सकती है। उस स्थिति में, आपको एक अलग डेटा संरचना पर विचार करना चाहिए। ध्यान दें कि यदि आप मोटे तौर पर मैच को कहां पाते हैं, तो आप index को संकेत दे सकते हैं। उदाहरण के लिए, इस स्निपेट में, l.index(999_999, 999_990, 1_000_000) सीधे l.index(999_999) तुलना में तीव्रता के लगभग पांच ऑर्डर हैं, क्योंकि पूर्व को केवल 10 प्रविष्टियां l.index(999_999) , जबकि बाद में दस लाख खोजें:

>>> 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 को 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 (साफ, पठनीय दृष्टिकोण) item in my_list साथ पहले इसकी जांच करें, या
  2. index कॉल को try/except ब्लॉक try/except जो ValueError पकड़ता है (शायद तेज़, कम से कम जब खोज की सूची लंबी होती है, और आइटम आमतौर पर मौजूद होता है।)

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)

यह तब खाता है जब स्ट्रिंग सूची में नहीं है, अगर यह सूची में नहीं है तो स्थान = -1







list