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




list (24)

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


Answers

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

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

>>> ["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 पकड़ता है (शायद तेज़, कम से कम जब खोज की सूची लंबी होती है, और आइटम आमतौर पर मौजूद होता है।)

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

यह कई उत्तरों में उल्लिखित है कि 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]

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

[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

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


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

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


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

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

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

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

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

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

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

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

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


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

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

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


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

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

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

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

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

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

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

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

class list(object)
 ...

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

जो आपको उस विधि के लिए ले जाएगा जो आप खोज रहे हैं।


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

एक सूची ["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 ), और वे ज्यादातर पार्सिंग में उपयोग किए जाते हैं (और यूआई के मामले में यूआई निष्क्रिय)।

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


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

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

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

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

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

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

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

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

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

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

# 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

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[-1:] # returns indexed value
    [3]
>>> list[-1]  # returns value
    3

इस तरह के एक लक्ष्य को प्राप्त करने के लिए कई अन्य तरीके हैं लेकिन इनका उपयोग करने के लिए छोटे और मीठे हैं।





python list