Բառը[Թաքցնել][Ցուցադրում]
Այս դասախոսության ընթացքում մենք կսովորենք դասերի, կոնստրուկտորների և python-ի ժառանգության մասին:
Այս հասկացություններն իսկապես կարևոր են մեծ ծրագրում, որտեղ տարբեր տեսակներ պետք է սահմանվեն:
Դասեր
Դասերը կարևոր են ծրագրավորման մեջ և հատուկ չեն python-ին: Շատ ուրիշներ ծրագրավորման լեզուները աջակցել դասերի հասկացությանը: Մենք օգտագործում ենք դասեր տվյալների նոր տեսակներ սահմանելու համար:
Մինչ այժմ մենք իմացել ենք Python-ի հիմնական տվյալների տեսակների մասին, ինչպիսիք են թվերը, տողերը և բուլյանները: Սրանք Python-ի հիմնական կամ պարզ տվյալների տեսակներն են: Մենք նաև տեսել ենք տվյալների մի քանի բարդ տեսակներ, ինչպիսիք են ցուցակները և բառարանները:
Թեև այս տեսակները չափազանց օգտակար են, դրանք միշտ չեն կարող օգտագործվել բարդ հասկացությունների մոդելավորման համար: Օրինակ, մտածեք կետի կամ զամբյուղի գաղափարի մասին: Գնումների զամբյուղը բուլյան կամ ցուցակ չէ: Դա այլ տեսակի տվյալներ են: Այսպիսով, մենք կարող ենք դասեր օգտագործել՝ իրական հասկացությունների մոդելավորման համար նոր տեսակներ սահմանելու համար:
Այժմ, եկեք սահմանենք տվյալների նոր տեսակ, որը կոչվում է կետ: Այս նոր տեսակը կունենա մեթոդներ, ինչպես մենք նախկինում ստուգել ենք:
Ահա թե ինչպես դուք դա կանեք.
Մենք սկսում ենք դաս սահմանելով՝ օգտագործելով «class» հիմնաբառը և անմիջապես դրանից հետո տալիս ենք մեր դասին անվանում:
class Point
Այժմ տեսեք անվանման կոնվենցիան, որը ես օգտագործել եմ այստեղ: Ես այստեղ մեծատառ եմ գրել առաջին տառը, սա այն է, ինչ մենք անվանում ենք պասկալ անվանման կոնվենցիա: Այս կոնվենցիան տարբերվում է նրանից, որը մենք օգտագործում ենք մեր փոփոխականների և ֆունկցիաների անվանման համար, որոնց համար մենք միշտ օգտագործում ենք փոքրատառեր և առանձնացնում մի քանի բառեր՝ օգտագործելով ընդգծում: Բայց դասեր անվանելիս մենք չենք օգտագործում ընդգծում մի քանի բառեր առանձնացնելու փոխարեն, մենք մեծատառով գրում ենք յուրաքանչյուր բառի առաջին տառը:
Մեր դասը սահմանելուց հետո օգտագործվում է երկու կետ, ինչը նշանակում է, որ այժմ բլոկ է սահմանված:
class Point:
def move (self):
Այս բլոկում մենք կարող ենք սահմանել բոլոր գործառույթները կամ մեթոդները, որոնք պատկանում են կետերին: Օրինակ, մենք կարող ենք սահմանել ֆունկցիա, որը կոչվում է «տեղափոխել»՝ կետ տեղափոխելու համար: Նկատի ունեցեք, որ հենց որ մենք մուտքագրում ենք բաց փակագծեր, PyCharm-ն այստեղ ավտոմատ կերպով ավելացնում է «self»: Սա հատուկ բանալի բառ է, և թույլ տվեք շուտով վերադառնալ դրան: Եկեք տպենք «տեղափոխել» տերմինալի վրա:
print("move")
Եկեք սահմանենք մեկ այլ մեթոդ, ինչպիսին է «նկարել» և տպել այն տերմինալի վրա:
def draw(self):
print("draw")
Մենք ավարտեցինք մեր «կետ» դասի սահմանումը: Այս նոր տեսակի միջոցով մենք կարող ենք նոր օբյեկտներ ստեղծել: Դասը պարզապես սահմանում է նախագիծը կամ ձևանմուշը օբյեկտների ստեղծման համար, որոնք իրական օրինակներ են՝ հիմնված այդ նախագծի վրա: Օբյեկտ ստեղծելու համար մենք մուտքագրում ենք մեր դասի անունը, այնուհետև այն անվանում ենք ֆունկցիայի նման: Սա ստեղծում է նոր օբյեկտ և այն վերադարձնում: Այնուհետև մենք կարող ենք պահել այդ օբյեկտը փոփոխականում: Թույլ տվեք ցույց տալ ձեզ:
Այստեղ մենք սահմանել ենք «կետ 1», որը եռաչափ կետ է: Դուք կարող եք տեսնել, որ մենք կարող ենք անհատական կոորդինատներ տպել տերմինալի վրա:
Այս կետով մենք կարող ենք օգտագործել երկու մեթոդները՝ «գծել» և «տեղափոխել»:
Այսպիսով, ամփոփելու համար, մենք օգտագործում ենք դասեր՝ նոր տեսակներ սահմանելու համար, և այս տիպերը կարող են ունենալ մեթոդներ, որոնք մենք սահմանում ենք դասի մարմնում: Դասերը կարող են ունենալ ատրիբուտներ, որոնք մենք կարող ենք սահմանել մեր ծրագրերի ցանկացած կետում:
Կոնստրուկտորներ
Մինչ այժմ մենք սովորել ենք, թե ինչպես ստեղծել նոր տեսակներ՝ օգտագործելով դասերը։ Հիմա այս իրականացման հետ կապված մի փոքր խնդիր կա. Մենք կարող ենք կետային օբյեկտ ստեղծել առանց x կամ y կոորդինատների՝ օգտագործելով դասեր, և դա իդեալական չէ: Թույլ տվեք ցույց տալ ձեզ.
Եկեք ստեղծենք կետ և տպենք այն նախքան x կոորդինատը դնելը: Մեր ծրագրի գործարկումը հանգեցնում է հետևյալ հատկանիշի սխալի.
Նշանակում է, որ կետային օբյեկտը չունի x կոչվող հատկանիշ: Հիմա խնդիրն այն է, որ հնարավոր է ունենալ կետային օբյեկտ առանց x կամ y կոորդինատների։ Սա իմաստ չունի, քանի որ երբ մենք խոսում ենք մի կետի մասին, մենք պետք է իմանանք, թե որտեղ է գտնվում այդ կետը: Այս խնդիրը լուծելու համար մենք օգտագործում ենք կոնստրուկտոր։ Կոնստրուկտորը ֆունկցիա է, որը կանչվում է օբյեկտ ստեղծելու պահին:
Ահա թե ինչպես ենք մենք օգտագործում կոնստրուկտորը. Նախ, եկեք փոխանցենք x և y կոորդինատների արժեքները վերը նշված ծրագրում:
point = Point(10, 20)
print(point.x)
Այժմ մենք պետք է այս դասում ավելացնենք հատուկ մեթոդ, որը կոչվում է կոնստրուկտոր: Դրա շարահյուսությունը այսպիսին է.
def __init__(self, x, y):
init
Նախնականացված բառի կարճ է, և սա այն ֆունկցիան կամ մեթոդն է, որը կանչվում է, երբ ստեղծվում է նոր կետային օբյեկտ: x-ը և y-ն ավելացվում են անմիջապես հետո self
երկու լրացուցիչ պարամետր ավելացնելու համար:
Դրանից հետո մենք պետք է քարտեզագրենք x-ը և y-ն անցած արժեքներին, այսինքն՝ 10 և 20
self.x = x
self.y = y
Մենք օգտագործում ենք self
հղում կատարել ընթացիկ օբյեկտին, այնուհետև մենք սահմանել ենք x հատկանիշը «x» ֆունկցիային փոխանցված x արգումենտին: Այս կերպ, օգտագործելով init
մեթոդով, մենք կարող ենք նախաստորագրել մեր օբյեկտները: Այս մեթոդը կոչվում է կոնստրուկտոր: Եկեք գործարկենք մեր ծրագիրը:
Այժմ մենք կարող ենք ավելի ուշ փոխել x և y կոորդինատները: Թարմացնենք x կոորդինատը՝
point = Point(10, 20)
point.x = 11
print(point.x)
Այժմ x կոորդինատը թարմացվում է մինչև 11 արժեք:
Վարժություն
Ահա ձեզ համար հետաքրքիր վարժություն.
Ես ուզում եմ, որ դուք սահմանեք նոր տեսակ, որը կոչվում է մարդ: Այս «անձ» օբյեկտները պետք է ունենան «name
«հատկանիշը, ինչպես նաև «talk()
»Մեթոդը:
Դա պարզ խնդիր է և չպետք է տևի մի քանի րոպեից ավելի:
լուծում
Սկսեք սահմանել «Անձ» դասը այսպես.
class Person:
self.name = name
Կոնստրուկտորին կսահմանենք ավելի ուշ։ Այժմ մենք կարող ենք ստեղծել «Person» օբյեկտը: Եկեք այն անվանենք Ջոն
john = Person("John Smith")
print(john.name)
john.talk()
Այժմ անցեք կոդի առաջին մասին և ստեղծեք կոնստրուկտոր:
def __init__(self, name):
Վերջնական ծածկագիրը կունենա հետևյալ տեսքը.
Կարող եք նաև օգտագործել ֆորմատավորված տողեր և այլ հասկացություններ դասերի և կոնստրուկտորների հետ համատեղ:
Ժառանգություն
Ժառանգությունը դասերի հետ կապված մեկ այլ հասկացություն է, որը թույլ է տալիս նորից օգտագործել ծածկագիրը:
Հաշվի առեք այս ծածկագիրը:
class Dog:
def walk(self):
print("walk")
Մենք ստեղծել ենք «Շուն» դաս՝ «քայլել» մեթոդով։ Այս մեթոդով մենք պարզապես տպում ենք քայլելու հաղորդագրությունը տերմինալում: Ասենք, իրական ծրագրում կա 10 տող կոդ՝ ընդամենը մեկ տողի փոխարեն։ Հետագայում, եթե մեկ այլ դասի կարիք լինի «քայլ» մեթոդն ունենալու համար, մենք ստիպված կլինենք կրկնել այդ ամբողջ կոդը։ Սա իդեալական չէ։
Ծրագրավորման մեջ մենք ունենք մի սկզբունք, որը կոչվում է DRY, որը կարճ է՝ չկրկնվել: Ենթադրենք, ապագայում մենք հայտնաբերում ենք խնդիր մեր «քայլելու» մեթոդի հետ, և եթե մենք կրկնել կամ կրկնօրինակել ենք այս մեթոդը շատ այլ վայրերում, մենք պետք է վերադառնանք և շտկենք այդ խնդիրը յուրաքանչյուր վայրում, որտեղ մենք կրկնօրինակել ենք սա: կոդը։ Ահա թե ինչու ծրագրավորման մեջ մենք չպետք է երկու անգամ ինչ-որ բան սահմանենք։
Այս խնդիրը լուծելու տարբեր մոտեցումներ կան, բայց այստեղ մենք սովորելու ենք այն մեկը, որն ավելի հեշտ է սկսնակների համար և կոչվում է ժառանգություն: Այս դեպքում մենք կստեղծենք մեկ այլ դաս «mammal» և կսահմանենք մեր «walk» հատկանիշը այդ դասում:
class Mammal:
def walk(self):
print("walk")
Մեր «Կաթնասունների» դասը սահմանելուց հետո մենք կարող ենք օգտագործել ժառանգությունը՝ ատրիբուտներն այսպես փոխանցելու համար.
Ե՛վ շների, և՛ կատուների դասերը ժառանգում են դասի բոլոր մեթոդները, որոնք սահմանված են իրենց ծնող դասում: Այժմ մենք կարող ենք ավելացնել հետևյալ շներին հատուկ մեթոդներ.
class Dog:
def bark(self):
print("bark")
Փաթաթել Up!
Այս ամենը վերաբերում էր դասերին, կոնստրուկտորներին և կոդի վերաօգտագործմանը ժառանգական հասկացություններ ունեցող դասերում: Այժմ մենք մոտենում ենք մեր շարքի ավարտին։ Այս պահին դուք պետք է կարողանաք լավ, ընթեռնելի և հակիրճ կոդեր ստեղծել Python-ում:
Մոդուլների և փաթեթների հայեցակարգը կտեսնենք հաջորդ դասախոսության ընթացքում:
Թողնել գրառում