Python හි For loop හි අනෙකුත් ක්‍රමලේඛන භාෂාවලට වඩා වෙනස් විශේෂාංග කිහිපයක් ඇත. වැඩිපුරම භාවිතා කරන ලද ලූපයකින් උපරිම ප්‍රයෝජන ගැනීමට මා ඉගෙන ගන්නා දේ මම ඔබට තබමි.
Python හි එය ලැයිස්තුවක්, වස්තුවක් හෝ වෙනත් මූලද්‍රව්‍යයක් විය හැකි, පුනරාවර්තනය කළ හැකි වස්තුවක් හරහා පුනරාවර්තනය කිරීමට අදහස් කෙරේ.
පහත ව්‍යුහය වේ
h2=[ 'Valencia', 'Castellón', 'Alicante'] for j in h2: instructions
මෙහි h2 යනු පුනරාවර්තනය කළ හැකි මූලද්‍රව්‍යයකි උදාහරණයක් ලෙස ලැයිස්තුව h2=[ 'Valencia', 'Castellón', 'Alicante']. ලූපයේ පුනරාවර්තන 3ක් ඇත, පළමු j=Valencia හි දෙවන විචල්‍යය j=Castellón.
තවද මෙයින් අපට අවශ්ය උපදෙස් නිර්වචනය කළ හැකිය, සෑම විටම ඉන්ඩෙන්ටේෂන් මතක තබා ගැනීම, පයිතන් හි අත්‍යවශ්‍ය දෙයක් සහ බොහෝ අය නොසලකා හරින, කේතයේ දෝෂ ලබා ගැනීම.
ලූප් සඳහා නිශ්චිත වාර ගණනක් පුනරාවර්තනය කරන්න.
අපිට C++ වලදී කරන්න පුළුවන් විදියට නිශ්චිත වාර ගණනක් නැවත නැවත කිරීමට අවශ්ය නම් අපිට range() භාවිතා කරන්න වෙනවා. 10 වතාවක් පුනරාවර්තනය කිරීමට අපි භාවිතා කරමු a
for element in Range(9):
instructions
අපි දාන්නේ 9 මිස 10 නෙවෙයි මොකද Range පටන් ගන්නේ 0 ඉඳන්, ඉතින් 0 ඉඳන් 9 වෙනකන් පුනරාවර්තන 10ක් හෝ වටයක් තියෙනවා.
Range() දැන ගැනීමෙන් අපට අංකයක් ඇතුලට දැමීම වෙනුවට විචල්‍යයක් තැබීමට ඉඩ සලසයි, එබැවින් අපට තවත් බොහෝ පාලනයක් ලැබෙනු ඇත.
var = 10
for element in Range(var):
instructions
Range ශ්‍රිතයට බොහෝ විකල්ප ඇත, මම ඒ ගැන වෙනත් පෝස්ට් එකකින් කතා කරමි, එවිට අන්තර්ගතය මිශ්‍ර කර එය හැකි තරම් සංවර්ධනය නොකිරීමට.
for loop හි ප්‍රවාහය පාලනය කිරීමට තවත් බොහෝ දේ කළ හැක.
ප්‍රකාශ කඩන්න සහ දිගටම කරගෙන යන්න
ෆෝ ලූප් එකක් ඉතා ක්‍රියාකාරී ලෙස, විවේකය සහ ඉදිරියට යාමට ඉඩ සලසන ඉතා ප්රයෝජනවත් විශේෂාංග 2ක් ඇත. ඒවා සාමාන්‍යයෙන් කොන්දේසි සහිතව භාවිතා වේ, නම්, යමක් සත්‍ය දැයි පරීක්ෂා කරයි.
ඒවා වෙනත් ලූපවල ක්‍රියා කරන අතර තවත් රසවත් ප්‍රකාශයක් තිබේ pass, එය ක්‍රියාත්මක කරන නමුත් කිසිවක් නොකරන ප්‍රකාශයක් වන අතර අපට විධාන අවශ්ය ව්‍යුහයක් නිර්වචනය කිරීමට අවශ්ය විට එය වඩාත් සුදුසු නමුත් අපට ඒවා පසුව තැබීමට අවශ්ය වේ (අදහස් වේ මේ සඳහා ප්රයෝජනවත් නොවේ)
විවේකයක්
විවේකයක් සමඟ අපට ඕනෑම වේලාවක ලූපයෙන් පිටවිය හැක. ඔබ සිතන පරිදි ඉතා ප්රයෝජනවත් වේ. විට, වැනි වෙනත් ව්‍යුහයන් ඇති බව සත්‍යයකි.
numeros = [1, 2, 4, 3, 5, 8, 6]
for n in numeros:
if n == 3:
break
else:
print('No se encontró el número 3')
දිගටම
එය ලූපයේ ඊළඟ අංගයට යාමට අපව පොළඹවයි.
numeros = [1, 2, 4, 3, 5, 8, 6]
for n in numeros:
if n == 3:
continue
else:
print('No se encontró el número 3')
https://j2logo.com/bucle-for-en-python/
වෙනත් ... සඳහා
For වලින් ව්‍යුත්පන්න වූ ව්‍යුහයක් ඇත, එය වෙනත් ...
datos = [1, 2, 3, 4, 5]
for n in datos:
if n == 2:
break
else:
print('No hay 2')
මෙම ව්‍යුහය ඇති වූයේ එය අවශ්ය බවත් බොහෝ අය මෙය සාක්ෂාත් කර ගැනීම සඳහා විකල්ප මාර්ග භාවිතා කරන බවත් දැකීමෙන් පසුවය. මේ අනුව, ඔවුන් මිනිසුන්ට උපකාර කරන අතර වඩාත් කියවිය හැකි කේතයක් ලබා ගනී
සඳහා _ පුනරාවර්තනය
මම මේක සමහර වැඩසටහන් වල දැකල තියෙනව මම කවදාවත් පාවිච්චි කරල නැති උනත්.
අපි වස්තුවක්, ලැයිස්තුවක්, ශබ්දකෝෂයක් යනාදිය පුනරුච්චාරණය කරන විට, නමුත් එම මූලද්‍රව්‍යවල අන්තර්ගතය අපට උනන්දුවක් නොදක්වන විට, අපට එය _ සමඟ දැක්විය හැක
උදාහරණයක්:
අපට ලැයිස්තුවක මූලද්‍රව්‍ය ගණන් කිරීමට අවශ්ය නමුත් එහි අඩංගු දේ අපට ප්‍රශ්නයක් නොවේ, අපට අවශ්ය වන්නේ එහි දිග පමණි.
h2=[ 'Valencia', 'Castellón', 'Alicante']
count = 0
for _ in h2:
cont += 1
බොහෝ වෙබ් අඩවි වල මෙම පුරුද්ද අනිසි ලෙස භාවිතා නොකරන ලෙස ඔවුන් නිර්දේශ කරයි. මම ඇත්තටම එය ඉදිරිපත් කරන වාසි දන්නේ නැහැ, එය වේගවත්ද?
එය Harvard Introduction to Python පාඨමාලාවේ නිර්දේශ කර ඇත. අපි variable එකක් උඩින් iterate කරද්දි ඒක පාවිච්චි කරන්න යන්නෙ නැති උනාම undescore එක දානවා, ඒ අය එතන කමෙන්ට් කරන නිසා තමයි Pythonic, Python practice එකක් වෙන භාෂා වල දකින්නෙ නැති එක, ඒක කියවීමට උදව් වෙන්නේ නැතුව ඉන්න එක. එය කුමක් සඳහා දැයි දැනුවත්.
පසුපසට ලූප කිරීම
ලූප් සඳහා පසුපසට. අවසානය සිට ආරම්භය දක්වා පුනරාවර්තනය කිරීමට
එය python 3 හි හඳුන්වා දී ඇති ප්‍රතිලෝම () ශ්‍රිතය භාවිතා කරයි
h2=[ 'Valencia', 'Castellón', 'Alicante']
for j in reversed(h2):
print (j)
දර්ශක දෙකකින් ලූප කිරීම, පුනරාවර්තනය කළ හැකි අගය සහ දර්ශකය
Enumerate() සමඟින් අපට එකතුවක දර්ශක සමඟ වැඩ කළ හැක. මක්නිසාද යත්, බොහෝ වාරයක්, පුනරාවර්තනය කළ හැකි වස්තුවේ වටිනාකමට අමතරව, අපි එහි දර්ශකය ගැන උනන්දු වෙමු.
h2=[ 'Valencia', 'Castellón', 'Alicante']
for j, h in enumerate(h2):
print j, '-->', h2[i]
ලැයිස්තු 2කට වඩා පුනරාවර්තනය වේ
තවත් ඉතා රසවත් විකල්පයක් වන්නේ zip() අපගේ කාර්යය පහසු කරවන අතර අපගේ කේතය සරල සහ වඩාත් කියවිය හැකි වනු ඇත.
h2=[ 'Valencia', 'Castellón', 'Alicante']
cod=[100, 200, 300]
for j, h in zip(h2, cod):
print h2, '-->', cod
Python 2.x izip() හි මෙම ශ්‍රිතය වැඩි දියුණු කිරීම සඳහා භාවිතා කරන ලදී, නමුත් Python 3 හි izip යනු zip()
අනුපිළිවෙලට ලූප කිරීම
වස්තුවේ දර්ශකය වෙනුවට එහි අගය අනුව අනුපිළිවෙලට පුනරාවර්තනය කරන්න. sorted() භාවිතා වේ
colors = ['rojo', 'amarillo', 'verde']
for color in sorted(colors):
print color
සහ අපට එය පසුපසට කිරීමට අවශ්ය නම්
colors = ['rojo', 'amarillo', 'verde']
for color in sorted(colors, reverse=True):
print color
අභිරුචි අනුපිළිවෙල
colors = ['rojo', 'amarillo', 'verde']
for color in sorted(colors, key=len):
print color
ලූප් සඳහා සෙන්ටිනල් අගය
සෙන්ටිනල් අගය යනු ලූපය අවසන් වීමට හේතු වන අගයකි. එය සාමාන්‍යයෙන් කෙටි ලූපයකින් ඉදිරිපත් කෙරේ, නමුත් Raymond Hetinger අපට එය for a සමඟ භාවිතා කරන ආකාරය පෙන්වා දෙයි, එය වේගවත් වේ.
blocks = []
for block in iter(partial(f.read, 32), ''):
blocks.append(block)
print (block)
සඳහා ශබ්ද කෝෂ ගමන් කරන්න
ශබ්ද කෝෂ යනු සබඳතා ප්‍රකාශ කිරීමට සහ කණ්ඩායම් සෑදීමට අත්‍යවශ්‍ය මෙවලම් වේ.
ඔබට සාම්ප්‍රදායික ආකාරයෙන් ශබ්ද කෝෂය හරහා යා හැකිය, නමුත් එමඟින් සියලු තොරතුරු ආපසු ලබා නොදෙනු ඇත, අපි කවුන්ටර සහ අනෙකුත් අංග එකතු කිරීම ආරම්භ නොකරන්නේ නම්, අපට මෙවැනි අගයන් සහ දර්ශක සමඟ වැඩ කිරීමට නොහැකි වනු ඇත.
d = {'casa': 'azul', 'coche': 'rojo', 'hombre': 'verde'}
for k in d.keys():
if k.startswith('r'):
del d[k]
මේ ආකාරයට, මූලද්‍රව්‍ය දැකීමට අමතරව, for loop පුනරාවර්තනය වන අවස්ථාවේදීම මූලද්‍රව්‍ය වෙනස් කිරීමෙන් හෝ ඒවා මකා දැමීමෙන් අපට ශබ්දකෝෂය වෙනස් කළ හැකිය.
d.keys() විසින් තර්ක කැඳවා එය අපට වෙනස් කළ හැකි ලැයිස්තුවක ගබඩා කරන පිටපතක් සාදයි.
සාම්ප්‍රදායික දෙයක් වෙනුවට දර්ශක සහ අගයන් ලබා ගැනීම සහ ක්‍රමලේඛනය ආරම්භ කරන අප වැනි අයට මතකයට එන පළමු දෙය එයයි.
for k in d:
print k, '-->', d[k]
අපි මෙම වඩාත් වේගවත් විකල්පය භාවිතා කරන්නෙමු
for k, v in d.items():
print k, '-->', v
අයිතම () වලට වඩා අයිතම ()
Raymond Hetinger විසින් Python හි Loops ගැන කතා කරන්න
එය පැරණි නමුත් ඉතා නිදර්ශන වීඩියෝවක් වන අතර, පළමු මිනිත්තු 20 තුළ Raymond Hetinger අපට Python හි ලූපවල විවිධ හැකියාවන් උගන්වා, ලූපය වඩාත් කියවිය හැකි සහ සරල කිරීම සඳහා මිනිසුන් විසින් බහුලව භාවිතා කරන ව්‍යුහයන් ශ්‍රිත බවට පරිවර්තනය කරන ආකාරය පිළිබඳ උදාහරණ සපයයි. කේතය.
