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



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

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

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

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




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

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



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

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



सबसे पहले, इंडेक्स 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



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



आपको enumerate समझाते हुए कई उत्तरों प्राप्त हुए हैं, लेकिन यदि आपको केवल दो सूचियों में मिलान प्रविष्टियों तक पहुंचने के लिए इंडेक्स की आवश्यकता है, तो एक और तरीका है जो पाइथन 3: zip में क्लीनर और सरल है।

उदाहरण के लिए, यदि आप अपनी सूची में संख्याओं के लिए संबंधित नाम खींचने के लिए इंडेक्स का उपयोग कर रहे हैं, तो आप इसे इस तरह से कर सकते हैं:

ints = [8, 23, 45, 12, 78]
names = ["John", "Sue", "Johannes", "Patel", "Ian"]
for int, name = zip(ints, names):
    print("{} - {}".format(name, int)

वह उत्पादन करेगा

8 - John
23 - Sue
45 - Johannes
12 - Patel
78 - Ian



ints = [9, 23, 45, 12, 78]
ints.extend([1,2,3,4,5,6,7,8])
for idx, val in enumerate(ints):
    print(idx,val)

इस तरह आप एक सूची का विस्तार कर सकते हैं। विस्तार का मतलब है कि आप एक समय में कई मान जोड़ सकते हैं।

इस सूची को जोड़ने के लिए आपको नीचे दिया गया कोड लिखना होगा:

ints = [9, 23, 45, 12, 78]
ints.append([1])
for idx, val in enumerate(ints):
    print(idx,val)

इस तरह आप एक समय में एक ही मूल्य जोड़ सकते हैं। यदि आप ints.append([1]) लिखते हैं तो यह इस तत्व के लिए एक उप सूची बनाएगा।




Related