பைதான் பொருள் சார்ந்த நிரலாக்கத்திற்கான தொடக்க வழிகாட்டி

பைதான் பொருள் சார்ந்த நிரலாக்கத்திற்கான தொடக்க வழிகாட்டி

ராஸ்பெர்ரி பை முதல் இயந்திர கற்றல் வரை எல்லாவற்றிலும் பைதான் பயன்படுத்தப்படுகிறது. நீங்கள் ஏதேனும் பெரிய திட்டத்தில் வேலை செய்ய விரும்பினால், பொருள் சார்ந்த நிரலாக்கத்துடன் (OOP) பைதான் எவ்வாறு செயல்படுகிறது என்பதை நீங்கள் தெரிந்து கொள்ள வேண்டும். இந்த கட்டுரை நீங்கள் தெரிந்து கொள்ள வேண்டிய அடிப்படைகளை உள்ளடக்கும்.





நீங்கள் உண்மையில் நிரலாக்கத்தில் ஈடுபடவில்லை என்றால், அதற்கு பதிலாக இந்த சிறந்த மான்டி பைதான் ஓவியங்களை ஏன் பார்க்கக்கூடாது? எல்லாவற்றிற்கும் மேலாக, அவர்கள் மொழியை ஊக்குவித்தனர்!





காத்திருங்கள், பைதான் உண்மையான மொழி அல்லவா?

ஒரு விஷயத்தை தெளிவாகப் புரிந்துகொள்வோம்: பைதான் ஒரு உண்மையான நிரலாக்க மொழி, அது பிரபலமானது, அது வேகமாக வளர்ந்து வருகிறது. இது சூடோகுறியீடு போல் படிப்பதால் உங்களால் முடியும் அதனுடன் Pi யில் Minecraft குறியீடு , நீங்கள் அதை குறைந்த மொழியாக தள்ளுபடி செய்ய வேண்டும் என்று அர்த்தமல்ல.





OOP என்பது நவீன மென்பொருள் வளர்ச்சியின் மூலக்கல்லாகும், மேலும் பைதான் தொடர்ந்து வைத்திருக்கும் திறன் கொண்டது. இது மற்ற முக்கிய மொழி மொழிகளை விட வித்தியாசமாக ஒன்று அல்லது இரண்டு விஷயங்களைச் செய்யலாம், ஆனால் அது உங்களைத் தள்ளி விடாதீர்கள்.

இந்த டுடோரியல் பைத்தானின் அடிப்படை அறிவை எடுத்துக் கொள்ளும், ஆனால் வழியில் உள்ள அனைத்து சிக்கலான விஷயங்களையும் நாங்கள் உள்ளடக்குவோம். நீங்கள் பைத்தானுக்குப் புதியவராக இருந்தால், ஒரு புதிய நிரலாக்க மொழியைக் கற்றுக்கொள்வதற்கான இந்த தந்திரங்களை ஏன் பார்க்கக்கூடாது, அல்லது பைத்தானுடன் கூகிள் தாள்களைப் படிப்பது மற்றும் எழுதுவது போன்ற எளிய திட்டம் பற்றி என்ன?



பைதான் முன்நிபந்தனைகள் மற்றும் அமைப்பு

தொடங்குவதற்கு முன், நீங்கள் உங்கள் பைதான் மேம்பாட்டு சூழல் அமைப்பைப் பெற விரும்பலாம். நாங்கள் பயன்படுத்துவோம் பைதான் 3.6.5 நீங்கள் பழைய பதிப்புகளைப் பயன்படுத்தும்போது, ​​நீங்கள் ஒரு புதிய பதிப்பைப் பயன்படுத்துகிறீர்கள் என்றால் உங்களுக்கு குறைவான சிக்கல்கள் இருக்கும்.

உங்களிடம் ஏற்கனவே ஒரு மெய்நிகர் சூழலை உருவாக்க விரும்பினால், மற்றும் பைத்தானுக்கு PIP ஐ நிறுவவும் அது நிறுவப்படவில்லை என்றால் (இது பைத்தானின் பெரும்பாலான நவீன நிறுவல்களுடன் வருகிறது). நீங்கள் அந்த அமைப்பைப் பெற்றவுடன், நீங்கள் செல்வது நல்லது. ஆரம்பிக்கலாம்!





பைத்தானின் அடிப்படைகள்: வகுப்புகள்

TO வர்க்கம் OOP இன் அடிப்படை கட்டிடத் தொகுதி ஆகும். ஒரு வகுப்பு என்பது ஒரு திட்டம் அல்லது வரைபடத்தைப் போன்றது. அவை ஒரு பொருளின் பண்புகளை வரையறுக்கின்றன. உதாரணமாக, உங்களிடம் கார் வகுப்பு இருந்தால், நான்கு சக்கரங்கள், குறைந்தபட்சம் ஒரு இருக்கை மற்றும் ஒரு இயந்திரம் இருப்பதாக அது குறிப்பிடலாம்.

பைத்தானில் ஒரு வகுப்பை எப்படி செய்வது என்பது இங்கே:





class Vehicle:
''' This class defines vehicles. '''
pass

எளிமையானது சரியா? இங்கே சில விஷயங்கள் நடக்கின்றன. வகுப்பின் மேல் உள்ள கருத்தைக் கவனியுங்கள். இது ஒரு சிறப்பு கருத்து docstring . இது உங்கள் குறியீட்டைப் பற்றி கொஞ்சம் விளக்க வேண்டும். மூன்று மேற்கோள்களைப் பயன்படுத்துவதன் மூலம் ( '' ' ), இது பைத்தானுக்கு இது ஒரு டாக்ஸ்ட்ரிங் என்று சொல்கிறீர்கள்.

தி பாஸ் முக்கிய சொல் பைத்தானை ஒன்றும் செய்யாது என்று கூறுகிறது. இது ஒரு சிறப்பு வார்த்தை, நீங்கள் அதை ஒரு டோடோ போல நினைக்கலாம். இது உங்கள் குறியீட்டை இயக்கும், ஆனால் அது உண்மையில் எதையும் செய்யாது.

இந்த குறியீட்டை நீங்கள் இயக்கினால், எதுவும் நடக்காது என்பதை நீங்கள் காண்பீர்கள். நீங்கள் வேண்டும் உடனடி நீங்கள் வகுப்பு. இது திறம்பட வகுப்பில் வரையறுக்கப்பட்ட திட்டத்தின் அடிப்படையில் ஒரு பொருளை சென்று உருவாக்குவதாகும். நீங்கள் விரும்பும் பல பிரதிகளை உருவாக்கலாம், ஒவ்வொன்றும் வெவ்வேறு பண்புகள் கொண்டவை. நீங்கள் அதை எப்படி செய்கிறீர்கள் என்பது இங்கே:

red_car = Vehicle()

நீங்கள் இதை மீண்டும் இயக்கினால், எதுவும் நடக்காது என்பதை நீங்கள் காண்பீர்கள். குறியீடு சரியாக வேலை செய்கிறது, ஆனால் கவனிக்கத்தக்க எதையும் செய்ய நீங்கள் அதை சொல்லவில்லை. தி வாகனம் வர்க்கம் ஒரு வாகனத்திற்கான வரைபடங்களை வரையறுக்கிறது, மேலும் இந்த சமீபத்திய வரி ஒரு வாகன பொருளை உருவாக்கி அதற்கு ஒரு பெயரைக் கொடுக்கிறது சிவப்பு_வண்டி .

நீங்கள் விரும்பும் பல பொருட்களை உருவாக்க முடியும்:

red_car = Vehicle()
green_car = Vehicle()
blue_car = Vehicle()

இன்னும் சில குறியீடுகளைச் சேர்ப்போம். என்ற முறையைச் சேர்க்கவும் __அதில் உள்ளது__ க்கு வாகனம் வர்க்கம்:

class Vehicle:
''' This class defines vehicles. '''
def __init__(self, color='plain'):
''' Setup some custom car properties '''
print('New car made!')
self.color = color
red_car = Vehicle()
green_car = Vehicle()
blue_car = Vehicle()

இதில் சிறப்பு கவனம் செலுத்துங்கள் __அதில் உள்ளது__ முறை இது இரண்டு அடிக்கோடுகளுடன் தொடங்க வேண்டும் மற்றும் முடிக்க வேண்டும். பைத்தானில் இது ஒரு சிறப்பு முறையாகும். நீங்கள் ஒரு புதிய பொருளை உருவாக்கும்போது அது தானாகவே அழைக்கப்படும். இந்தக் குறியீட்டை இயக்குவது 'புதிய கார் தயாரிக்கப்பட்டது!' மூன்று முறை.

இறுதியாக, __அதில் உள்ளது__ என்ற தனிப்பயன் வாதத்தை எடுத்துக்கொள்கிறது நிறம் . சமமான அடையாளம் மற்றும் சரம் உடனடியாகக் குறிப்பிடப்படாவிட்டால், வண்ணத்தை 'வெற்று' என அமைக்குமாறு பைத்தானிடம் சொல்லுங்கள். உருவாக்கும் போது உங்கள் காரின் நிறத்தை அமைக்க உங்கள் நிகழ்வுகளை நீங்கள் மாற்றலாம்:

red_car = Vehicle(color='red')
green_car = Vehicle(color='green')
blue_car = Vehicle(color='blue')

நீங்கள் காரின் நிறத்தை அச்சிட்டால், மூன்று நிகழ்வுகளும் ஒரே மாதிரியாக (வர்க்கம்) செய்யப்பட்டிருந்தாலும், ஒவ்வொரு நிகழ்வும் வெவ்வேறு நிறத்தைக் கொண்டிருப்பதைக் காண்பீர்கள். ஏறக்குறைய எந்த மாறி அல்லது பொருளையும் அணுக பைதான் உங்களை அனுமதிக்கிறது --- இதைச் செய்ய வேறு பல மொழிகள் உங்களை அனுமதிக்காது:

print(red_car.color)
print(green_car.color)
print(blue_car.color)

நீங்கள் ஒதுக்கியதால் இது வேலை செய்கிறது நிறம் க்கு சுய நிறம் . பைத்தானில் சுயமானது மற்றொரு சிறப்புச் சொல், இது ஒரு வகுப்பின் ஒவ்வொரு குறிப்பிட்ட நிகழ்வையும் குறிக்கிறது. நீங்கள் சுயத்தைப் பயன்படுத்தும் போதெல்லாம், அந்த நிகழ்வுக்கு தனித்துவமான தரவை நீங்கள் அமைக்கலாம் அல்லது அணுகலாம். சிவப்பு காரில் சிவப்பு நிறம் உள்ளது, எடுத்துக்காட்டாக.

உங்கள் மாற்றவும் __அதில் உள்ளது__ காரின் சத்தத்தை மாறி மாறி சேமிக்கும் முறை:

self.noise = 'Vroooom'

கார் சத்தத்தை அச்சிட, நீங்கள் அதை அணுகலாம் சத்தம் மாறி, நீங்கள் நிறத்துடன் செய்தது போல், ஆனால் இது சிறந்த யோசனை அல்ல. நீங்கள் காரை ஓட்டும்போது, ​​அதே நேரத்தில் வேறு சில குறியீடுகளை இயக்க விரும்பினால், ஒருவேளை நீங்கள் இன்னும் எழுதாத குறியீடாக இருந்தால் என்ன செய்வது? அல்லது எதிர்காலத்தில் ஒரு கார் எப்படி ஓடுகிறது என்பதை நீங்கள் மாற்ற விரும்பினால் என்ன செய்வது? உருவாக்குவதன் மூலம் செயல்பாடு (ஏ என்றும் அழைக்கப்படுகிறது முறை ), விஷயங்கள் எவ்வாறு செயல்படுகின்றன என்பதை நீங்கள் இறுக்கமாக கட்டுப்படுத்தலாம். இதை உங்கள் கீழே சேர்க்கவும் __அதில் உள்ளது__ முறை:

def drive(self):
print(self.noise)

நீங்கள் இந்த முறையை மிகவும் எளிமையாக அழைக்கலாம்:

red_car.drive()

நீங்கள் அழைக்கும் போதெல்லாம் ஓட்டு முறை, பைதான் ஒலியை அச்சிடும். அனைத்து பணிகளையும் செய்ய நீங்கள் இதை விரிவாக்கலாம், ஆனால் இப்போதைக்கு அதை விட்டு விடுங்கள்.

நல்லது! இப்போது நீங்கள் அடிப்படைகளில் உறுதியான பிடியை வைத்திருக்க வேண்டும். நீங்கள் உங்கள் சொந்த வகுப்புகளை உருவாக்க மற்றும் பயன்படுத்த முடியும், ஒவ்வொன்றும் அதன் தனித்துவமான திறன்கள் மற்றும் செயல்பாடுகளுடன்.

பைத்தானில் உள்ள தனியார் மாறிகள் பற்றி என்ன?

பெரும்பாலான பிற மொழிகளில் தனியார் பொருள்கள் மிகவும் பொதுவானவை. அவை வெறுமனே மாறிகள் அல்லது செயல்பாடுகளை வகுப்பிற்கு வெளியே அணுக முடியாது. அவை பயன்பாட்டிற்கு முன் சிறப்பு நிபந்தனைகளை பூர்த்தி செய்ய வேண்டிய குறியீடாக இருக்கலாம் அல்லது உள் பயன்பாட்டிற்கு மட்டுமே வடிவமைக்கப்பட்டுள்ளது. காரணம் எதுவாக இருந்தாலும், நீங்கள் பைத்தானில் குறியாக்கம் செய்யாவிட்டால் தனிப்பட்ட உறுப்பினர்களை அணுக முடியாது.

பைத்தானுக்கு தனிப்பட்ட உறுப்பினர்கள் இல்லை. அதற்கு பதிலாக, பைதான் ஒரு மரியாதை முறையை நம்பியுள்ளது: 'நாங்கள் அனைவரும் பெரியவர்களை ஒப்புக்கொள்கிறோம்.' பைதான் புரோகிராமர்கள் நீங்கள் ஒரு வகுப்பின் உணர்ச்சிகரமான உட்புறங்களுடன் டிங்கர் செய்ய விரும்புவதை புரிந்துகொள்கிறார்கள், அது பரவாயில்லை, எனவே எதுவும் உண்மையில் அணுக முடியாததாக இருக்கக்கூடாது.

இருப்பினும், பைதான் சில மாறிகள் 'தனியார்' என்று குறிப்பதற்காக ஏற்றுக்கொள்ளப்பட்ட ஒரு மாநாட்டைக் கொண்டுள்ளது. மாநாடு ஒரு அடிக்கோடிட்டு மாறி பெயர்களை முன்னுரை செய்வதாகும்:

_some_secret_variable = 42

இது மற்ற புரோகிராமர்களுக்கு ஒரு எச்சரிக்கையாக செயல்படுகிறது. நீங்கள் இதை அணுகுவதை பைதான் தடுக்காது, ஆனால் இது இந்த வழியில் பயன்படுத்த வடிவமைக்கப்படவில்லை என்று அடிக்கோடிட்டுக் கூறுகிறது, மேலும் நீங்கள் உங்கள் சொந்த ஆபத்தில் தொடர வேண்டும்.

இது சில நேரங்களில் மறைக்கப்பட்ட பொருட்களை டிங்கர் செய்ய பைதான் வழி, ஆனால் விஷயங்கள் சரியாக வேலை செய்யாமல் போகும் அபாயத்தை நீங்கள் இயக்குகிறீர்கள்.

பைத்தானில் பரம்பரை புரிதல்

பரம்பரை நகல் மற்றும் குறியீட்டை மீண்டும் பயன்படுத்த மற்றொரு வழி. பெற்றோர் மற்றும் குழந்தை உறவை நினைத்து, பரம்பரை அனுமதிக்கிறது குழந்தை உடன் பொதுவான குறியீட்டைப் பகிர்ந்து கொள்ள பெற்றோர் . பெற்றோரிடமிருந்து பெறப்படும் மின்சார காரை செயல்படுத்துவோம்.

இந்த குறியீட்டை உங்கள் கீழே சேர்க்கவும் வாகனம் வர்க்கம்:

class ElectricCar(Vehicle):
''' Electric vehicle class. '''
def charge(self):
print('Zzz')
electric_car = ElectricCar()
electric_car.charge()
electric_car.noise = 'Whoosh'
electric_car.drive()

பிறகு மின்சார கார் வரையறுக்கப்பட்டுள்ளது, தி வாகனம் வகுப்பு இரண்டு அடைப்புக்குறிக்குள் குறிப்பிடப்பட்டுள்ளது. இது பைத்தானுக்கு சொல்கிறது மின்சார கார் ஒரு குழந்தை ஆகும் வாகனம் . இது வழங்கப்பட்ட அனைத்து தரவு மற்றும் முறைகளுக்கான அணுகலை வழங்குகிறது வாகனம் .

எலக்ட்ரிக் காருக்கு அதன் சொந்த சிறப்பு முறைகள் உள்ளன. இது சார்ஜ் செய்ய முடியும் (மற்ற வாகனங்களால் செய்ய முடியாத ஒன்று). கார் சத்தத்தை மாற்றுவதன் மூலமும், பின்னர் வாகனம் ஓட்டுவதன் மூலமும், மின்சார கார் வித்தியாசமான ஒலியை எழுப்புவதை நீங்கள் காணலாம், மேலும் நீங்கள் ஓட்டு முறையை வரையறுக்க வேண்டியதில்லை. ஏனென்றால், டிரைவ் பெற்றோரிடமிருந்து மரபுரிமை பெற்றது.

உங்கள் பைதான் அறிவை மேலும் விரிவாக்குங்கள்

பைத்தானில் OOP எவ்வளவு எளிதாக இருக்கும் என்பதை இந்த உதாரணங்கள் காட்டுகின்றன. நாங்கள் மிக அடிப்படைகளை மட்டுமே உள்ளடக்கியுள்ளோம், ஆனால் நீங்கள் கீழே இறங்கியவுடன், மீதமுள்ளவை எளிது.

பேஸ்புக் கணக்கு குளோன் செய்யப்பட்டால் என்ன செய்வது

நீங்கள் தொடர்ந்து பைத்தானைக் கற்றுக்கொள்ள விரும்பினால், அல்லது இந்த OOP திறன்களை நடைமுறையில் பயன்படுத்தினால், ஏன் பார்க்கக் கூடாது பைத்தானில் உள்ள வரிசைகள் மற்றும் பட்டியல்கள் , அல்லது பைதான் மற்றும் ஜாவாஸ்கிரிப்ட் தொடர்பு கொள்ள என்ன செய்வது?

இவை அனைத்தும் உங்களுக்கு அதிக விருப்பத்தை ஏற்படுத்தியிருந்தால், பைத்தானைக் கற்றுக்கொள்ள இந்த சிறந்த வலைத்தளங்களைப் பார்க்க மறக்காதீர்கள்.

பகிர் பகிர் ட்வீட் மின்னஞ்சல் வட்டு இடத்தை விடுவிக்க இந்த விண்டோஸ் கோப்புகள் மற்றும் கோப்புறைகளை நீக்கவும்

உங்கள் விண்டோஸ் கணினியில் வட்டு இடத்தை அழிக்க வேண்டுமா? வட்டு இடத்தை விடுவிக்க பாதுகாப்பாக நீக்கக்கூடிய விண்டோஸ் கோப்புகள் மற்றும் கோப்புறைகள் இங்கே.

அடுத்து படிக்கவும்
தொடர்புடைய தலைப்புகள்
  • நிரலாக்க
  • நிரலாக்க
  • பைதான்
  • பொருள் சார்ந்த நிரலாக்கம்
எழுத்தாளர் பற்றி ஜோ கோபர்ன்(136 கட்டுரைகள் வெளியிடப்பட்டன)

ஜோ இங்கிலாந்தின் லிங்கன் பல்கலைக்கழகத்தில் கணினி அறிவியலில் பட்டதாரி. அவர் ஒரு தொழில்முறை மென்பொருள் டெவலப்பர், அவர் ட்ரோன்களை பறக்காதபோது அல்லது இசை எழுதாதபோது, ​​அவர் அடிக்கடி புகைப்படம் எடுப்பதை அல்லது வீடியோக்களை தயாரிப்பதை காணலாம்.

ஜோ கோபர்னிடமிருந்து மேலும்

எங்கள் செய்திமடலுக்கு குழுசேரவும்

தொழில்நுட்ப குறிப்புகள், மதிப்புரைகள், இலவச மின் புத்தகங்கள் மற்றும் பிரத்யேக ஒப்பந்தங்களுக்கு எங்கள் செய்திமடலில் சேரவும்!

குழுசேர இங்கே சொடுக்கவும்