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)