පහත දැක්වෙන්නේ පහත දැක්වෙන එක් එක් අවස්ථා සඳහා, ලැයිස්තුවක් (අරාවක්) Python හි අනුපිටපත් මූලද්රව්ය (සියලුම මූලද්රව්ය අනන්‍ය/අද්විතීය) තිබේ දැයි තීරණය කරන්නේ කෙසේද යන්න පිළිබඳ විස්තරයකි.
- මූලද්රව්යයේ ලැයිස්තුවක් නොමැති ලැයිස්තුවක් සඳහා
- මූලද්රව්ය ලැයිස්තු සහිත ලැයිස්තු සඳහා (ද්විමාන අරා, ලැයිස්තු ලැයිස්තු ආදිය)
ලැයිස්තුවකින් අනුපිටපත් මූලද්රව්ය ඉවත් කරන්නේ කෙසේද යන්න පිළිබඳ පහත ලිපිය බලන්න.
ලැයිස්තුවලට විවිධ වර්ගයේ දත්ත ගබඩා කළ හැකි අතර ඒවා අරාවලින් දැඩි ලෙස වෙනස් වන බව සලකන්න. ඔබට මතක ප්‍රමාණය සහ මතක ලිපින හෝ විශාල දත්ත සංඛ්‍යාත්මක සැකසුම් අවශ්ය වන ක්‍රියාවලි වල අරා හැසිරවීමට අවශ්ය නම්, array (සම්මත පුස්තකාලය) හෝ NumPy භාවිතා කරන්න.
ලැයිස්තුවේ අනුපිටපත් මූලද්රව්ය තිබේ දැයි තීරණය කරන්න (මූලද්‍රව්‍යයට ලැයිස්තුවක් නොමැති නම්)
මූලද්රව්යයේ ලැයිස්තුවක් වැනි යාවත්කාලීන කළ හැකි වස්තුවක් නොමැති නම්, කුලක කුලකයේ කන්ස්ට්‍රක්ටර් කට්ටලය() භාවිතා කරන්න.
කට්ටල වර්ගය යනු අනුපිටපත් මූලද්රව්ය නොමැති දත්ත වර්ගයකි. ලැයිස්තුවක් කන්ස්ට්‍රක්ටර් කට්ටලයට (), අනුපිටපත් අගයන් නොසලකා හරින අතර මූලද්රව්ය ලෙස අනන්‍ය අගයන් පමණක් ඇති ආකාරයේ වස්තුවක් ආපසු ලබා දේ.
මෙම කට්ටල වර්ගයේ වස්තුවේ ඇති මූලද්රව්ය සංඛ්‍යාව සහ මුල් ලැයිස්තුව ලබාගෙන සංසන්දනය කරනු ලබන්නේ බිල්ට්-ඉන් ශ්‍රිතය භාවිතා කර len().
- මූලද්රව්ය ගණන සමාන නම්, මුල් ලැයිස්තුවේ අනුපිටපත් මූලද්රව්ය නොමැත
- මූලද්රව්ය ගණන වෙනස් නම් අනුපිටපත් මූලද්රව්ය මුල් ලැයිස්තුවට ඇතුළත් වේ
අනුපිටපත් මූලද්රව්ය නොමැති නම් අසත්‍ය සහ අනුපිටපත් මූලද්රව්ය තිබේ නම් සත්‍ය යන ශ්‍රිත පහත පරිදි වේ.
def has_duplicates(seq):
return len(seq) != len(set(seq))
l = [0, 1, 2]
print(has_duplicates(l))
# False
l = [0, 1, 1, 2]
print(has_duplicates(l))
# True
උදාහරණය ලැයිස්තුවකි, නමුත් එම කාර්යයම ටියුපල් සමඟ භාවිතා කළ හැක.
ලැයිස්තු වැනි වෙනස් කළ හැකි (යාවත්කාලීන කළ හැකි) වස්තු වර්ග කට්ටලයේ මූලද්රව්ය විය නොහැක. එබැවින්, මූලද්රව්ය ලෙස ලැයිස්තු සහිත ලැයිස්තු (ද්විමාන අරා, ලැයිස්තු ලැයිස්තු, ආදිය) TypeError ඇති කරයි. ප්රතිවිරෝධතා පහත දැක්වේ.
l_2d = [[0, 1], [1, 1], [0, 1], [1, 0]]
# print(has_duplicates(l_2d))
# TypeError: unhashable type: 'list'
ලැයිස්තුවේ අනුපිටපත් මූලද්රව්ය තිබේ දැයි තීරණය කරන්න (මූලද්‍රව්‍යයට ලැයිස්තුවක් තිබේ නම්)
මූලද්රව්ය ලැයිස්තුවක් සහිත ලැයිස්තුවක (ලැයිස්තු ලැයිස්තුවක් වැනි), අනුපිටපත් මූලද්රව්ය තිබේදැයි තීරණය කිරීමට පහත ශ්‍රිත භාවිතා කළ හැක.
def has_duplicates2(seq):
seen = []
unique_list = [x for x in seq if x not in seen and not seen.append(x)]
return len(seq) != len(unique_list)
l_2d = [[0, 0], [0, 1], [1, 1], [1, 0]]
print(has_duplicates2(l_2d))
# False
l_2d = [[0, 0], [0, 1], [1, 1], [1, 1]]
print(has_duplicates2(l_2d))
# True
set() වෙනුවට, ලැයිස්තු අවබෝධතා අංකනය මඟින් මූලද්රව්ය අද්විතීය අගයන් පමණක් වන ලැයිස්තුවක් ජනනය කරයි, සහ මූලද්රව්ය ගණන සංසන්දනය කරයි. විස්තර සඳහා පහත ලිපිය බලන්න.
මූලද්රව්ය ලැයිස්තුවක් නොමැති ලැයිස්තු සඳහාද මෙම ශ්‍රිතය වලංගු වේ.
l = [0, 1, 2]
print(has_duplicates2(l))
# False
l = [0, 1, 1, 2]
print(has_duplicates2(l))
# True
මෙතෙක් උදාහරණය වන්නේ මූලද්රව්ය ලැයිස්තුව අනුපිටපත් කර තිබේද යන්න තීරණය කිරීමයි (එකම ලැයිස්තුවම අඩංගු වේ).
එක් එක් ලැයිස්තුවේ මූලද්රව්ය අතිච්ඡාදනය වන්නේද යන්න තීරණය කළ හැක්කේ මුල් ලැයිස්තුව එක් මානයකට සමතලා කිරීමෙන් පසුවය.
l_2d = [[0, 1], [2, 3]]
print(sum(l_2d, []))
# [0, 1, 2, 3]
print(has_duplicates(sum(l_2d, [])))
# False
l_2d = [[0, 1], [2, 0]]
print(has_duplicates(sum(l_2d, [])))
# True
මෙහි ලැයිස්තුව සමතලා කිරීමට sum() භාවිතා කරයි, නමුත් itertools.chain.from_iterable() ද භාවිතා කළ හැක. මීට අමතරව, මානයන් තුනක් හෝ වැඩි ගණනක ලැයිස්තුවක් සමතලා කිරීමේදී, නව කාර්යයක් නිර්වචනය කිරීම අවශ්ය වේ.
