python 'फॉर' लूप में इंडेक्स तक पहुंचना?





10 Answers

फॉर लूप का उपयोग करके, मैं इस मामले में 1 से 5 तक लूप इंडेक्स तक कैसे पहुंचूं?

इंडेक्स को तत्व के साथ प्राप्त करने के लिए enumerate करें, जैसा कि आप पुन: करते हैं:

for index, item in enumerate(items):
    print(index, item)

और ध्यान दें कि पायथन की अनुक्रमणिका शून्य से शुरू होती है, इसलिए आपको ऊपर के साथ 0 से 4 मिलेंगे। यदि आप गिनती चाहते हैं, 1 से 5, ऐसा करें:

for count, item in enumerate(items, start=1):
    print(count, item)

यूनिडायोटिक नियंत्रण प्रवाह

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

index = 0            # Python's indexing starts at zero
for item in items:   # Python's for loops are a "for each" loop 
    print(index, item)
    index += 1

या उन भाषाओं में जिनके लिए प्रत्येक लूप नहीं है:

index = 0
while index < len(items):
    print(index, items[index])
    index += 1

या पाइथन में कभी-कभी अधिक सामान्य (लेकिन unidiomatically) पाया जाता है:

for index in range(len(items)):
    print(index, items[index])

गणना कार्य का प्रयोग करें

पायथन का enumerate फ़ंक्शन इंडेक्स के लिए लेखांकन को छिपाने के द्वारा दृश्य अव्यवस्था को कम करता है, और पुनरावर्तनीय को एक अन्य पुनरावर्तनीय (एक enumerate वस्तु) में समाहित करता है जो सूचकांक के दो-आइटम टुपल और मूल वस्तु प्रदान करने वाली वस्तु उत्पन्न करता है। ऐसा लगता है:

for index, item in enumerate(items, start=0):   # default is zero
    print(index, item)

यह कोड नमूना काफी अच्छा है जो कोड के बीच अंतर का canonical उदाहरण है जो पाइथन और कोड की मूर्खतापूर्ण है। बेवकूफ कोड परिष्कृत (लेकिन जटिल नहीं) पाइथन है, जिस तरह से इसका इस्तेमाल किया जाना था। भाषा के डिजाइनरों द्वारा Idiomatic कोड की उम्मीद है, जिसका मतलब है कि आमतौर पर यह कोड सिर्फ अधिक पठनीय नहीं है, बल्कि यह भी अधिक कुशल है।

एक गिनती प्राप्त करना

भले ही आपको इंडेक्स की आवश्यकता नहीं है, लेकिन आपको पुनरावृत्तियों की गिनती की आवश्यकता है (कभी-कभी वांछनीय) आप 1 शुरू कर सकते हैं और अंतिम संख्या आपकी गिनती होगी।

for count, item in enumerate(items, start=1):   # default is zero
    print(item)

print('there were {0} items printed'.format(count))

जब आप कहते थे कि आप 1 से 5 तक चाहते हैं तो गिनती उतनी ही अधिक होती है जितनी आप पूछना चाहते हैं (इंडेक्स के विपरीत)।

इसे तोड़ना - चरण-दर-चरण स्पष्टीकरण

इन उदाहरणों को तोड़ने के लिए, कहें कि हमारे पास ऐसी वस्तुओं की एक सूची है जिसे हम एक इंडेक्स के साथ फिर से चालू करना चाहते हैं:

items = ['a', 'b', 'c', 'd', 'e']

अब हम गणना करने के लिए यह पुनरावर्तनीय पास करते हैं, एक गणना वस्तु बनाते हैं:

enumerate_object = enumerate(items) # the enumerate object

हम इस आइटम से पहले आइटम को खींच सकते हैं कि हम next फंक्शन के साथ एक लूप में प्राप्त करेंगे:

iteration = next(enumerate_object) # first iteration from enumerate
print(iteration)

और हम देखते हैं कि हमें 0 का पहला टुपल, पहला इंडेक्स और 'a' , पहला आइटम:

(0, 'a')

हम इन दो-टुपल के तत्वों को निकालने के लिए " अनुक्रम अनपॅकिंग " के रूप में संदर्भित किया जा सकता है:

index, item = iteration
#   0,  'a' = (0, 'a') # essentially this.

और जब हम index का निरीक्षण करते index , तो हम पाते हैं कि यह पहली अनुक्रमणिका, 0, और item संदर्भित करता है, पहला आइटम 'a' को संदर्भित करता है।

>>> print(index)
0
>>> print(item)
a

निष्कर्ष

  • पायथन इंडेक्स शून्य से शुरू होता है
  • इन इंडेक्स को एक पुनरावृत्त से प्राप्त करने के लिए जब आप इसे फिर से चालू करते हैं, तो गणना कार्य का उपयोग करें
  • बेवकूफ तरीके (टुपल अनपॅकिंग के साथ) में गणना का उपयोग कोड बनाता है जो अधिक पठनीय और रखरखाव योग्य होता है:

तो यह करो:

for index, item in enumerate(items, start=0):   # Python indexes start at zero
    print(index, item)
python loops list

मैं निम्न सूची की सूची के लिए खुद को इंडेक्स तक कैसे एक्सेस करूं?

ints = [8, 23, 45, 12, 78]

जब मैं लूप का उपयोग करके इसे लूप करता हूं, तो मैं इस मामले में 1 से 5 तक लूप इंडेक्स तक कैसे पहुंचूं?




for i in range(len(ints)):
   print i, ints[i]



पुराने जमाने का तरीका:

for ix in range(len(ints)):
    print ints[ix]

सूची समझ:

[ (ix, ints[ix]) for ix in range(len(ints))]

>>> ints
[1, 2, 3, 4, 5]
>>> for ix in range(len(ints)): print ints[ix]
... 
1
2
3
4
5
>>> [ (ix, ints[ix]) for ix in range(len(ints))]
[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]
>>> lc = [ (ix, ints[ix]) for ix in range(len(ints))]
>>> for tup in lc:
...     print tup
... 
(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
>>> 



मुझे नहीं पता कि निम्नलिखित पाइथोनिक है या नहीं, लेकिन यह पाइथन फ़ंक्शन enumerate का उपयोग करता है और इंडेक्स और मान प्रिंट करता है।

int_list = [8, 23, 45, 12, 78]
for index, value in enumerate(int_list):
   print(index, value)

आउटपुट:

0 8
1 23
2 45
3 12
4 78



सबसे पहले, इंडेक्स 0 से 4 तक होंगे। प्रोग्रामिंग भाषाएं 0 से गिनती शुरू करेंगी; इसे मत भूलना या आप बाध्य अपवाद से बाहर एक सूचकांक में आ जाएगा। लूप में आपको बस इतना ही चाहिए कि 0 से 4 तक एक वैरिएबल गिनती है:

for x in range(0, 5):

ध्यान रखें कि मैंने 0 से 5 लिखा है क्योंकि लूप अधिकतम से पहले एक नंबर रोकता है। :)

एक सूचकांक उपयोग के मूल्य प्राप्त करने के लिए

list[index]



आप इसे इस कोड से कर सकते हैं:

ints = [8, 23, 45, 12, 78]
index = 0

for value in (ints):
    index +=1
    print index, value

यदि आपको लूप के अंत में इंडेक्स मान को रीसेट करने की आवश्यकता है तो इस कोड का उपयोग करें:

ints = [8, 23, 45, 12, 78]
index = 0

for value in (ints):
    index +=1
    print index, value
    if index >= len(ints)-1:
        index = 0



आप यह भी कोशिश कर सकते हैं:

data = ['itemA.ABC', 'itemB.defg', 'itemC.drug', 'itemD.ashok']
x = []
for (i, item) in enumerate(data):
      a = (i, str(item).split('.'))
      x.append(a)
for index, value in x:
     print(index, value)

आउटपुट है

0 ['itemA', 'ABC']
1 ['itemB', 'defg']
2 ['itemC', 'drug']
3 ['itemD', 'ashok']



आप index विधि का उपयोग कर सकते हैं

ints = [8, 23, 45, 12, 78]
inds = [ints.index(i) for i in ints]

इस टिप्पणी में हाइलाइट किया गया है कि अगर ints में डुप्लीकेट होते हैं तो यह विधि काम नहीं करती है, नीचे दी गई विधि को ints में किसी भी मान के लिए काम करना चाहिए:

ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup[0] for tup in enumerate(ints)]

या वैकल्पिक रूप से

ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup for tup in enumerate(ints)]

यदि आप ints सूची के रूप में ints में सूचकांक और मूल्य दोनों प्राप्त करना चाहते हैं।

यह इस प्रश्न के चयनित उत्तर में enumerate के तरीके का उपयोग करता है, लेकिन सूची समझ के साथ, इसे कम कोड के साथ तेज़ी से बनाते हैं।




यदि सूची में कोई डुप्लिकेट मान नहीं है:

for i in ints:
        indx=ints.index(i)
        print(i,indx)

इसके बजाय enumerate. उपयोग करें enumerate.

for counter, value in enumerate(ints):
    print(counter, value)

या नीचे उपयोग करें:

for counter in range(len(ints)):
    print(counter,ints[counter])



लूप का उपयोग करके सूची समझ में (इंडेक्स, वैल्यू) के tuple को मुद्रित करने के for :

ints = [8, 23, 45, 12, 78]
print [(i,ints[i]) for i in range(len(ints))]

आउटपुट:

[(0, 8), (1, 23), (2, 45), (3, 12), (4, 78)]



Related