Python နှင့် အဆင့်မြင့်နည်းလမ်းများ၊ ပိုမိုကောင်းမွန်သော ပရိုဂရမ်ရေးသားခြင်းအတွက် လုပ်ဆောင်ချက်များကို ရှောင်ပါ။

Python သည် အလွန်ကောင်းမွန်သော ပရိုဂရမ်းမင်းဘာသာစကားဖြစ်ပြီး သက်သေပြထားသည့်အတိုင်းဖြစ်သည်။ GitHub2022 တွင် ဒုတိယလူကြိုက်အများဆုံးဘာသာစကားလည်းဖြစ်သည်။

Python ၏ စိတ်ဝင်စားစရာအကောင်းဆုံးအားသာချက်များမှာ ပရိုဂရမ်မာများ၏ ကြီးမားသောအသိုင်းအဝိုင်းဖြစ်သည်။

Python တွင် မည်သည့်ကိစ္စမဆို အသုံးပြုရန်အတွက် ပက်ကေ့ချ်တစ်ခု ပါရှိသည်။

Python ပရိုဂရမ်းမင်း၏ကျယ်ပြောလှသောကမ္ဘာကြီးတွင်၊ အစပြုသူများသတိမပြုမိဘဲဖြစ်နေတတ်သော်လည်း ဘာသာစကား၏ဂေဟစနစ်တွင် သိသာထင်ရှားသောအရေးကြီးသောအင်္ဂါရပ်အစုံရှိပါသည်။

မှော်နည်းလမ်းများသည် ကြိုတင်နည်းလမ်းများဖြစ်သည်။defiအထူး syntactic အင်္ဂါရပ်များကိုပေးဆောင်သော Python ရှိ nites ။ ၎င်းတို့ကို အစနှင့်အဆုံးတွင် ၎င်းတို့၏ အက္ခရာနှစ်ထပ်ဖြင့် အလွယ်တကူ မှတ်မိသည်။ __init__, __call__, __len__ … စသဖြင့်

မှော်နည်းလမ်းများ

မှော်နည်းလမ်းများသည် စိတ်ကြိုက်အရာဝတ္တုများကို တပ်ဆင်ထားသော Python အမျိုးအစားများနှင့် ဆင်တူစွာ ပြုမူနိုင်စေပါသည်။

ဤဆောင်းပါးတွင်၊ ကျွန်ုပ်တို့သည် အားကောင်းသည့် dunder လုပ်ဆောင်ချက်များကို အာရုံစိုက်ပါမည်။ သူတို့ရဲ့ ရည်ရွယ်ချက်ကို လေ့လာပြီး သူတို့ရဲ့ အသုံးပြုမှုကို ဆွေးနွေးပါမယ်။

သင်သည် Python အတွေ့အကြုံမရှိသေးသူ သို့မဟုတ် အတွေ့အကြုံရှိ ပရိုဂရမ်မာတစ်ဦးဖြစ်စေ၊ ဤဆောင်းပါးသည် သင့်အား Dunder လုပ်ဆောင်ချက်များကို ကျယ်ကျယ်ပြန့်ပြန့်နားလည်သဘောပေါက်စေရန် ရည်ရွယ်ပြီး သင်၏ Python ကုဒ်ရေးနည်းကို ပိုမိုထိရောက်ပြီး ပျော်ရွှင်ဖွယ်ဖြစ်စေရန် ရည်ရွယ်ပါသည်။

Python ၏ မှော်အတတ်သည် ၎င်း၏ရိုးရှင်းမှုနှင့် ဘက်စုံသုံးနိုင်မှုတွင်သာမက Dunder လုပ်ဆောင်ချက်များကဲ့သို့ အစွမ်းထက်သောအင်္ဂါရပ်များတွင်ပါရှိသည်။

__init__

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

အတန်းအစား ပီဇာ
    def __init__(ကိုယ်တိုင်၊ အရွယ်အစား၊ ထိပ်တန်းအရာများ-
        self.size = အရွယ်အစား
        self.toppings = ထိပ်ဖျား

# အခု ပီဇာဖန်တီးလိုက်ကြရအောင်
my_pizza = ပီဇာ('အကြီး'၊ ['pepperoni'၊ 'မှို'])

print(my_pizza.size) # ၎င်းသည် print ထုတ်မည်- အကြီး
print(my_pizza.toppings) # ၎င်းသည် ပရင့်ထုတ်ပါမည်- ['pepperoni'၊ 'မှို']

ဤဥပမာတွင် Pizza ဟုခေါ်သော အတန်းတစ်ခုကို ဖန်တီးထားသည်။ စတင်ချိန်၌ သတ်မှတ်ရမည့် ဘောင်များကို ထည့်သွင်းရန် ကျွန်ုပ်တို့၏ __init__ လုပ်ဆောင်ချက်ကို သတ်မှတ်ပြီး ၎င်းတို့ကို ကျွန်ုပ်တို့၏ စိတ်ကြိုက်အရာဝတ္တုအတွက် ဂုဏ်သတ္တိများအဖြစ် သတ်မှတ်ပါသည်။

ဤတွင်၊ ၎င်းကို class ၏ဥပမာကိုကိုယ်စားပြုရန်အသုံးပြုသည်။ ဒီတော့ self.size = size လို့ရေးတဲ့အခါ "ဟေ့၊ ဒီပီဇာအရာဝတ္တုမှာ attribute အရွယ်အစားရှိတယ်၊ sizeပြီးတော့ အရာဝတ္တုကို ဖန်တီးတဲ့အခါ ငါပေးခဲ့တဲ့ အရွယ်အစားပဲ ဖြစ်စေချင်တယ်။"

__str__ နှင့် __repr__

__Str__

ဒါက Python ရဲ့ မှော်နည်းလမ်းတစ်ခုပါ။ defiကျွန်ုပ်တို့၏ စိတ်ကြိုက်ပစ္စည်းအတွက် ဖော်ပြချက်တစ်ခုကို ဖြည့်စွက်ပါ။

သင်သည် အရာဝတ္ထုတစ်ခုကို ပရင့်ထုတ်သောအခါ သို့မဟုတ် ၎င်းကို အသုံးပြု၍ စာကြောင်းအဖြစ်သို့ ပြောင်းလဲပါ။ str()ရှိလျှင် Python ကိုစစ်ဆေးပါ။ defiနည်းလမ်းတစ်ခုရလာတယ်။ __str__ ထိုအရာဝတ္ထု၏အတန်းအတွက်။

သို့ဆိုလျှင်၊ အရာဝတ္ထုကို စာကြောင်းအဖြစ် ပြောင်းရန် ထိုနည်းလမ်းကို အသုံးပြုပါ။

လုပ်ဆောင်ချက်တစ်ခုပါဝင်ရန် ကျွန်ုပ်တို့၏ပီဇာနမူနာကို တိုးချဲ့နိုင်ပါသည်။ __str__ အောက်ပါအတိုင်း:

အတန်းအစား ပီဇာ- def __init__(ကိုယ်တိုင်၊ အရွယ်အစား၊ ထိပ်တန်း) − self.size = အရွယ်အစား self.toppings = toppings def __str__(self): return f"A {self.size} ပီဇာ {','.join(self.toppings ) }" my_pizza = Pizza('large', ['pepperoni', 'mhrooms']) print(my_pizza) # ၎င်းသည် print ထုတ်မည်- pepperoni၊ မှိုပါသော ပီဇာအကြီး၊

__repr__

__str__ လုပ်ဆောင်ချက်သည် အရာဝတ္တုတစ်ခု၏ ဂုဏ်သတ္တိများကို ဖော်ပြခြင်း၏ တရားဝင်နည်းလမ်းတစ်ခုဖြစ်သည်။ အခြားတစ်ဖက်တွင်၊ __repr__ သည် စိတ်ကြိုက်အရာဝတ္တု၏ ပိုမိုတရားဝင်၊ အသေးစိတ်နှင့် မရှင်းလင်းသော ဖော်ပြချက်တစ်ခုပေးရန်အတွက် အသုံးပြုသည်။

ခေါ်ရင် repr() အရာဝတ္ထုတစ်ခုပေါ်တွင် သို့မဟုတ် သင် console ထဲသို့ အရာဝတ္ထုအမည်ကို ရိုက်ထည့်လိုက်ရုံဖြင့် Python သည် နည်းလမ်းတစ်ခုကို ရှာဖွေမည်ဖြစ်သည်။ __repr__.

Se __str__ မဟုတ်ပါဘူး definite မှာ Python ကိုသုံးပါလိမ့်မယ်။ __repr__ အရာဝတ္ထုကို ပရင့်ထုတ်ရန် သို့မဟုတ် ၎င်းကို စာကြောင်းအဖြစ် ပြောင်းရန် ကြိုးစားသောအခါ အရန်အဖြစ်။ ဒါကြောင့် အကြံကောင်း ပေးတတ်တယ်။ defiအနည်းဆုံးပြီးအောင်လုပ်ပါ။ __repr__မပြုလျှင်ပင်၊ defiနစ်စီ __str__.

ဒါကတော့ ကျွန်တော်တို့ ဘယ်လိုဖြစ်နိုင်မလဲ။ defiပြီးအောင် __repr__ ကျွန်ုပ်တို့၏ပီဇာဥပမာအတွက်

အတန်းအစား ပီဇာ
    def __init__(ကိုယ်တိုင်၊ အရွယ်အစား၊ ထိပ်တန်းအရာများ-
        self.size = အရွယ်အစား
        self.toppings = ထိပ်ဖျား

    def __repr__(ကိုယ်တိုင်):
        ပြန်ပို့ f"ပီဇာ('{self.size}'၊ {self.toppings})"

my_pizza = ပီဇာ('အကြီး'၊ ['pepperoni'၊ 'မှို'])
print(repr(my_pizza)) # ၎င်းသည် print ထုတ်ပါမည်- ပီဇာ('large'၊ ['pepperoni', 'mushrooms'])

__repr__ ပီသွန်အမိန့်ပေးသည့်အတိုင်း လုပ်ဆောင်နိုင်သော စာကြောင်းတစ်ခု ပေးသော်လည်း ပီဇာအရာဝတ္တုကို ပြန်လည်ဖန်တီးပါ။ __str__ သင့်အား ပို၍ လူသားဖော်ပြချက် ပေးသည်။ ဒီနည်းတွေကို နည်းနည်းပိုကောင်းအောင် ဝါးစားနိုင်မယ်လို့ မျှော်လင့်ပါတယ်။

__ထည့်__

Python တွင်၊ အော်ပရေတာအသုံးပြု၍ နံပါတ်များထည့်နိုင်သည်ကိုကျွန်ုပ်တို့အားလုံးသိသည်။ +, လာ 3 + 5.

သို့သော် ကျွန်ုပ်တို့သည် စိတ်ကြိုက်အရာဝတ္တုအချို့၏ သာဓကများကို ထည့်လိုလျှင်ကော။

အဆိုပါ dunder function ကို __add__ အဲဒါက ငါတို့ကို ဒီလိုလုပ်ခွင့်ပေးတယ်။ အဲဒါက ကျွန်တော်တို့ကို ပေးနိုင်စွမ်းရှိတယ်။ defiအော်ပရေတာ၏အမူအကျင့်ကိုအဆုံးသတ်ပါ။ + ကျွန်ုပ်တို့၏ စိတ်ကြိုက်ပစ္စည်းများပေါ်တွင်

ရှေ့နောက်ညီညွတ်မှု အကျိုးစီးပွားအတွက် လိုချင်တယ်လို့ ယူဆကြပါစို့ defiအပြုအမူကို ပြီးအောင်လုပ်ပါ။ + ကျွန်ုပ်တို့၏ပီဇာဥပမာတွင်။ ပီဇာ နှစ်ခု သို့မဟုတ် ထို့ထက်ပိုသော ပီဇာများကို ပေါင်းထည့်သည့်အခါတိုင်း ၎င်းသည် ၎င်းတို့၏ ထိပ်တန်း အစားအစာများအားလုံးကို အလိုအလျောက် ပေါင်းစပ်သွားလိမ့်မည် ဟုဆိုကြပါစို့။ ဒါက ဘယ်လိုပုံစံဖြစ်နိုင်သလဲ-

အတန်းအစား ပီဇာ
    def __init__(ကိုယ်တိုင်၊ အရွယ်အစား၊ ထိပ်တန်းအရာများ-
        self.size = အရွယ်အစား
        self.toppings = ထိပ်ဖျား

    def __add__(ကိုယ်တိုင်၊ အခြား):
        isinstance (အခြား၊ ပီဇာမဟုတ်လျှင်)
            TypeError ကိုမြှင့်ပါ("သင်သည်အခြားပီဇာတစ်ခုသာထည့်နိုင်သည်။")
        new_toppings = self.toppings + other.toppings
        ပြန်ပေးမည့် ပီဇာ(self.size, new_toppings)

# ပီဇာနှစ်ခုဖန်တီးလိုက်ရအောင်
pizza1 = ပီဇာ('ကြီး'၊ ['pepperoni'၊ 'မှို'])
ပီဇာ၂ = ပီဇာ('ကြီး'၊ ['သံလွင်'၊ 'နာနတ်သီး'])

# အခုသူတို့ကို "ထည့်" လိုက်ကြရအောင်
รวม_ပီဇာ = ပီဇာ၁ + ပီဇာ ၂

print(combined_pizza.toppings) # ၎င်းသည် ပုံနှိပ်ထုတ်ဝေပါမည်- ['pepperoni'၊ 'မှို'၊ 'သံလွင်'၊ 'နာနတ်သီး']

ကြမ်းကြုတ်ဖို့လည်း အလားတူပါပဲ။ __add__ငါတို့လည်း လုပ်နိုင်ပါတယ်။ defiကဲ့သို့သော အခြားဂဏန်းသင်္ချာလုပ်ဆောင်ချက်များကို အပြီးသတ်ပါ။ __sub__ (အော်ပရေတာအသုံးပြု၍ အနုတ်အားဖြင့် -) နှင့် __mul__ (အော်ပရေတာအသုံးပြု၍ မြှောက်ခြင်းအတွက် *).

__len__

ဒီနည်းက ကျွန်တော်တို့ကို နိုင်စေတယ်။ defiလုပ်ဆောင်ချက်ကို အပြီးသတ်ပါ။ len() ကျွန်ုပ်တို့၏စိတ်ကြိုက်ပစ္စည်းများအတွက် ပြန်ပေးရပါမည်။

Python ကိုအသုံးပြုသည်။ len() စာရင်း သို့မဟုတ် စာကြောင်းကဲ့သို့ ဒေတာဖွဲ့စည်းပုံ၏ အရှည် သို့မဟုတ် အရွယ်အစားကို ရယူရန်။

ကျွန်ုပ်တို့၏ဥပမာ၏စကားရပ်တွင်၊ ပီဇာတစ်ခု၏ "အရှည်" သည် ၎င်းတွင်ပါရှိသော toppings အရေအတွက်ဟု ဆိုနိုင်သည်။ အဲဒါကို ကျွန်တော်တို့ ဘယ်လို အကောင်အထည်ဖော်နိုင်မလဲဆိုတာက ဒီလိုပါ။

အတန်းအစား ပီဇာ
    def __init__(ကိုယ်တိုင်၊ အရွယ်အစား၊ ထိပ်တန်းအရာများ-
        self.size = အရွယ်အစား
        self.toppings = ထိပ်ဖျား

    def __len__(ကိုယ်တိုင်):
        return len(self.toppings)

#ပီဇာဖန်တီးကြရအောင်
my_pizza = ပီဇာ('အကြီး'၊ ['pepperoni'၊ 'မှို'၊ 'သံလွင်'])

print(len(my_pizza)) # ၎င်းသည် print ထုတ်မည်- ၃

__len__ နည်းလမ်းတွင်၊ ကျွန်ုပ်တို့သည် စာရင်း၏အရှည်ကိုသာ ပြန်ပေးသည်။ toppings။ အခုတော့ len(my_pizza) ၎င်းတွင် toppings မည်မျှရှိသည်ကိုပြောပြလိမ့်မည်။ my_pizza.

__လုပ်ထုံးလုပ်နည်း __

ဤ dunder method သည် အရာဝတ္တုများကို ထပ်ကာထပ်ကာဖြစ်စေရန် ခွင့်ပြုသည်၊ ဆိုလိုသည်မှာ ၎င်းကို for loop တွင်သုံးနိုင်သည်။

ဒီလိုလုပ်ဖို့လည်း ကျွန်တော်တို့ လုပ်ရမယ်။ defifunction ကို အပြီးသတ်ပါ။ __next__, ဤသည်အသုံးပြုသည်။ defiiteration တွင် နောက်တန်ဖိုးကို ပြန်ပေးမည့် အပြုအမူကို နိပ်ပါ။ ၎င်းသည် အစီအစဥ်တွင် နောက်ထပ်ဒြပ်စင်များမရှိတော့ကြောင်း အဖြစ်အပျက်တွင် ထပ်တလဲလဲအချက်ပြသင့်သည်။ ကျွန်ုပ်တို့သည် ခြွင်းချက်တစ်ခုအား ပစ်ချခြင်းဖြင့် ၎င်းကို ပုံမှန်အားဖြင့် ရရှိနိုင်သည်။ StopIteration.

ကျွန်ုပ်တို့၏ပီဇာနမူနာအတွက်၊ ကျွန်ုပ်တို့သည် toppings များကို ထပ်လောင်းလိုသည်ဆိုကြပါစို့။ ကျွန်တော်တို့ရဲ့ Pizza အတန်းကို ပိုအဆင်ပြေအောင် လုပ်နိုင်ပါတယ်။ defiနည်းလမ်းတစ်ခု __iter__:

အတန်းအစား ပီဇာ
    def __init__(ကိုယ်တိုင်၊ အရွယ်အစား၊ ထိပ်တန်းအရာများ-
        self.size = အရွယ်အစား
        self.toppings = ထိပ်ဖျား

    def __iter__(ကိုယ်တိုင်):
        self.n = ၀
        ကိုယ့်ကိုယ်ကိုပြန်ပါ။

    def __next__(ကိုယ်တိုင်):
        အကယ်၍ self.n < len(self.toppings):
            ရလဒ် = self.toppings[self.n]
            self.n += ၁
            ရလဒ်
        အခြား:
            StopIteration ကိုမြှင့်ပါ။

#ပီဇာဖန်တီးကြရအောင်
my_pizza = ပီဇာ('အကြီး'၊ ['pepperoni'၊ 'မှို'၊ 'သံလွင်'])

# အခုပဲ ထပ်ပြောကြည့်ရအောင်
my_pizza တွင် topping အတွက်
    ပုံနှိပ်ခြင်း(topping)

ဤကိစ္စတွင်၊ for loop ခေါ်ဆိုမှုများ __iter__ကောင်တာတစ်ခုကို အစပြုသည်။ (self.n) ပြီးတော့ ပီဇာကို သူ့ဘာသာသူ ပြန်ပေးတယ်။ (self).

ထို့နောက် for loop calls များ __next__ တစ်လှည့်စီ topping ရဖို့။

Quando __next__ ဟင်းခတ်အမွှေးအကြိုင်တွေ အကုန်ပြန်ပေး၊ StopIteration ၎င်းသည် ခြွင်းချက်တစ်ခုအား လွှတ်ချလိုက်ပြီး for loop သည် ယခုတွင် toppings များမရှိတော့သည်ကို သိသောကြောင့် ထပ်ကာထပ်ကာလုပ်ခြင်းလုပ်ငန်းစဉ်ကို ပျက်စေမည်ဖြစ်သည်။

Ercole Palmeri