Python ရှိ အကြီးဆုံးနှင့် အသေးငယ်ဆုံးတန်ဖိုးများမှ စာရင်းတစ်ခု၏ n အစိတ်အပိုင်းများကို ရယူခြင်း။

စီးပွားရေးလုပ်ငန်း

အကယ်၍ သင်သည် Python တွင် အကြီးဆုံး သို့မဟုတ် အသေးငယ်ဆုံးတန်ဖိုး နှင့် n=1 တို့မှ စာရင်း (array) ၏ n အစိတ်အပိုင်းများကို ရယူလိုပါက အောက်ပါ built-in လုပ်ဆောင်ချက်ကို အသုံးပြုနိုင်သည်။

  • max()
  • min()

n>1 ဆိုလျှင်၊ စာရင်းကိုခွဲရန် သို့မဟုတ် စံစာကြည့်တိုက်၏ heapq module ကိုသုံးရန် နည်းလမ်းနှစ်ခုရှိသည်။

  • အများဆုံးနှင့် အနည်းဆုံးတန်ဖိုးများကို ရယူပါ။:max()၊min()
  • အမြင့်ဆုံးနှင့် အနိမ့်ဆုံးတန်ဖိုးအစီအစဥ်အလိုက် n အစိတ်အပိုင်းများကို ရယူပါ။:အမျိုးအစား
  • အမြင့်ဆုံးနှင့် အနိမ့်ဆုံးတန်ဖိုးအစီအစဥ်အလိုက် n အစိတ်အပိုင်းများကို ရယူပါ။:heapqမော်ဂျူး

ပြန်လည်ရယူရမည့်ဒြပ်စင်အရေအတွက်သည် ကြီးမားပါက၊ ၎င်းတို့ကို sorted() သို့မဟုတ် sort() ကို အသုံးပြု၍ ပထမဦးစွာ စီရန်သည် ပိုမိုထိရောက်ပြီး အရေအတွက်သည် သေးငယ်ပါက၊ nargest() နှင့် nsmallest() တို့သည် heapq module ၏ ပိုမိုထိရောက်ပါသည်။

အမြင့်ဆုံးနှင့် အနိမ့်ဆုံးတန်ဖိုးများ၏ အညွှန်းကိန်းများကို ရယူရန် max(), min() နှင့် index() ကိုသုံးပါ။

အများဆုံးနှင့် အနည်းဆုံးတန်ဖိုးများကို ရယူပါ။:max()၊min()

စာရင်း၏ အမြင့်ဆုံးနှင့် အနိမ့်ဆုံး အစိတ်အပိုင်းများကို ရယူရန် တပ်ဆင်ထားသော လုပ်ဆောင်ချက် max() နှင့် min() ကို အသုံးပြုပါ။

l = [3, 6, 7, -1, 23, -10, 18]

print(max(l))
# 23

print(min(l))
# -10

အများဆုံးနှင့် အနိမ့်ဆုံးတန်ဖိုးအစီအစဥ်အလိုက် n အစိတ်အပိုင်းများကို ရယူပါ- အမျိုးအစားခွဲပါ။

စာရင်းတစ်ခု၏ n အစိတ်အပိုင်းများကို အကြီးဆုံး သို့မဟုတ် အငယ်ဆုံးတန်ဖိုးမှ အစဉ်လိုက်ရယူလိုပါက၊ ပထမနည်းလမ်းမှာ စာရင်းကို စီရန် (sort) ပြုလုပ်ရန်ဖြစ်သည်။

စာရင်းကို စီစဥ်ရန်၊ စာရင်း၏ built-in လုပ်ဆောင်ချက်ကို sorted() သို့မဟုတ် sort() နည်းလမ်းကို အသုံးပြုပါ။ sort() သည် မူလစာရင်းကို ပြန်စီထားစဉ်တွင် အမျိုးအစားခွဲထားသောစာရင်းအသစ်ကို ပြန်ပေးသည်။

အငြင်းအခုံပြောင်းပြန်ဖြင့် ကြီးလိုက်ကြီးလိုက် ကြီးလိုက်/ကြီးလိုက် အစဉ်လိုက်ပြောင်းကာ ထိပ်မှ အချပ်အရေအတွက်ကို ရွေးခြင်းဖြင့်၊ စာရင်း၏ အကြီးဆုံး/အသေးစားတန်ဖိုးမှ n အစိတ်အပိုင်းများကို သင်ရနိုင်သည်။

ld = sorted(l, reverse=True)
print(ld)
# [23, 18, 7, 6, 3, -1, -10]

print(ld[:3])
# [23, 18, 7]

la = sorted(l)
print(la)
# [-10, -1, 3, 6, 7, 18, 23]

print(la[:3])
# [-10, -1, 3]

၎င်းတို့အားလုံးကို တစ်ကြောင်းတည်းဖြင့် ရေးနိုင်သည်။

print(sorted(l, reverse=True)[:3])
# [23, 18, 7]

print(sorted(l)[:3])
# [-10, -1, 3]

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

print(l)
# [3, 6, 7, -1, 23, -10, 18]

l.sort(reverse=True)
print(l[:3])
# [23, 18, 7]

print(l)
# [23, 18, 7, 6, 3, -1, -10]

l.sort()
print(l[:3])
# [-10, -1, 3]

print(l)
# [-10, -1, 3, 6, 7, 18, 23]

အမြင့်ဆုံးနှင့် အနိမ့်ဆုံးတန်ဖိုးအစီအစဥ်အလိုက် n အစိတ်အပိုင်းများကို ရယူပါ။:heapqမော်ဂျူး

စာရင်းတစ်ခု၏ n အစိတ်အပိုင်းများကို အကြီးဆုံး သို့မဟုတ် အငယ်ဆုံးတန်ဖိုးမှ အစဉ်လိုက်ရယူလိုပါက heapq module ကိုသုံးနိုင်သည်။

heapq module တွင်အောက်ပါလုပ်ဆောင်ချက်ကိုသုံးပါ။ ဤကိစ္စတွင်၊ မူရင်းစာရင်းကို ပြောင်းလဲမည်မဟုတ်ပါ။

  • nlargest()
  • nsmallest()

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

import heapq

l = [3, 6, 7, -1, 23, -10, 18]

print(heapq.nlargest(3, l))
# [23, 18, 7]

print(heapq.nsmallest(3, l))
# [-10, -1, 3]

print(l)
# [3, 6, 7, -1, 23, -10, 18]

အစတွင် ကျွန်တော်ရေးခဲ့သည့်အတိုင်း၊ ပြန်ယူရမည့်ဒြပ်စင်အရေအတွက်သည် ကြီးမားပါက၊ ၎င်းတို့ကို sorted() သို့မဟုတ် sort() ဖြင့် အရင်စီရန် ပိုထိရောက်ပြီး အရေအတွက်သည် သေးငယ်ပါက၊ nargest() နှင့် nsmallest() တို့ဖြစ်သည်။ heapq module က ပိုထိရောက်တယ်။