'ফর' লুপগুলিতে সূচকটি অ্যাক্সেস করবেন?


3599

forনীচের মত লুপে আমি কীভাবে সূচকটি অ্যাক্সেস করব ?

ints = [8, 23, 45, 12, 78]
for i in ints:
    print('item #{} = {}'.format(???, i))

আমি এই আউটপুট পেতে চাই:

item #1 = 8
item #2 = 23
item #3 = 45
item #4 = 12
item #5 = 78

আমি যখন লুপটি ব্যবহার করে forলুপ করি, তখন এই ক্ষেত্রে 1 থেকে 5 পর্যন্ত কীভাবে লুপ সূচকটি অ্যাক্সেস করব?


42
দ্রষ্টব্য যে পাইথনের সূচকগুলি 0 থেকে শুরু হয়, সুতরাং আপনার উদাহরণ তালিকার সূচীগুলি 1 থেকে 5 না হয়ে 0 থেকে 4
প্লাগওয়াশ

উত্তর:


6105

একটি অতিরিক্ত স্টেট ভেরিয়েবল, যেমন একটি সূচক ভেরিয়েবল (যা আপনি সাধারণত সি বা পিএইচপি হিসাবে ভাষাতে ব্যবহার করতে পারেন) ব্যবহার অ-পাইথোনিক হিসাবে বিবেচিত।

enumerate()পাইথন 2 এবং 3 উভয় ক্ষেত্রেই অন্তর্নির্মিত ফাংশনটি ব্যবহার করা আরও ভাল বিকল্প :

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

পরীক্ষা করে দেখুন PEP 279 আরো অনেক কিছুর জন্য।


61
অ্যারন নীচে উল্লেখ করেছেন, আপনি যদি 0-4-এর পরিবর্তে 1-5 পেতে চান তবে শুরু = 1 ব্যবহার করুন।
ক্লোজাচ

2
না enumerateঅন্য ওভারহেড বহন করতে না?
TheRealChx101

@ TheRealChx101 আমার পরীক্ষাগুলি অনুসারে (পাইথন ৩.6.৩) পার্থক্যটি নগণ্য এবং মাঝে মাঝে এমনকি পক্ষেও যায় enumerate
বায়োটোসমেটেক

803

লুপের জন্য একটি ব্যবহার করে, আমি এই ক্ষেত্রে 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

বা কখনও কখনও পাইথনে আরও সাধারণভাবে (তবে একচেটিয়াভাবে) পাওয়া যায়:

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

গণনা কার্যটি ব্যবহার করুন Use

পাইথনের enumerateফাংশন সূচকগুলির জন্য অ্যাকাউন্টিং গোপন করে এবং পুনরাবৃত্তিকে অন্য পুনরাবৃত্ত (একটি enumerateবস্তু) -এর মধ্যে সংযুক্ত করে যা সূচকটির দ্বি-আইটেম টুপল দেয় এবং যে আইটেমটি মূল পুনরাবৃত্তিযোগ্য তা সরবরাহ করে। এটি দেখতে এরকম দেখাচ্ছে:

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

এই কোড নমুনা মোটামুটি ভাল হয় ক্যানোনিকাল কোডটি Python- র কথ্য হয় এবং কোড মধ্যে পার্থক্য নয় উদাহরণ। আইডিয়োমেটিক কোডটি পরিশীলিত (তবে জটিল নয়) পাইথন, এটি যেভাবে ব্যবহারের উদ্দেশ্যে হয়েছিল সেভাবে লেখা। আইডোমেটিক কোডটি ভাষার ডিজাইনার দ্বারা প্রত্যাশিত হয়, যার অর্থ সাধারণত এই কোডটি কেবল আরও বেশি পঠনযোগ্য নয়, তবে আরও কার্যকর efficient

একটি গণনা করা

আপনার যেতে যেতে সূচকের প্রয়োজন না হলেও আপনার পুনরাবৃত্তির একটি গণনা প্রয়োজন (কখনও কখনও কাম্য) আপনি শুরু করতে পারেন 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, আমরা এটা প্রথম সূচক, 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)

1
"কি পথ গণনা " উদাহরণ কাজ যখন itemsখালি?
বার্গি

আমি অ্যাজ্যাক্স ব্যবহার করে জ্যাঞ্জো ভিউগুলিতে ভ্যারিয়েবল লেগডাটা হিসাবে মান হিসাবে দুটি মান আকারে অ্যারে হিসাবে অ্যাজেक्स ব্যবহার করে ডেটা প্রেরণ করছি [1406, 1409]। যদি আমি কনসোলটি ব্যবহার করে মুদ্রণ করি print(legData)তবে আউটপুটটি [1406,1409] । যাইহোক, আমি যদি তালিকার পৃথক মানগুলিকে পার্স করার চেষ্টা করি তবে for idx, xLeg in enumerate(legData): print(idx, xLeg)এটি আমার জন্য পৃথক পূর্ণসংখ্যার যেমন [, 1, 4, 0, 6, এবং 0, 1, 2, 3, 4 সূচকগুলির বিপরীতে আউটপুট পায় ইত্যাদি (হ্যাঁ, বর্গাকার বন্ধনী & কমা এছাড়াও আউটপুট হচ্ছে যেন তারা তথ্য নিজেই অংশ ছিল )। এখানে কি ভুল হচ্ছে?
ব্যবহারকারী 12379095

@ user12379095 আপনার কাছে সম্ভবত ভুল টাইপের (একটি স্ট্রিং) ডেটা রয়েছে এবং আপনার এটি স্ট্রিংয়ের পরিবর্তে সংখ্যার একটি আসল তালিকায় রূপান্তর করতে হবে। এটি এখানে কিছুটা বন্ধ বিষয়, আপনার মন্তব্যটি মুছে ফেলুন এবং আপনি যখন এটি দেখবেন তখন আর প্রয়োজন হবে না বলে মুছে ফেলার জন্য আমার পতাকাটি খনন করুন।
হারুন হলের

151

এগুলি 1অন্যটি থেকে শুরু করা বেশ সহজ 0:

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

বিঃদ্রঃ

গুরুত্বপূর্ণ ইঙ্গিত, যদিও থেকে এখানে কিছুটা বিভ্রান্তিমূলক indexহবে a tuple (idx, item)যেতে ভাল।


10
প্রশ্নটি তালিকা সূচকগুলি সম্পর্কে ছিল; যেহেতু তারা 0 থেকে শুরু করে অন্য সংখ্যা থেকে শুরু করার খুব কম পয়েন্ট নেই যেহেতু সূচকগুলি ভুল হবে (হ্যাঁ, ওপিও প্রশ্নটিতে এটি ভুল বলেছে)। অন্যথায়, ভেরিয়েবলের tuple যে কলিং index, itemশুধু indexখুব বিভ্রান্তিকর হয়, হিসাবে আপনি লক্ষনীয়। শুধু ব্যবহার for index, item in enumerate(ints)
এন্টি হাপাল

1
(সূচক) হিসাবে প্রথম বন্ধনী
জুটির

1
@ আন্টিহাপালা কারণ, আমার ধারণা, প্রশ্নটির প্রত্যাশিত আউটপুটটি 0 এর পরিবর্তে 1 সূচকে শুরু হবে
পুশকিন

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

10
এটি সম্ভবত xrangeপ্রাক-3.0 এর জন্য হওয়া উচিত ।
বেন ফাঁকা 22

42
পরিবর্তে গণনাটি ব্যবহার করুন
saulspatz

3
পাইথন ২.৩-এর জন্য, গণনা অন্তর্নির্মিত ফাংশনটি ব্যবহার করুন কারণ এটি বেশি পাইথোনিক।
জানুয়ার্ভস

গণনা করা সর্বদা ভাল হয় না - এটি অ্যাপ্লিকেশনটির প্রয়োজনীয়তার উপর নির্ভর করে। আমার বর্তমান পরিস্থিতিতে অবজেক্টের দৈর্ঘ্যের মধ্যে সম্পর্কগুলি আমার আবেদনের জন্য অর্থপূর্ণ। যদিও আমি গণনা ব্যবহার শুরু করেছি, কোন পদার্থটি গণনা করতে হবে তা নির্বাচন করার জন্য যুক্তি লিখতে না পেরে আমি এই পদ্ধতির দিকে চলে এসেছি।
এডজি

1
@ এডজি আমি কীভাবে এড়ানো enumerateকোনও যুক্তি রক্ষা করতে দেখছি না ; আপনাকে এখনও কোন বস্তুটি সূচকে নির্বাচন করতে হবে i, না?
চিপনার

47

পাইথনের আদর্শ হিসাবে এটি করার বিভিন্ন উপায় রয়েছে। সমস্ত উদাহরণে ধরে নেওয়া:lst = [1, 2, 3, 4, 5]

১. গণনা ব্যবহার করা ( সর্বাধিক প্রতিবন্ধক হিসাবে বিবেচিত )

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

আমার মতে এটিও সবচেয়ে নিরাপদ বিকল্প কারণ অসীম পুনরাবৃত্তিতে যাওয়ার সুযোগটি কেটে গেছে। আইটেম এবং এর সূচি উভয়ই ভেরিয়েবলগুলিতে রাখা হয় এবং আইটেমটি অ্যাক্সেস করার জন্য আর কোনও কোড লেখার দরকার নেই।

২. সূচক ধরে রাখতে একটি ভেরিয়েবল তৈরি করা ( ব্যবহার করেfor )

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

৩. সূচক ধরে রাখতে একটি ভেরিয়েবল তৈরি করা ( ব্যবহার করেwhile )

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

৪. সর্বদা অন্য উপায় রয়েছে

আগে যেমন ব্যাখ্যা করা হয়েছে, এটি করার অন্যান্য উপায় রয়েছে যা এখানে ব্যাখ্যা করা হয়নি এবং তারা অন্যান্য পরিস্থিতিতে আরও প্রয়োগ করতে পারে। যেমন জন্য ব্যবহার করে itertools.chain। এটি অন্যান্য উদাহরণগুলির চেয়ে নেস্টেড লুপগুলি পরিচালনা করে।


30

পুরানো ফ্যাশন উপায়:

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

3
এটি ভুল নয় এবং সি / সি ++ এবং অন্যান্যতে ব্যবহৃত হয়। এটি অ পাইথোনিক হিসাবে বিবেচিত, তবে পাইথনটিতেও এটি ব্যবহার করা যেতে পারে। উত্সটিতে এটি ভেঙে দেওয়া এমন সাধারণ সমাধানগুলির মতো: +
বীরত্বের নারম

কিছু অজগর চরমপন্থী বলতেন, এটি করবেন না। তবে আমি এটি কেবলমাত্র একাধিক সম্ভাব্য পথ নির্দেশ করার জন্য বলেছিলাম
বোরোর নারাম

21

পাইথন ২.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বিজয়ী।

নীচে কিছু দরকারী লিঙ্ক যুক্ত করা হচ্ছে:


5
"পঠনযোগ্যতা গণনা করা হয়" ছোট <1000 ব্যাপ্তির গতির পার্থক্য নগণ্য। এটি ইতিমধ্যে স্বল্প সময়ের মেট্রিকের তুলনায় 3% ধীর।

পাইথন 3 এর উত্তর আপডেট করার বিষয়ে কীভাবে?
জর্জি

14

প্রথমত, সূচকগুলি 0 থেকে 4 পর্যন্ত হবে প্রোগ্রামিং ভাষা 0 থেকে গণনা শুরু করে; এটি ভুলবেন না বা সীমা ব্যতিক্রমের বাইরে আপনি একটি সূচক জুড়ে আসবেন। লুপের জন্য আপনার যা দরকার তা হ'ল 0 থেকে 4 এর মত একটি পরিবর্তনশীল গণনা:

for x in range(0, 5):

মনে রাখবেন যে আমি 0 থেকে 5 লিখেছি কারণ লুপটি সর্বোচ্চের আগে একটি নম্বর থামায়। :)

একটি সূচক ব্যবহারের মান পেতে

list[index]

13

forলুপগুলিতে সূচক অ্যাক্সেস করার সময় আপনি যা পাবেন তা এখানে :

for i in enumerate(items): print(i)

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

for i in enumerate(items):
    print("index/value", i)

ফলাফল:

# index/value (0, 8)
# index/value (1, 23)
# index/value (2, 45)
# index/value (3, 12)
# index/value (4, 78)

for i, val in enumerate(items): print(i, val)

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

for i, val in enumerate(items):
    print("index", i, "for value", val)

ফলাফল:

# index 0 for value 8
# index 1 for value 23
# index 2 for value 45
# index 3 for value 12
# index 4 for value 78

for i, val in enumerate(items): print(i)

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

for i, val in enumerate(items):
    print("index", i)

ফলাফল:

# index 0
# index 1
# index 2
# index 3
# index 4

12

এই আলোচনা অনুসারে: http://bytes.com/topic/python/answers/464012-objects-list-index

লুপ কাউন্টার পুনরাবৃত্তি

সূচকগুলিতে লুপিংয়ের জন্য বর্তমান প্রতিমাটি অন্তর্নির্মিত rangeফাংশনটি ব্যবহার করে:

for i in range(len(sequence)):
    # work with index i

উভয় উপাদান এবং সূচকের উপর লুপিং পুরানো আইডিয়ম দ্বারা বা নতুন zipঅন্তর্নির্মিত ফাংশন ব্যবহার করে অর্জন করা যেতে পারে :

for i in range(len(sequence)):
    e = sequence[i]
    # work with index i and element e

অথবা

for i, e in zip(range(len(sequence)), sequence):
    # work with index i and element e

http://www.python.org/dev/peps/pep-0212/ এর মাধ্যমে


22
এটি জেনারেটরের মাধ্যমে পুনরাবৃত্তি করার জন্য কাজ করবে না। শুধু গণনা () ব্যবহার করুন।
টাডেক

আজকাল, বর্তমান প্রতিমাটি গণনা করা হচ্ছে, রেঞ্জ কল নয়।
ট্যানকোরস্যামশ

: এবং এটি পুরোনো উত্তর হিসাবে একই stackoverflow.com/a/522576/6451573
জাঁ ফ্রাসোয়া Fabre

11

আপনি এই কোড দিয়ে এটি করতে পারেন:

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

10

এই সমস্যার জন্য সবচেয়ে ভালো সমাধান ব্যবহার গনা ইন-বিল্ড পাইথন ফাংশন। রিটার্ন টুপল প্রথম মান
গণনা সূচক দ্বিতীয় মান যে সূচকের অ্যারের উপাদান

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)

9

আপনার প্রশ্নে আপনি লিখেন "এই ক্ষেত্রে 1 থেকে 5 পর্যন্ত আমি কীভাবে লুপ সূচকটি অ্যাক্সেস করব?"

তবে একটি তালিকার সূচকটি শূন্য থেকে চলে। সুতরাং, তবে আমাদের জানতে হবে যা আপনি আসলে যা চান তা তালিকার প্রতিটি আইটেমের জন্য সূচক এবং আইটেম কিনা বা আপনি আসলেই ১ থেকে শুরু করে সংখ্যাগুলি চান কিনা ভাগ্যক্রমে পাইথনে, দু'টিই করা সহজ।

প্রথমে স্পষ্ট করার জন্য, enumerateফাংশনটি পুনরাবৃত্তভাবে তালিকার প্রতিটি আইটেমের জন্য সূচক এবং সংশ্লিষ্ট আইটেমটি প্রদান করে।

alist = [1, 2, 3, 4, 5]

for n, a in enumerate(alist):
    print("%d %d" % (n, a))

উপরের ফলাফলটি তখন,

0 1
1 2
2 3
3 4
4 5

লক্ষ্য করুন যে সূচকটি 0 থেকে চলেছে Py পাইথন এবং সি সহ আধুনিক প্রোগ্রামিং ভাষার মধ্যে সূচকগুলি এই জাতীয় is

আপনি যদি চান যে আপনার লুপটি তালিকার একটি অংশ বিস্তৃত হয় তবে আপনি তালিকার একটি অংশের জন্য স্ট্যান্ডার্ড পাইথন বাক্য গঠন ব্যবহার করতে পারেন। উদাহরণস্বরূপ, তালিকার দ্বিতীয় আইটেম থেকে লুপ করতে তবে শেষ আইটেমটি অন্তর্ভুক্ত না করে আপনি ব্যবহার করতে পারেন

for n, a in enumerate(alist[1:-1]):
    print("%d %d" % (n, a))

মনে রাখবেন যে আবারও, আউটপুট সূচক 0 থেকে চলে যায়,

0 2
1 3
2 4

এটি আমাদের জন্য start=nস্যুইচ এনে দেয় enumerate()। এটি কেবল সূচকটি অফসেট করে, আপনি সমানভাবে লুপের ভিতরে সূচীতে একটি সংখ্যা যুক্ত করতে পারেন।

for n, a in enumerate(alist, start=1):
    print("%d %d" % (n, a))

যার জন্য আউটপুট হয়

1 1
2 2
3 3
4 4
5 5

9

আমি যদি পুনরাবৃত্তি nums = [1, 2, 3, 4, 5]করতাম তবে আমি করতাম

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

বা হিসাবে দৈর্ঘ্য পেতে l = len(nums)

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

7

তালিকায় কোনও সদৃশ মান না থাকলে:

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

1
মনে রাখবেন যে প্রথম বিকল্পটি ব্যবহার করা উচিত নয়, কারণ এটি কেবল তখনই সঠিকভাবে কাজ করে যখন ক্রমের প্রতিটি আইটেমটি অনন্য।
স্ট্যাম কালি

2
প্রথম বিকল্পটি হ'ল হে (n²), একটি ভয়ানক ধারণা। যদি আপনার তালিকাটি 1000 টি উপাদান দীর্ঘ হয় তবে এটি আক্ষরিক ব্যবহারের চেয়ে 1000 গুণ বেশি সময় নেবে enumerate। আপনার এই উত্তরটি মুছে ফেলা উচিত।
বোরিস

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

3

আপনি 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টিপলগুলির একটি তালিকা হিসাবে।

এটি enumerateএই প্রশ্নের নির্বাচিত উত্তরের পদ্ধতিটি ব্যবহার করে তবে তালিকাটি বোঝার সাথে কম কোড দিয়ে দ্রুত তৈরি করে।


2

লুপের সময় ব্যবহার করে সহজ উত্তর:

arr = [8, 23, 45, 12, 78]
i = 0
while i<len(arr):
    print("Item ",i+1," = ",arr[i])
    i +=1

আউটপুট:

এখানে চিত্র বর্ণনা লিখুন


1

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

1

এটি উদ্দেশ্যটিকে যথেষ্ট ভালভাবে পরিবেশন করে:

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

4
তালিকায় যদি পুনরাবৃত্ত উপাদানগুলির index()প্রথম উপস্থিতি সন্ধান করা হয় তবে প্রতিটি উপাদানকে অনুসন্ধান করার জন্য প্রয়োজনীয় xও ( এন ^ 2 ) সময় উল্লেখ না করে এটি ভেঙে যাবে ।
পিটার সজলডান

সম্পূর্ণরূপে সম্মত হয়েছে যে এটি তালিকার সদৃশ উপাদানগুলির জন্য কাজ করবে না। শেষ পর্যন্ত আমি অজগর শিখছি।
সুমিত কুমার
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.