Python ရှိ စာရင်း (array) တစ်ခုမှ ပွားနေသော အစိတ်အပိုင်းများကို ဖယ်ရှားပြီး ထုတ်ယူပါ။

ဤကဏ္ဍသည် စာရင်း (array) တစ်ခုမှ ပွားနေသော အစိတ်အပိုင်းများကို ဖယ်ရှားခြင်း သို့မဟုတ် ထုတ်ယူခြင်းဖြင့် Python တွင် စာရင်းအသစ်တစ်ခု မည်သို့ထုတ်လုပ်ရမည်ကို ဖော်ပြထားပါသည်။

အောက်ပါအသေးစိတ်အချက်အလက်များကို ဤနေရာတွင် ဖော်ပြထားပါသည်။

• ထပ်နေသောဒြပ်စင်များကိုဖယ်ရှားပြီး စာရင်းအသစ်များကိုထုတ်ပေးပါ။
  • မူလစာရင်း၏ အစီအစဥ်ကို မထိန်းသိမ်းပါနှင့်:set()
  • မူရင်းစာရင်းကို ထိန်းသိမ်းပါ။:dict.fromkeys()၊sorted()
  • နှစ်ဘက်မြင် ခင်းကျင်းမှု (စာရင်းများစာရင်း)
• ပွားနေသော အစိတ်အပိုင်းများကို ထုတ်ယူပြီး စာရင်းအသစ်တစ်ခု ဖန်တီးပါ။
  • မူလစာရင်း၏ အစီအစဥ်ကို မထိန်းသိမ်းပါနှင့်
  • မူရင်းစာရင်းကို ထိန်းသိမ်းပါ။
  • နှစ်ဘက်မြင် ခင်းကျင်းမှု (စာရင်းများစာရင်း)

တူညီသောအယူအဆကို စာရင်းများအစား tuple တွင် အသုံးချနိုင်သည်။

အောက်ပါဆောင်းပါးကိုကြည့်ပါ။

• စာရင်းတစ်ခု သို့မဟုတ် tuple တစ်ခုတွင် ထပ်နေသောဒြပ်စင်များ ရှိ၊မရှိ ဆုံးဖြတ်လိုပါက
• စာရင်းတစ်ခုတည်းအစား များပြားသောစာရင်းများကြားတွင် ဘုံ သို့မဟုတ် ဘုံမဟုတ်သောဒြပ်စင်များကို ထုတ်ယူလိုပါက

• ဆက်စပ်-စာရင်း (array) တစ်ခုတွင် Python တွင် ထပ်နေသော အစိတ်အပိုင်းများ ရှိမရှိ ဆုံးဖြတ်ခြင်း။

စာရင်းများသည် မတူညီသောဒေတာအမျိုးအစားများကို သိမ်းဆည်းနိုင်ပြီး array များနှင့် တင်းကြပ်စွာကွဲပြားသည်ကို သတိပြုပါ။ မန်မိုရီအရွယ်အစားနှင့် မမ်မိုရီလိပ်စာများ သို့မဟုတ် ကြီးမားသောဒေတာ၏ ကိန်းဂဏာန်းလုပ်ဆောင်မှု လိုအပ်သည့် လုပ်ငန်းစဉ်များတွင် ခင်းကျင်းမှုများကို ကိုင်တွယ်လိုပါက၊ ခင်းကျင်းမှု (စံပြစာကြည့်တိုက်) သို့မဟုတ် NumPy ကို အသုံးပြုပါ။

ထပ်နေသောဒြပ်စင်များကိုဖယ်ရှားပြီး စာရင်းအသစ်များကိုထုတ်ပေးပါ။

မူလစာရင်း၏ အစီအစဥ်ကို မထိန်းသိမ်းပါနှင့်:set()

မူလစာရင်း၏အစီအစဥ်ကို ထိန်းသိမ်းရန်မလိုအပ်ပါက၊ set type set ကိုထုတ်ပေးသည့် set() ကိုအသုံးပြုပါ။

သတ်မှတ်အမျိုးအစားသည် ထပ်နေသောဒြပ်စင်များမရှိသော ဒေတာအမျိုးအစားဖြစ်သည်။ စာရင်းတစ်ခု သို့မဟုတ် အခြားဒေတာအမျိုးအစားကို set()သို့ ဖြတ်သွားသောအခါ၊ ထပ်တူတန်ဖိုးများကို လျစ်လျူရှုပြီး ထူးခြားသောတန်ဖိုးများသာ ဒြပ်စင်များဖြစ်သည့် အမျိုးအစားအစုံ၏ အရာဝတ္ထုကို ပြန်ပေးမည်ဖြစ်သည်။

tuple ဖြစ်ချင်ရင် tuple() ကိုသုံးပါ။

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]

ဟုတ်ပါတယ်၊ သတ်မှတ်အတိုင်း ထားနိုင်ပါတယ်။ သတ်မှတ်အမျိုးအစားအစုံနှင့်ပတ်သက်သော နောက်ထပ်အချက်အလက်များအတွက် အောက်ပါဆောင်းပါးကို ကြည့်ပါ။

• ဆက်စပ်-Python ၏ သတ်မှတ်အမျိုးအစားဖြင့် လုပ်ဆောင်ချက်များကို သတ်မှတ်ခြင်း (ဥပမာ၊ သမဂ္ဂအစုံများ၊ ထုတ်ကုန်အစုံများနှင့် အပိုင်းခွဲများ)

မူရင်းစာရင်းကို ထိန်းသိမ်းပါ။:dict.fromkeys()၊sorted()

မူရင်းစာရင်း၏ အစီအစဥ်ကို ထိန်းသိမ်းလိုပါက၊ အဘိဓာန်အမျိုးအစား၏ class method fromkeys() သို့မဟုတ် built-in function sorted() ကို အသုံးပြုပါ။

dict.fromkeys() သည် အငြင်းအခုံများတွင် သတ်မှတ်ထားသော သော့များစာရင်းများ၊ tuples စသည်တို့ပါရှိသော အဘိဓာန်အရာဝတ္တုအသစ်ကို ဖန်တီးသည်။ ဒုတိယအငြင်းအခုံကို ချန်လှပ်ထားလျှင် တန်ဖိုးသည် None ဖြစ်သည်။

• classmethod fromkeys(iterable[, value]) — Built-in Types — Python 3.10.4 Documentation

အဘိဓာန်ကီးများတွင် ပွားနေသောဒြပ်စင်များမရှိသောကြောင့်၊ ပွားနေသောတန်ဖိုးများကို set() တွင် လျစ်လျူရှုထားသည်။ ထို့အပြင်၊ ဒြပ်စင်များသည် အဘိဓာန်သော့များဖြစ်သည့် စာရင်းတစ်ခုကို ရယူရန်အတွက် အဘိဓာန်အရာဝတ္တုကို list() အဖြစ် ဖြတ်သွားနိုင်သည်။

print(dict.fromkeys(l))
# {3: None, 2: None, 1: None, 5: None, 4: None}

print(list(dict.fromkeys(l)))
# [3, 2, 1, 5, 4]

dict.fromkeys() သည် argument sequence ၏ အစီအစဥ်ကို ထိန်းသိမ်းထားသောကြောင့် Python 3.7 (CPython သည် 3.6) ကတည်းက အာမခံထားပါသည်။ အစောပိုင်းဗားရှင်းများတွင် အောက်ပါအတိုင်း built-in function sorted() ကိုအသုံးပြုသည်။

စီထားသောဒြပ်စင်များစာရင်းကို ပြန်ပေးသည့် စီစစ်ထားသော အငြင်းအခုံသော့အတွက် tuple နည်းလမ်းအညွှန်း() ကို သတ်မှတ်ပါ။

index() သည် မူလစာရင်း၏ အစီအစဥ်အလိုက် စာရင်းကို စီရန် အမျိုးအစားခွဲခြင်း() သော့အဖြစ် သတ်မှတ်နိုင်သည့် တန်ဖိုး၏ အညွှန်းကိန်း (စာရင်းရှိ ဒြပ်စင်နံပါတ်) ကို ပြန်ပေးသည့် နည်းလမ်းတစ်ခုဖြစ်သည်။ အငြင်းအခုံကီးကို ခေါ်ဆိုနိုင်သော (ခေါ်ဆိုနိုင်သော) အရာဝတ္ထုတစ်ခုအဖြစ် သတ်မှတ်ထားသောကြောင့် () မရေးပါနှင့်။

print(sorted(set(l), key=l.index))
# [3, 2, 1, 5, 4]

နှစ်ဘက်မြင် ခင်းကျင်းမှု (စာရင်းများစာရင်း)

နှစ်ဘက်မြင် arrays (စာရင်းများ) အတွက် 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'

အဘယ်ကြောင့်ဆိုသော် စာရင်းများကဲ့သို့သော ဟက်ကင်းမဖြစ်နိုင်သော အရာဝတ္ထုများသည် အမျိုးအစားသတ်မှတ်မှု၏ဒြပ်စင်များ သို့မဟုတ် type dict ၏သော့များမဖြစ်နိုင်သောကြောင့်ဖြစ်သည်။

အောက်ပါလုပ်ဆောင်ချက်များကို သတ်မှတ်ခြင်း မူရင်းစာရင်း၏အစီအစဥ်ကို ထိန်းသိမ်းထားပြီး တစ်ဘက်မြင်စာရင်းများနှင့် tuples များအတွက် အလုပ်လုပ်ပါသည်။

• python – How do you remove duplicates from a list whilst preserving order? – Stack Overflow

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]

List comprehension notation ကို အသုံးပြုသည်။

• ဆက်စပ်-Python list comprehensions ကိုအသုံးပြုနည်း

ဤတွင်၊ ကျွန်ုပ်တို့သည် အောက်ပါတို့ကို အသုံးပြုသည်။

• အကယ်၍ “ X နှင့် Y” ရှိ X သည် ပတ်လမ်းတိုနှင့် အော်ပရေတာများ၏ ပတ်လမ်းအကဲဖြတ်မှုတွင် မှားယွင်းနေပါက Y ကို အကဲဖြတ်မည်မဟုတ်ပါ (လုပ်ဆောင်မည်မဟုတ်ပါ)။
• append() method သည် None ကို ပြန်ပေးသည်။

မူလစာရင်း seq ၏ဒြပ်စင်များကိုမြင်သည့်တွင်မရှိပါက၊ ထို့နောက်နှင့်နောက်ကိုအကဲဖြတ်သည်။
See.append(x) ကို လုပ်ဆောင်ပြီး အစိတ်အပိုင်းကို မြင်နိုင်ရန် ပေါင်းထည့်ထားသည်။
append() method သည် None နှင့် None သည် False ဖြစ်သောကြောင့် see.append(x) သည် True အဖြစ်အကဲဖြတ်သည်မဟုတ်ပါ။
စာရင်းနားလည်မှုမှတ်စုရှိ အခြေအနေဆိုင်ရာဖော်ပြချက်သည် အမှန်ဖြစ်လာပြီး နောက်ဆုံးထုတ်လုပ်လိုက်သောစာရင်း၏ အစိတ်အပိုင်းတစ်ခုအဖြစ် ထည့်သွင်းထားသည်။

မူရင်းစာရင်း seq ၏ဒြပ်စင်များကိုမြင်ရပါက၊ x သည် မမြင်ရသော False ဖြစ်ပြီး၊ list comprehension expression အတွက် conditional expression သည် False ဖြစ်သည်။
ထို့ကြောင့်၊ ၎င်းတို့ကို နောက်ဆုံးထုတ်လုပ်လိုက်သည့်စာရင်း၏ အစိတ်အပိုင်းများအဖြစ် ထည့်သွင်းမထားပါ။

အခြားနည်းလမ်းမှာ NumPy ၏လုပ်ဆောင်ချက် np.unique() တွင် အငြင်းအခုံဝင်ရိုးကို သတ်မှတ်ရန် ရလဒ်ကို စီစဥ်ထားမည်ဖြစ်သည်။

ပွားနေသော အစိတ်အပိုင်းများကို ထုတ်ယူပြီး စာရင်းအသစ်တစ်ခု ဖန်တီးပါ။

မူလစာရင်း၏ အစီအစဥ်ကို မထိန်းသိမ်းပါနှင့်

မူရင်းစာရင်းမှ ထပ်နေသောဒြပ်စင်များကိုသာ ထုတ်ယူရန် collections.Counter() ကို အသုံးပြုပါ။
စုစည်းမှုများကို ပြန်ပေးသည်။ သော့များအဖြစ် ဒြပ်စင်များနှင့် တန်ဖိုးများအဖြစ် ဒြပ်စင်အရေအတွက်များပါရှိသော (အဘိဓာန်အမျိုးအစားခွဲတစ်ခု) ကို တန်ပြန်ပါ။

• ဆက်စပ်-Python’s 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})

၎င်းသည် အဘိဓာန်၏ အတန်းခွဲတစ်ခုဖြစ်သောကြောင့်၊ သော့များနှင့် တန်ဖိုးများကို ပြန်လည်ရယူရန် items() ကို အသုံးပြုနိုင်သည်။ နံပါတ်နှစ်ခု သို့မဟုတ် ထို့ထက်ပိုသော သော့များကို ထုတ်ယူရန် လုံလောက်ပါသည်။

• ဆက်စပ်-ကွင်းဆက်လုပ်ဆောင်ခြင်းအတွက် Python အဘိဓာန် (အမိန့်) (သော့များ၊ တန်ဖိုးများ၊ ပစ္စည်းများ)

print([k for k, v in collections.Counter(l).items() if v > 1])
# [3, 2, 1]

မူရင်းစာရင်းကို ထိန်းသိမ်းပါ။

အထက်နမူနာတွင် ပြထားသည့်အတိုင်း Python 3.7 မှစတင်၍ စုစည်းမှုများ၏သော့များ။Counter သည် မူရင်းစာရင်း၏အစီအစဥ်ကို ဆက်လက်ထိန်းသိမ်းထားသည်။

အစောပိုင်းဗားရှင်းများတွင်၊ ပွားနေသောဒြပ်စင်များကို ဖျက်ခြင်းကဲ့သို့ စီထား() ဖြင့် စီထားခြင်းသည် လုံလောက်ပါသည်။

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]

နှစ်ဘက်မြင် ခင်းကျင်းမှု (စာရင်းများစာရင်း)

နှစ်ဘက်မြင် arrays (စာရင်းများ) အတွက် မူရင်းစာရင်း၏ အစီအစဥ်ကို မထိန်းသိမ်းထားသည့်အခါနှင့် ၎င်းကို ထိန်းသိမ်းထားသည့်အခါတွင် အောက်ပါလုပ်ဆောင်ချက်များ ဖြစ်နိုင်သည်။ ၎င်းသည် one-dimensional lists နှင့် tuples များအတွက်လည်း လုပ်ဆောင်သည်။

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]]

count() ၏ တွက်ချက်မှုဆိုင်ရာ ရှုပ်ထွေးမှုသည် O(n) ဖြစ်သောကြောင့် အထက်တွင်ပြသထားသည့် လုပ်ဆောင်ချက်သည် count() ကို ထပ်ခါတလဲလဲ လုပ်ဆောင်ပေးသည့် လုပ်ဆောင်ချက်သည် အလွန်ထိရောက်မှုမရှိသည်ကို သတိပြုပါ။ ပိုထက်မြက်တဲ့နည်းလမ်း ရှိကောင်းရှိနိုင်ပါတယ်။

Counter သည် အဘိဓာန်၏ အမျိုးအစားခွဲတစ်ခုဖြစ်သောကြောင့် အကယ်၍ သင်သည် စာရင်း သို့မဟုတ် tuple ၏ဒြပ်စင်များစာရင်းများ သို့မဟုတ် အခြားသော ဟက်ရှ်မရနိုင်သော အရာဝတ္ထုများကို collections.Counter() သို့ ပေးပို့ပါက အမှားအယွင်းဖြစ်သွားပြီး ၎င်းကို သင်အသုံးပြုနိုင်မည်မဟုတ်ပါ။

# print(collections.Counter(l_2d))
# TypeError: unhashable type: 'list'