မာတိကာ[ဖျောက်][ရှိုး]
ဤဟောပြောပွဲတွင်၊ အတန်းများ၊ တည်ဆောက်သူများနှင့် python တွင် အမွေဆက်ခံမှုများအကြောင်း လေ့လာပါမည်။
မတူညီသောအမျိုးအစားများကို သတ်မှတ်ရန်လိုအပ်သည့် ပရိုဂရမ်ကြီးတစ်ခုတွင် ဤသဘောတရားများသည် အမှန်တကယ်အရေးကြီးပါသည်။
အတန်း
အတန်းများသည် ပရိုဂရမ်ရေးသားခြင်းတွင် မရှိမဖြစ်လိုအပ်ပြီး ၎င်းတို့သည် python နှင့် သီးခြားမဟုတ်ပါ။ တခြား အများကြီး programming ဘာသာစကားများ အတန်း၏သဘောတရားကိုထောက်ခံသည်။ ကျွန်ုပ်တို့သည် ဒေတာအမျိုးအစားအသစ်များကို သတ်မှတ်ရန် အတန်းများကို အသုံးပြုပါသည်။
ယခုအချိန်အထိ၊ Python တွင် နံပါတ်များ၊ စာကြောင်းများနှင့် booleans ကဲ့သို့သော အခြေခံဒေတာအမျိုးအစားများအကြောင်း လေ့လာသိရှိထားပြီးဖြစ်သည်။ ၎င်းတို့သည် Python ရှိ အခြေခံ သို့မဟုတ် ရိုးရှင်းသော ဒေတာအမျိုးအစားများဖြစ်သည်။ စာရင်းများနှင့် အဘိဓာန်များကဲ့သို့ ရှုပ်ထွေးသော ဒေတာအမျိုးအစားအချို့ကိုလည်း ကျွန်ုပ်တို့တွေ့ခဲ့ရသည်။
ဤအမျိုးအစားများသည် အလွန်အသုံးဝင်သော်လည်း ၎င်းတို့ကို ရှုပ်ထွေးသော အယူအဆများကို စံနမူနာပြုရန်အတွက် အမြဲတမ်းအသုံးမပြုနိုင်ပါ။ ဥပမာ၊ အချက်တစ်ခု သို့မဟုတ် စျေးဝယ်လှည်းတစ်ခုကို စဉ်းစားပါ။ စျေးဝယ်လှည်းသည် boolean သို့မဟုတ် စာရင်းတစ်ခုမဟုတ်ပါ။ ၎င်းသည် မတူညီသောဒေတာအမျိုးအစားဖြစ်သည်။ ထို့ကြောင့် ကျွန်ုပ်တို့သည် စစ်မှန်သော သဘောတရားများကို စံနမူနာပြုရန်အတွက် အမျိုးအစားအသစ်များကို သတ်မှတ်ရန် အတန်းများကို အသုံးပြုနိုင်သည်။
ယခု၊ point ဟုခေါ်သော ဒေတာအမျိုးအစားအသစ်ကို သတ်မှတ်ကြပါစို့။ ဤအမျိုးအစားအသစ်တွင် ကျွန်ုပ်တို့အရင်စစ်ဆေးထားသည့်အတိုင်း နည်းလမ်းများရှိနေမည်ဖြစ်သည်။
ဤသည်မှာ သင်ပြုလုပ်မည့်နည်းဖြစ်သည်-
ကျွန်ုပ်တို့သည် “အတန်း” သော့ချက်စကားလုံးကို အသုံးပြု၍ အတန်းတစ်ခုကို သတ်မှတ်ခြင်းဖြင့် စတင်ပြီး ကျွန်ုပ်တို့၏အတန်းအမည်ကို ပေးပြီးနောက်တွင် ကျွန်ုပ်တို့ စတင်ပါသည်။
class Point
ယခု ဤနေရာတွင် ကျွန်ုပ်အသုံးပြုခဲ့သည့် အမည်ပေးသည့် ကွန်ဗင်းရှင်းကို ကြည့်ပါ။ ပထမစာလုံးကို ဒီမှာ စာလုံးအကြီးနဲ့ရေးထားပြီး၊ ဒါကို ပါစကယ်အမည်ပေးခြင်း ကွန်ဗင်းရှင်းလို့ခေါ်တယ်။ ဤစည်းဝေးကြီးသည် ကျွန်ုပ်တို့၏ကိန်းရှင်များနှင့် လုပ်ဆောင်ချက်များကို အမည်ပေးရန်အတွက် ကျွန်ုပ်တို့အသုံးပြုသည့်ပုံစံနှင့် ကွဲပြားသည် သို့သော် အတန်းများကို အမည်ပေးသောအခါတွင် စကားလုံးများစွာကို ခွဲထုတ်ရန် အောက်တန်းကို မသုံးဘဲ စကားလုံးတိုင်း၏ ပထမစာလုံးကို စာလုံးကြီးဖြင့် ရေးပါသည်။
ကျွန်ုပ်တို့၏အတန်းကိုသတ်မှတ်ပြီးနောက်၊ ကော်လံတစ်ခုကိုအသုံးပြုသည်၊ ဆိုလိုသည်မှာ ယခုအခါ ဘလောက်တစ်ခုကို သတ်မှတ်လိုက်ခြင်းဖြစ်သည်။
class Point:
def move (self):
ဤဘလောက်တွင်၊ အမှတ်များနှင့်သက်ဆိုင်သည့် လုပ်ဆောင်ချက်များ သို့မဟုတ် နည်းလမ်းအားလုံးကို ကျွန်ုပ်တို့ သတ်မှတ်နိုင်သည်။ ဥပမာအားဖြင့်၊ အမှတ်တစ်ခုရွှေ့ရန်အတွက် “ရွှေ့” ဟုခေါ်သော လုပ်ဆောင်ချက်ကို ကျွန်ုပ်တို့ သတ်မှတ်နိုင်သည်။ အဖွင့်ကွင်းပိတ်ရိုက်ပြီးသည်နှင့် PyCharm သည် ဤနေရာတွင် "self" အလိုအလျောက်ထည့်ကြောင်း သတိပြုပါ။ ဤသည်မှာ အထူးသော့ချက်စာလုံးဖြစ်ပြီး ကျွန်ုပ်အား ဤအရာကို မကြာမီ ပြန်ပြောပြပါမည်။ terminal တွင် "ရွှေ့" ကို print ထုတ်ကြပါစို့။
print("move")
“draw” ကဲ့သို့သော အခြားနည်းလမ်းကို သတ်မှတ်ပြီး ၎င်းကို terminal တွင် ပရင့်ထုတ်ကြပါစို့။
def draw(self):
print("draw")
ကျွန်ုပ်တို့၏ “အမှတ်” အတန်း၏ အဓိပ္ပါယ်ဖွင့်ဆိုချက်ဖြင့် ပြီးပါပြီ။ ဤအမျိုးအစားအသစ်ဖြင့်၊ ကျွန်ုပ်တို့သည် အရာဝတ္ထုအသစ်များကို ဖန်တီးနိုင်သည်။ အတန်းတစ်ခုသည် အဆိုပါအသေးစိတ်ပုံစံအပေါ်အခြေခံ၍ အမှန်တကယ်ဖြစ်ရပ်များဖြစ်သည့် အရာဝတ္ထုများဖန်တီးရန်အတွက် ပုံစံခွက်ပုံစံ သို့မဟုတ် ပုံစံခွက်ကို ရိုးရိုးရှင်းရှင်းသတ်မှတ်သည်။ အရာဝတ္ထုတစ်ခုဖန်တီးရန်၊ ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏အတန်း၏အမည်ကို ရိုက်ထည့်ပြီးနောက် ၎င်းကို လုပ်ဆောင်ချက်တစ်ခုကဲ့သို့ ခေါ်သည်။ ၎င်းသည် အရာဝတ္ထုအသစ်တစ်ခုကို ဖန်တီးပြီး ၎င်းကို ပြန်ပေးသည်။ ထို့နောက် ထိုအရာဝတ္ထုကို ကိန်းရှင်တစ်ခုတွင် သိမ်းဆည်းနိုင်သည်။ ငါ မင်းကို ပြပါရစေ-
ဤနေရာတွင် ကျွန်ုပ်တို့သည် သုံးဖက်မြင်အမှတ်ဖြစ်သည့် “point1” ကို သတ်မှတ်ပေးထားပါသည်။ ကျွန်ုပ်တို့သည် terminal တွင်တစ်ဦးချင်းစီသြဒိနိတ်များကိုပုံနှိပ်နိုင်သည်ကိုသင်တွေ့မြင်နိုင်သည်။
ဤအချက်ဖြင့် "ဆွဲ" နှင့် "ရွှေ့" နည်းလမ်းနှစ်ခုကို ကျွန်ုပ်တို့ အသုံးပြုနိုင်ပါသည်။
ထို့ကြောင့် ပြန်ချုပ်ရန်၊ အမျိုးအစားအသစ်များကို သတ်မှတ်ရန် အတန်းများကို အသုံးပြုပြီး ဤအမျိုးအစားများသည် အတန်း၏ကိုယ်ထည်တွင် ကျွန်ုပ်တို့သတ်မှတ်ထားသော နည်းလမ်းများ ရှိနိုင်ပါသည်။ အတန်းများတွင် ကျွန်ုပ်တို့၏ ပရိုဂရမ်များတွင် မည်သည့်နေရာတွင်မဆို သတ်မှတ်နိုင်သည့် အရည်အချင်းများ ရှိနိုင်ပါသည်။
ဆောက်လုပ်ရေးလုပ်ငန်း
ယခုအချိန်အထိ၊ အတန်းများကို အသုံးပြု၍ အမျိုးအစားအသစ်များ ဖန်တီးနည်းကို ကျွန်ုပ်တို့ လေ့လာခဲ့ပြီးဖြစ်သည်။ အခု ဒီအကောင်အထည်ဖော်မှုမှာ ပြဿနာလေးတစ်ခုရှိတယ်။ ကျွန်ုပ်တို့သည် အတန်းများကို အသုံးပြု၍ x သို့မဟုတ် y သြဒိနိတ်မပါဘဲ အမှတ်အရာဝတ္ထုတစ်ခုကို ဖန်တီးနိုင်သည်၊ ၎င်းသည် စံပြမဟုတ်ပေ။ ပြပါရစေ။
x coordinate ကို မသတ်မှတ်ခင် အမှတ်တစ်ခုကို ဖန်တီးပြီး ပရင့်ထုတ်ကြပါစို့။ ကျွန်ုပ်တို့၏ပရိုဂရမ်ကိုလုပ်ဆောင်ခြင်းသည် ဤကဲ့သို့သော attribute error ကိုဖြစ်စေသည်-
ဆိုလိုသည်မှာ point object တွင် x ဟုခေါ်သော attribute မရှိပါ။ ယခုပြဿနာမှာ x သို့မဟုတ် y သြဒိနိတ်များမပါဘဲ point object တစ်ခုရှိနိုင်သည် ။ အချက်တစ်ခုအကြောင်းပြောတိုင်း အဲဒီအချက်က ဘယ်မှာလဲဆိုတာ သိဖို့လိုတယ်။ ဤပြဿနာကိုဖြေရှင်းရန် constructor ကိုအသုံးပြုသည်။ constructor သည် object တစ်ခုကို ဖန်တီးချိန်တွင် ခေါ်ဝေါ်သော function တစ်ခုဖြစ်သည်။
ဒါက constructor ကိုအသုံးပြုပုံပါ။ ဦးစွာ၊ အထက်ပရိုဂရမ်ရှိ x နှင့် y သြဒိနိတ်တန်ဖိုးများကို ကျော်ဖြတ်ကြပါစို့။
point = Point(10, 20)
print(point.x)
ယခု၊ constructor ဟုခေါ်သော ဤအတန်းတွင် အထူးနည်းလမ်းတစ်ခုကို ထည့်ရန်လိုသည်။ ၎င်း၏ syntax သည် ဤကဲ့သို့ဖြစ်သည်-
def __init__(self, x, y):
init
အစပြုခြင်းအတွက် အတိုကောက်ဖြစ်ပြီး ၎င်းသည် အမှတ်အသစ်တစ်ခုကို ဖန်တီးသည့်အခါ ၎င်းသည် လုပ်ဆောင်ချက် သို့မဟုတ် နည်းလမ်းဖြစ်သည်။ x နဲ့ y ကို ပြီးတာနဲ့ ပေါင်းထည့်တယ်။ self
အပိုဘောင်နှစ်ခုထည့်ရန်။
ထို့နောက် x နှင့် y ကို 10 နှင့် 20 ဖြစ်သည့် လွန်တန်ဖိုးများနှင့် မြေပုံဆွဲသင့်သည်။
self.x = x
self.y = y
ငါတို့သုံးတယ် self
လက်ရှိအရာဝတ္တုကိုရည်ညွှန်းရန်၊ ထို့နောက် function “x” သို့ပေးပို့သော x အငြင်းအခုံသို့ x attribute ကို သတ်မှတ်ပေးသည်။ ဒီနည်းနဲ့ သုံးတယ်။ init
နည်းလမ်း၊ ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏ အရာဝတ္ထုများကို အစပြုနိုင်သည်။ ဤနည်းလမ်းကို constructor ဟုခေါ်သည်။ ကျွန်တော်တို့ရဲ့ program ကို run ကြရအောင်။
ယခု၊ ကျွန်ုပ်တို့သည် x နှင့် y သြဒိနိတ်များကို နောက်ပိုင်းတွင် ပြောင်းလဲနိုင်သည်။ x coordinate ကို အပ်ဒိတ်လုပ်ကြရအောင်။
point = Point(10, 20)
point.x = 11
print(point.x)
ယခု၊ x သြဒိနိတ်ကို တန်ဖိုး 11 သို့ အပ်ဒိတ်လုပ်ထားသည်။
လေ့ကျင့်
ဒါကတော့ သင့်အတွက် စိတ်ဝင်စားစရာကောင်းတဲ့ လေ့ကျင့်ခန်းတစ်ခုပါ။
လူလို့ခေါ်တဲ့ အမျိုးအစားအသစ်ကို မင်းကို သတ်မှတ်စေချင်တယ်။ ဤ "ပုဂ္ဂိုလ်" အရာဝတ္ထုများတွင် "ရှိသင့်သည်"name
"ဂုဏ်သတ္တိအပြင်"talk()
"နည်းလမ်း။
၎င်းသည် ရိုးရှင်းသောအလုပ်ဖြစ်ပြီး မိနစ်အနည်းငယ်ထက် ပိုမယူသင့်ပါ။
ဖြေရှင်းချက်
ဤကဲ့သို့သောအတန်း "လူ" ကိုသတ်မှတ်ခြင်းဖြင့်စတင်ပါ။
class Person:
self.name = name
နောက်မှ constructor ကို သတ်မှတ်ပါမယ်။ ယခု၊ ကျွန်ုပ်တို့သည် "Person" အရာဝတ္ထုကိုဖန်တီးနိုင်သည်။ John လို့ ခေါ်ရအောင်
john = Person("John Smith")
print(john.name)
john.talk()
ယခု၊ ကုဒ်၏ပထမအပိုင်းသို့သွားကာ constructor တစ်ခုကိုဖန်တီးပါ။
def __init__(self, name):
နောက်ဆုံးကုဒ်သည် ဤကဲ့သို့ဖြစ်လိမ့်မည်-
အတန်းများနှင့် တည်ဆောက်သူများနှင့်အတူ ဖော်မတ်လုပ်ထားသော စာကြောင်းများနှင့် အခြားသော သဘောတရားများကိုလည်း သင်အသုံးပြုနိုင်ပါသည်။
အမွေကို
Inheritance သည် သင့်အား ကုဒ်တစ်ခုကို ပြန်သုံးနိုင်စေမည့် အတန်းများနှင့် ဆက်စပ်နေသော အခြားအယူအဆတစ်ခုဖြစ်သည်။
ဤကုဒ်အပိုင်းအစကို သုံးသပ်ကြည့်ပါ။
class Dog:
def walk(self):
print("walk")
ကျွန်ုပ်တို့သည် “လမ်းလျှောက်” နည်းလမ်းဖြင့် “ခွေး” အတန်းကို ဖန်တီးထားသည်။ ဤနည်းလမ်းတွင်၊ ကျွန်ုပ်တို့သည် terminal ပေါ်ရှိ လမ်းလျှောက် မက်ဆေ့ချ်ကို ရိုးရိုးရှင်းရှင်း ရိုက်နှိပ်ခြင်း ဖြစ်ပါသည်။ ဆိုကြပါစို့၊ တကယ့်ပရိုဂရမ်မှာ၊ ဒီမှာ စာကြောင်းတစ်ကြောင်းတည်းအစား ကုဒ် ၁၀ ကြောင်းရှိတယ်။ အနာဂတ်တွင်၊ "လမ်းလျှောက်ခြင်း" နည်းလမ်းရှိရန် အခြားအတန်းတစ်ခု လိုအပ်ပါက၊ ကျွန်ုပ်တို့သည် ထိုကုဒ်အားလုံးကို ပြန်လုပ်ရမည်ဖြစ်ပါသည်။ ဒါက စံပြမဟုတ်ပါဘူး။
ပရိုဂရမ်ရေးဆွဲခြင်းတွင်၊ ကျွန်ုပ်တို့တွင် DRY ဟုခေါ်သော နိယာမတစ်ခုရှိပြီး သင့်ကိုယ်သင် ထပ်ခါတလဲလဲ မလုပ်ရန် အတိုကောက်ဖြစ်သည်။ နောင်တစ်ချိန်ချိန်တွင် ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏ "လမ်းလျှောက်ခြင်း" နည်းလမ်းဖြင့် ပြဿနာတစ်ခုကို ရှာဖွေတွေ့ရှိပြီး ဤနည်းလမ်းကို အခြားနေရာများစွာတွင် ထပ်ခါထပ်ခါ သို့မဟုတ် ထပ်ပွားပါက၊ ကျွန်ုပ်တို့ ဤပုံပွားထားသော နေရာတိုင်းတွင် အဆိုပါပြဿနာကို ပြန်လည်ဖြေရှင်းရမည်ဖြစ်ပါသည်။ ကုဒ်။ ဒါကြောင့် ပရိုဂရမ်ရေးခြင်းမှာ တစ်ခုခုကို နှစ်ခါမသတ်မှတ်သင့်ပါဘူး။
ဤပြဿနာကို ကုစားရန် ကွဲပြားသော ချဉ်းကပ်နည်းများ ရှိသော်လည်း ယခုတွင် စတင်သူများအတွက် ပိုမိုလွယ်ကူသော ပညာရပ်ကို လေ့လာပြီး အမွေဆက်ခံခြင်းဟုခေါ်သည်။ ဤကိစ္စတွင်၊ ကျွန်ုပ်တို့သည် အခြားအတန်းအစား “နို့တိုက်သတ္တဝါ” ကို ဖန်တီးပြီး ထိုအတန်းတွင် ကျွန်ုပ်တို့၏ “လမ်းလျှောက်ခြင်း” ရည်ညွှန်းချက်ကို သတ်မှတ်ပါမည်။
class Mammal:
def walk(self):
print("walk")
ကျွန်ုပ်တို့၏ “နို့တိုက်သတ္တဝါ” အတန်းအစားကို သတ်မှတ်ပြီးနောက် ဤကဲ့သို့သော ဂုဏ်ရည်များကို ကျော်ဖြတ်ရန် အမွေဆက်ခံမှုကို အသုံးပြုနိုင်သည်။
ခွေးနှင့်ကြောင်အတန်းနှစ်ခုစလုံးသည် ၎င်းတို့၏မိဘအတန်းတွင် သတ်မှတ်ထားသော အတန်းနည်းလမ်းအားလုံးကို အမွေဆက်ခံကြသည်။ ယခု၊ ဤကဲ့သို့သောခွေးများအတွက် သီးခြားနည်းလမ်းများကို ထည့်သွင်းနိုင်သည်-
class Dog:
def bark(self):
print("bark")
အပြီးသတ်သည်!
ဤအရာအားလုံးသည် အတန်းများ၊ တည်ဆောက်သူများနှင့် အမွေဆက်ခံခြင်းဆိုင်ရာ အယူအဆများဖြင့် အတန်းများတွင် ကုဒ်ကို ပြန်လည်အသုံးပြုခြင်းအကြောင်းဖြစ်သည်။ ယခု ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏ စီးရီး၏ အဆုံးကို နီးကပ်နေပြီဖြစ်သည်။ ဤအချက်ဖြင့် သင်သည် Python တွင် ကောင်းမွန်သော၊ ဖတ်နိုင်သော၊ တိုတိုတုတ်တုတ် ကုဒ်များကို ထုတ်လုပ်နိုင်သင့်သည်။
နောက်သင်ခန်းစာတွင် modules နှင့် packages များ၏ concept ကိုတွေ့ရပါမည်။
တစ်ဦးစာပြန်ရန် Leave