Python என்பது ஒரு உயர்நிலை மொழியாகும், இது பொதுவான குறியீடுகளைச் செய்வதற்கு வடிவமைக்கப்பட்டுள்ளது மற்றும் எந்தவொரு குறிப்பிட்ட பிரச்சனைக்கும் அல்ல. பைத்தானைப் பயன்படுத்தி இணையதளங்களை உருவாக்குவது அல்லது இந்த பைதான் மொழியைப் பயன்படுத்தி தரவை பகுப்பாய்வு செய்வது போன்ற பொதுவான நோக்கங்களுக்காக இதைப் பயன்படுத்தலாம். “Python” நிரலாக்கமானது command_line வாதங்களையும் வழங்குகிறது. கட்டளை வரி வாதங்கள் என்பது கோப்பு நீட்டிப்புடன் குறியீட்டு கோப்பின் பெயரைக் குறிப்பிட்ட பிறகு, எந்தவொரு இயக்க முறைமையின் கன்சோல் அல்லது முனையத்தில் நாம் வழங்கிய வாதங்கள் ஆகும். எந்தவொரு நிரலிலும், கட்டளை வரி வாதங்கள் என்று கூறப்படும் கட்டளை வரியில் அனுப்பப்படும் மதிப்பு என்றும் நாம் அதை வரையறுக்கலாம். இந்த வழிகாட்டியில், 'பைதான்' நிரலாக்கத்தில் கட்டளை வரி வாதத்தைப் பற்றி விவாதிப்போம்.
பைத்தானில் கட்டளை வரி வாதங்களுக்கான முறைகள்
- “sys.argv” ஐப் பயன்படுத்துவதன் மூலம்
- 'argparse' தொகுதியைப் பயன்படுத்துவதன் மூலம்
- 'getopt' தொகுதியைப் பயன்படுத்துவதன் மூலம்
இந்த வழிகாட்டியில் அனைத்து முறைகளையும் விரிவாக விளக்குவோம், மேலும் அந்த முறைகளின் நடைமுறை விளக்கத்தையும் காண்பிப்போம்.
எடுத்துக்காட்டு # 01: sys.argv முறை மூலம்
இந்த பைதான் குறியீடுகளை 'ஸ்பைடர்' பயன்பாட்டில் செய்கிறோம். கணினியை இறக்குமதி செய்வதன் மூலம் கட்டளை வரி மாறிகள் மற்றும் செயல்பாடுகளை நாம் அணுகலாம். எனவே, நாம் “sys” ஐ இறக்குமதி செய்கிறோம், பின்னர் “len(sys.argv)” உடன் “num” மாறியை அறிவித்து துவக்குகிறோம். 'argv' என்பது சரம் மதிப்புகளின் பட்டியலாக இருக்கும், அவை எங்கள் கட்டளை வரியாக மாறும். 'len' என்பது நிறைவேற்றப்பட்ட வாதங்களின் நீளத்தைக் குறிக்கிறது. எனவே, 'எண்' மாறியில், கட்டளை வரியாக டெர்மினலில் அனுப்பப்பட்ட மதிப்புகளின் எண்ணிக்கை சேமிக்கப்படுகிறது.
'அச்சு' பயன்படுத்தி அனுப்பப்படும் அந்த வாத எண்களையும் நாங்கள் காண்பிக்கிறோம். இதற்குக் கீழே, அச்சு அறிக்கையில் “sys.argv[0]” ஐ வைக்கிறோம். 'argv' எப்போதும் நிரல் பெயர் அல்லது குறியீட்டு கோப்பு பெயரை வைத்திருக்கும். எனவே, நாம் உருவாக்கிய கோப்பின் பெயர் டெர்மினலில் ரெண்டர் செய்யப்படும். இதற்குப் பிறகு, முனையத்தில் அனுப்பப்படும் அந்த வாதங்களை நாங்கள் அச்சிடுகிறோம். கன்சோல் திரையில் கட்டளை வரி வாதங்களாக நாம் அனுப்பிய அனைத்து எண்களையும் இது அச்சிடும்.
இதற்குக் கீழே, ஒரு for loopஐ வரையறுத்து, 'a' என்ற மாறியை அறிவித்துள்ளோம், அதன் வரம்பு '1' முதல் 'num' இல் சேமிக்கப்படும் argv இன் நீளம் வரை இருக்கும். கன்சோலில் அனைத்து வாதங்களையும் அச்சிடவும். “argv[a]” அனைத்து command_line வாதங்களையும் கொண்டுள்ளது. இது அவற்றை கன்சோலிலும் காண்பிக்கும். இப்போது, 'தொகை' என்பதை துவக்குகிறோம், ஏனெனில் முனையத்தில் செயல்படுத்தும் நேரத்தில் நாம் அனுப்பும் அனைத்து மதிப்புகளின் கூட்டுத்தொகையை கணக்கிட வேண்டும்.
நாங்கள் மீண்டும் 'for' லூப்பைப் பயன்படுத்தி வரம்பைக் கடக்கிறோம். ஆனால் இந்த நேரத்தில், முனையத்தில் நாம் கடந்து வந்த அனைத்து மதிப்புகளின் கூட்டுத்தொகையைக் கணக்கிடுகிறோம். இந்தத் தொகை “தொகை” மாறியில் சேமிக்கப்படும். பின்னர், டெர்மினலில் செயல்படுத்தும் நேரத்தில் நாம் அனுப்பும் அனைத்து மதிப்புகளின் கூட்டுத்தொகையையும் அச்சிடுவோம்.
இறக்குமதி sysஒன்றில் = மட்டுமே ( sys . argv )
அச்சு ( 'மொத்த வாதங்கள் இங்கே நிறைவேற்றப்பட்டன:' , ஒன்றில் )
அச்சு ( ' \n பைதான் கோப்பின் பெயர்:' , sys . argv [ 0 ] )
அச்சு ( ' \n நாங்கள் நிறைவேற்றிய வாதங்கள்:' , முடிவு = '' )
க்கான அ உள்ளே சரகம் ( 1 , ஒன்றில் ) :
அச்சு ( sys . argv [ அ ] , முடிவு = '' )
தொகை = 0
க்கான நான் உள்ளே சரகம் ( 1 , ஒன்றில் ) :
தொகை + = முழு எண்ணாக ( sys . argv [ நான் ] )
அச்சு ( ' \n \n நிறைவேற்றப்பட்ட வாதங்களின் கூட்டுத்தொகை: ' , தொகை )
முனையத்தில், முதலில் 'ரன்' முக்கிய சொல்லை வைக்கிறோம். பின்னர், கோப்பு பெயரை சரியான நீட்டிப்புடன் சேர்த்து, கட்டளை வரி வாதங்களை இங்கே அனுப்பவும். எனவே, மேலே உள்ள குறியீட்டில் நாம் வரையறுத்துள்ள அனைத்து வரிகளையும் இது காட்டுகிறது. இது முதலில் கட்டளை வரி வாதங்களின் நீளத்தையும் பின்னர் கோப்பின் பெயரையும் வழங்குகிறது. இதற்குப் பிறகு, இது அனைத்து கட்டளை வரி வாதங்களையும் வழங்குவதோடு அவை அனைத்தின் தொகையையும் வழங்குகிறது.
எடுத்துக்காட்டு # 02: argparse முறை மூலம்
இப்போது, இந்த எடுத்துக்காட்டில் 'argparse' முறையைப் பயன்படுத்துகிறோம். நாம் முதலில் 'argparse' ஐ இறக்குமதி செய்கிறோம். எனவே, இதன் மாறிகள் மற்றும் செயல்பாட்டை அணுகுவோம். நாங்கள் ஒரு 'தரவு' மாறியை துவக்கி, எங்கள் குறியீட்டில் பயன்படுத்தக்கூடிய ஒரு வரியை சேமிக்கிறோம். இதற்குப் பிறகு, நாங்கள் ஒரு “பாகுபடுத்தலை” துவக்குகிறோம், மேலும் “விளக்கத்தில்” “தரவு” மாறியை அனுப்புகிறோம், அதில் நாம் காட்ட விரும்பும் செய்தியை சேமித்து வைத்திருக்கிறோம், மேலும் இவை அனைத்தையும் “my_parser” மாறியில் வைக்கிறோம். இறுதியில் “parse.args()” ஐயும் வைக்கிறோம்.
இறக்குமதி argparseதகவல்கள் = 'நாங்கள் இங்கே argparse முறையைப் பயன்படுத்துகிறோம்'
என்_பாகுபடுத்தி = argparse. வாதப் பாகுபடுத்தி ( விளக்கம் = தகவல்கள் )
என்_பாகுபடுத்தி. parse_args ( )
கீழே உள்ள முடிவைப் பாருங்கள். கட்டளை வரி வாதமாக “-h” ஐ அனுப்பும்போது, அது முதலில் நாம் “தரவு” மாறியில் சேமித்து வைத்திருக்கும் செய்தியை ரெண்டர் செய்கிறது மற்றும் இந்த “h” உதவி செய்தியைக் காட்டுவது போல “விருப்ப வாதத்தையும்” காட்டுகிறது. கட்டளை வரி வாதமாக “-o” ஐ வைக்கும்போது, அது அங்கீகரிக்கப்படாத வாதம் என்று பிழை செய்தியை வழங்குகிறது.
எடுத்துக்காட்டு # 03: getopt முறை மூலம்
இந்த குறியீட்டில் நாம் பயன்படுத்தும் கடைசி முறை இங்கே. இந்த குறியீட்டில் 'sys' மற்றும் 'getopt' ஐ இறக்குமதி செய்கிறோம். இந்த 'getopt' என்பது கட்டளை வரி வாதங்களுக்கு நாம் பயன்படுத்திய பாகுபடுத்தியாகும். பின்னர், “argumentList” மாறியில், கட்டளை வரியில் நாம் அனுப்பும் முதல் வாதத்தை அகற்ற “sys.argv[1:]” ஐ கடந்துவிட்டோம். 'hmo:' உடன் 'my_option' ஐ துவக்குகிறோம்.
இதற்குப் பிறகு, 'my_long_option' மாறியை துவக்குகிறோம். பிழையைச் சரிபார்க்கும் 'முயற்சி' என்பதை நாங்கள் பயன்படுத்துகிறோம். இதற்குப் பிறகு, நாங்கள் வாதங்களை அலசுகிறோம். 'getopt' குறுகிய மற்றும் நீண்ட விருப்பங்களை வழங்குகிறது, மேலும் ஒரு மதிப்பைக் குறிக்கும் விருப்பத்துடன். இதற்குப் பிறகு, நாங்கள் கட்டளை வரி வாதங்களாக அனுப்பும் அனைத்து வாதங்களையும் சரிபார்க்கிறோம். கட்டளை வரி வாதம் '-h' அல்லது '-Help' எனில், இது கீழே கொடுக்கப்பட்டுள்ள செய்தியை அச்சிடும். கட்டளை வரி வாதம் “-m” அல்லது “—My_file” எனில், அதன் பிறகு எழுதப்பட்ட செய்தியைக் காண்பிக்கும்.
மேலும், கட்டளை வரி வாதம் “-o” அல்லது “–Output” ஆக இருந்தால், இதற்குப் பிறகு நாம் இங்கு எழுதியுள்ள செய்தியையும் இது காட்டுகிறது. கட்டளை வரி வாதம் மேலே உள்ள எல்லாவற்றிலிருந்தும் இல்லை என்றால், அது நாம் 'getopt' ஐ வைத்தது போல் பிழை செய்தியைக் காண்பிக்கும். குறியீட்டில் பிழை'.
இறக்குமதி முதலிடம் பிடித்தது , sysவாதப் பட்டியல் = sys . argv [ 1 : ]
my_options = 'இரவு:'
புதிய_நீண்ட_விருப்பங்கள் = [ 'உதவி' , 'My_file' , 'வெளியீடு='
முயற்சி :
வாதங்கள் , மதிப்புகள் = முதலிடம் பிடித்தது . முதலிடம் பிடித்தது ( வாதப் பட்டியல் , my_options , புதிய_நீண்ட_விருப்பங்கள் )
க்கான என்_வாதம் , என்_மதிப்பு உள்ளே வாதங்கள்:
என்றால் என்_வாதம் உள்ளே ( '-h' , '--உதவி' ) :
அச்சு ( 'உதவியைக் காட்டுகிறது' )
எலிஃப் என்_வாதம் உள்ளே ( '-m' , '--My_file' ) :
அச்சு ( 'கோப்பு_பெயரைக் காட்டுகிறது:' , sys . argv [ 0 ] )
எலிஃப் என்_வாதம் உள்ளே ( '-ஓ' , '--வெளியீடு' ) :
அச்சு ( ( 'சிறப்பு வெளியீட்டு பயன்முறையை இயக்குகிறது (% s)' ) % ( என்_மதிப்பு ) )
தவிர முதலிடம் பிடித்தது . பிழை என தவறு:
அச்சு ( str ( தவறு ) )
இங்கே நீங்கள் '-h' ஐ கட்டளை வரியாக வைக்கும்போது, குறியீட்டில் நாம் எழுதிய அதே செய்தியைக் காட்டுகிறது. “–Help” மற்றும் “-m” என இரண்டு கட்டளை வரி வாதங்களை வைக்கும்போது, அது கீழே இரண்டு செய்திகளைக் காட்டுகிறது. “-o” கட்டளை வரி வாதத்தில், செய்தியில் காட்டப்படும் சரத்தையும் கடந்துவிட்டோம்.
முடிவுரை
'Python' இல் 'கட்டளை வரி வாதங்கள்' என்ற கருத்தை நீங்கள் அறிய இந்த வழிகாட்டியை வழங்கியுள்ளோம். 'கட்டளை வரி வாதத்தை' நாங்கள் ஆராய்ந்தோம், மேலும் இங்கு மூன்று முறைகளையும் விளக்கியுள்ளோம். கட்டளை வரியில் செயல்பாட்டின் போது நிரல் பெயருடன் மதிப்புகளை நிரலுக்கு அனுப்பும் செயல்முறையின் கட்டளை வரி வாதத்தை நாங்கள் விளக்கியுள்ளோம்.