பைத்தானின் __பெயர்__ == "__main__" அறிக்கையைப் புரிந்துகொள்வது

டிகோடிங் பைத்தானின் முக்கிய தொகுதி

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

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

def main():
    print("Hello, World!")

if __name__ == "__main__":
    main()

பைத்தானின் எக்ஸிகியூஷன் மாதிரியை ஆராய்கிறது

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

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

பைத்தானில் __பெயர்__ == "__முதன்மை__" பொறிமுறையை ஆராய்தல்

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

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