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




list (24)

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

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

एक सूची ["foo", "bar", "baz"] और सूची "bar" में एक आइटम के लिए, मैं पाइथन में अपनी अनुक्रमणिका (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 माध्यम से स्थापित करें।


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

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

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


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

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

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

# 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

पाइथन index() विधि एक त्रुटि फेंकता है अगर आइटम नहीं मिला, जो बेकार है!

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

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

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

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

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

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

एफएमसी और उपयोगकर्ता 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]}
>>> 

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


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

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

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

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


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

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

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

[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

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


a = ["foo","bar","baz",'bar','any','much']

indexes = [index for index in range(len(a)) if a[index] == 'bar']

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

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

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


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

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

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


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

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

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

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

चलो नाम सूची में आपके पास नाम दें। कोई सूची सूची को एक 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 

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

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

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

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


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

 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]


यह सबसे प्रभावी तरीका नहीं हो सकता है लेकिन मैंने एक लाइनर (वास्तव में एक दो-लाइनर) डालने का विचार किया। दोनों संस्करण मनमाने ढंग से पदानुक्रम नेस्टेड सूचियों पर काम करेंगे, और भाषा सुविधाओं (पायथन 3.5) और रिकर्सन का शोषण करेंगे।

def make_list_flat (l):
    flist = []
    flist.extend ([l]) if (type (l) is not list) else [flist.extend (make_list_flat (e)) for e in l]
    return flist

a = [[1, 2], [[[[3, 4, 5], 6]]], 7, [8, [9, [10, 11], 12, [13, 14, [15, [[16, 17], 18]]]]]]
flist = make_list_flat(a)
print (flist)

आउटपुट है

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]

यह पहली बार गहराई में काम करता है। रिकर्सन तब तक नीचे चला जाता है जब तक कि यह एक गैर-सूची तत्व नहीं पाता है, फिर स्थानीय चर को बढ़ाता है flistऔर उसके बाद इसे माता-पिता को वापस ले जाता है। जब भी flistवापस आ जाता है, तो यह माता-पिता की flistसूची समझ में बढ़ाया जाता है । इसलिए, जड़ पर, एक फ्लैट सूची लौटा दी जाती है।

उपरोक्त एक कई स्थानीय सूचियां बनाता है और उन्हें वापस देता है जिनका उपयोग माता-पिता की सूची को बढ़ाने के लिए किया जाता है। मुझे लगता है कि इसके लिए रास्ता flistनीचे की तरह एक ग्लोबल बना सकता है ।

a = [[1, 2], [[[[3, 4, 5], 6]]], 7, [8, [9, [10, 11], 12, [13, 14, [15, [[16, 17], 18]]]]]]
flist = []
def make_list_flat (l):
    flist.extend ([l]) if (type (l) is not list) else [make_list_flat (e) for e in l]

make_list_flat(a)
print (flist)

आउटपुट फिर से है

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]

हालांकि मैं इस समय दक्षता के बारे में निश्चित नहीं हूं।





python list