பொருளடக்கம்[மறை][காட்டு]
இந்த விரிவுரையில், பைத்தானில் உள்ள வகுப்புகள், கட்டமைப்பாளர்கள் மற்றும் பரம்பரை பற்றி அறிந்து கொள்வோம்.
பல்வேறு வகைகளை வரையறுக்க வேண்டிய ஒரு பெரிய திட்டத்தில் இந்த கருத்துக்கள் மிகவும் முக்கியமானவை.
வகுப்புகள்
நிரலாக்கத்தில் வகுப்புகள் இன்றியமையாதவை மற்றும் அவை பைத்தானுக்கு குறிப்பிட்டவை அல்ல. வேறு பல கணிப்பொறி செயல்பாடு மொழி வகுப்புகளின் கருத்தை ஆதரிக்கவும். புதிய தரவு வகைகளை வரையறுக்க வகுப்புகளைப் பயன்படுத்துகிறோம்.
இதுவரை, பைத்தானில் உள்ள எண்கள், சரங்கள் மற்றும் பூலியன்கள் போன்ற அடிப்படை தரவு வகைகளைப் பற்றி அறிந்து கொண்டோம். இவை பைத்தானில் உள்ள அடிப்படை அல்லது எளிமையான தரவு வகைகள். பட்டியல்கள் மற்றும் அகராதிகள் போன்ற சிக்கலான தரவு வகைகளையும் நாங்கள் பார்த்துள்ளோம்.
இந்த வகைகள் மிகவும் பயனுள்ளவையாக இருந்தாலும், அவை எப்போதும் சிக்கலான கருத்துக்களை மாதிரியாகப் பயன்படுத்த முடியாது. எடுத்துக்காட்டாக, ஒரு புள்ளி அல்லது ஒரு வணிக வண்டியின் யோசனையைப் பற்றி சிந்தியுங்கள். ஷாப்பிங் கார்ட் என்பது பூலியன் அல்லது பட்டியல் அல்ல. இது வேறு வகையான தரவு. எனவே உண்மையான கருத்துகளை மாதிரியாக மாற்ற புதிய வகைகளை வரையறுக்க வகுப்புகளைப் பயன்படுத்தலாம்.
இப்போது, புள்ளி எனப்படும் புதிய தரவு வகையை வரையறுப்போம். இந்த புதிய வகை நாம் முன்பு சரிபார்த்த முறைகளைக் கொண்டிருக்கப் போகிறது.
நீங்கள் அதை எப்படி செய்வீர்கள்:
"வகுப்பு" முக்கிய சொல்லைப் பயன்படுத்தி ஒரு வகுப்பை வரையறுப்பதன் மூலம் தொடங்குகிறோம், அதன் பிறகு எங்கள் வகுப்பிற்கு ஒரு பெயரைக் கொடுக்கிறோம்.
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
கட்டமைப்பாளரை பின்னர் வரையறுப்போம். இப்போது, நாம் "நபர்" பொருளை உருவாக்கலாம். ஜான் என்று அழைப்போம்
john = Person("John Smith")
print(john.name)
john.talk()
இப்போது, குறியீட்டின் முதல் பகுதிக்குச் சென்று ஒரு கட்டமைப்பாளரை உருவாக்கவும்.
def __init__(self, name):
இறுதி குறியீடு இப்படி இருக்கும்:
வகுப்புகள் மற்றும் கட்டமைப்பாளர்களுடன் இணைந்து வடிவமைக்கப்பட்ட சரங்கள் மற்றும் பிற கருத்துகளையும் நீங்கள் பயன்படுத்தலாம்.
வாரிசு உரிமை
மரபு என்பது ஒரு குறியீட்டை மீண்டும் பயன்படுத்த அனுமதிக்கும் வகுப்புகளுடன் தொடர்புடைய மற்றொரு கருத்தாகும்.
இந்த குறியீட்டின் பகுதியைக் கவனியுங்கள்.
class Dog:
def walk(self):
print("walk")
"நடை" முறையுடன் "நாய்" வகுப்பை உருவாக்கியுள்ளோம். இந்த முறையில், டெர்மினலில் நடை செய்தியை அச்சிடுகிறோம். ஒரு உண்மையான நிரலில், இங்கே ஒரு வரிக்கு பதிலாக 10 கோடுகள் உள்ளன என்று வைத்துக்கொள்வோம். எதிர்காலத்தில், "நடை" முறையைப் பெற மற்றொரு வகுப்பு தேவைப்பட்டால், அந்தக் குறியீட்டை மீண்டும் செய்ய வேண்டும். இது உகந்ததல்ல.
நிரலாக்கத்தில், DRY எனப்படும் ஒரு கொள்கை எங்களிடம் உள்ளது, இது உங்களை மீண்டும் செய்ய வேண்டாம் என்பதற்கான சுருக்கமாகும். எதிர்காலத்தில் எப்போதாவது சொல்லலாம், எங்கள் "நடை" முறையில் ஒரு சிக்கலைக் கண்டறிந்துள்ளோம், மேலும் பல இடங்களில் இந்த முறையைத் திரும்பத் திரும்ப அல்லது நகல் செய்திருந்தால், நாங்கள் மீண்டும் வந்து இந்தப் பிரச்சனையை நகல் செய்த ஒவ்வொரு இடத்திலும் சரி செய்ய வேண்டும். குறியீடு. அதனால்தான் நிரலாக்கத்தில் நாம் எதையாவது இருமுறை வரையறுக்கக்கூடாது.
இந்த சிக்கலை தீர்க்க பல்வேறு அணுகுமுறைகள் உள்ளன, ஆனால் இங்கே நாம் ஆரம்பநிலைக்கு எளிதான ஒன்றைக் கற்றுக்கொள்கிறோம், அது பரம்பரை என்று அழைக்கப்படுகிறது. இந்த வழக்கில், நாங்கள் மற்றொரு வகுப்பான “பாலூட்டி”யை உருவாக்கி, அந்த வகுப்பில் எங்கள் “நடை” பண்புகளை வரையறுப்போம்.
class Mammal:
def walk(self):
print("walk")
எங்கள் "பாலூட்டி" வகுப்பை வரையறுத்த பிறகு, இது போன்ற பண்புகளை அனுப்ப நாம் பரம்பரை பயன்படுத்தலாம்:
நாய் மற்றும் பூனை வகுப்புகள் இரண்டும் தங்கள் பெற்றோர் வகுப்பில் வரையறுக்கப்பட்ட அனைத்து வகுப்பு முறைகளையும் பெறுகின்றன. இப்போது, இதுபோன்ற நாய்களுக்கான குறிப்பிட்ட முறைகளை நாம் சேர்க்கலாம்:
class Dog:
def bark(self):
print("bark")
மடக்கு!
இது வகுப்புகள், கட்டமைப்பாளர்கள் மற்றும் மரபுரிமைக் கருத்துகளுடன் வகுப்புகளில் குறியீட்டை மீண்டும் பயன்படுத்துவது பற்றியது. இப்போது எங்கள் தொடரின் இறுதிக் கட்டத்தை நெருங்கிவிட்டோம். இந்த கட்டத்தில், நீங்கள் பைத்தானில் நல்ல, படிக்கக்கூடிய மற்றும் சுருக்கமான குறியீடுகளை உருவாக்க முடியும்.
தொகுதிகள் மற்றும் தொகுப்புகள் பற்றிய கருத்தை அடுத்த விரிவுரையில் பார்ப்போம்.
ஒரு பதில் விடவும்