මෙම පිළිතුර මුලින් ලියා ඇත්තේ එතැන් සිට අනුපිටපතක් ලෙස සලකුණු කර ඇති ප්‍රශ්නයකට පිළිතුරු වශයෙනි:
පයිතන් ලැයිස්තුවෙන් ඛණ්ඩාංක ඉවත් කිරීම
ඔබගේ කේතයේ ගැටළු දෙකක් තිබේ:
1) ඉවත් කිරීම () භාවිතා කරන විට, ඔබ පූර්ණ සංඛ්‍යාවක් ඉවත් කිරීමට උත්සාහ කරන අතර ඔබට ටුපල් එකක් ඉවත් කිරීමට අවශ්ය වේ.
2) for loop ඔබේ ලැයිස්තුවේ ඇති අයිතම මඟ හරිනු ඇත.
අපි ඔබේ කේතය ක්රියාත්මක කරන විට කුමක් සිදුවේදැයි බලමු:
>>> L1 = [(1,2), (5,6), (-1,-2), (1,-2)]
>>> for (a,b) in L1:
... if a < 0 or b < 0:
... L1.remove(a,b)
...
Traceback (most recent call last):
File "<stdin>", line 3, in <module>
TypeError: remove() takes exactly one argument (2 given)
පළමු ගැටළුව නම් () ඉවත් කිරීම සඳහා ඔබ 'a' සහ 'b' යන දෙකම පසුකර යාමයි, නමුත් ඉවත් කරන්න () පිළිගන්නේ තනි තර්කයක් පමණි. ඔබගේ ලැයිස්තුව සමඟ නිසියාකාරව වැඩ කිරීම සඳහා අපි ඉවත් කිරීම () ලබා ගන්නේ කෙසේද? ඔබගේ ලැයිස්තුවේ එක් එක් අංග මොනවාදැයි අපට සොයා ගැනීමට අවශ්‍යය. මෙම අවස්ථාවේ දී, සෑම එකක්ම ටුපල් ය. මෙය බැලීමට, අපි ලැයිස්තුවේ එක් අංගයකට ප්‍රවේශ වෙමු (සුචිගත කිරීම 0 සිට ආරම්භ වේ):
>>> L1[1]
(5, 6)
>>> type(L1[1])
<type 'tuple'>
ආහා! L1 හි සෑම මූලද්‍රව්‍යයක්ම ඇත්ත වශයෙන්ම ටුපල් ය. () ඉවත් කිරීමට අප සමත් විය යුත්තේ එයයි. පයිතන්හි ටුපල් ඉතා පහසුය, ඒවා හුදෙක් වරහන් තුළ අගයන් ඇතුළත් කිරීමෙන් සෑදී ඇත. "a, b" යනු ටුපල් එකක් නොවේ, නමුත් "(a, b)" යනු ටුපල් ය. එබැවින් අපි ඔබේ කේතය වෙනස් කර නැවත එය ක්රියාත්මක කරමු:
# The remove line now includes an extra "()" to make a tuple out of "a,b"
L1.remove((a,b))
මෙම කේතය කිසිදු දෝෂයකින් තොරව ක්රියාත්මක වේ, නමුත් එය ප්‍රතිදානය කරන ලැයිස්තුව දෙස බලමු:
L1 is now: [(1, 2), (5, 6), (1, -2)]
(1, -2) තවමත් ඔබේ ලැයිස්තුවේ ඇත්තේ ඇයි? විශේෂ අවධානයක් නොමැතිව ඉතා නරක අදහසකි. (1, -2) ලැයිස්තුවේ රැඳී සිටීමට හේතුව නම්, ලැයිස්තුවේ ඇති එක් එක් අයිතමයේ පිහිටීම් for for loop හි පුනරාවර්තන අතර වෙනස් වීමයි. අපි ඉහත කේතය දිගු ලැයිස්තුවක් පෝෂණය කළහොත් කුමක් සිදුවේදැයි බලමු:
L1 = [(1,2),(5,6),(-1,-2),(1,-2),(3,4),(5,7),(-4,4),(2,1),(-3,-3),(5,-1),(0,6)]
### Outputs:
L1 is now: [(1, 2), (5, 6), (1, -2), (3, 4), (5, 7), (2, 1), (5, -1), (0, 6)]
එම ප්‍රති result ලයෙන් ඔබට අනුමාන කළ හැකි පරිදි, කොන්දේසි සහිත ප්‍රකාශය සත්‍ය ලෙස තක්සේරු කර ලැයිස්තු අයිතමයක් ඉවත් කරන සෑම අවස්ථාවකම, ලූපයේ ඊළඟ ක්‍රියාකාරීත්වය ලැයිස්තුවේ ඊළඟ අයිතමය ඇගයීම මඟ හරිනු ඇත, මන්ද එහි අගයන් දැන් විවිධ දර්ශකවල පිහිටා ඇත.
වඩාත්ම අවබෝධාත්මක විසඳුම වන්නේ ලැයිස්තුව පිටපත් කිරීම, පසුව මුල් ලැයිස්තුවට නැවත නැවත පිටපත් කිරීම පමණි. ඔබට මේ ආකාරයට එසේ කිරීමට උත්සාහ කළ හැකිය:
L2 = L1
for (a,b) in L1:
if a < 0 or b < 0 :
L2.remove((a,b))
# Now, remove the original copy of L1 and replace with L2
print L2 is L1
del L1
L1 = L2; del L2
print ("L1 is now: ", L1)
කෙසේ වෙතත්, ප්‍රතිදානය පෙරට සමාන වේ:
'L1 is now: ', [(1, 2), (5, 6), (1, -2), (3, 4), (5, 7), (2, 1), (5, -1), (0, 6)]
මෙයට හේතුව අප L2 නිර්මාණය කරන විට පයිතන් ඇත්ත වශයෙන්ම නව වස්තුවක් නිර්මාණය නොකිරීමයි. ඒ වෙනුවට, එය හුදෙක් L2 යන්න L1 හා සමාන වස්තුවකට යොමු කරයි. අපට මෙය "is" සමඟ සත්‍යාපනය කළ හැකි අතර එය හුදෙක් "සමාන" (==) ට වඩා වෙනස් වේ.
>>> L2=L1
>>> L1 is L2
True
Copy.copy () භාවිතයෙන් අපට සත්‍ය පිටපතක් සෑදිය හැකිය. එවිට සියල්ල අපේක්ෂා කළ පරිදි ක්රියාත්මක වේ:
import copy
L1 = [(1,2), (5,6),(-1,-2), (1,-2),(3,4),(5,7),(-4,4),(2,1),(-3,-3),(5,-1),(0,6)]
L2 = copy.copy(L1)
for (a,b) in L1:
if a < 0 or b < 0 :
L2.remove((a,b))
# Now, remove the original copy of L1 and replace with L2
del L1
L1 = L2; del L2
>>> L1 is now: [(1, 2), (5, 6), (3, 4), (5, 7), (2, 1), (0, 6)]
අවසාන වශයෙන්, L1 හි සම්පූර්ණයෙන්ම නව පිටපතක් සෑදීමට වඩා පිරිසිදු විසඳුමක් තිබේ. ආපසු හරවන ලද () ශ්‍රිතය:
L1 = [(1,2), (5,6),(-1,-2), (1,-2),(3,4),(5,7),(-4,4),(2,1),(-3,-3),(5,-1),(0,6)]
for (a,b) in reversed(L1):
if a < 0 or b < 0 :
L1.remove((a,b))
print ("L1 is now: ", L1)
>>> L1 is now: [(1, 2), (5, 6), (3, 4), (5, 7), (2, 1), (0, 6)]
අවාසනාවට, ආපසු හැරවූ () ක්‍රියා කරන ආකාරය මට ප්‍රමාණවත් ලෙස විස්තර කළ නොහැක. ලැයිස්තුවක් සම්මත කළ විට එය 'listreverseiterator' වස්තුවක් ලබා දෙයි. ප්‍රායෝගික අරමුණු සඳහා, එහි තර්කයේ ප්‍රතිලෝම පිටපතක් නිර්මාණය කිරීමක් ලෙස ඔබට සිතිය හැකිය. මම නිර්දේශ කරන විසඳුම මෙයයි.