+, * என்ற இரு இயக்கிகளைச் சரத்தோடு பயன்படுத்தலாம், ஆனால் இவற்றை என்கணித இயக்கிகள் என்ற அர்த்தத்தில் புரிந்துகொள்ளக் கூடாது. பார்வைக்கு அப்படித் தோன்றினாலும் , அவை இயங்கும் தரவு வகை/கட்டமைப்புக்கு ஏற்ப பயன்பாடு மாறுபடும். சரத்தை பொறுத்தவரையில் + என்பது இணைத்தல் இயக்கி, பிரதி செய்கைக்காகப் பயன்படுவது *.
நிரல் 1: இரண்டு சரங்களை இணைத்தல்
s1 மற்றும் s ஆகிய இரண்டு சரங்களின் மதிப்புகளையும், இரயிலில் பெட்டிகள் இணைக்கப்படுவதைப் போல இணைக்கிறோம். s1 முடிகிற இடத்தில் s தொடங்குகிறது. ஆக சர தரவு வகையை நீங்கள் கையாளுகிறீர்கள் என்றால், + என்பதை இணைத்தல் இயக்கி(கூட்டல் அல்ல)
என்றே புரிந்துகொள்ள வேண்டும்.
நிரல் 2: எழுத்துகளை இணைத்து சரம் சமைத்தல்
முதலில் s என்கிற ஒரு காலி சரத்தை உருவாக்கிக் கொள்கிறோம். பிறகு பயனரிடமிருந்து அதில்(s) எத்தனை உறுப்புகள் இடம்பெற வேண்டும் என்கிற எண்ணிக்கையைக் கேட்டுப்பெற்று, அதை for loopக்கு அனுப்பிவைக்கிறோம்.
மேற்கண்ட நிரலில் பயனர் 5 என்கிறார், ஆக 5 எழுத்துக்களை தனித்தனியே பெற்று அவற்றை இணைத்தல் இயக்கியைக்கொண்டு ஒற்றை சரமாகச் சமைக்கிறோம்.
நிரல் 3: சரத்தைப் பிரதி எடுத்தல்
* இயக்கியைக்கொண்டு சரத்தைப் பிரதியெடுக்க முடியும். மேலே “பாம்பு” என்கிற சொல்லை(சரம்) 3 முறை பிரதி செய்யச் சொல்லிக் கேட்கிறோம். நிரலும் சமர்த்தாகச் செய்துகொடுத்து விடுகிறது.
நிரல் 4: பிரதி செய்கை இயக்கியைக்கொண்டு புதிதாக ஒரு சரத்தை உருவாக்குதல்
சரத்தின் மதிப்பு மற்றும் எத்தனைமுறை பிரதியெடுக்கப்பட வேண்டுமென்பதையும் பயனர் சொல்கிறார். அதை அப்படியே சிந்தாமல் சிதறாமல் for loopற்கு அனுப்புவதற்கு முன்பு ஒரு காலி சரத்தை உருவாக்கிக்கொள்கிறோம். பயனர் 3 என்று குறிப்பிட்டு இருப்பதால், மூலச்சரம் மூன்றுமுறை பிரதியெடுக்கப்பட்டு, காலி சரத்திற்கு என உருவாக்கப்பட்ட அடையாளங்காட்டியில் சேமிக்கப்படுகிறது.
குறிப்புகள்:
1) சரத்திற்கும், எண்ணிற்கும் இடையே + இயக்கியைப் பயன்படுத்தக்கூடாது
2) * இயக்கியைச் சரத்திற்கும், சரத்திற்கும் இடையே பயன்படுத்தக்கூடாது.
ஏன் அப்படி?
+ இயக்கியாக இருந்து யோசித்துப் பாருங்கள். தனக்கு இருபுறமும் எண்கள் இருந்தால் அவற்றைக் கூட்டி மதிப்பைச் சொல்ல வேண்டும், இருபுறமும் சரங்கள் இருந்தால் அவற்றை இணைக்க வேண்டும். அவ்வளவுதான் அதற்குச் சொல்லப்பட்டு இருக்கிறது. ஒருபுறம் சரம், மறுபுறம் எண் என்றால், இதில் என்ன மாதிரியான செயல்பாட்டைச் செய்துவிட முடியும். ஆகவே நிரலாளர் இவ்வகையில் முயன்றால், பிழையைத் தான் காணவேண்டிவரும்.
அதெல்லாம் தெரியாது ஒரு சரத்தையும், எண்ணையும் இணைத்தே ஆகவேண்டும் என்று அடம் பிடிப்பீர்கள் என்றால், பின்வருமாறு முயன்று பாருங்கள். அவ்வளவுதான் சாத்தியம்.
>>> “Paambu” + “3”
மேற்சொன்ன விதி அப்படியே *க்கும் பொருந்தும். *க்கு இடையே எண்கள் மட்டும் இருந்தால் பெருக்கி அதன் மதிப்பைத் தரும், அல்லது ஒரு எண் மற்றும் ஒரு சரம் இருந்தால் செய்கையில் ஈடுபடும். இரண்டுமே சரமாக இருக்கும் பட்சத்தில் * இயக்கியின் மனக்குரல் “ஏலேய் கலெக்ட்டரு, என் வயிறு பத்தி எரியுதுலேய்”.
இவ்விதிகளை எளிமையாக நினைவில் வைத்துக்கொள்ள ஏதாவது வழி இருக்கிறதா?
ருக்கு ருக்கு ருக்கு.
சரம் + சரம் – சாத்தியம்
சரம் + எண் – அசாத்தியம்
சரம் * எண் – சத்தியம்
சரம் * சரம் – அசாத்தியம்
ஏற்கனவே நாம் பேசியதைப் போல, சரத்தின் மு.வ.செயல்பாடுகளின் பட்டியல் நீளமானது. அவற்றை இனி ஒவ்வொன்றாக எடுத்துக்காட்டுகளின் உதவியோடு பார்ப்போம்.
1) len()
நிரல் 5: சரத்தின் உறுப்புகளை எண்ணுதல்
சரத்திற்கு உண்டான பிரத்தியேக மு.வ.செயல்பாடு என்று இதைச்சொல்ல இயலாது. பட்டியல், மா.பட்டியல், சரம் ஆகிய மூன்றுக்கும், வரவிருக்கும் தரவு கட்டமைப்புகளுக்கும் கூட len() பொதுவானது. text என்ற அடையாளங்காட்டியில் மொத்தம் 13 உறுப்புகள் உள்ளதாக நிரலின் வெளியீடு சொல்கிறது.
இது என்ன அநியாயம்?
Helloவையும், Worldஐயும் கூட்டினால் மொத்தம் 10 எழுத்துகள்(உறுப்புகள்) தானே வருகிறது? பிறகெப்படி 13 என்கிறீர்களா? இரட்டை மேற்கோள் குறிகளுக்கு இடையே உள்ள அனைத்துமே சரம் என்ற கணக்கில் தான் வரும் இல்லையா? அப்படிப் பார்த்தால், “Hello, World”க்குள் இன்னும் என்னென்னவோ இருக்கிறது உற்றுப்பாருங்கள். காற்புள்ளி, ஆச்சரியக்குறி, இடைவெளி ஆக மூன்று வெவ்வேறு உறுப்புகள். நிரலின் கணக்கும் நமது கணக்கும் நேரானது இப்போது, இதில் கவனிக்கவேண்டியது ஒன்றுதான் மேற்கோள் குறிகளுக்கு இடையே உள்ளது எதையும் நீங்கள் தவறவிடக் கூடாது.
நிரல் 6: இரவு உறங்கச் செல்வதற்கு முன்பு ஒருமுறை எண்ணிச் சரிபார்த்து விடுங்கள்.
2) lower()
நிரல் 7: சரத்தின் உறுப்புகளைச் சிறிய எழுத்துக்களாக மாற்றுதல்
சரத்தின் உள்ள உறுப்புகள் எந்த நிலையிலிருந்தாலும் சரி, அவற்றைச் சிறிய எழுத்துக்களாக மாற்றுவதுதான் இந்த செயல்பாட்டின் நோக்கம். அடுத்த நிரலிலும் இதையேதான் முயன்று பார்த்திருக்கிறோம்.
நிரல் 8:
சிறியதற்கு என்று ஒன்றிருந்தால், கட்டாயம் பெரிய எழுத்துகளுக்கு என்று ஒரு செயல்பாடு இருந்தாக வேண்டுமல்லவா? அதுதானே உலக வழக்கம்.
மேலே பார்த்த அதே சரத்தின் உறுப்புகளைப் பெரிய எழுத்துக்களாக மாற்றி அடுத்த 2 நிரல்களிலும் விளையாடியிருக்கிறோம்.
எல்லாம் சரி, இதையெல்லாம் எங்கே பயன்படுத்துகிறோம். பயனரிடமிருந்து ஒரு சரத்தைப் பெறுகிறோம் என்று வைத்துக்கொள்வோம், அவரை சிறிய எழுத்துக்களில்/பெரிய எழுத்துக்களில் அல்லது முதல் எழுத்தை மட்டும் பெரியதாக அச்சிடச்சொல்லி நிர்ப்பந்திக்க இயலாது தானே? ஆகவே அவர் வசதிக்கு அவர் எப்படியோ அடிக்கட்டும், நிரலில் நமக்குத் தேவையான படி சேமிக்க இத்தனை மு.வ.செயல்பாடுகள்.
இனி அந்த 2 நிரல்கள்.
3) upper()
நிரல் 9: சரத்தின் உறுப்புகளைப் பெரிய எழுத்துக்களாக மாற்றுதல்
நிரல் 10:
சரத்தின் உறுப்புகளில் முதலில் உள்ளதை மட்டும் பெரிய எழுத்தாக மாற்றுதல்
4) capitalize()
நிரல் 11: முதல் எழுத்தை மட்டும் பெரியதாக மாற்றுதல்
5) title()
போன செயல்பாட்டில் உள்ள ஒரு வரையறை என்று, முதல் எழுத்தை மட்டும் பெரிதாக்குவதைச் சொல்லலாம். அக்குறை title()ன் மூலம் சரி செய்யப்படும். சரத்தின் முதல் எழுத்து மற்றும் இடைவெளி விட்டுவரும் சொல்லின் முதலெழுத்து ஆகியன பெரிய எழுத்துக்களாக மாற்றப்படும்.
நிரல் 12: சொற்களின் முதல் எழுத்துக்களை பெரியதாக மாற்றுதல்
நிரல் 13:
6) strip()
சரத்தின் உறுப்புகளுக்கு முன்னும், பின்னும் உள்ள தேவையற்ற இடைவெளியை நீக்க இச்செயல்பாடு பயன்படுகிறது.
நிரல் 14: தேவையற்ற இடைவெளியை நீக்குதல்
நிரல் 15:
7) lstrip()
போன செயல்பாட்டின் செம்மைப்படுத்தப்பட்ட தொடர்ச்சி என இதைச் சொல்லலாம். அதாவது சரத்தைத் தொடர்ந்து வரும் இடைவெளி அவசியமானது, அது அப்படியே இருக்கட்டும். எனக்குச் சரத்திற்கு முன்னிருக்கும் இடைவெளியை மட்டும் நீக்க வேண்டுமென்று விரும்புபவர்கள் இச்செயல்பாட்டைக் கவனிக்கலாம். lstrip() என்பதை left strip என்று விரித்து எழுதலாம், அதாவது இடதுபக்க இடைவெளியை நீக்கி தருகிறது.
நிரல் 16: இடப்பக்க இடைவெளியை நீக்குதல்
இடது என்று இருந்தால் வலது என்றும் …
8) rstrip()
அதேதான். நீங்கள் சொல்வது சரிதான். இவர் வலப்பக்க இடைவெளியை மட்டும் நீக்க வல்லவர்.
நிரல் 17: வலப்பக்க இடைவெளியை நீக்குதல்
9) startswith()
சரம் குறிப்பிட்ட ஒரு சொல்லோடு தான் துவங்குகிறதா என்பதை இச்செயல்பாட்டைக் கொண்டு கண்டறியலாம்.
நிரல் 18: குறிப்பிட்ட ஒரு சொல்லோடுதான் துவங்குகிறதா என்பதைக் கண்டறிவது
“Hello” என்றுதான் “Hello, World!” ஆரம்பிக்கிறது இல்லையா? அதை நிரலைக்கொண்டு பரிசோதிக்கிறோம்.
10) endswith()
போன நிரலுக்குத் தொடக்கம் தான் முக்கியம் என்றால், இந்நிரலுக்கு முடிவு தான் எல்லாமே. சரத்தின் உறுப்புகள் குறிப்பிட்ட சொல்லால் தான் முடிகிறதா என்பதை இச்செயல்பாடு அறிந்து சொல்லும்.
நிரல் 19: குறிப்பிட்ட ஒரு சொல்லால் தான் முடிகிறதா என்பதையறிவது
11) count()
ஒரு உறுப்பைத் தந்து அது எத்தனை முறை சரத்தில் இடம்பெறுகிறது என்பதன் எண்ணிக்கையைச் சொல்ல இச்செயல்பாட்டை நீங்கள் அணுகவேண்டும்.
நிரல் 20: குறிப்பிட்ட உறுப்பின் இருப்பு எண்ணிக்கையை அறிதல்
ஒரு எழுத்து மட்டுமல்ல, ஒரு சொல்லையே கூட தந்து அதன் இருப்பு எண்ணிக்கையை அறியலாம். தில்லானா தில்லானா பாடலில் தில்லானா எத்தனைமுறை வருகிறது என்று போட்டியெல்லாம் வைத்தார்கள் நினைவிருக்கிறதா? கணநேரத்தில் நீங்கள் அதை இப்போது சொல்லிவிடலாம். வளையோசை பாடலில் எத்தனை கல வருகிறது என்பதையும் அப்படியே இந்நிரலைக் கொண்டு எண்ணிச் சொல்லுங்கள். உங்கள் சேவை, இந்நாட்டுக்குத் தேவை.
நிரல் 21:
12) find()
ஒரு உறுப்பைத் தந்து எண்ணுவதெல்லாம் ஒருபுறம் இருக்கட்டும், முதலில் அவ்வுறுப்பு சரத்தில் இருக்கிறதா என்பதைப் பார்க்க முடியுமா?
ஏன் முடியாது?
நிரல் 22: சரத்தில் குறிப்பிட்ட ஒரு உறுப்பு இடம்பெற்றுள்ளதா என்று பார்ப்பது
அது என்ன சம்பந்தமே இல்லாமல் 9 என்று நிரலின் வெளியீடு காட்டுகிறது. முதலில் அவ்வுறுப்பு மூலச்சரத்தில் இடம்பெற்றுள்ளதா என்று நிரல் உறுதி செய்துகொள்கிறது. அப்படி இடம்பெற்றிருந்தால் குறிப்பிட்ட அந்த உறுப்பின் முதல் எழுத்தை எடுத்துக்கொண்டு அதன் நேர் குறியீட்டு எண்ணை அச்சிடுகிறது.
“today” என்ற உறுப்பு text அடையாளங்காட்டியில் சேமிக்கப்பட்டிருக்கும் சரத்தில் இடம்பெற்றிருக்கிறதா?
ஆம். எனில் அவ்வுறுப்பின் முதல் எழுத்து என்ன?
‘t’. அவ்வளவுதான், அதன் நேர் குறியீட்டு எண்ணைக் கண்டுபிடியுங்கள். நிரல் எதற்காக 9 என்ற வெளியீட்டை அச்சிட்டிருக்கிறது என்பது விளங்கும்.
ஒருவேளை சரத்தில் நிறைய ‘t’க்கள் இருந்தால் முதலில் வரும் ‘t’யின் குறியீட்டு எண் எடுத்துக்கொள்ளப்படும்.
ஒருவேளை சரத்தில் குறிப்பிட்ட அவ்வுறுப்பு இடம்பெறாமல் இருந்தால் …
நிரல் 23: இல்லாத உறுப்பைக் கண்டறிய முயலுதல்
ஒருவேளை நீங்கள் பெறவிரும்பும் உறுப்பு சரத்தில் எங்கேயும் இடம்பெறவில்லை என்றால், வெளியீடு கட்டாயம் -1 என்றிருக்கும்.(நே.அ.கே.கே)
12) index()
ஒரு உறுப்பைத் தேடி, அதைக் கண்டறிந்து, ஒருவேளை இருந்தால் அதன் குறியீட்டு எண்ணைப் பெறுவதற்குப் பதிலாக, உறுப்பை அனுப்பினால் அதன் குறியீட்டு எண் கிடைக்கும் வகையில் ஏதேனும் செயல்பாடு இருக்கிறதா என்று கேட்பவர்களுக்காக
நிரல் 24: குறியீட்டு எண்ணைக் கண்டறிதல்
ஒருவேளை அவ்வுறுப்பு இல்லாமல் இருந்தால் அதேதான்,
“ஏலேய் கலெக்ட்டரு, வயிறு …”.
நிரல் 25:
0
இன்னும் ஒரு டஜன் மு.வ.செயல்பாடுகள் சரத்தின் சார்பாகக் காத்திருக்கின்றன. அவற்றையும், அவற்றைப் பயன்படுத்தி சரம் சார்ந்த சிக்கல்களைத் தீர்க்க நிரல் எழுதுவது குறித்தும் அடுத்த வாரம் காண்போம்.
(தொடரும்)
