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




loops list (18)

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

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

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


Answers

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

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

0 से 1 अलावा इसे शुरू करना बहुत आसान है:

for index, item in enumerate(iterable, start=1):
   print index, item

ध्यान दें

महत्वपूर्ण संकेत, हालांकि index बाद से थोड़ा भ्रामक एक tuple (idx, item) यहाँ होगा। जाना अच्छा है।


मुझे नहीं पता कि निम्नलिखित पाइथोनिक है या नहीं, लेकिन यह पाइथन फ़ंक्शन 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

यह इस उद्देश्य को पर्याप्त रूप से पर्याप्त सेवा प्रदान करता है:

list1 = [10, 'sumit', 43.21, 'kumar', '43', 'test', 3]
for x in list1:
    print('index:', list1.index(x), 'value:', x)

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

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

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

for x in range(0, 5):

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

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

list[index]

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]) लिखते हैं तो यह इस तत्व के लिए एक उप सूची बनाएगा।


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

बेहतर विकल्प अंतर्निहित फ़ंक्शन enumerate() , जो कि पाइथन 2 और 3 दोनों में उपलब्ध है:

for idx, val in enumerate(ints):
    print(idx, val)

अधिक के लिए पीईपी 279 देखें।


इस समस्या का सबसे अच्छा समाधान इन-बिल्ड पायथन फ़ंक्शन का उपयोग करना है।
गणना वापसी ट्यूपल
पहला मान सूचकांक है
दूसरा मान उस सूचकांक में सरणी का तत्व है

In [1]: ints = [8, 23, 45, 12, 78]

In [2]: for idx, val in enumerate(ints):
   ...:         print(idx, val)
   ...:     
(0, 8)
(1, 23)
(2, 45)
(3, 12)
(4, 78)

अगर मैं संख्याओं को दोहराना चाहता था = [1,2,3,4,5] मैं करूँगा

for i, num in enumerate(nums, start = 1):
    print(i, num)

या एल = लेन (अंक) के रूप में लंबाई प्राप्त करें

for i, num in range(1, l + 1):
    print(i, nums[i])

पायथन 2.7 में लूप के भीतर सूची के इंडेक्स तक पहुंचने का सबसे तेज़ तरीका मध्यम सूचियों और मध्यम आकार के सूचियों के लिए छोटी सूचियों और गणना विधि के लिए रेंज विधि का उपयोग करना है।

कृपया अलग-अलग दृष्टिकोण देखें जो नीचे दिए गए कोड नमूनों में सूची और एक्सेस इंडेक्स मूल्य और उनके प्रदर्शन मीट्रिक (जो मुझे लगता है कि आपके लिए उपयोगी होगा) पर पुन: उपयोग करने के लिए उपयोग किया जा सकता है:

from timeit import timeit

# Using range
def range_loop(iterable):
    for i in range(len(iterable)):
        1 + iterable[i]

# Using xrange
def xrange_loop(iterable):
    for i in xrange(len(iterable)):
        1 + iterable[i]

# Using enumerate
def enumerate_loop(iterable):
    for i, val in enumerate(iterable):
        1 + val

# Manual indexing
def manual_indexing_loop(iterable):
    index = 0
    for item in iterable:
        1 + item
        index += 1

नीचे दी गई प्रत्येक विधि के लिए प्रदर्शन मीट्रिक देखें:

from timeit import timeit

def measure(l, number=10000):
print "Measure speed for list with %d items" % len(l)
print "xrange: ", timeit(lambda :xrange_loop(l), number=number)
print "range: ", timeit(lambda :range_loop(l), number=number)
print "enumerate: ", timeit(lambda :enumerate_loop(l), number=number)
print "manual_indexing: ", timeit(lambda :manual_indexing_loop(l), number=number)

measure(range(1000))
# Measure speed for list with 1000 items
# xrange:  0.758321046829
# range:  0.701184988022
# enumerate:  0.724966049194
# manual_indexing:  0.894635915756

measure(range(10000))
# Measure speed for list with 100000 items
# xrange:  81.4756360054
# range:  75.0172479153
# enumerate:  74.687623024
# manual_indexing:  91.6308541298

measure(range(10000000), number=100)
# Measure speed for list with 10000000 items
# xrange:  82.267786026
# range:  84.0493988991
# enumerate:  78.0344707966
# manual_indexing:  95.0491430759

नतीजतन, range विधि का उपयोग 1000 वस्तुओं के साथ सूची में सबसे तेज़ है। आकार के साथ सूची के लिए> 10 000 आइटम enumerate विजेता है।

नीचे कुछ उपयोगी लिंक जोड़ना:


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

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

जैसा कि पायथन में मानक है, ऐसा करने के कई तरीके हैं। सभी उदाहरणों में मान लें: lst = [1, 2, 3, 4, 5]

1. गणना का उपयोग करना ( सबसे बेवकूफ माना जाता है )

for index, element in enumerate(lst):
    # do the things that need doing here

यह मेरी राय में सबसे सुरक्षित विकल्प भी है क्योंकि अनंत रिकर्सन में जाने का मौका समाप्त हो गया है। आइटम और इसकी अनुक्रमणिका दोनों चर में आयोजित की जाती हैं और आइटम तक पहुंचने के लिए कोई और कोड लिखने की आवश्यकता नहीं होती है।

2. इंडेक्स को पकड़ने के लिए एक चर बनाना (इसके लिए उपयोग for )

for index in range(len(lst)):   # or xrange
    # you will have to write extra code to get the element

3. इंडेक्स को पकड़ने के लिए एक चर बनाना ( while उपयोग करना )

index = 0
while index < len(lst):
    # you will have to write extra code to get the element
    index += 1  # escape infinite recursion

4. हमेशा एक और तरीका है

जैसा कि पहले बताया गया है, ऐसा करने के अन्य तरीके हैं जिन्हें यहां समझाया नहीं गया है और वे अन्य स्थितियों में और भी लागू हो सकते हैं। उदाहरण के लिए itertools.chain का उपयोग कर। यह अन्य उदाहरणों की तुलना में नेस्टेड लूप को बेहतर तरीके से संभालता है।


आप 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 के तरीके का उपयोग करता है, लेकिन सूची समझ के साथ, इसे कम कोड के साथ तेज़ी से बनाते हैं।


फॉर लूप का उपयोग करके, मैं इस मामले में 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)

लूप का उपयोग करके सूची समझ में (इंडेक्स, वैल्यू) के 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)]

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

boolean broken = false; // declared outside of the loop for efficiency
for (Type type : types) {
    for (Type t : types2) {
        if (some condition) {
            broken = true;
            break;
        }
    }

    if (broken) {
        break;
    }
}






python loops list