სარჩევი[დამალვა][ჩვენება]
ამ ლექციაში გავეცნობით კლასებს, კონსტრუქტორებს და მემკვიდრეობას პითონში.
ეს ცნებები მართლაც მნიშვნელოვანია დიდ პროგრამაში, სადაც საჭიროა სხვადასხვა ტიპის განსაზღვრა.
კლასები
კლასები აუცილებელია პროგრამირებაში და ისინი არ არიან სპეციფიკური პითონისთვის. ბევრი სხვა პროგრამირების ენები მხარს უჭერს კლასების ცნებას. ჩვენ ვიყენებთ კლასებს მონაცემთა ახალი ტიპების დასადგენად.
აქამდე ჩვენ ვისწავლეთ პითონის ძირითადი მონაცემთა ტიპების შესახებ, როგორიცაა რიცხვები, სტრიქონები და ლოგინები. ეს არის ძირითადი ან მარტივი მონაცემთა ტიპები Python-ში. ჩვენ ასევე ვნახეთ მონაცემთა რამდენიმე რთული ტიპი, როგორიცაა სიები და ლექსიკონები.
მიუხედავად იმისა, რომ ეს ტიპები ძალიან სასარგებლოა, ისინი ყოველთვის არ შეიძლება გამოყენებულ იქნას რთული კონცეფციების მოდელირებისთვის. მაგალითად, იფიქრეთ წერტილის, ან საყიდლების კალათის იდეაზე. საყიდლების კალათა არ არის ლოგიკური ან სია. სხვანაირი მონაცემებია. ასე რომ, ჩვენ შეგვიძლია გამოვიყენოთ კლასები ახალი ტიპების დასადგენად რეალური ცნებების მოდელირებისთვის.
ახლა, მოდით განვსაზღვროთ მონაცემთა ახალი ტიპი, რომელსაც ეწოდება წერტილი. ამ ახალ ტიპს ექნება მეთოდები, როგორც ადრე შევამოწმეთ.
აი, როგორ გააკეთებ ამას:
ჩვენ ვიწყებთ კლასის განსაზღვრას საკვანძო სიტყვის გამოყენებით "კლასი" და ამის შემდეგ ვაძლევთ ჩვენს კლასს სახელს.
class Point
ახლა შეხედეთ დასახელების კონვენციას, რომელიც მე აქ გამოვიყენე. მე აქ დიდი ასოებით ვაწერე პირველი ასო, ამას ჩვენ ვუწოდებთ პასკალის სახელების კონვენციას. ეს კონვენცია განსხვავდება იმ კონვენციისგან, რომელსაც ვიყენებთ ჩვენი ცვლადებისა და ფუნქციების დასასახელებლად, რისთვისაც ყოველთვის ვიყენებთ მცირე ასოებს და გამოვყოფთ რამდენიმე სიტყვას ხაზგასმულის გამოყენებით. მაგრამ კლასების დასახელებისას, ჩვენ არ ვიყენებთ ხაზგასმას რამდენიმე სიტყვის გამოყოფისთვის, ჩვენ ვაკეთებთ ყველა სიტყვის პირველ ასოს.
ჩვენი კლასის განსაზღვრის შემდეგ გამოიყენება ორწერტილი, რაც ნიშნავს, რომ ახლა ბლოკი არის განსაზღვრული.
class Point:
def move (self):
ამ ბლოკში ჩვენ შეგვიძლია განვსაზღვროთ ყველა ფუნქცია ან მეთოდი, რომელიც ეკუთვნის წერტილებს. მაგალითად, ჩვენ შეგვიძლია განვსაზღვროთ ფუნქცია სახელწოდებით "გადაადგილება" წერტილის გადასატანად. გაითვალისწინეთ, რომ როგორც კი აკრიფებთ ღია ფრჩხილებს, PyCharm აქ ავტომატურად ამატებს "self-ს". ეს არის სპეციალური საკვანძო სიტყვა და ნება მომეცით მალე დავუბრუნდე ამას. ტერმინალზე დავბეჭდოთ „გადაადგილება“.
print("move")
მოდით განვსაზღვროთ სხვა მეთოდი, როგორიცაა „დახაზვა“ და დავბეჭდოთ ტერმინალზე.
def draw(self):
print("draw")
ჩვენ დავასრულეთ ჩვენი „წერტილის“ კლასის განმარტება. ამ ახალი ტიპის საშუალებით ჩვენ შეგვიძლია შევქმნათ ახალი ობიექტები. კლასი უბრალოდ განსაზღვრავს გეგმას ან შაბლონს ობიექტების შესაქმნელად, რომლებიც ამ გეგმაზე დაფუძნებული რეალური ინსტანციებია. ობიექტის შესაქმნელად, ჩვენ ვწერთ ჩვენი კლასის სახელს და შემდეგ ვუწოდებთ მას ისევე, როგორც ფუნქციას. ეს ქმნის ახალ ობიექტს და შემდეგ აბრუნებს მას. შემდეგ ჩვენ შეგვიძლია შევინახოთ ეს ობიექტი ცვლადში. ნება მომეცით გაჩვენოთ:
აქ ჩვენ განვსაზღვრეთ "point1", რომელიც არის სამგანზომილებიანი წერტილი. თქვენ ხედავთ, რომ ჩვენ შეგვიძლია დავბეჭდოთ ინდივიდუალური კოორდინატები ტერმინალზე.
ამ წერტილით შეგვიძლია გამოვიყენოთ ორი მეთოდი „დახაზვა“ და „გადაადგილება“.
შეჯამების მიზნით, ჩვენ ვიყენებთ კლასებს ახალი ტიპების განსასაზღვრად და ამ ტიპებს შეიძლება ჰქონდეთ მეთოდები, რომლებსაც ჩვენ განვსაზღვრავთ კლასის სხეულში. კლასებს შეიძლება ჰქონდეთ ატრიბუტები, რომლებიც ჩვენ შეგვიძლია დავაყენოთ სადმე ჩვენს პროგრამებში.
კონსტრუქტორები
აქამდე ვისწავლეთ როგორ შევქმნათ ახალი ტიპები კლასების გამოყენებით. ახლა ამ განხორციელებასთან დაკავშირებით მცირე პრობლემაა. ჩვენ შეგვიძლია შევქმნათ წერტილის ობიექტი 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()
”მეთოდი.
ეს მარტივი ამოცანაა და არ უნდა დასჭირდეს რამდენიმე წუთზე მეტს.
Solution
დაიწყეთ კლასის „Person“ განსაზღვრით ასე:
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, რომელიც მოკლედ არ გაიმეოროთ. ვთქვათ, ოდესმე მომავალში, ჩვენ აღმოვაჩენთ პრობლემას ჩვენს "გასეირნების" მეთოდთან დაკავშირებით და თუ ეს მეთოდი გავიმეორეთ ან გამეორდა ბევრ სხვა ადგილას, ჩვენ უნდა დავბრუნდეთ და მოვაგვაროთ ეს პრობლემა თითოეულ ადგილზე, სადაც ეს დუბლირებულია. კოდი. ამიტომ პროგრამირებისას რაღაც ორჯერ არ უნდა განვსაზღვროთ.
ამ პრობლემის მოსაგვარებლად სხვადასხვა მიდგომა არსებობს, მაგრამ აქ ჩვენ ვაპირებთ ვისწავლოთ დამწყებთათვის უფრო მარტივი და მას მემკვიდრეობა ჰქვია. ამ შემთხვევაში, ჩვენ შევქმნით სხვა კლასს "ძუძუმწოვარი" და განვსაზღვრავთ ჩვენს "walk" ატრიბუტს ამ კლასში.
class Mammal:
def walk(self):
print("walk")
ჩვენი "ძუძუმწოვრების" კლასის განსაზღვრის შემდეგ, ჩვენ შეგვიძლია გამოვიყენოთ მემკვიდრეობა ატრიბუტების ასე გადასაცემად:
ძაღლების და კატების ორივე კლასი მემკვიდრეობით იღებს ყველა კლასის მეთოდს, რომელიც განსაზღვრულია მათ მშობელ კლასში. ახლა ჩვენ შეგვიძლია დავამატოთ ასეთი ძაღლებისთვის სპეციფიკური მეთოდები:
class Dog:
def bark(self):
print("bark")
Გახვევა!
ეს ყველაფერი ეხებოდა კლასებს, კონსტრუქტორებს და კოდის ხელახლა გამოყენებას კლასებში მემკვიდრეობის კონცეფციებით. ახლა ჩვენ ვუახლოვდებით ჩვენი სერიის დასასრულს. ამ ეტაპზე, თქვენ უნდა შეგეძლოთ პითონში კარგი, წასაკითხი და ლაკონური კოდების შექმნა.
მოდულების და პაკეტების კონცეფციას შემდეგ ლექციაზე ვიხილავთ.
დატოვე პასუხი