பைத்தான் ரிஜெக்ஸ் 3 – ஒன்றுக்கு மேற்பட்ட அலைபேசி எண்களை எப்படிச் சோதிப்பது?

முந்தைய பதிவில் தொலைபேசி எண் இருக்கிறதா என்பதைப் பார்த்தோம். அதைப் பார்க்கும் போது நண்பர் ஒருவர், 91 என்று நாட்டுக் குறியீட்டுக்குப் பதிலாகச் சில நேரங்களில் நாம் சுழி(0) கொடுப்போமே! அதை உங்கள் நிரல் கையாளுமா? என்று கேட்டிருந்தார்.
சிலர் 91 என நாட்டுக்குறியீடு கொடுப்பார்கள். சிலர், சுழி(0) கொடுப்பார்கள். ரிஜெக்சில் இதை எப்படிக் கையாள்வது? 91 அல்லது 0 என்பதை ரிஜெக்ஸ் முறையில் எழுத வேண்டும். (91|0) அவ்வளவு தான்! இங்கே நடுவில் இருக்கும் | குறியீட்டைக் குழாய்(pipe) என்று சொல்வார்கள். இந்தக் குழாயை நடுவில் வைத்து விட்டால் போதும். இடப்புறம் அல்லது வலப்புறம் – இரண்டில் ஏதாவது ஒன்று எனப் பைத்தான் புரிந்து கொள்ளும்.

import re

def isLandLine(sentence):
  landLinePattern = re.compile(r'(((91|0)((\d){2,4}))-)?([1-9][0-9]{5,8})')
  present = landLinePattern.search(sentence)
  if present.group(1)==None:
    std=0
  else:
    std=len(present.group(1))
    phone = len(present.group(5))
  if (std+phone)==12: or 11:
    return True
  else:
    return False

sentence = 'My number is 0462-2921129'
landline_present = isLandLine(sentence)
if(landline_present):
print("Landline number is present in the sentence")
else:
print("Landline Number is not present in the sentence")

சரி, இந்தக் கதை முடிந்தது என்று மகிழ்ந்தால், அதே நண்பர், “நான் ஒரே வரியில் இரண்டு அலைபேசி எண்களைக் கொடுத்தால் உங்கள் நிரல் வேலை செய்யுமா? என்கிறார்”. “பாட்டெழுதிப் பேர் வாங்கும் புலவர்கள் உண்டு. குற்றம் கண்டுபிடித்துப் பேர் வாங்கும் புலவர்களும் உண்டு” என்னும் திருவிளையாடல் வசனம் தான் நினைவுக்கு வந்தது. இருந்தாலும் அவருடைய கேள்வி நியாயமாகத் தெரிந்தது. ஒருவர், ஒரே வரியில் இரண்டு அலைபேசி எண்களைக் கொடுத்தால், நம்முடைய நிரல் வேலை செய்யுமா?

import re #முதலில் இதை இறக்கிக் கொள்ள வேண்டும் - நினைவிருக்கிறது அல்லவா!

def isMobileNumber(sentence): #def என்பது வேலையின் பெயருக்கு முன் கொடுக்கவேண்டிய பைத்தான் குறிச்சொல்.
  mobileNumberPattern = re.compile("(0|91)[6-9][0-9]{9}")
  return mobileNumberPattern.search(sentence)
#மேல் இருப்பது தான் நம்முடைய வேலை. இப்போது பைத்தானைக் கூப்பிட்டு இந்த வேலையைச் செய்யச் சொல்ல வேண்டுமே!
#கீழ் இருக்கும் வரிகளைப் பாருங்கள்.

sentence = "My mobile no is 918344777333"
mobileNumber_present = isMobileNumber(sentence) #இங்குத் தான், பைத்தானிடம் இந்த வேலையைச் செய்யச் சொல்கிறோம்.
if (mobileNumber_present):
  print("Mobile Number is present in the sentence")
else:
  print("Mobile Number is not present in the sentence")

இப்போது இந்த நிரலை isMobileNo.py எனச் சேமித்து ஓட்டிப் பாருங்கள். இது தான் நம்முடைய பழைய நிரல். இந்த நிரல், ஒரே ஓர் அலைபேசி எண்ணைக் கொடுத்த போது சரியாக வேலை செய்தது. இப்போது இரண்டு எண்களைக் கொடுத்துப் பாருங்கள். எங்கே?
sentence = “My mobile no is 918344777333” வரியை
sentence = “My mobile numbers are 918344777333 and 918883775533” என்று கொடுத்துப் பாருங்களேன். முதல் எண்ணை மட்டும் தான் பைத்தான் எடுக்கும். எடுத்து, அது அலைபேசி எண்ணா என்று பார்க்கும்.
return mobileNumberPattern.search(sentence) என்றொரு வரி மேலே எழுதியிருக்கிறோம் அல்லவா! இந்த வரி, முதல் எண், பொது வடிவத்திற்குப் பொருந்தியிருந்தால் அதை எடுத்தவுடன் திரும்பி(return) விடும். இரண்டு எண்களையும் பொது வடிவத்தில் பொருத்திப் பார்க்க வேண்டும் என்றால், findall() என்றொரு செயல்கூறு(function) பைத்தானில் இருக்கிறது. அதைப் பயன்படுத்தலாம்.

ஒன்றுக்கு மேற்பட்ட அலைபேசி எண்களை ஒரு வரியில் இருந்து எடுக்க நிரல்:

import re

def isMobileNumber(sentence):
  mobileNumberPattern = re.compile("(91[6-9][0-9]{9})")
  number = mobileNumberPattern.findall(sentence)
  return number

sentence = "My mobile no is 918344777333 and 918883775533, 91234567890"
mobileNumber_present = isMobileNumber(sentence)
print(type(mobileNumber_present))

for number in mobileNumber_present:
  print(number)

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

– கி. முத்துராமலிங்கம் (muthu@payilagam.com)