Python හි අනුයාත ක්රියාවලිය
ප්රෝග්රෑමින් කිරීමේ දී, ශ්රිතයක් තමන්වම අමතන විට අනුයාත ක්රියාවලිය යන සංකල්පය පවතී.
උදාහරණය . ගණන් කරනයක් සහිත සරල අනුයාත ක්රියාවලිය
අනුයාත ක්රියාවලියක් භාවිතයෙන් අංක
1 සිට 10 දක්වා මුද්රණය කරමු:
i = 1
def func():
global i
print(i)
i += 1
if i <= 10:
func() # මෙහිදී ශ්රිතය තමන්වම අමතයි
func()
මෙම කේතය ක්රියාත්මක වන ආකාරය සාකච්ඡා කරමු.
අපට ගෝලීය විචල්යය i
සහ ශ්රිතය func ඇත, එහි ඇතුළත
විචල්යයේ අන්තර්ගතය
i කොන්සෝලයට මුද්රණය වන අතර පසුව එයට
එකක් එකතු කරනු ලැබේ.
අපගේ විචල්යය i අඩු හෝ
සමාන නම් 10, ශ්රිතය
නැවත ක්රියාත්මක වේ. විචල්යය i
ගෝලීය වන නිසා, සෑම නව ශ්රිත ක්රියාකාරීත්වයකදීම
පෙර ක්රියාකාරීත්වයේ දී
තබන ලද විචල්ය අගය i එහි පවතිනු ඇත.
i වන තෙක් ශ්රිතය තමන්වම
අමතමින් පවතිනු ඇත
වැඩි 10.
මෙම අවස්ථාවේ දී, ශ්රිතය
if නොමැතිව ක්රියාත්මක කළ නොහැකි බව සලකන්න
- මෙය කළහොත්,
අනන්ත ශ්රිත කැඳවීම් පෙළක් ලැබෙනු ඇත.
උදාහරණය . අන්තර්ගත ලැයිස්තුවල මූලද්රව්ය මුද්රණය කිරීම සඳහා අනුයාත ක්රියාවලිය
විවිධ මට්ටම්වල අන්තර්ගතය සහිත ලැයිස්තු හරස් කිරීම සඳහා අනුයාත ක්රියාවලි බහුලව භාවිතා වේ. අපට පහත ලැයිස්තුව ඇතැයි සිතමු:
lst = [1, [2, 3], [[4, 5], [6, 7, 8, [9]]]]
එය හරස් කරන ශ්රිතයක් සාදමු.
එහිදී පළමුව කොන්දේසියක් සකස් කළ යුතු අතර,
මූලික මූලද්රව්යයක් වන,
එනම් ලැයිස්තුවෙන් සරලව ගත් අංකය,
කොන්සෝලයට මුද්රණය වේ.
මූලද්රව්යය වස්තුවක් වන අවස්ථාවක,
උදාහරණයක් ලෙස, අන්තර්ගත ලැයිස්තුවක්, එවිට
මෙම අවස්ථාවේ දී ශ්රිතය තමන්වම
අමතමින්, එනම් අනුයාත ක්රියාවලියක් සිදු වේ.
මූලද්රව්යයේ වර්ගය පරීක්ෂා කිරීම සඳහා isinstance ශ්රිතය
භාවිතා කරමු.
අපගේ උදාහරණය සඳහා පළමු පරාමිතියේ
isinstance වෙත el ලියන්න, සහ
දෙවනුව - වර්ගය list:
def func(lst):
for el in lst:
if isinstance(el, list):
func(el)
else:
print(el)
ශ්රිතය ක්රියා කරන විට අන්තර්ගත ලැයිස්තුවෙන් සියලුම අංක පෙළක් මුද්රණය වේ:
func(lst) # 1, 2, ... 8, 9 මුද්රණය කරයි
උදාහරණය . අන්තර්ගත ලැයිස්තුවල මූලද්රව්ය සමඟ ක්රියා කිරීම සඳහා අනුයාත ක්රියාවලිය
විවිධ මට්ටම්වල අන්තර්ගතය සහිත ලැයිස්තු වල මූලද්රව්ය සමඟ ක්රියා කිරීම සඳහා අනුයාත ක්රියාවලි ද භාවිතා කළ හැකිය. අපට පහත ලැයිස්තුව ඇතැයි සිතමු:
lst = [1, [2, 3], [[4, 5], [6, 7, 8, [9]]]]
එහි සියලුම මූලද්රව්යවල එකතුව ලබා ගනිමු.
මේ සඳහා ශ්රිතය තුළ විචල්යය res ප්රකාශ කරමු,
එහි අංකවල එකතුව රැස් වේ.
කොන්දේසිය තුළ අපි ලියන්නෙමු, මූලද්රව්යය
සංකීර්ණ වස්තුවක් නම්, එය
ශ්රිත පරාමිතියට func සහ එකතුවට එකතු වේ
එකතුවට.
මෙයින් අදහස් කරන්නේ මූලද්රව්යය
ශ්රිතයේ පරාමිතියේ func පවතින අතර එකතු වේ
මූලික මූලද්රව්යයක් නොවන තෙක් අනුයාත ක්රියාවලියේ පවතිනු ඇති බවයි.
මෙම අවස්ථාවේ දී එය සරලව
වෙත ලියා ඇති එකතුවට එකතු වේ res:
def func(lst):
res = 0
for el in lst:
if isinstance(el, list):
res += func(el)
else:
res += el
return res
ශ්රිතය ක්රියා කර එහි ප්රතිඵලය කොන්සෝලයට මුද්රණය කරමු:
print(func(lst)) # 45 මුද්රණය කරයි
උදාහරණය . ලැයිස්තුවකට රැස් කිරීම සඳහා අනුයාත ක්රියාවලිය
අනුයාත ක්රියාවලිය භාවිතයෙන් අන්තර්ගත ලැයිස්තු එක් එක් මාන ලැයිස්තුවකට වියෝජනය කළ හැකිය. අපට පහත ලැයිස්තුව ඇතැයි සිතමු:
lst = [1, [2, 3], [[4, 5], [6, 7, 8, [9]]]]
ශ්රිතය තුළ හිස් ලැයිස්තුවක්
res ලියමු, එයට මුල් ලැයිස්තුවේ
මූලද්රව්ය රැස් වේ.
පසුව අපි චක්රයක් ආරම්භ කර කොන්දේසියක් සකසන්නෙමු - මූලද්රව්යය
ලැයිස්තුවක් නම්, එය ක්රමයට වැටේ
extend.
මෙම ක්රමය එක් ලැයිස්තුවක මූලද්රව්ය දෙවන
ලැයිස්තුවේ කෙළවරට අමුණයි,
එනම් අන්තර්ගත ලැයිස්තුවේ
මූලද්රව්ය res ලැයිස්තුවේ කෙළවරට වැටේ:
def func(lst):
res = []
for el in lst:
if isinstance(el, list):
res.extend(func(el))
else:
res.append(el)
return res
print(func(lst))
ක්රියාත්මක කරන ලද කේතයේ ප්රතිඵලය:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
ප්රායෝගික කාර්යයන්
අත්තනෝමතික මට්ටමේ අන්තර්ගතය සහිත ශබ්දකෝෂයේ සියලුම සංඛ්යාත්මක මූලද්රව්ය මුද්රණය කරන්න:
{
'a': {
'b': 1,
'c': 2,
'd': {
'e': 3,
'f': 4
}
},
'j': {
'h': 5,
'k': 6,
},
'l': 7
}
පෙර කාර්යයේ ශබ්දකෝෂ මූලද්රව්යවල එකතුව සොයන්න.
පෙර කාර්යයේ ශබ්දකෝෂයේ මූලික මූලද්රව්ය ලැයිස්තුවක් ලබා ගන්න.
