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 දක්වා ලූප් දර්ශකයට ප්‍රවේශ වන්නේ කෙසේද?

දර්ශක විචල්‍යය (ඔබ සාමාන්‍යයෙන් සී හෝ පීඑච්පී වැනි භාෂාවලින් භාවිතා කරන) වැනි අතිරේක රාජ්‍ය විචල්‍යයක් භාවිතා කිරීම පයිතොනික් නොවන ලෙස සැලකේ.

වඩා හොඳ විකල්පය වන්නේ enumerate()පයිතන් 2 සහ 3 යන දෙකින්ම ලබා ගත හැකි සාදන ලද ශ්‍රිතය භාවිතා කිරීමයි :

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

වැඩි විස්තර සඳහා PEP 279 බලන්න .

For for loop එකක් භාවිතා කරමින්, මෙම අවස්ථාවේ දී 1 සිට 5 දක්වා ලූප් දර්ශකයට ප්‍රවේශ වන්නේ කෙසේද?

enumerateඔබ පුනරාවර්තනය වන විට මූලද්‍රව්‍යය සමඟ දර්ශකය ලබා ගැනීමට භාවිතා කරන්න :

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

පයිතන්ගේ දර්ශක බිංදුවෙන් ආරම්භ වන බව සලකන්න, එවිට ඔබට ඉහත 0 සමඟ 4 සිට 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])

ගණන් ගැනීමේ කාර්යය භාවිතා කරන්න

පයිතන්ගේ enumerateක්‍රියාකාරිත්වය මඟින් දර්ශක සඳහා ගිණුම්කරණය සැඟවීමෙන් දෘශ්‍ය කැළඹීම අඩු කරයි, සහ අයිටරයේ enumerateඅයිතම දෙකක ටුපල් එකක් සහ මුල් නැවත ලබා ගත හැකි අයිතමය ලබා දෙන අයිටරය වෙනත් පුනරාවර්තනයකට ( වස්තුවකට) සම්බන්ධ කරයි. එය මේ වගේ ය:

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

මෙම කේත නියැදිය පයිතන්ගේ මුග්ධ සංකේතය සහ නැති කේතය අතර වෙනස පිළිබඳ කැනොනිකල් උදාහරණය තරමක් හොඳ ය . අයිඩියොමැටික් කේතය අති නවීන (නමුත් සංකීර්ණ නොවේ) පයිතන්, එය භාවිතා කිරීමට අදහස් කරන ආකාරයට ලියා ඇත. භාෂාවේ නිර්මාණකරුවන් විසින් මුග්ධ කේතය අපේක්ෂා කරන අතර එයින් අදහස් කරන්නේ සාමාන්‍යයෙන් මෙම කේතය වඩා කියවිය හැකි පමණක් නොව වඩා කාර්යක්ෂම බවයි.

ගණන් කිරීම

ඔබ යන විට ඔබට දර්ශක අවශ්‍ය නොවුවද, ඔබට ආරම්භ කළ හැකි පුනරාවර්තන ගණනක් (සමහර විට යෝග්‍ය වේ) ඔබට අවශ්‍ය වන 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ය 0:

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

සටහන

වැදගත් ඉඟියක් සිට ටිකක් නොමඟ යවන නමුත් indexඑය වනු ඇත tuple (idx, item)මෙතන. යන්න හොඳයි.

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

පයිතන්හි සම්මතයට අනුව මෙය කිරීමට ක්‍රම කිහිපයක් තිබේ. සෑම උදාහරණයකින්ම උපකල්පනය කරන්න: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 . සඳහා භාවිතා කිරීම. එය අනෙක් උදාහරණ වලට වඩා හොඳින් කැදැලි වළළු හසුරුවයි.

පැරණි විලාසිතාව:

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

පයිතන් 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

ප්රති result ලයක් ලෙස, භාවිතා කිරීම range අයිතම 1000 ක් සමඟ ලැයිස්තුගත කිරීම සඳහා වේගවත්ම ක්‍රමය වන්නේ ක්‍රමය කිරීමයි. ප්‍රමාණය> 10 000 අයිතම සහිත ලැයිස්තුව enumerateසඳහා ජයග්‍රාහකයා වේ.

පහත ප්‍රයෝජනවත් සබැඳි කිහිපයක් එකතු කිරීම:

• පයිතන් 2.X හි පරාසය සහ xrange ශ්‍රිත අතර වෙනස කුමක්ද?

• ගණන් කිරීම භාවිතා කරන ලූප සඳහා හෝ පයිතන්හි xrange භාවිතා කරන ලූප සඳහා වේගවත් වන්නේ කුමක්ද?

• පරාසය (ලෙන් (ලැයිස්තුව)) හෝ ගණන් කිරීම (ලැයිස්තුව)?

පළමුවෙන්ම, දර්ශක 0 සිට 4 දක්වා වනු ඇත. ක්‍රමලේඛන භාෂා 0 සිට ගණන් කිරීම ආරම්භ කරයි; එය අමතක නොකරන්න, නැතහොත් ඔබ සීමාවෙන් ඔබ්බට දර්ශකයක් හමුවනු ඇත. For for loop හි ඔබට අවශ්‍ය වන්නේ 0 සිට 4 දක්වා විචල්‍ය ගණනය කිරීමකි:

for x in range(0, 5):

මා 0 සිට 5 දක්වා ලියා ඇති බව මතක තබා ගන්න, ලූපය උපරිමයට පෙර එක් අංකයක් නතර කරයි. :)

දර්ශක භාවිතයක වටිනාකම ලබා ගැනීම සඳහා

list[index]

ඔබ forලූප වලින් දර්ශකයට ප්‍රවේශ වන විට ඔබට ලැබෙන දේ මෙන්න :

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

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

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

ප්‍රති ult ලය:

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

ප්‍රති ult ලය:

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

ප්‍රති ult ලය:

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

මෙම සාකච්ඡාවට අනුව: 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/ හරහා

ඔබට මෙම කේතය සමඟ එය කළ හැකිය:

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

මෙම ගැටළුවට හොඳම විසඳුම වන්නේ ගණනය කළ හැකි පයිතන් ශ්‍රිතයයි.
කීයක් නැවත tuple
පළමු අගය කරයි දර්ශකය
දෙවන අගය අංගයක් බව දර්ශකය දී අරාව

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 සිට 5 දක්වා ලූප් දර්ශකයට ප්‍රවේශ වන්නේ කෙසේද?"

කෙසේ වෙතත්, ලැයිස්තුවක් සඳහා දර්ශකය ශුන්‍යයෙන් ක්‍රියාත්මක වේ. ඉතින්, ඔබට ඇත්ත වශයෙන්ම අවශ්‍ය වන්නේ ලැයිස්තුවක ඇති එක් එක් අයිතමය සඳහා වන දර්ශකය සහ අයිතමයද, නැතිනම් ඔබට 1 සිට ආරම්භ වන සංඛ්‍යා සැබවින්ම අවශ්‍යද යන්න අප දැනගත යුතුය. වාසනාවකට මෙන්, පයිතන්හිදී හෝ දෙකම කිරීම පහසුය.

පළමුව, පැහැදිලි කිරීම සඳහා, 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 සිට ක්‍රියාත්මක වන බව සැලකිල්ලට ගන්න. පයිතන් සහ සී ඇතුළු නවීන ක්‍රමලේඛන භාෂා අතර මේ ආකාරයේ සුචිගත කිරීම පොදු වේ.

ඔබේ ලූපය ලැයිස්තුවෙන් කොටසක් විහිදුවාලීමට ඔබට අවශ්‍ය නම්, ඔබට ලැයිස්තුවේ කොටසක් සඳහා සම්මත පයිතන් සින්ටැක්ස් භාවිතා කළ හැකිය. නිදසුනක් ලෙස, ලැයිස්තුවේ දෙවන අයිතමයෙන් අවසන් අයිතමය ඇතුළත් නොවීමට, ඔබට භාවිතා කළ හැකිය

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

මම නැවත කියනවා නම් මම 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])

ලැයිස්තුවේ අනුපිටපත් අගයක් නොමැති නම්:

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

ඔබට මෙය උත්සාහ කළ හැකිය:

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 ටුපල් ලැයිස්තුවක් ලෙස .

එය enumerateමෙම ප්‍රශ්නයට තෝරාගත් පිළිතුරේ ක්‍රමය භාවිතා කරයි , නමුත් ලැයිස්තු අවබෝධය සමඟ, අඩු කේතයකින් එය වේගවත් කරයි.

අතරතුර ලූප් භාවිතා කරමින් සරල පිළිතුර:

arr = [8, 23, 45, 12, 78]
i = 0
while i<len(arr):
    print("Item ",i+1," = ",arr[i])
    i +=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)]

මෙය අරමුණට ප්‍රමාණවත් ලෙස සේවය කරයි:

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