பைத்தான் – ரிஜெக்ஸ்(Regex) – 1

கி. முத்துராமலிங்கம் July 21, 2020 1 Comment

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

def isPhoneNumber(text):
  if len(text) != 10:
    return False
  for i in range(0, 9):
    if not text[i].isdecimal():
      return False
    if text[0] == '0':
      return False
    return True

print('Is 8344777333 a phone number?')
print(isPhoneNumber('8344777333'))
print('Is 0123456789 a phone number?')
print(isPhoneNumber('0123456789'))

இதே நிரலில், எண்ணில் +91 சேர்த்தாலோ, 0 சேர்த்தாலோ இன்னும் பெரிய நிரலாக எழுத வேண்டியது வரும். அதிலும் சில பேர், அலைபேசி எண்ணை இடம் விட்டு (83447 77333) என்று எழுதுவார்கள். அப்போது அலைபேசி எண்ணா எனக் கண்டுபிடிப்பது இன்னும் சிரமமாக இருக்கும். இதைத் தவிர்க்க உதவுவது தான் Regex எனப்படும் Regular Expressions!

Regular Expressions என்பதைச் சரியாகப் புரிந்து கொள்ள வேண்டும் என்றால், ஒரே பொது வடிவம் கொண்ட வார்த்தைகள் – அலைபேசிஎண்கள், மின்னஞ்சல்கள் ஆகியவற்றிற்கு என்று ஒரே பொது வடிவம் உண்டு அல்லவா! எனவே தான் அவற்றை regexஇன் கீழ் படிக்கிறோம்.

இப்போது ஒரு வார்த்தையில் இடையில் உள்ள எழுத்துகள், எண்களா எனக் கண்டுபிடிக்க வேண்டும் என்றால் ‘\d’ என்று கொடுத்தால் போதுமானது. இதே போல, பத்து எழுத்துகளும் எண்களாக இருந்தால் தானே, அந்த வார்த்தை, அலைபேசி எண்ணைக் குறிக்கிறது என்று எடுத்துக் கொள்ள முடியும்? அப்படியானால் என்ன செய்வது? \d\d\d\d\d\d\d\d\d\d என்று பத்துத் தடவையும் கொடுக்கலாம். இதற்கு மாற்றாக \d{10} என்றும் கொடுக்கலாம். இங்கே, பூவளையத்திற்குள் 10 என்று கொடுத்திருப்பது எதைக் குறிக்கிறது? எத்தனை தடவை எண் வரும் என்பதை! உங்களுக்கே அது புரிந்திருக்கும் தானே!

சரி, இந்த \d என்பது பைத்தானில் எங்கே இருக்கும்? அதை நான் எப்படிப் பயன்படுத்தத் தொடங்குவது? என்பன போன்ற கேள்விகள் உங்களுக்கு இருந்தால் உங்கள் கேள்விகள் சரியானவை தான்! அதைப் பார்க்கத் தொடங்குவோமா!

re module

பைத்தானில் regex வேலைகள் எல்லாமே re moduleஇல் இருக்கின்றன. எனவே, regex வேலைகளைச் செய்வதற்கு, re moduleஐ இறக்கிக் கொள்ள வேண்டும். எப்படி இறக்குவது?

import re
என்று கொடுத்தால் போதுமானது.

இந்த moduleஇல் compile என்றொரு வேலையைத் தொடங்கினால் போதும். compile வேலை செய்வதாக இருந்தால், அந்த வேலைக்கு ஏதாவது உள்ளீடு கொடுக்க வேண்டாமா? அந்த உள்ளீடு தான் நாம் கொடுக்கப் போகும் பொதுவடிவம்! இங்கே பொதுவடிவம் என்பது 10 இலக்க எண்! எப்படிக் கொடுக்க வேண்டும்?

mobileNoRegex = re.compile(r’\d\d\d\d\d\d\d\d\d\d’)

இப்படித்தான்! என்ன செய்திருக்கிறோம். re moduleஇல் இருந்து, 10 இலக்க எண்ணை compile செய்கிறோம். compile வேலையைச் செய்தால், விடையாக ஏதாவது வரவேண்டும் அல்லவா? அப்படி விடையாக நமக்கு வருவது தான் பொதுவடிவத்திற்கான பொருள் – அதாவது regex object! சுருக்கமாகச் சொல்ல வேண்டும் என்றால், re moduleஇல் compiல் செய்தால், regex object கிடைக்கும்! அந்தப் பொருளுக்குத் தான் mobileNoRegex என்று பெயர் வைத்திருக்கிறோம். இப்போது நாம் எந்த வார்த்தையைக் கொண்டு போய், regex Object கையில் கொடுத்தாலும், அந்த வார்த்தையில் பத்து இலக்க எண் இருக்கிறதா என்று regex object பார்த்துச் சொல்லிவிடும். எப்படி regex object பார்த்துச் சொல்லும்? அதற்கென்ன கண்ணா இருக்கிறது – பார்ப்பதற்கு! என்று யோசிக்கிறீர்களா? சரியாகத் தான் யோசிக்கிறீர்கள் போங்கள்!

உங்கள் கையில் இருக்கும் regex objectஐக் கூப்பிட்டு,”ஒரு வார்த்தை கொடுக்கிறேன். அதில் பத்து இலக்க எண் இருக்கிறதா? என்று தேடிச் சொல்” என்று சொல்ல வேண்டும். இதை எப்படிச் சொல்வது?

mobileNoRegex.search(‘My number is 8344777333.’)
என்று சொல்ல வேண்டும்.

import re

mobileNumberPattern = re.compile(‘\d{10}’)
present = mobileNumberPattern.search(“My Number is 8344777333”)
என்று கொடுத்துப் பாருங்கள்.
< _sre.SRE_Match object; span=(13, 23), match=’8344777333′> என்று விடை வரும். அதாவது, 13ஆவது இடத்தில் இருந்து நீங்கள் கேட்ட வடிவத்தில் எண் இருக்கிறது என்று பைத்தான் சொல்கிறது. அதை மட்டும் அச்சிட்டுப் பார்க்க வேண்டுமென்றால்,
print(present.group())
என்று கொடுங்கள். நாம் கொடுத்த எண் மட்டும் ஒன்றுசேர்க்கப்பட்டு அச்சாகும்.

இப்போது இதே நிரலை இன்னும் கொஞ்சம் விரிவாகப் பார்க்கலாம். நாம் கொடுக்கும் அலைபேசி எண்ணில் பத்து இலக்கங்களும் எண்கள் தாம் என்பதை, [0-9] {10} என்றும் கொடுக்கலாம். அதாவது, 0 முதல் 9 வரை பத்து எண்கள் என்று இதற்கு அர்த்தம். ஆனால், முதல் எண் சுழியாக (அதாங்க, 0 ஆக) இருக்காதே என்பதும் இங்கு பார்க்க வேண்டும் அல்லவா? அதை எப்படி எழுதுவது?

இந்தியாவில் தற்போதைய நிலையில் அலைபேசியின் முதல் எண், 6,7,8,9 ஆகிய எண்களாக இருக்கின்றன. எனவே இதே regexஐக் கொஞ்சம் மாற்றி,
re.compile(“[6-9][0-9]{9}”)
என்று கொடுக்கலாம். அதாவது, முதல் எண் 6 முதல் 9 வரை ஏதோ ஓர் எண், மீதி ஒன்பது எண்களும் சுழி முதல் ஒன்பது வரை உள்ள ஏதோ எண்கள். இப்படிக் கொடுக்க நினைக்கும் போது, உங்கள் நண்பர் ஒருவர், முதலில் சுழியோ 91 என்பதையோ நாம் கொடுப்போமே என்று கேட்டால் எப்படிக் கொடுப்பது?

அல்லது:
இது அல்லது அது என்று இரண்டு எண்களைக் கொடுக்க வேண்டும் என்றால் இரண்டு எண்களையும் () அடைப்புக்குள் கொடுத்து இடையில் | குறியைச் சேர்த்து விடவேண்டும். வேலை முடிந்தது! எப்படிக் கொடுப்பது?
re.compile(“(0|91)?[6-9][0-9]{9}”)
என்பது தான், இப்போது நாம் எதிர்பார்த்தபடி ஓர் அலைபேசியின் பொது வடிவம்.
mobileNoPattern = re.compile(“(0|91)[6-9][0-9]{9}”)
இப்போது நாம் கொடுத்த பொதுவடிவம் பைத்தானுக்குப் புரியும் பொருட்டு, compile செய்யப்பட்டு mobileNoPattern என்னும் பெயரில் சேர்க்கப்பட்டுள்ளது. அந்தப் பொதுவடிவம், இப்போது நாம் கொடுக்கும் வாக்கியத்தில் இருக்கிறதா என்று தேட வேண்டும் அல்லவா?
sentence = “My Number is 918344777333”
mobileNoPattern.search(s)
என்று கொடுத்தால் போதும். இதைத் தானே முன்னரும் செய்தோம் – நினைவிருக்கிறது அல்லவா!

இப்போது இதையே ஒரு வேலை(function)யாகச் செய்து அதற்கொரு பெயர் வைத்துக் கொள்வோம். என்ன பெயர் சூட்டலாம்? அலைபேசி_எண்ணா_பார்(isMobileNumber) என்று சூட்டுவோமா?

அலைபேசி எண் இருக்கிறதா எனப் பார்க்கும் நிரல்:

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 எனச் சேமித்து ஓட்டிப் பாருங்கள். வெற்றி நமதே! இந்தியாவில் தான் இப்படி அலைபேசி எண்களைக் கொடுப்பீர்கள். அமெரிக்கா போன்ற நாடுகளில் எல்லாம், மூன்றுஎண்கள்-மூன்றுஎண்கள்-நான்குஎண்கள் என்னும் பொது வடிவத்தில் கொடுப்பார்களே! அதை எப்படி இங்கே சோதிப்பது? ரொம்ப எளிது!

mobileNumberPattern = re.compile(“(0|91)[6-9][0-9]{9}”) என்னும் வரியைக் கொஞ்சம் மாற்றி,
mobileNumberPattern = re.compile(“\d{3}-\d{3}-\d{4}”) என்று கொடுத்துப் பாருங்கள்! அமெரிக்க அலைபேசி எண்முறையையும் சோதித்து விட்டோம்.

இந்தியத் தொலைபேசி எண்களை எப்படிச் சோதிப்பது?
நம் நாட்டில் உள்ள தொலைபேசி எண்களைக் குறிப்பிடும் போது, ஊருக்கான குறியீட்டு எண்ணைக் குறிப்பிட்டு, அதன் பிறகு, தொலைபேசி எண்ணைக் குறிப்பிடுவோம் அல்லவா? அதை எப்படிச் சோதிப்பது? அடுத்த பதிவில் பார்ப்போமே!

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

துணை நின்ற தளங்கள்:
automatetheboringstuff.com/2e/chapter7/
www.geeksforgeeks.org/java-program-check-valid-mobile-number/