நிரலாக்கத்தில், எழுத்துத் தரவைச் சரிபார்க்கும் மற்றும் கையாளும் திறன் மிக முக்கியமானது. Python போன்ற பிரபலமான மற்றும் நெகிழ்வான நிரலாக்க மொழியில் உள்ள பல உள்ளமைக்கப்பட்ட செயல்பாடுகள் இந்த வேலைகளை எளிதாக்க உதவுகின்றன. கொடுக்கப்பட்ட சரம் முழுவதுமாக அகரவரிசை எழுத்துக்களால் ஆனது என்பதை தீர்மானிப்பது ஒரு அடிப்படை முறையாகும். பயனர் உள்ளீடு சரிபார்க்கப்பட வேண்டும் அல்லது குறிப்பிட்ட செயல்பாடுகள் அகரவரிசை தரவுகளில் பிரத்தியேகமாக செய்யப்பட வேண்டிய சூழ்நிலைகளில் இந்த செயல்முறை முக்கியமானது. வழங்கப்பட்ட சரம் காலியாக இல்லாமலும், அனைத்து எழுத்துகளும் அகரவரிசையில் (எழுத்துக்களால் ஆனது) இருந்தால், பைத்தானில் உள்ள 'isalpha' சரம் செயல்பாடு 'True' என்பதை வழங்கும். இல்லையெனில், 'தவறு' திரும்பும். பயனர் உள்ளீட்டுடன் பணிபுரியும் போது அல்லது வெவ்வேறு பயன்பாடுகளில் சரங்களை சரிபார்க்கும் போது, இந்த செயல்பாடு கைக்கு வரும்.
எடுத்துக்காட்டு 1: அடிப்படை பயன்பாடு
Python இன் 'isalpha' செயல்பாட்டின் அடிப்படை பயன்பாட்டை விளக்குவதற்கு, கொடுக்கப்பட்ட சரத்தில் அகரவரிசை எழுத்துக்கள் மட்டுமே உள்ளதா என்பதைச் சரிபார்க்க விரும்பும் ஒரு எளிய காட்சியைக் கருத்தில் கொள்வோம்:
உரை = 'பைத்தான்'
முடிவு = text.isalpha ( )
அச்சு ( விளைவாக )
உரை = 'பைதான் 3'
முடிவு = text.isalpha ( )
அச்சு ( விளைவாக )
வழங்கப்பட்ட எடுத்துக்காட்டில், 'பைதான்' என அமைக்கப்பட்ட 'உரை' என்ற சரம் மாறியின் அறிவிப்புடன் தொடங்கினோம். பின்னர், 'isalpha' முறை இந்த சரத்தில் செயல்படுத்தப்பட்டு, சரத்தில் உள்ள அனைத்து எழுத்துக்களும் அகரவரிசையில் உள்ளதா என்பதைக் குறிக்கும் பூலியன் முடிவை வழங்குகிறது. 'முடிவு' மாறி முடிவைக் கொண்டுள்ளது. குறியீடு இந்த முடிவை அச்சிடுவதற்குத் தொடர்கிறது, இது சரத்தின் அகரவரிசை அமைப்பு பற்றிய நுண்ணறிவை வழங்குகிறது.
எடுத்துக்காட்டின் இரண்டாவது பகுதி முழுவதும், 'உரை' சரத்திற்கு இப்போது 'Python3' மதிப்பு ஒதுக்கப்பட்டுள்ளது. சரத்தின் அகரவரிசையை மதிப்பிடுவதற்கு 'isalpha' முறையை செயல்படுத்துவதன் மூலம் அதே செயல்முறை மீண்டும் மீண்டும் செய்யப்படுகிறது. அதன் பிறகு, பூலியன் முடிவு மீண்டும் 'முடிவு' மாறியில் எழுதப்பட்டு சேமிக்கப்படும்.
இந்த உதாரணம் 'இசல்பா' முறையின் எளிமை மற்றும் செயல்திறனை விளக்குகிறது, பைத்தானில் உள்ள சரங்களின் அகரவரிசையின் தூய்மையைக் கண்டறிய நேரடியான அணுகுமுறையை வழங்குகிறது.
எடுத்துக்காட்டு 2: பயனர் உள்ளீட்டைக் கையாளுதல்
உள்ளிடப்பட்ட தரவு அகரவரிசை எழுத்துக்களை மட்டுமே கொண்டிருப்பதை உறுதி செய்வதன் மூலம் பயனர் உள்ளீட்டைக் கையாள 'isalpha' செயல்பாட்டைப் பயன்படுத்துவதற்கான நடைமுறை உதாரணத்தைக் கருத்தில் கொள்வோம். இந்தச் சூழ்நிலையில், பயனரின் முதல் பெயரை உள்ளிடுமாறு நாங்கள் கேட்க விரும்புகிறோம், மேலும் உள்ளீட்டைச் சரிபார்க்க 'isalpha' செயல்பாட்டைப் பயன்படுத்துவோம். உள்ளீடு செல்லுபடியாக இருந்தால் (அகர வரிசைப்படி எழுத்துக்கள் மட்டுமே உள்ளன), நாங்கள் தனிப்பயனாக்கப்பட்ட வாழ்த்துக்களுடன் தொடர்கிறோம். இல்லையெனில், சரியான பெயரை உள்ளிடுமாறு பயனரைக் கேட்கிறோம்.
பின்வரும் பைதான் குறியீடு துணுக்கைக் கவனியுங்கள்:
user_input = உள்ளீடு ( 'உங்கள் முதல் பெயரை உள்ளிடவும்:' )
என்றால் user_input.isalpha ( ) :
அச்சு ( f 'வணக்கம், {user_input}! வரவேற்கிறோம்.' )
வேறு:
அச்சு ( 'தயவுசெய்து அகரவரிசை எழுத்துக்களை மட்டுமே கொண்ட சரியான முதல் பெயரை உள்ளிடவும்.' )
இந்த நிகழ்வில், பயனர் உள்ளீடு 'உள்ளீடு' செயல்பாட்டின் மூலம் பெறப்படுகிறது. 'isalpha' இன் அடுத்தடுத்த பயன்பாடு, உள்ளிடப்பட்ட தரவு அகரவரிசை எழுத்துக்களை மட்டுமே கொண்டுள்ளது என்பதை உறுதி செய்கிறது. நிபந்தனை பூர்த்தி செய்யப்பட்டால், தனிப்பயனாக்கப்பட்ட வாழ்த்து காட்டப்படும். இல்லையெனில், அகரவரிசை எழுத்துக்களை வழங்குவதன் முக்கியத்துவத்தை வலியுறுத்தி, சரியான முதல் பெயரை உள்ளிடுமாறு பயனர் தூண்டப்படுவார்.
பயனர் உருவாக்கிய தரவைக் கையாள்வதில் நிரலின் நம்பகத்தன்மையை மேம்படுத்தி, குறிப்பிட்ட அளவுகோல்களுடன் பயனர் உள்ளீடு சீரமைக்கப்படுவதை இந்த மறுசெயல்முறை உறுதி செய்கிறது.
எடுத்துக்காட்டு 3: ஒரு சரத்தில் அகரவரிசை எழுத்துக்களைச் சரிபார்த்தல்
பல்வேறு நிரலாக்க சூழ்நிலைகளில், ஒரு சரத்தின் கலவையை சரிபார்க்க வேண்டிய அவசியம் எழுகிறது, குறிப்பாக கடவுச்சொற்கள் போன்ற பயனர் உள்ளீட்டைக் கையாளும் போது. பாதுகாப்பு மற்றும் தரவு ஒருங்கிணைப்பு நோக்கங்களுக்காக, ஒரு சரம் பிரத்தியேகமாக அகரவரிசை எழுத்துக்களைக் கொண்டுள்ளது என்பதை உறுதிப்படுத்துவது அவசியம்.
இந்தச் சந்தர்ப்பத்தில், பயனரின் கடவுச்சொல்லைக் குறிக்கும் ஒரு சரம் எங்களிடம் உள்ளது, மேலும் செயல்பாடுகளைத் தொடர்வதற்கு முன் அது எழுத்துக்களால் மட்டுமே உருவாக்கப்பட்டுள்ளதா என்பதை உறுதிப்படுத்த விரும்புகிறோம்.
def contains_only_letters ( உள்ளீடு_str ) :திரும்ப அனைத்து ( சார்.இசல்பா ( ) க்கான கரி உள்ளே உள்ளீடு_str )
test_string = 'AbCdEfG'
என்றால் மட்டுமே_எழுத்துக்களைக் கொண்டுள்ளது ( சோதனை_சரம் ) :
அச்சு ( 'சரத்தில் அகரவரிசை எழுத்துக்கள் மட்டுமே உள்ளன.' )
வேறு:
அச்சு ( 'சரத்தில் எழுத்துக்கள் அல்லாத எழுத்துக்கள் உள்ளன.' )
எங்கள் செயலாக்கத்தில், உள்ளீட்டு சரத்தை அளவுருவாகக் கொண்ட “contains_only_letters” என்ற செயல்பாட்டை வரையறுக்கிறோம். உள்ளீட்டு சரத்தில் உள்ள ஒவ்வொரு எழுத்தும் ஒரு பட்டியல் புரிதல் மற்றும் 'isalpha' முறையைப் பயன்படுத்தி மீண்டும் மீண்டும் செய்யப்படுகிறது. ஒவ்வொரு எழுத்தும் ஒரு அகரவரிசை எழுத்து என்ற நிபந்தனையை பூர்த்திசெய்கிறதா என்பதைச் சரிபார்க்க “அனைத்தும்” செயல்பாடு பயன்படுத்தப்படுகிறது. எல்லா எழுத்துகளும் இந்த அளவுகோலைச் சந்தித்தால், செயல்பாடு 'உண்மை' என்று திரும்பும், சரத்தில் எழுத்துக்கள் மட்டுமே உள்ளன என்பதைக் குறிக்கிறது.
குறியீட்டின் அடுத்தப் பிரிவில், 'AbCdEfG' என்ற சோதனைச் சரத்தை வழங்குகிறோம், மேலும் அதில் அகரவரிசை எழுத்துக்கள் மட்டும் உள்ளதா என்பதைத் தீர்மானிக்க எங்கள் தனிப்பயன் செயல்பாட்டைப் பயன்படுத்துகிறோம். 'if' அறிக்கையைப் பயன்படுத்தி முடிவின் அடிப்படையில் பொருத்தமான செய்தியை அச்சிடுகிறோம். சரம் சரிபார்ப்பைக் கடந்தால், நிரல் 'சரத்தில் அகரவரிசை எழுத்துக்கள் மட்டுமே உள்ளன' என்று வெளியிடுகிறது. இல்லையெனில், 'சரத்தில் அகர வரிசையற்ற எழுத்துக்கள் உள்ளன' என்று அச்சிடுகிறது.
பைத்தானின் 'isalpha' செயல்பாடு எவ்வாறு நமது குறியீட்டிற்குள் உள்ள எழுத்து சரிபார்ப்பு பணிகளை திறம்பட நிவர்த்தி செய்ய உதவுகிறது என்பதை இந்த எடுத்துக்காட்டு விளக்குகிறது.
எடுத்துக்காட்டு 4: கேஸ் சென்சிட்டிவிட்டி
இந்த எடுத்துக்காட்டில், 'இசல்பா' முறையின் பின்னணியில் கேஸ் சென்சிட்டிவிட்டி என்ற கருத்தை ஆராய்வோம். கலப்பு எழுத்து, சிற்றெழுத்து மற்றும் பெரிய எழுத்துகள் கொண்ட சரங்களில் இந்த முறை எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்துகொள்வதை நோக்கமாகக் கொண்டுள்ளோம்.
mixed_case = 'AbCdEfG'சிற்றெழுத்து = 'abcdefg'
பெரிய எழுத்து = 'ABCDEFG'
அச்சு ( mixed_case.isalpha ( ) )
அச்சு ( சிற்றெழுத்து.இசல்பா ( ) )
அச்சு ( பெரிய எழுத்து.isalpha ( ) )
இந்த குறியீடு துணுக்கில், மூன்று தனித்துவமான சரங்களைப் பயன்படுத்தி கேஸ் சென்சிட்டிவிட்டியின் பின்னணியில் 'இசல்பா' முறையின் நடத்தையை நாங்கள் ஆய்வு செய்தோம். முதல் சரம், 'AbCdEfG', பெரிய எழுத்து மற்றும் சிறிய எழுத்துக்களை உள்ளடக்கியது, கலப்பு-வழக்கு காட்சிகளுக்கான சோதனை வழக்கை வழங்குகிறது. இரண்டாவது சரம், 'abcdefg', சிறிய எழுத்துக்களை உள்ளடக்கியது, மூன்றாவது சரமான 'ABCDEFG', பெரிய எழுத்துகளை மட்டுமே கொண்டுள்ளது. அந்தந்த 'அச்சு' அறிக்கைகள் மூலம், ஒவ்வொரு சரத்திற்கும் 'isalpha' முறை எவ்வாறு பதிலளிக்கிறது என்பதை நாங்கள் கவனிக்கிறோம்.
எடுத்துக்காட்டு 5: வெற்று சரங்களைக் கையாளுதல்
வெற்று சரங்கள் சில பயன்பாடுகளில் ஒரு தனித்துவமான சவாலை ஏற்படுத்தும், மேலும் பைதான் அவற்றை எவ்வாறு கையாள்கிறது என்பதைப் புரிந்துகொள்வது முக்கியமானது. ஒரு சரம் முழுக்க முழுக்க அகரவரிசை எழுத்துக்களால், குறிப்பாக வெற்று மற்றும் காலியாக இல்லாத சரங்களில் உள்ளதா என்பதைச் சரிபார்க்க, 'isalpha' முறையை எவ்வாறு பயன்படுத்தலாம் என்பதை விளக்க, குறியீட்டை ஆராய்வோம்.
காலி_str = ''non_empty_str = 'பைத்தான்'
அச்சு ( வெற்று_str.isalpha ( ) )
அச்சு ( அல்லாத_வெற்று_str.isalpha ( ) )
வழங்கப்பட்ட குறியீட்டில், எங்களிடம் இரண்டு சரங்கள் உள்ளன: “empty_str” மற்றும் “non_empty_str”. 'isalpha' முறை இரண்டு சரங்களுக்கும் பயன்படுத்தப்படுகிறது, மேலும் முடிவுகள் அச்சிடப்படுகின்றன.
'isalpha' முறையானது 'empty_str'க்கு 'False' என்பதை வழங்குகிறது, இது வெற்று சரத்தின் பிரதிநிதித்துவமாகும். ஏனென்றால், வெற்று சரம் என்பது வரையறையின்படி அனைத்து அகரவரிசை எழுத்துக்களும் இல்லாத ஒன்றாகும். மறுபுறம், 'Python' சரம் கொண்ட 'non_empty_str' க்கு, 'isalpha' முறையானது 'True' என்பதை வழங்குகிறது, ஏனெனில் சரத்தில் உள்ள அனைத்து எழுத்துக்களும் அகரவரிசையில் உள்ளன.
முடிவுரை
சுருக்கமாக, பைத்தானில் உள்ள 'isalpha' செயல்பாடு ஒரு சரத்தில் அகரவரிசை எழுத்துக்கள் மட்டுமே உள்ளதா என்பதைச் சரிபார்க்க விரைவான மற்றும் எளிதான முறையை வழங்குகிறது. அதன் தகவமைப்புத் தன்மையின் காரணமாக, சரம் கையாளுதல், தரவு சுத்திகரிப்பு மற்றும் பயனர் உள்ளீடு சரிபார்ப்பு ஆகியவற்றிற்கு இது பல்வேறு பயன்பாடுகளில் பயன்படுத்தப்படலாம். இந்தக் கட்டுரையில் கொடுக்கப்பட்டுள்ள உதாரணங்களை ஆராய்வதன் மூலம், டெவலப்பர்கள் தங்கள் பைதான் திட்டங்களில் 'isalpha' செயல்பாட்டை எவ்வாறு மேம்படுத்துவது என்பதை நன்கு புரிந்து கொள்ள முடியும். படிவத்தின் மேல்