python හි loop සඳහා. වාක්‍ය ඛණ්ඩය, ලැයිස්තු පුනරාවර්තනය, බිඳීම, දිගටම සහ අනෙකුත් විශේෂාංග

Цpython i සඳහා ikl චක්රය අතරතුර - ප්රකාශයන් මෘදුකාංග භාෂාව, එනම්: පුනරාවර්තන ක්රියාකරුවන්, ඉඩ දෙන්නආර් නැවත කේතය ලබා දී ඇති අංකය කාලය.

Цහෝ සඳහා - сintaxis

දැනටමත් පැහැදිලි කර ඇති පරිදි, සීපයිතන් සඳහා ඇතුළත් කිරීම පදනම් වූ පුනරාවර්තකයකිй චක්රයකටඅනන්යතාවය. ඔහු ය ක්රියා ටුපල් මූලද්රව්ය මගින් и ලැයිස්තුව, වචන මාලාව යතුරු සහ අනික් නැවත කළ හැකි වස්තූන්.

Python හි ලූපයක් ආරම්භ වන්නේ for keyword වලින් වන අතර, පසුව ලබා දී ඇති අනුපිළිවෙලෙහි ඊළඟ වස්තුවේ අගය ගබඩා කරන අත්තනෝමතික විචල්‍ය නාමයකින්. python හි… සඳහා සාමාන්‍ය වාක්‍ය ඛණ්ඩය මේ ආකාරයට පෙනේ:

සඳහා: else:      

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

නිශ්චිත උදාහරණයක් සමඟ Python හි ලූප් සඳහා සරල:

>>> භාෂා = ["C", "C++", "Perl", "Python"] >>> භාෂාවලින් x සඳහා: ... print(x) ... C C++ Perl Python >>>

අනෙක් කොටස විශේෂයිth. අ වැඩසටහන් සම්පාදකයාыවැඩ с පර්ල් හුරුපුරුදුයы ඔහු සමග, එම අන්තර් ක්රියා කරන අය සඳහා с C සහ C++ — මෙය නවෝත්පාදනයකි. අර්ථමය වශයෙන් එය කාර්යයන් тසමානව ලූප අතර.

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

පයිතන් හි ක්‍රියාකරු බිඳ දමන්න - බිඳ දමන්න

වැඩසටහනට for loop එකක් තිබේ නම් අවශ්යයි බාධා කරන්නඑම විරාම ප්රකාශය, he සම්පූර්ණඒක යනවාසහ වැඩසටහන ගලනවා ඇත දිගටමවිය තොරව සක්රිය කිරීම වෙනත් අයගෙන්.

බොහෝ විට python හි වාක්‍ය ඛණ්ඩ බිඳ දමන්නuyutsya කොන්දේසි සහිත ප්රකාශයන් සමඟ.

ආහාරයට ගත හැකි දේ = ["චොප්ස්", "ඩම්ප්ලිං", "බිත්තර", "ගෙඩි"] ආහාරයට ගතහැකි ආහාර සඳහා: ආහාර නම් == "ඩම්ප්ලිං": මුද්‍රණය ("මම ඩම්ප්ලිං කන්නේ නැහැ!") මුද්‍රණය කඩන්න("නියමයි, රසවත් " + කෑම) වෙනත්: මුද්‍රණය ("ඩම්ප්ලිං නොතිබීම හොඳයි!") මුද්‍රණය("රාත්‍රී ආහාරය අවසන්.")

ඔබ මෙම කේතය ධාවනය කරන්නේ නම්, ඔබට පහත ප්‍රතිඵලය ලැබේ:

නියම, රසවත් චොප්සි. මම ඩම්ප්ලිං කන්නේ නැහැ! රෑ කෑම ඉවරයි.

අපි පවතින දත්ත ලැයිස්තුවෙන් "ඩම්ප්ලිං" ඉවත් කර ලබා ගනිමු:

විශිෂ්ට, රසවත් චොප්ස් විශිෂ්ට, රසවත් බිත්තර විශිෂ්ට, රසවත් ඇට වර්ග හොඳ දෙයක් ඩම්ප්ලිං තිබුණේ නැහැ! රෑ කෑම ඉවරයි.

python skip operator - දිගටම කරගෙන යන්න

එවැනි නිෂ්පාදන සඳහා පරිශීලකයාගේ විරෝධය ඔවුන්ගේ පරිභෝජනය සම්පූර්ණයෙන්ම අත්හැර දැමීමට තරම් විශාල නොවන බව කියමු. එහි ප්රතිඵලයක් වශයෙන්, ලූපය ක්රියාකරු සමඟ දිගටම පවතී continue. පහත ස්ක්‍රිප්ට් එක ප්‍රකාශය භාවිතා කරයි continue, "ඩම්ප්ලිං සම්බන්ධතා" මත ලැයිස්තුව හරහා නැවත නැවත කිරීමට.

edibles = ["චොප්ස්", "ඩම්ප්ලිං", "බිත්තර", "ගෙඩි"] ආහාරයට ගතහැකි ආහාර සඳහා: ආහාර නම් == "ඩම්ප්ලිං": මුද්‍රණය ("මම ඩම්ප්ලිං කන්නේ නැහැ!") දිගටම මුද්‍රණය කරන්න("නියමයි, රසවත් " + ආහාර) # මෙය ආහාර රස විඳීමේ කේතය විය හැකිය :-) වෙනත්: මුද්‍රණය("මම ඩම්ප්ලිං වලට වෛර කරනවා!") මුද්‍රණය("රාත්‍රී ආහාරය අවසන්.")

නිගමනය:

නියම, රසවත් චොප්සි. මම ඩම්ප්ලිං කන්නේ නැහැ! විශිෂ්ට, රසවත් බිත්තර විශිෂ්ට, රසවත් ඇට වර්ග මම ඩම්ප්ලිං වලට වෛර කරනවා! රෑ කෑම ඉවරයි.

පරාසය() ශ්‍රිතය සමඟ ලැයිස්තු හරහා පුනරාවර්තනය කිරීම

ඔබට ලැයිස්තුවක දර්ශක වෙත ප්‍රවේශ වීමට අවශ්‍ය නම්, මෙම කාර්යය සඳහා for loop එකක් භාවිතා කරන්නේ කෙසේද යන්න පැහැදිලි නැත. සියලුම මූලද්‍රව්‍ය වෙත ප්‍රවේශ විය හැකි නමුත්, මූලද්‍රව්‍යයේ දර්ශකය ප්‍රවේශ විය නොහැකි වනු ඇත. කෙසේ වෙතත්, මූලද්‍රව්‍යයේ දර්ශකය සහ මූලද්‍රව්‍යය යන දෙකටම ප්‍රවේශ වීමට ක්‍රමයක් තිබේ. මෙම කාර්යය සඳහා, කාර්යය භාවිතා වේ range() දිග ශ්රිතය සමඟ ඒකාබද්ධ වේ len():

fibonacci = [0,1,1,2,3,5,8,13,21] i සඳහා පරාසයක (len(fibonacci)): print(i,fibonacci[i])

ලබා ගන්න:

0 0 1 1 2 1 3 2 4 3 5 5 6 8 7 13 8 21

අවධානය! අයදුම් කළ විට len() к list or tuple, ලබා දී ඇති අනුපිළිවෙලෙහි අනුරූප මූලද්රව්ය සංඛ්යාව ලබා ගනී.

ලැයිස්තු මත පුනරුච්චාරණය කිරීමේ දුෂ්කරතා

ලැයිස්තුවක් මත පුනරාවර්තනය කරන විට, ලූප් බොඩි තුළ ලැයිස්තු ගතිකත්වය වළක්වා ගැනීම නිර්දේශ කෙරේ. පැහැදිලිකම සඳහා, අපට පහත විකල්පය ඉදිරිපත් කළ හැකිය:

වර්ණ = ["රතු"] සඳහා i සඳහා වර්ණ: i == "රතු" නම්: වර්ණ += ["කළු"] i == "කළු" නම්: වර්ණ += ["සුදු"] මුද්‍රණය (වර්ණ)

අයදුම් කිරීමේදී සිදු වන දේ print(colours)?

['රතු', 'කළු', 'සුදු']

මෙය වලක්වා ගැනීම සඳහා, පහත උදාහරණයේ මෙන්, පෙති භාවිතයෙන් පිටපත සමඟ අන්තර් ක්‍රියා කිරීම රෙකමදාරු කරනු ලැබේ:

වර්ණ = ["රතු"] සඳහා i සඳහා වර්ණ[:]: i == "රතු" නම්: වර්ණ += ["කළු"] නම් i == "කළු": වර්ණ += ["සුදු"] මුද්‍රණය (වර්ණ )

ප්රතිඵලය:

['රතු කළු']

ලැයිස්තුව වෙනස් කර ඇත colours, නමුත් මෙම ක්‍රියාව ලූපයට බලපෑවේ නැත. ලූපය ක්‍රියාත්මක කිරීමේදී පුනරාවර්තනය කිරීමට අවශ්‍ය දත්ත නොවෙනස්ව පැවතුනි.

python 3 හි ගණන් කරන්න

Enumerate යනු බිල්ට් පයිතන් ශ්‍රිතයකි. බොහෝ ආරම්භකයින් මෙන්ම සමහර පළපුරුදු ක්‍රමලේඛකයින් එහි පැවැත්ම ගැන නොදනිති. ලූපයේ පුනරාවර්තන ස්වයංක්‍රීයව ගණනය කිරීමට එය ඔබට ඉඩ සලසයි. උදාහරණ වශයෙන්:

කවුන්ටරය සඳහා, ගණන් කිරීමේ අගය (සමහර_ලැයිස්තුව): මුද්‍රණය (කවුන්ටරය, අගය)

කාර්යයන් enumerate විකල්ප තර්කයක් ද ගනී (සම්භවයේ අගය, පෙරනිමියෙන් ගනු ලැබේ 0) එය වඩාත් කාර්යක්ෂම කරයි.

my_list = ['ඇපල්', 'කෙසෙල්', 'චෙරි', 'පීච්'] c සඳහා, ගණන් කිරීමේ අගය(මගේ_ලැයිස්තුව, 1): මුද්‍රණය (c, අගය) # ප්‍රතිඵලය: # 1 ඇපල් # 2 කෙසෙල් # 3 චෙරි # 4 පීච්