පයිතන් හි ලූප් වේ. එය ක්රියා කරන ආකාරය, භාවිතය සඳහා උදාහරණ

Loops යනු ඕනෑම භාෂාවක ප්‍රධාන මෙවලම් වලින් එකකි. Python හි මූලික ලූප දෙකක් ඇත, ඉන් එකක් while වේ. එය සලකා බලන්න, පින්තූරය පිළිබඳ වඩා හොඳ අවබෝධයක් සඳහා තවත් එකක්. ඇත්ත වශයෙන්ම, සමාන දෙයක් සමඟ සසඳන විට, ඕනෑම ද්රව්යයක් තේරුම් ගැනීම වඩා පහසුයි, එසේ නොවේ ද?

චක්රය පිළිබඳ සංකල්පය

යම් ක්‍රියාවක් කිහිප වතාවක් සිදු කිරීමට අවශ්‍ය වූ විට ලූපයක් අවශ්‍ය වේ. මෙය ඉතා සරල ය, මන්ද යථාර්ථයේ දී චක්‍ර සඳහා වන යෙදුම් පරාසය වඩා පුළුල් ය. Python හි ප්‍රධාන ලූප වර්ග දෙකක් ඇත: සඳහා සහ කාලය. සඳහා වඩාත් ජනප්රිය වේ.

නිශ්චිත ක්‍රියා වලට අමතරව, ඔබට නිශ්චිත ලක්ෂ්‍යයක් දක්වා විවිධ කේත කැබලි ලූප් කළ හැකිය. මෙය නිශ්චිත වාර ගණනක් හෝ යම් කොන්දේසියක් සත්‍ය වන තාක් විය හැක.

අපි ලූප වර්ග තේරුම් ගැනීමට පෙර සහ විශේෂයෙන්ම, පුනරාවර්තනය යනු කුමක්දැයි අප තවමත් තේරුම් ගත යුතුය. මෙය වත්මන් යෙදුම් ධාවනය තුළ වත්මන් චක්‍රය තුළ ක්‍රියාවක හෝ ක්‍රියා අනුපිළිවෙලක එක් පුනරාවර්තනයකි.

සඳහා චක්රය

අපගේ For loop වෙනත් බොහෝ භාෂා වල මෙන් කවුන්ටරයක් ​​නොවේ. එහි කාර්යය වන්නේ යම් අගයන් අනුපිළිවෙලක් ගණනය කිරීමයි. මෙමගින් කුමක් වෙයිද? අපි හිතමු අපිට මුලද්‍රව්‍ය ලැයිස්තුවක් තියෙනවා කියලා. පළමුව, ලූපය පළමු, දෙවන, තෙවන, ආදිය ගනී.

Python හි මෙම ලූපයේ ඇති වාසිය නම් ලූපයෙන් පිටවිය යුත්තේ කවදාදැයි දැන ගැනීමට මූලද්‍රව්‍යයේ දර්ශකය තීරණය කිරීමට අවශ්‍ය නොවීමයි. සෑම දෙයක්ම ස්වයංක්රීයව සිදුවනු ඇත.

>>> spisok = [10, 40, 20, 30]

>>> spisok හි මූලද්‍රව්‍ය සඳහා:

… මුද්‍රණය (මූලද්‍රව්‍යය + 2)

...

12

42

22

32

අපගේ උදාහරණයේ දී, අපි විචල්යය භාවිතා කළෙමු මූලද්රව්යය for විධානයෙන් පසුව. පොදුවේ, නම ඕනෑම දෙයක් විය හැකිය. උදාහරණයක් ලෙස, ජනප්‍රිය තනතුරක් වන්නේ i. තවද එක් එක් පුනරාවර්තනය සමඟ, මෙම විචල්‍යයට ලැයිස්තුවෙන් නිශ්චිත වස්තුවක් පවරනු ලැබේ, එය අපි සුදුසු වචනය ලෙස හැඳින්වුවෙමු.

අපගේ නඩුවේදී, ලැයිස්තුව අංක 10,40,20,30 අනුපිළිවෙලකි. සෑම පුනරාවර්තනයකදීම, අනුරූප අගය විචල්‍යයේ දිස්වේ. උදාහරණයක් ලෙස, ලූපය ආරම්භ වූ වහාම, විචල්යය මූලද්රව්යය අගය 10 පවරා ඇත. ඊළඟ පුනරාවර්තනයේදී, දහය අංක 40 බවටත්, තුන්වන වරට එය අංක 20 බවටත්, අවසානයේ, ලූපයේ අවසාන පුනරාවර්තනයේදී එය 30 බවටත් හැරේ.

චක්රයේ අවසානය සඳහා සංඥාව ලැයිස්තුවේ මූලද්රව්යවල අවසානය වේ.

අනෙකුත් ක්‍රමලේඛන භාෂා වල මෙන් සම්භාව්‍ය අගයන් ගණනය කිරීමක් සිදු කිරීමට ඔබට ලූපය අවශ්‍ය නම්, ඔබ අපට අවශ්‍ය අගය දක්වා ස්වභාවික සංඛ්‍යා අනුපිළිවෙලක් සහිත ලැයිස්තුවක් සෑදිය යුතුය.

>>> spisok = [1,2,3,4,5]

නැතහොත් කාර්යය භාවිතා කරන්න ලෙන්(), ලැයිස්තුවේ දිග තීරණය කිරීමට. නමුත් මෙම නඩුවේදී ලූපයක් භාවිතා කිරීම වඩා හොඳය අතර, මොකද variable එකක් පාවිච්චි කරන්න ඕන නෑ.

ඔබට ලැයිස්තුවේ ඇති අගයන් අනුපිළිවෙල වෙනස් කිරීමට අවශ්‍ය නම්, ලූප් කරන්න සදහා සහ මෙන්න ගලවා ගැනීමට පැමිණේ. මෙය සිදු කිරීම සඳහා, එක් එක් පුනරාවර්තනයකදී, ලැයිස්තුවේ සෑම අංගයකටම සුදුසු අගයක් පැවරිය යුතුය.

ලූප් අතර

චක්රය මෙන් නොව සදහා, එය අනුපිළිවෙලෙහි අගයන්, ලූපය මත සරලව පුනරාවර්තනය වේ අතර වැඩි භාවිතයන් ඇත. මෙම වර්ගයේ චක්රවල නම "තවමත්" ලෙස පරිවර්තනය කර ඇත. එනම්, "තෙක්".

මෙය සියලුම ක්‍රමලේඛන භාෂා වල දක්නට ලැබෙන විශ්ව ලූපයකි. සහ සමහර ආකාරවලින් එය කොන්දේසි සහිත ක්රියාකරුට සමාන වේ ඔව්, යම් කොන්දේසියක් සපුරා ඇත්දැයි පරීක්ෂා කිරීම සිදු කරයි. කොන්දේසි සහිත ක්‍රියාකරුට ප්‍රතිවිරුද්ධව පමණි, අතර එක් වරක් පමණක් නොව, එක් එක් පුනරාවර්තනයකදී චෙක්පත සිදු කරයි. කොන්දේසිය අසත්‍ය නම් පමණක්, ලූපය අවසන් වන අතර එය අනුගමනය කරන විධානය ක්‍රියාත්මක වේ. සරල වචන වලින්, ඔහු වැඩ කරන තත්වය තවදුරටත් වලංගු නොවේ නම්.

අපි චක්රයක් අඳින්න නම් අතර සරලව, මෙය සිදු කරනු ලබන්නේ එවැනි යෝජනා ක්රමයක් භාවිතා කරමිනි.

වැඩසටහනේ ප්රධාන ශාඛාව (ලූපයෙන් පිටත ධාවනය වන) නිල් සෘජුකෝණාස්රාකාර මෙම රූපයේ දැක්වේ. ටර්කියුයිස් චක්රයේ ශරීරය නියෝජනය කරයි. අනෙක් අතට, රොම්බස් යනු එක් එක් පුනරාවර්තනයකදී පරීක්ෂා කරනු ලබන කොන්දේසියකි.

චක්රය අතර ව්යතිරේක දෙකක් ඇති විය හැක:

1. ලූපයේ ආරම්භයේදී තාර්කික ප්‍රකාශනය සත්‍ය බවට පත් නොවන්නේ නම්, එය ක්‍රියාත්මක කිරීමට පෙර සම්පූර්ණ කිරීමෙන් පසුව එය සරලව ආරම්භ නොවේ. පොදුවේ ගත් කල, මෙම තත්වය සාමාන්‍ය ය, මන්ද යම් යම් තත්වයන් යටතේ, ලූප් ශරීරයේ ප්‍රකාශන තිබීම සඳහා යෙදුම ලබා නොදේ.
2. ප්රකාශනය සැමවිටම සත්ය නම්, මෙය ලූපයකට තුඩු දිය හැකිය. එනම්, චක්රයේ නිමක් නැති අනුචලනය වෙත. එබැවින්, එවැනි වැඩසටහන් වලදී, ලූපයෙන් හෝ වැඩසටහනෙන් පිටවීමේ ප්රකාශයක් සෑම විටම තිබිය යුතුය. කෙසේ වෙතත්, යම් කොන්දේසියක සත්‍ය අසත්‍යතාවය තීරණය කිරීමට වැඩසටහනට හැකි වූයේ නම් මෙම තත්වය පැන නගී. ඇය මෙය කිරීමට අපොහොසත් වූවා නම්, වැඩසටහන අවසන් කිරීමත් සමඟ දෝෂයක් නැවත පැමිණේ. නැතහොත් ඔබට දෝෂය හැසිරවිය හැකි අතර, එය සිදු වුවහොත්, යම් කේතයක් ක්රියාත්මක වේ.

දෝෂයක් හසුරුවන්නේ කෙසේද යන්න සඳහා විශාල විකල්ප ගණනාවක් තිබිය හැකිය. උදාහරණයක් ලෙස, වැඩසටහන නිවැරදිව දත්ත ඇතුළත් කිරීමට පරිශීලකයාගෙන් ඉල්ලා සිටිය හැක. එබැවින්, පුද්ගලයෙකු ධනාත්මක විය හැකි සෘණ අංකයක් සඳහන් කළහොත් හෝ අංක පමණක් තිබිය යුතු අකුරු ඇතුළත් කළහොත්, වැඩසටහනට ඒ ගැන පැවසිය හැකිය.

ලූප් උදාහරණ

මෙම නඩුවේ දෝෂයක් හසුරුවන කේතයේ උදාහරණයක් මෙන්න.

n = ආදානය ("පූර්ණ සංඛ්‍යාවක් ඇතුලත් කරන්න:") 

while type(n) != int:

    උත්සාහ කරන්න:

        n = int(n)

    අගය දෝෂය හැර:

        මුද්‍රණය ("වැරදි ඇතුල්වීම!")

        n = ආදානය ("පූර්ණ සංඛ්‍යාවක් ඇතුලත් කරන්න:") 

n % 2 == 0 නම්:

    මුද්‍රණය ("පවා")

වෙනත්:

    මුද්‍රණය ("ඔත්තේ")

Python විසින් සංකීර්ණ කේත නිර්මිතයන් ප්‍රකාශ කිරීමට colon භාවිතා කරන බව මතක තබා ගන්න.

ඉහත කේතයේ, අපි අංකය නිඛිලයක් දැයි පරීක්ෂා කළ යුතු කොන්දේසියක් ලෙස අර්ථ දක්වා ඇත. ඔව් නම්, අසත්‍යය ආපසු එවනු ලැබේ. එසේ නොවේ නම්, ඇත්ත.

කේතයේ දෙවන කොටසෙහි, ක්රියාකරු භාවිතා කරනු ලැබේ if, බෙදීමේ මෙහෙයුමෙන් පසු ඉතිරිය සොයා ගැනීමට අපි % ක්‍රියාකරු භාවිතා කළෙමු. ඊළඟ පියවර වන්නේ අංකය ඉරට්ටේ දැයි පරීක්ෂා කිරීමයි. එසේ නොවේ නම්, මෙම නඩුවේ ඉතිරිය එකකි. ඒ අනුව එම සංඛ්‍යාව ඔත්තේ වේ. 

සරලව කිවහොත්, ඉහත කේතය පළමුව පරිශීලකයා විසින් ඇතුළත් කරන ලද තන්තුව අංකයක් දැයි පරීක්ෂා කරයි. එසේ නම්, දෙකකින් බෙදීමේ ඉතිරියක් තිබේදැයි බැලීමට දෙවන චෙක්පතක් සිදු කෙරේ. නමුත් පරිශීලකයා විසින් ඇතුලත් කරන ලද අගය සංඛ්‍යාත්මක වන තෙක් දෙවන වාරණ ක්‍රියාත්මක නොවේ.

එනම්, තත්වය ඇති වන තුරු ලූපය නිතිපතා ක්රියාත්මක වේ. මෙම තත්වය තුළ, එය මේ ආකාරයෙන් ක්රියා කරයි. 

එනම්, ඔබට ප්‍රතිවිරුද්ධ පැත්තෙන් යා හැකිය: සිදුවීම අසත්‍ය වන තෙක් යම් ක්‍රියාවක් ලූප් කරන්න.

කේත විග්‍රහ කිරීම

දැන් අපි බලමු මෙම කේතය ක්‍රියා කරන ආකාරය වඩාත් විස්තරාත්මකව. මෙය සිදු කිරීම සඳහා, අපි එය පියවරෙන් පියවර විශ්ලේෂණය කරන්නෙමු.

1. පළමුව, පරිශීලකයා n විචල්‍යය මගින් පිළිගනු ලබන තන්තුවකට ඇතුල් වේ. 
2. ලූපයක් භාවිතා කිරීම අතර මෙම විචල්‍යයේ වර්ගය පරීක්ෂා කරනු ලැබේ. පළමු ප්රවේශයේදී එය සමාන නොවේ int. එම නිසා පරීක්ෂණයේ ප්‍රතිඵලයක් ලෙස මෙම තත්ත්වය සත්‍ය බව පෙනී යයි. එබැවින්, ලූප් ශරීරය ඇතුල් වේ.
3. ක්රියාකරුගේ සහාය ඇතිව උත්සාහ අපි තන්තුවක් අංකයකට පරිවර්තනය කිරීමට උත්සාහ කරනවා. මෙය සිදු කරන්නේ නම්, කිසිදු දෝෂයක් සිදු නොවේ. ඒ අනුව, එය සැකසීමට අවශ්ය නොවේ. එමනිසා, පරිවර්තකයා ලූපයේ ආරම්භයට නැවත පැමිණෙන අතර, චෙක්පතේ ප්රතිඵල අනුව, එය පූර්ණ සංඛ්යාවක් බවට පත් වී ඇති බව පෙනී යයි. එහෙනම් අපි 7 වන පියවරට යමු
4. පරිවර්තනය අසාර්ථක නම්, ValueError එකක් දමනු ලැබේ. මෙම අවස්ථාවේදී, වැඩසටහන් ප්රවාහය හැර හසුරුවන්නා වෙත යවනු ලැබේ.
5. පරිශීලකයා නව අගයක් ඇතුල් කරයි, එය n විචල්‍යයට පවරා ඇත.
6. පරිවර්තකයා පියවර 2 වෙත ආපසු ගොස් නැවත පරීක්ෂා කරයි. එය නිඛිල අගයක් නම්, පියවර 7 වෙත යන්න. එසේ නොවේ නම්, පියවර 3 අනුව නැවත පරිවර්තනය කිරීමට උත්සාහ කරයි.
7. ක්රියාකරුගේ සහාය ඇතිව if සංඛ්‍යාවක් 2න් බෙදූ පසු ඉතිරියක් තිබේද යන්න තීරණය කරයි. 
8. එසේ නොවේ නම්, "පවා" යන පාඨය ආපසු ලබා දෙනු ලැබේ.
9. එසේ නොවේ නම්, "ඔත්තේ" යන පාඨය ආපසු ලබා දෙනු ලැබේ.

දැන් එවැනි උදාහරණයක් සලකා බලන්න. මෙම චක්‍රය කොපමණ වාර ගණනක් ගමන් කරයිද යන්න තීරණය කිරීමට උත්සාහ කරන්න?

මුළු = 100 

i = 0

මම <5:

    n = int(input())

    මුළු = මුළු - n

    i = i + 1 

මුද්‍රණය ("ඉතිරි", එකතුව)

නිවැරදි පිළිතුර 5. මුලදී, විචල්‍යයේ අගය i - ශුන්ය. පරිවර්තකයා විචල්‍යය සමාන දැයි පරීක්ෂා කරයි i 4 හෝ ඊට අඩු. ඔව් නම්, අගය ආපසු ලබා දෙනු ලැබේ. සැබෑ, සහ ලූපය ඒ අනුව ක්‍රියාත්මක වේ. අගය එකකින් වැඩි වේ.

පළමු පුනරාවර්තනයෙන් පසුව, විචල්‍යයේ අගය 1 බවට පත් වේ. චෙක්පතක් සිදු කරනු ලබන අතර, මෙම සංඛ්‍යාව නැවතත් 5 ට වඩා අඩු බව වැඩසටහන තේරුම් ගනී. ඒ අනුව, ලූප් බොඩි දෙවන වරටත් ක්‍රියාත්මක වේ. පියවර සමාන බැවින්, අගය ද එකකින් වැඩි වන අතර, විචල්යය දැන් 2 ට සමාන වේ.

මෙම අගය ද පහකට වඩා අඩුය. එවිට ලූපය තුන්වන වරටත් ක්රියාත්මක වේ, විචල්යයට එකතු කරනු ලැබේ i 1 සහ එයට 3 අගය පවරනු ලැබේ. මෙය නැවතත් පහකට වඩා අඩුය. එබැවින් එය විචල්‍යයේ අගය වන ලූපයේ හයවන පුනරාවර්තනයට පැමිණේ i 5 ට සමාන වේ (සියල්ලට පසු, එය මුලින් ශුන්‍ය විය, අපට මතක ඇති පරිදි). ඒ අනුව, මෙම කොන්දේසිය පරීක්ෂණයෙන් සමත් නොවන අතර, ලූපය ස්වයංක්රීයව අවසන් වන අතර, ඉන් පිටත (හෝ පහත සඳහන් පියවරයන් සපයා නොමැති නම්, වැඩසටහන අවසන් කිරීම) ඊළඟ පියවර වෙත සංක්රමණය කිරීම සිදු කරනු ලැබේ.

චක්රය ප්රතිවිරුද්ධ දිශාවට ද සිදු විය හැක. එක් එක් පසු පුනරාවර්තනය සමඟ, විචල්‍යයේ වත්මන් අගයෙන් එකක් අඩු කරන කේතයේ උදාහරණයක් මෙන්න. 

මුළු = 100 

මුළු > 0 අතර:

    n = int(input())

    මුළු = මුළු - n 

මුද්‍රණය (“සම්පත් ඉවරයි”)

මෙම වැඩසටහන කරන්නේ කුමක්දැයි අනුමාන කිරීමට උත්සාහ කරන්න! එය විචල්‍යයකින් යැයි සිතන්න මුළු වැඩසටහන් සම්පත පිළිබඳ තොරතුරු ගබඩා කර ඇත. සෑම අවස්ථාවකදීම පරිවර්තකයා සම්පත තිබේදැයි පරීක්ෂා කරයි. එසේ නොවේ නම්, "සම්පත් අවසන්" යන පාඨය දර්ශනය වන අතර වැඩසටහන වසා දමයි. ලූපයේ සෑම පුනරාවර්තනයක් සමඟම, පරිශීලකයා සඳහන් කරන සංඛ්‍යාවෙන් සම්පත අඩු වේ.

දැන් ගෙදර වැඩ. ඉහත කේතය වෙනස් කිරීමට උත්සාහ කරන්න එවිට විචල්‍යය භෞතිකව ඍණ විය නොහැක.