ලැයිස්තුවකින් (අරාවකින්) අනුපිටපත් මූලද්‍රව්‍ය ඉවත් කිරීමෙන් හෝ උපුටා ගැනීමෙන් පයිතන් හි නව ලැයිස්තුවක් උත්පාදනය කරන්නේ කෙසේද යන්න මෙම කොටස විස්තර කරයි.
පහත විස්තර මෙහි විස්තර කර ඇත.
- අනුපිටපත් මූලද්‍රව්‍ය ඉවත් කර නව ලැයිස්තුගත කිරීම් උත්පාදනය කරන්න
- මුල් ලැයිස්තුගත කිරීමේ අනුපිළිවෙල ආරක්ෂා නොකරන්න:
set() - මුල් ලැයිස්තුගත කිරීමේ අනුපිළිවෙල ආරක්ෂා කරයි:
dict.fromkeys(),sorted() - ද්විමාන අරාව (ලැයිස්තු ලැයිස්තුව)
- මුල් ලැයිස්තුගත කිරීමේ අනුපිළිවෙල ආරක්ෂා නොකරන්න:
- අනුපිටපත් මූලද්‍රව්‍ය උපුටා ගෙන නව ලැයිස්තුවක් ජනනය කරන්න
- මුල් ලැයිස්තුගත කිරීමේ අනුපිළිවෙල ආරක්ෂා නොකරන්න
- මුල් ලැයිස්තුගත කිරීමේ අනුපිළිවෙල ආරක්ෂා කරයි
- ද්විමාන අරාව (ලැයිස්තු ලැයිස්තුව)
ලිස්ට් වෙනුවට ටියුපල් සඳහා එකම සංකල්පය යෙදිය හැකිය.
සඳහා පහත ලිපිය බලන්න
- ඔබට ලැයිස්තුවක් හෝ ටියුපල් අනුපිටපත් මූලද්‍රව්‍ය තිබේදැයි තීරණය කිරීමට අවශ්‍ය නම්
- ඔබට තනි ලැයිස්තුගත කිරීමක් වෙනුවට බහු ලැයිස්තුගත කිරීම් අතර පොදු හෝ පොදු නොවන මූලද්‍රව්‍ය උපුටා ගැනීමට අවශ්‍ය නම්
ලැයිස්තුවලට විවිධ වර්ගයේ දත්ත ගබඩා කළ හැකි අතර ඒවා අරාවලින් දැඩි ලෙස වෙනස් වන බව සලකන්න. ඔබට මතක ප්‍රමාණය සහ මතක ලිපින හෝ විශාල දත්ත සංඛ්‍යාත්මක සැකසුම් අවශ්‍ය වන ක්‍රියාවලි වල අරා හැසිරවීමට අවශ්‍ය නම්, array (සම්මත පුස්තකාලය) හෝ NumPy භාවිතා කරන්න.
අනුපිටපත් මූලද්‍රව්‍ය ඉවත් කර නව ලැයිස්තුගත කිරීම් උත්පාදනය කරන්න
මුල් ලැයිස්තුගත කිරීමේ අනුපිළිවෙල ආරක්ෂා නොකරන්න:set()
මුල් ලැයිස්තුවේ අනුපිළිවෙල සුරැකීමේ අවශ්‍යතාවයක් නොමැති නම්, කට්ටල වර්ග කට්ටලයක් උත්පාදනය කරන set() භාවිතා කරන්න.
කට්ටල වර්ගය යනු අනුපිටපත් මූලද්‍රව්‍ය නොමැති දත්ත වර්ගයකි. ලැයිස්තුවක් හෝ වෙනත් දත්ත වර්ගයක් set() වෙත ගිය විට අනුපිටපත් අගයන් නොසලකා හරින අතර අනන්‍ය අගයන් පමණක් මූලද්‍රව්‍ය වන ආකාරයේ කට්ටලයක වස්තුවක් ආපසු ලබා දෙනු ලැබේ.
ඔබට එය ටියුපල් බවට පත් කිරීමට අවශ්‍ය නම්, ටුපල්() භාවිතා කරන්න.
l = [3, 3, 2, 1, 5, 1, 4, 2, 3]
print(set(l))
# {1, 2, 3, 4, 5}
print(list(set(l)))
# [1, 2, 3, 4, 5]
ඇත්ත වශයෙන්ම, එය කට්ටලයක් ලෙස ද තැබිය හැකිය. කට්ටල වර්ග කට්ටලය පිළිබඳ වැඩි විස්තර සඳහා පහත ලිපිය බලන්න.
මුල් ලැයිස්තුගත කිරීමේ අනුපිළිවෙල ආරක්ෂා කරයි:dict.fromkeys(),sorted()
ඔබට මුල් ලැයිස්තුවේ අනුපිළිවෙල ආරක්ෂා කර ගැනීමට අවශ්‍ය නම්, ශබ්ද කෝෂ වර්ගයේ fromkeys() හෝ බිල්ට්-ඉන් ශ්‍රිතය sorted() භාවිතා කරන්න.
dict.fromkeys() නව ශබ්ද කෝෂ වස්තුවක් නිර්මාණය කරයි, එහි යතුරු ලිස්ට්, ටියුපල් යනාදිය තර්කවල දක්වා ඇත. දෙවන තර්කය ඉවත් කර ඇත්නම්, අගය None වේ.
ශබ්ද කෝෂ යතුරුවල අනුපිටපත් මූලද්‍රව්‍ය නොමැති බැවින්, කට්ටලය() හි මෙන් අනුපිටපත් අගයන් නොසලකා හරිනු ලැබේ. මීට අමතරව, ශබ්ද කෝෂ වස්තුවක් ශබ්ද කෝෂ යතුරු වන මූලද්‍රව්‍ය ලැයිස්තුවක් ලබා ගැනීම සඳහා ලැයිස්තුව() වෙත තර්කයක් ලෙස සම්මත කළ හැක.
print(dict.fromkeys(l))
# {3: None, 2: None, 1: None, 5: None, 4: None}
print(list(dict.fromkeys(l)))
# [3, 2, 1, 5, 4]
Python 3.7 (CPython යනු 3.6) සිට dict.fromkeys() තර්ක අනුපිළිවෙලෙහි අනුපිළිවෙල ආරක්ෂා කරන බව සහතික කර ඇත. පෙර අනුවාද වල බිල්ට්-ඉන් ශ්‍රිතය පහත පරිදි වර්ග කළ() භාවිතා කරයි.
වර්ග කළ මූලද්‍රව්‍ය ලැයිස්තුවක් ලබා දෙන අනුපිළිවෙලෙහි තර්ක යතුර සඳහා ලැයිස්තු ටුපල් ක්‍රම දර්ශකය() සඳහන් කරන්න.
index() යනු අගයෙහි දර්ශකය (ලැයිස්තුවෙහි ඇති මූලද්‍රව්‍ය අංකය) ආපසු ලබා දෙන ක්‍රමයකි, එය මුල් ලැයිස්තුවේ අනුපිළිවෙල මත පදනම්ව ලැයිස්තුව වර්ග කිරීම සඳහා වර්ග කළ() යතුර ලෙස දැක්විය හැක. තර්ක යතුර ඇමතීමට හැකි (ඇමතුම් කළ හැකි) වස්තුවක් ලෙස දක්වා ඇත, එබැවින් () ලියන්න එපා.
print(sorted(set(l), key=l.index))
# [3, 2, 1, 5, 4]
ද්විමාන අරාව (ලැයිස්තු ලැයිස්තුව)
ද්විමාන අරා (ලැයිස්තු ලැයිස්තු) සඳහා set() හෝ dict.fromkeys() භාවිතා කරන ක්‍රමය TypeError එකක් ඇති කරයි.
l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]
# l_2d_unique = list(set(l_2d))
# TypeError: unhashable type: 'list'
# l_2d_unique_order = dict.fromkeys(l_2d)
# TypeError: unhashable type: 'list'
මක්නිසාද යත් ලැයිස්තු වැනි හෑෂ් කළ නොහැකි වස්තු වර්ග කට්ටලයේ මූලද්‍රව්‍ය හෝ ටයිප් ඩික්ට් වර්ගයේ යතුරු විය නොහැකි බැවිනි.
පහත සඳහන් කාර්යයන් නිර්වචනය කරන්න මුල් ලැයිස්තුවේ අනුපිළිවෙල සංරක්ෂණය කර ඇති අතර ඒක මාන ලැයිස්තු සහ ටියුපල් සඳහා ක්‍රියා කරයි.
def get_unique_list(seq):
seen = []
return [x for x in seq if x not in seen and not seen.append(x)]
print(get_unique_list(l_2d))
# [[1, 1], [0, 1], [0, 0], [1, 0]]
print(get_unique_list(l))
# [3, 2, 1, 5, 4]
ලැයිස්තු අවබෝධතා අංකනය භාවිතා වේ.
මෙන්න, අපි පහත සඳහන් දේ භාවිතා කරමු
- “X සහ Y” හි X සහ ක්‍රියාකරුගේ කෙටි-පරිපථ ඇගයීමේදී අසත්‍ය නම්, Y ඇගයීමට ලක් නොකෙරේ (ක්‍රියාත්මක නොවේ).
- append() ක්‍රමය කිසිවක් නැත.
මුල් ලැයිස්තු අනුක්‍රමයේ මූලද්‍රව්‍ය දුටුවේ නොපවතී නම්, පසුව සහ පසුව ඇගයීමට ලක් කෙරේ.
seen.append(x) ක්‍රියාත්මක වන අතර එම මූලද්‍රව්‍යය see වෙත එකතු වේ.
append() method එක Return කරන නිසා None සහ None is False, not seen.append(x) evaluate True.
ලැයිස්තු අවබෝධතා අංකනයෙහි ඇති කොන්දේසිගත ප්‍රකාශනය සත්‍ය බවට පත්වන අතර අවසාන ජනනය කරන ලද ලැයිස්තුවේ මූලාංගයක් ලෙස එකතු කරනු ලැබේ.
මුල් ලැයිස්තු seq හි මූලද්‍රව්‍ය දුටුවේ තිබේ නම්, x නොපෙනේ යනු අසත්‍ය වන අතර ලැයිස්තු අවබෝධතා ප්‍රකාශනය සඳහා කොන්දේසි සහිත ප්‍රකාශනය අසත්‍ය වේ.
එබැවින්, ඒවා අවසන් ජනනය කරන ලද ලැයිස්තුවේ අංග ලෙස එකතු නොකෙරේ.
තවත් ක්‍රමයක් නම් NumPy හි ශ්‍රිතය np.unique() හි තර්ක අක්ෂය සැකසීමයි, නමුත් ප්‍රතිඵලය වර්ග කරනු ලැබේ.
අනුපිටපත් මූලද්‍රව්‍ය උපුටා ගෙන නව ලැයිස්තුවක් ජනනය කරන්න
මුල් ලැයිස්තුගත කිරීමේ අනුපිළිවෙල ආරක්ෂා නොකරන්න
මුල් ලැයිස්තුවෙන් අනුපිටපත් මූලද්‍රව්‍ය පමණක් උකහා ගැනීමට, collections.Counter() භාවිතා කරන්න.
එකතුවක් ආපසු ලබා දෙයි. මූලද්‍රව්‍ය යතුරු ලෙස සහ මූලද්‍රව්‍ය ගණන අගයන් ලෙස සහිත කවුන්ටරය (ශබ්දකෝෂයේ උප පංතියක්).
import collections
l = [3, 3, 2, 1, 5, 1, 4, 2, 3]
print(collections.Counter(l))
# Counter({3: 3, 2: 2, 1: 2, 5: 1, 4: 1})
එය ශබ්දකෝෂයේ උප පංතියක් බැවින්, යතුරු සහ අගයන් ලබා ගැනීමට අයිතම() භාවිතා කළ හැක. සංඛ්‍යා දෙකක් හෝ වැඩි ගණනක් ඇති යතුරු උපුටා ගැනීම ප්‍රමාණවත් වේ.
print([k for k, v in collections.Counter(l).items() if v > 1])
# [3, 2, 1]
මුල් ලැයිස්තුගත කිරීමේ අනුපිළිවෙල ආරක්ෂා කරයි
ඉහත උදාහරණයේ පෙන්වා ඇති පරිදි, Python 3.7 සිට, එකතු කිරීමේ යතුරු. කවුන්ටරය මුල් ලැයිස්තුවේ අනුපිළිවෙල රඳවා තබා ගනී.
පෙර අනුවාදවල අනුපිටපත් මූලද්‍රව්‍ය මකා දැමීම මෙන්ම අනුකරණය කළ() සමඟ වර්ග කිරීම ප්‍රමාණවත් වේ.
print(sorted([k for k, v in collections.Counter(l).items() if v > 1], key=l.index))
# [3, 2, 1]
ඔබට අනුපිටපත් ලබා ගැනීමට අවශ්‍ය නම්, මුල් ලැයිස්තුවෙන් මූලද්‍රව්‍ය දෙකක් හෝ වැඩි ගණනක් සමඟ තබන්න. ඇණවුම ද සංරක්ෂණය කර ඇත.
cc = collections.Counter(l)
print([x for x in l if cc[x] > 1])
# [3, 3, 2, 1, 1, 2, 3]
ද්විමාන අරාව (ලැයිස්තු ලැයිස්තුව)
ද්විමාන අරා (ලැයිස්තු ලැයිස්තු) සඳහා, මුල් ලැයිස්තුවේ අනුපිළිවෙල රඳවා නොගත් විට සහ පිළිවෙලින් එය රඳවා තබා ඇති විට පහත සඳහන් කාර්යයන් කළ හැකිය. එය ඒක මාන ලැයිස්තු සහ ටියුපල් සඳහා ද ක්‍රියා කරයි.
l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]
def get_duplicate_list(seq):
seen = []
return [x for x in seq if not seen.append(x) and seen.count(x) == 2]
def get_duplicate_list_order(seq):
seen = []
return [x for x in seq if seq.count(x) > 1 and not seen.append(x) and seen.count(x) == 1]
print(get_duplicate_list(l_2d))
# [[0, 1], [1, 1]]
print(get_duplicate_list_order(l_2d))
# [[1, 1], [0, 1]]
print(get_duplicate_list(l))
# [3, 1, 2]
print(get_duplicate_list_order(l))
# [3, 2, 1]
ඔබට අනුපිටපත් සමඟ උපුටා ගැනීමට අවශ්‍ය නම්, මුල් ලැයිස්තුවෙන් මූලද්‍රව්‍ය දෙකක් හෝ ඊට වැඩි ගණනකින් තබන්න.
print([x for x in l_2d if l_2d.count(x) > 1])
# [[1, 1], [0, 1], [0, 1], [1, 1], [1, 1]]
ගණන්() හි ගණනය කිරීමේ සංකීර්ණතාව O(n) වන බැවින්, නැවත නැවතත් ගණන්() ක්‍රියාත්මක කරන ඉහත පෙන්වා ඇති ශ්‍රිතය ඉතා අකාර්යක්ෂම බව සලකන්න. වඩා බුද්ධිමත් ක්‍රමයක් තිබිය හැක.
කවුන්ටරය යනු ශබ්දකෝෂයේ උපපංතියකි, එබැවින් ඔබ ලැයිස්තු හෝ වෙනත් හෑෂ් කළ නොහැකි වස්තු එකතු කරන ලද ලැයිස්තුවක් හෝ ටපල් එකක් එකතු කළහොත් දෝෂයක් ඇති වන අතර ඔබට එය භාවිතා කිරීමට නොහැකි වනු ඇත.
# print(collections.Counter(l_2d))
# TypeError: unhashable type: 'list'
