មាតិកា[លាក់][បង្ហាញ]
នៅក្នុងការបង្រៀននេះ យើងនឹងសិក្សាអំពី classes, constructors and inheritance in python ។
គោលគំនិតទាំងនេះពិតជាមានសារៈសំខាន់នៅក្នុងកម្មវិធីធំមួយ ដែលប្រភេទផ្សេងៗគ្នាគឺចាំបាច់ដើម្បីកំណត់។
ថ្នាក់
ថ្នាក់មានសារៈសំខាន់ក្នុងការសរសេរកម្មវិធី ហើយវាមិនជាក់លាក់ចំពោះ python ទេ។ ជាច្រើនទៀត ភាសាសរសេរកម្មវិធី គាំទ្រគំនិតនៃថ្នាក់។ យើងប្រើថ្នាក់ដើម្បីកំណត់ប្រភេទទិន្នន័យថ្មី។
រហូតមកដល់ពេលនេះ យើងបានសិក្សាអំពីប្រភេទទិន្នន័យមូលដ្ឋាននៅក្នុង Python ដូចជា លេខ ខ្សែអក្សរ និងប៊ូលីន។ ទាំងនេះគឺជាប្រភេទទិន្នន័យមូលដ្ឋាន ឬសាមញ្ញនៅក្នុង Python ។ យើងក៏បានឃើញប្រភេទទិន្នន័យស្មុគ្រស្មាញមួយចំនួនដូចជា បញ្ជី និងវចនានុក្រមជាដើម។
ទោះបីជាប្រភេទទាំងនេះមានប្រយោជន៍ខ្លាំងក៏ដោយ ពួកវាមិនអាចតែងតែប្រើដើម្បីធ្វើគំរូគំនិតស្មុគស្មាញបានទេ។ ជាឧទាហរណ៍ គិតអំពីគំនិតនៃចំណុច ឬរទេះទិញទំនិញ។ រទេះទិញទំនិញមិនមែនជា boolean ឬបញ្ជីទេ។ វាជាប្រភេទទិន្នន័យផ្សេងគ្នា។ ដូច្នេះយើងអាចប្រើ classes ដើម្បីកំណត់ប្រភេទថ្មី ដើម្បីយកគំរូតាមគោលគំនិតពិត។
ឥឡូវនេះ ចូរយើងកំណត់ប្រភេទទិន្នន័យថ្មីមួយហៅថា ចំណុច។ ប្រភេទថ្មីនេះនឹងមានវិធីសាស្រ្តដូចដែលយើងបានពិនិត្យពីមុនមក។
នេះជារបៀបដែលអ្នកនឹងធ្វើវា៖
យើងចាប់ផ្តើមដោយកំណត់ថ្នាក់ដោយប្រើពាក្យគន្លឹះ "ថ្នាក់" ហើយបន្ទាប់ពីនោះយើងផ្តល់ឈ្មោះថ្នាក់របស់យើង។
class Point
ឥឡូវនេះ សូមក្រឡេកមើលអនុសញ្ញាដាក់ឈ្មោះ ដែលខ្ញុំបានប្រើនៅទីនេះ។ ខ្ញុំបានសរសេរអក្សរធំជាអក្សរទីមួយនៅទីនេះ នេះជាអ្វីដែលយើងហៅថាអនុសញ្ញាឈ្មោះប៉ាស្កាល់។ អនុសញ្ញានេះខុសពីពាក្យដែលយើងប្រើសម្រាប់ដាក់ឈ្មោះអថេរ និងមុខងាររបស់យើងដែលយើងតែងតែប្រើអក្សរតូច និងពាក្យជាច្រើនដោយឡែកពីគ្នាដោយប្រើសញ្ញាគូសក្រោម។ ប៉ុន្តែនៅពេលដាក់ឈ្មោះថ្នាក់ យើងមិនប្រើសញ្ញាគូសដើម្បីបំបែកពាក្យច្រើនទេ ផ្ទុយទៅវិញយើងដាក់អក្សរធំជាអក្សរទីមួយនៃពាក្យនីមួយៗ។
បន្ទាប់ពីកំណត់ថ្នាក់របស់យើង សញ្ញាមួយត្រូវបានប្រើដែលមានន័យថាឥឡូវនេះប្លុកមួយត្រូវបានកំណត់។
class Point:
def move (self):
នៅក្នុងប្លុកនេះ យើងអាចកំណត់មុខងារ ឬវិធីសាស្រ្តទាំងអស់ដែលជាកម្មសិទ្ធិរបស់ចំនុច។ ឧទាហរណ៍ យើងអាចកំណត់មុខងារមួយហៅថា "ផ្លាស់ទី" សម្រាប់ផ្លាស់ទីចំណុច។ ចំណាំថាដរាបណាយើងវាយបើកវង់ក្រចក PyCharm បន្ថែម "ខ្លួនឯង" នៅទីនេះដោយស្វ័យប្រវត្តិ។ នេះជាពាក្យគន្លឹះដ៏ពិសេសមួយ ហើយខ្ញុំសូមត្រឡប់ទៅវាវិញក្នុងពេលខ្លី។ តោះបោះពុម្ព "ផ្លាស់ទី" នៅលើស្ថានីយ។
print("move")
ចូរកំណត់វិធីមួយផ្សេងទៀតដូចជា "គូរ" ហើយបោះពុម្ពវានៅលើស្ថានីយ។
def draw(self):
print("draw")
យើងបានបញ្ចប់ជាមួយនឹងនិយមន័យនៃថ្នាក់ "ចំណុច" របស់យើង។ ជាមួយនឹងប្រភេទថ្មីនេះ យើងអាចបង្កើតវត្ថុថ្មី។ ថ្នាក់មួយគ្រាន់តែកំណត់ប្លង់មេ ឬគំរូសម្រាប់បង្កើតវត្ថុដែលជាវត្ថុជាក់ស្តែងដោយផ្អែកលើប្លង់មេនោះ។ ដើម្បីបង្កើត Object យើងវាយឈ្មោះ class របស់យើង រួចហៅវាដូច function ដែរ។ វាបង្កើតវត្ថុថ្មី ហើយបន្ទាប់មកបញ្ជូនវាមកវិញ។ បន្ទាប់មកយើងអាចរក្សាទុកវត្ថុនោះនៅក្នុងអថេរមួយ។ ខ្ញុំសូមបង្ហាញអ្នក៖
នៅទីនេះយើងបានកំណត់ "ចំណុច 1" ដែលជាចំណុចបីវិមាត្រ។ អ្នកអាចមើលឃើញថាយើងអាចបោះពុម្ពកូអរដោនេបុគ្គលនៅលើស្ថានីយ។
យើងអាចប្រើវិធីពីរគឺ "គូរ" និង "ផ្លាស់ទី" ជាមួយចំណុចនេះ។
ដូច្នេះដើម្បីសង្ខេប យើងប្រើថ្នាក់ដើម្បីកំណត់ប្រភេទថ្មី ហើយប្រភេទទាំងនេះអាចមានវិធីសាស្រ្តដែលយើងកំណត់នៅក្នុងតួនៃថ្នាក់។ ថ្នាក់អាចមានគុណលក្ខណៈដែលយើងអាចកំណត់គ្រប់ទីកន្លែងនៅក្នុងកម្មវិធីរបស់យើង។
អ្នកសាងសង់
រហូតមកដល់ពេលនេះ យើងបានរៀនពីរបៀបបង្កើតប្រភេទថ្មីដោយប្រើថ្នាក់។ ឥឡូវនេះមានបញ្ហាតូចមួយជាមួយនឹងការអនុវត្តនេះ។ យើងអាចបង្កើតវត្ថុចំណុចដោយគ្មានកូអរដោណេ x ឬ y ដោយប្រើថ្នាក់ ហើយវាមិនសមហេតុផលទេ។ អនុញ្ញាតឱ្យខ្ញុំបង្ហាញអ្នក។
ចូរបង្កើតចំណុចមួយ ហើយបោះពុម្ពវា មុនពេលយើងកំណត់ x កូអរដោណេ។ ការដំណើរការកម្មវិធីរបស់យើងបណ្តាលឱ្យមានកំហុសគុណលក្ខណៈដូចនេះ៖
វាមានន័យថាវត្ថុចំណុចមិនមានគុណលក្ខណៈដែលហៅថា x ។ ឥឡូវនេះបញ្ហាគឺថាវាអាចមានវត្ថុចំណុចដោយគ្មានកូអរដោណេ x ឬ y ។ នេះមិនសមហេតុផលទេ នៅពេលដែលយើងនិយាយអំពីចំណុចណាមួយ យើងត្រូវដឹងថាចំណុចនោះស្ថិតនៅត្រង់ណា។ ដើម្បីដោះស្រាយបញ្ហានេះ យើងប្រើ constructor ។ Constructor គឺជាមុខងារមួយដែលត្រូវបានហៅនៅពេលបង្កើតវត្ថុមួយ។
នេះជារបៀបដែលយើងប្រើ constructor ។ ដំបូងយើងហុចតម្លៃកូអរដោណេ x និង y ក្នុងកម្មវិធីខាងលើ។
point = Point(10, 20)
print(point.x)
ឥឡូវនេះ យើងត្រូវបន្ថែម method ពិសេសមួយនៅក្នុង class នេះហៅថា constructor។ វាក្យសម្ព័ន្ធរបស់វាគឺដូចនេះ៖
def __init__(self, x, y):
init
គឺខ្លីសម្រាប់ការចាប់ផ្តើម ហើយនេះគឺជាមុខងារ ឬវិធីសាស្ត្រដែលត្រូវបានហៅនៅពេលដែលវត្ថុចំណុចថ្មីមួយត្រូវបានបង្កើត។ x និង y ត្រូវបានបន្ថែមភ្លាមៗបន្ទាប់ពី self
ដើម្បីបន្ថែមប៉ារ៉ាម៉ែត្របន្ថែមពីរ។
បន្ទាប់ពីនោះ យើងគួរគូសផែនទី x និង y ទៅនឹងតម្លៃដែលបានអនុម័ត ពោលគឺ 10 និង 20
self.x = x
self.y = y
យើងប្រើ self
ដើម្បីយោងទៅវត្ថុបច្ចុប្បន្ន ហើយបន្ទាប់មកយើងកំណត់គុណលក្ខណៈ x ទៅនឹងអាគុយម៉ង់ x ដែលបានបញ្ជូនទៅអនុគមន៍ “x” ។ នៅក្នុងវិធីនេះដោយប្រើ init
វិធីសាស្រ្ត យើងអាចចាប់ផ្តើមវត្ថុរបស់យើង។ វិធីសាស្រ្តនេះត្រូវបានគេហៅថា constructor ។ តោះដំណើរការកម្មវិធីរបស់យើង។
ឥឡូវនេះ យើងអាចផ្លាស់ប្តូរកូអរដោនេ x និង y នៅពេលក្រោយ។ តោះធ្វើបច្ចុប្បន្នភាព x កូអរដោណេ៖
point = Point(10, 20)
point.x = 11
print(point.x)
ឥឡូវនេះ កូអរដោនេ x ត្រូវបានធ្វើបច្ចុប្បន្នភាពទៅតម្លៃ 11 ។
ហាត់ប្រាណ
នេះជាលំហាត់ដ៏គួរឱ្យចាប់អារម្មណ៍សម្រាប់អ្នក។
ខ្ញុំចង់ឱ្យអ្នកកំណត់ប្រភេទថ្មីហៅថាមនុស្ស។ វត្ថុ "បុគ្គល" ទាំងនេះគួរតែមាន "name
"គុណលក្ខណៈក៏ដូចជា"talk()
” វិធីសាស្ត្រ។
វាជាកិច្ចការសាមញ្ញ ហើយមិនគួរចំណាយពេលលើសពីពីរបីនាទីឡើយ។
ជាដំណោះស្រាយ
ចាប់ផ្តើមដោយកំណត់ថ្នាក់ "មនុស្ស" ដូចនេះ៖
class Person:
self.name = name
យើងនឹងកំណត់អ្នកសាងសង់នៅពេលក្រោយ។ ឥឡូវនេះយើងអាចបង្កើតវត្ថុ "មនុស្ស" ។ ចូរហៅវាថាចន
john = Person("John Smith")
print(john.name)
john.talk()
ឥឡូវបន្តទៅផ្នែកទីមួយនៃកូដ ហើយបង្កើត constructor ។
def __init__(self, name):
លេខកូដចុងក្រោយនឹងមើលទៅដូចនេះ៖
អ្នកក៏អាចប្រើខ្សែអក្សរដែលបានធ្វើទ្រង់ទ្រាយ និងគោលគំនិតផ្សេងទៀតដោយភ្ជាប់ជាមួយថ្នាក់ និងអ្នកសាងសង់។
មរតក។
Inheritance គឺជាគោលគំនិតមួយផ្សេងទៀតដែលភ្ជាប់ជាមួយនឹងថ្នាក់ដែលអនុញ្ញាតឱ្យអ្នកប្រើកូដឡើងវិញ។
ពិចារណាផ្នែកនៃកូដនេះ។
class Dog:
def walk(self):
print("walk")
យើងបានបង្កើតថ្នាក់ "ឆ្កែ" ជាមួយនឹងវិធីសាស្រ្ត "ដើរ" ។ នៅក្នុងវិធីនេះ យើងគ្រាន់តែបោះពុម្ពសារដើរនៅលើស្ថានីយ។ ឧបមាថានៅក្នុងកម្មវិធីពិត មាន 10 បន្ទាត់នៃកូដជំនួសឱ្យបន្ទាត់តែមួយនៅទីនេះ។ នៅពេលអនាគត ប្រសិនបើថ្នាក់ផ្សេងទៀតត្រូវការដើម្បីមានវិធីសាស្ត្រ "ដើរ" នោះយើងនឹងត្រូវធ្វើកូដនោះម្តងទៀត។ នេះមិនមែនជាឧត្តមគតិទេ។
ក្នុងការសរសេរកម្មវិធី យើងមានគោលការណ៍មួយដែលហៅថា DRY ដែលខ្លីសម្រាប់កុំធ្វើខ្លួនឯងឡើងវិញ។ ឧបមាថានៅពេលអនាគត យើងរកឃើញបញ្ហាជាមួយវិធីសាស្ត្រ "ដើរ" របស់យើង ហើយប្រសិនបើយើងធ្វើម្តងទៀត ឬចម្លងវិធីសាស្ត្រនេះនៅកន្លែងផ្សេងទៀតជាច្រើន យើងនឹងត្រូវតែត្រលប់មកវិញ ហើយដោះស្រាយបញ្ហានោះនៅគ្រប់កន្លែងដែលយើងបានចម្លងវា កូដ។ នោះហើយជាមូលហេតុដែលក្នុងការសរសេរកម្មវិធីយើងមិនគួរកំណត់អ្វីមួយពីរដងទេ។
មានវិធីសាស្រ្តផ្សេងគ្នាដើម្បីដោះស្រាយបញ្ហានេះ ប៉ុន្តែនៅទីនេះយើងនឹងរៀនមួយដែលងាយស្រួលសម្រាប់អ្នកចាប់ផ្តើមដំបូង ហើយវាត្រូវបានគេហៅថាមរតក។ ក្នុងករណីនេះ យើងនឹងបង្កើតថ្នាក់មួយទៀត "ថនិកសត្វ" ហើយកំណត់គុណលក្ខណៈ "ដើរ" របស់យើងនៅក្នុងថ្នាក់នោះ។
class Mammal:
def walk(self):
print("walk")
បន្ទាប់ពីកំណត់ថ្នាក់ "ថនិកសត្វ" របស់យើង យើងអាចប្រើមរតកដើម្បីឆ្លងកាត់គុណលក្ខណៈដូចនេះ៖
ទាំងថ្នាក់ឆ្កែ និងឆ្មាកំពុងទទួលមរតកវិធីសាស្រ្តថ្នាក់ទាំងអស់ដែលបានកំណត់នៅក្នុងថ្នាក់មេរបស់ពួកគេ។ ឥឡូវនេះ យើងអាចបន្ថែមវិធីសាស្រ្តជាក់លាក់ចំពោះសត្វឆ្កែដូចនេះ៖
class Dog:
def bark(self):
print("bark")
ក្តោប!
នេះគឺជាការទាំងអស់អំពី classes, constructors និងការប្រើកូដឡើងវិញនៅក្នុង classes ដែលមានគោលគំនិតមរតក។ ឥឡូវនេះយើងជិតដល់ទីបញ្ចប់នៃស៊េរីរបស់យើង។ ត្រង់ចំណុចនេះ អ្នកគួរតែអាចបង្កើតកូដល្អ អាចអានបាន និងសង្ខេបនៅក្នុង Python។
យើងនឹងឃើញគំនិតនៃម៉ូឌុល និងកញ្ចប់នៅក្នុងការបង្រៀនបន្ទាប់។
សូមផ្ដល់យោបល់