NumPy டாக்ஸ்ட்ரிங்

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

செயல்பாடுகளுடன் docstrings ஐப் பயன்படுத்தும் போது, ​​நாம் வாதங்களை அனுப்ப வேண்டும். வகுப்புகளுடன் அவற்றைப் பயன்படுத்தும் போது, ​​பண்புகளையும் முறைகளையும் கடந்து செல்கிறோம். தொகுதிகள் விஷயத்தில், வகுப்புகள் மற்றும் செயல்பாடுகளின் பட்டியலை வழங்க வேண்டும். தொகுப்பின் விஷயத்தில், செயல்பாட்டுடன் கூடிய தொகுதிகளின் பட்டியலை நாங்கள் அனுப்புகிறோம். எனவே அடிப்படையில், டாக்ஸ்ட்ரிங்கின் நோக்கம், பெயர் விளக்குவது போல, இது எங்கள் குறியீட்டின் ஆவணமாக்கலுக்கு உதவுகிறது. எதிர்காலத்தில் யாராவது நமது குறியீட்டைப் பயன்படுத்தினால், அவர் நமது குறியீட்டையும், நமது குறியீட்டின் பின்னால் உள்ள தர்க்கத்தையும் docstring உதவியுடன் புரிந்து கொள்ள முடியும் என்பதற்காக நாங்கள் ஆவணப்படுத்துகிறோம். உள்ளமைக்கப்பட்ட செயல்பாடுகளில் டாக்ஸ்ட்ரிங்க்களும் உள்ளன; உள்ளமைக்கப்பட்ட செயல்பாடுகளின் டாக்ஸ்ட்ரிங் பார்க்க help() செயல்பாட்டைப் பயன்படுத்தலாம்.

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

தொடரியல்:

NumPy இல் டாக்ஸ்ட்ரிங்ஸை எழுதுவதற்கான தொடரியல்:

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

எடுத்துக்காட்டு 1:

டாக்ஸ்ட்ரிங்ஸை சிறந்த முறையில் புரிந்து கொள்ள, ஒரு உதாரணத்தைச் செய்வோம். இந்த எடுத்துக்காட்டில், NumPy நூலகத்தைச் சேர்த்த பிறகு, 'a' என்ற மாறியையும் மற்றொரு மாறி 'b'ஐயும் அறிவிக்கிறோம். அதன் பிறகு, 'a' மற்றும் 'b' மாறிகளை சேர்ப்போம்' என்று கூறும் எங்கள் டாக்ஸ்ட்ரிங்கை உருவாக்குகிறோம். எங்கள் விஷயத்தில், இது எளிதான உதாரணம், ஆனால் எங்கள் குறியீடு சிக்கலானதாக இருந்தால், குறியீட்டைப் புரிந்துகொள்வதில் குறியீட்டாளருக்கு இது பெரிதும் உதவுகிறது. அதன் பிறகு, 'a' மற்றும் 'b' மாறிகளை தொகுத்து, அவற்றின் வெளியீட்டு முடிவை 'c' என்ற மற்றொரு மாறியில் சேமிக்கிறோம். இறுதியாக, 'c' மாறியின் மதிப்பை அச்சிடுகிறோம். இப்போது, ​​நாங்கள் எங்கள் குறியீட்டை இயக்குகிறோம்.

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

எடுத்துக்காட்டு 2:

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

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

முடிவுரை

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