റെഗുലർ എക്സ്പ്രഷനുകൾ
/h[aeiou]+/g(ഒന്നോ അതിലധികമോ സ്വരാക്ഷരങ്ങൾ h എന്ന അക്ഷരത്തെ പിന്തുടരുന്നു)ഒരു ടെക്സ്റ്റിനകത്ത് തിരയാൻ ഉപയോഗിക്കുന്ന അക്ഷരം, സംഖ്യ , ചിഹ്നം എണ്ണിയവയുടെ ക്രമീകരണത്തെയാണ് റെഗുലർ എക്സ്പ്രെഷൻസ് അല്ലെങ്കിൽ റാഷണൽ എക്സ്പ്രെഷൻസ് എന്ന് പറയുന്നത് [1]. ഇത് സ്ട്രിംഗ്-സെർച്ചിങ് അൽഗോരിതങ്ങളിൽ ഒരു പദത്തെ കണ്ടെത്താനോ അല്ലെങ്കിൽ ഒരു പദത്തെ മാറ്റി മറ്റൊരു പദം ചേർക്കാനോ ആണ് സാധാരണയായി ഉപയോഗിക്കുന്നത്.
1950 കളിൽ അമേരിക്കൻ ഗണിത ശാസ്ത്രജ്ഞനായിരുന്ന സ്റ്റീഫൻ കോലെ ക്ളീൻ ഒരു റെഗുലർ ലാംഗ്വേജ് രൂപീകരിച്ചതിനു പിന്നാലെയാണ് റെഗുലർ എക്സ്പ്രെഷൻസ് എന്ന ചിന്ത ഉടലെടുക്കുന്നത്. വൈകാതെ തന്നെ യൂനിക്സ് ടെക്സ്റ്റ് പ്രോസസ്സിംഗ് യൂട്ടിലിറ്റികളുടെ കൂടെ ഇവയും ദൈനം ദിന ഉപയോഗത്തിലേക്ക് കടന്ന് വന്നു. ഇന്ന് പല പ്രോഗ്രാമിങ് ലാംഗ്വേജുകളിലും റിഗ്രെസ് അവയുടെ കൂടെതന്നയോ അല്ലെങ്കിൽ ആവശ്യാനുസരണം പെട്ടെന്ന് തന്നെ ഉപയോഗിക്കാനാവുന്ന തരത്തിൽ ലൈബ്രറികളായോ ഉൾപെടുത്തുന്നുണ്ട്.
ചരിത്രം
[തിരുത്തുക]
1951-ൽ ഗണിതശാസ്ത്രജ്ഞനായ സ്റ്റീഫൻ കോൾ ക്ലീൻ റെഗുലർ ഇവന്റുകൾ എന്ന തന്റെ ഗണിതശാസ്ത്ര നൊട്ടേഷൻ ഉപയോഗിച്ച് റെഗുലർ ഭാഷകളെക്കുറിച്ച് വിവരിച്ചപ്പോഴാണ് റെഗുലർ എക്സ്പ്രക്ഷൻസ് ഉത്ഭവിച്ചത്.[2] സൈദ്ധാന്തിക കമ്പ്യൂട്ടർ സയൻസിൽ, ഓട്ടോമാറ്റ സിദ്ധാന്തത്തിന്റെ (automata theory-കമ്പ്യൂട്ടേഷന്റെ മാതൃകകൾ) ഉപവിഭാഗങ്ങൾ ഔപചാരിക ഭാഷകളുടെ വിവരണത്തിലുടെയും വർഗ്ഗീകരണത്തിലുടെയും ഇവ ഉടലെടുത്തു. പാറ്റേൺ മാച്ചിങ്ങിന്റെ മറ്റ് ആദ്യകാല നിർവ്വഹണങ്ങൾ സ്നോബോൾ(SNOBOL) ഭാഷയിൽ നിന്ന് ഉടലെടുത്തതാണ്, അത് റെഗുലർ എക്സ്പ്രക്ഷൻ ഉപയോഗിക്കുന്നില്ല, പകരം സ്വന്തം പാറ്റേൺ മാച്ചിങ് ഉപയോഗിക്കുന്നു.
പ്രധാനആശയങ്ങൾ
[തിരുത്തുക]ഒരുകൂട്ടം പദങ്ങളെ പ്രസ്താവിക്കാൻ ആയി ഉള്ള ഒരു മാർഗം അവ ഓരോന്നിനെയും എടുത്തു പറയുക എന്നുള്ളതാണ്. പലപ്പോഴും ഇവയെ അവയെ ചിഹ്നങ്ങളും അക്ഷരങ്ങളും ഉപയോഗിച്ച് കൊണ്ട് ചുരുക്കി സൂചിപ്പിക്കാനും കഴിയും. ഉദാഹരണത്തിന്, "Handel, Händel, Haendel" ഈ മൂന്ന് പദങ്ങളെയും H(ä|ae?)ndel ഈ ഒരു പാറ്റേൺ കൊണ്ട് സൂചിപ്പിക്കുന്നു. ഒരുകൂട്ടം പദങ്ങളെ ഉൾപ്പെടുത്തിക്കൊണ്ട് കൊണ്ട് വിവിധതരത്തിൽ ഇങ്ങനെ റഗുലർ എക്സ്പ്രഷൻസ് എഴുതാവുന്നതാണ്. (Hän|Han|Haen)del ഈ ഒരു പാറ്റേണും മുന്നേ സൂചിപ്പിച്ച 3 പദങ്ങളെയും ഉൾക്കൊള്ളുന്നതാണ്.
റെഗുലർ എക്സ്പ്രഷനിൽ ഉപയോഗിക്കുന്ന പ്രധാനപ്പെട്ട ചിഹ്നങ്ങളെയും അക്ഷരങ്ങളെയും താഴെ കൊടുക്കുന്നു. പൈത്തൺ പ്രോഗ്രാമിങ് ലാംഗ്വേജ് ഉൾപ്പെടുന്ന re മൊഡ്യൂൾ വഴി റെഗുലർ എക്സ്പ്രഷൻസ് ഉപയോഗിക്കാനാവും. import re എന്ന കമാൻഡ് ഉപയോഗിക്കാം.
പ്രോഗ്രാമിങ് ഘടന
[തിരുത്തുക]മെറ്റാക്യാരക്ടർ
[തിരുത്തുക]പാറ്റേൺ പ്രോസസ്സിംഗ് സമയത്ത് ഒരു പ്രത്യേക അർത്ഥമുള്ള ചിഹ്നങ്ങളെയാണ് ആണ് മെറ്റാക്യാരാക്ടർ എന്ന് വിളിക്കുന്നത്[3]. റെഗുലർ എക്സ്പ്രഷനിൽ സാധാരണഗതിയിൽ ഉപയോഗിക്കുന്ന ചില മെറ്റാക്യാരക്ടേഴ്സ് ചുവടെ കൊടുക്കുന്നു.
| മെറ്റാക്യാരക്ടർ | വിശദീകരണം | ഉദാഹരണം ( പൈത്തൺ ) |
|---|---|---|
.
|
പുതിയ ഒരു വരി തുടങ്ങുന്നു എന്നത് ഒഴികെയുള്ള എല്ലാ അടയാളങ്ങളെയും സൂചിപ്പിക്കുന്നു | pattern = r"eg."
if re.match(pattern, "egg spam eg2 foo eg"):
print("Match")
print(re.findall(pattern, "egg spam eg2 foo eg"))
ഔട്ട്പുട്ട്:
Match
['egg', 'eg2']
|
+
|
തൊട്ടു മുന്നേ വരുന്ന പാറ്റേൺ ഒന്നോ അതിലധികമോ തവണ ആവർത്തിച്ചു വരുന്നതിനെയും ഉൾക്കൊള്ളുന്നു | pattern = r"egg(spam)+"
if re.match(pattern, "egg" ):
print("Match 1")
if re.match(pattern, "eggspamspam" ):
print("Match 2")
if re.match(pattern, "spamspam" ):
print("Match 3")
ഔട്ട്പുട്ട്:
Match 2
|
?
|
മുന്നേയുള്ള പാറ്റേൺ പൂജ്യം അല്ലെങ്കിൽ ഒരു തവണ ആവർത്തിക്കുന്നതിനെ സൂചിപ്പിക്കുന്നു | pattern = r"egg(spam)?"
if re.match(pattern, "egg" ):
print("Match 1")
if re.match(pattern, "eggspamspam" ):
print("Match 2")
if re.match(pattern, "spamspam" ):
print("Match 3")
ഔട്ട്പുട്ട്:
Match 1
|
*
|
തൊട്ടു മുന്നേ വരുന്ന പാറ്റേൺ പൂജ്യമോ അതിലധികമോ തവണ വരുന്നതിന് പൊരുത്തപ്പെടുന്നു. | pattern = r"egg(spam)*"
if re.match(pattern, "egg" ):
print("Match 1")
if re.match(pattern, "eggspamspam" ):
print("Match 2")
if re.match(pattern, "spamspam" ):
print("Match 3")
ഔട്ട്പുട്ട്:
Match 1
Match 2
|
|
|
അല്ലെങ്കിൽ എന്ന അർത്ഥം നൽകുന്നു. രണ്ടു വ്യത്യസ്ത സാധ്യതകളെ നാളെ ഉൾക്കൊള്ളുന്നു | pattern = r"gr(a|e)y"
if re.match(pattern, "grey" ):
print("Match 1")
if re.match(pattern, "groy" ):
print("Match 2")
ഔട്ട്പുട്ട്:
Match 1
|
^
|
ഒരു വരിയുടെയോ അല്ലെങ്കിൽ ഒരു ശ്രേണിയുടെ തുടക്കത്തെ സൂചിപ്പിക്കുന്നു | pattern = r"^fo."
if re.match(pattern, "foo" ):
print("Match 1")
if re.match(pattern, "koo" ):
print("Match 2")
ഔട്ട്പുട്ട്:
Match 1
|
$
|
വരിയുടെയും ശ്രേണിയുടെയോ അവസാനത്തെ സൂചിപ്പിക്കുന്നു | pattern = r"f.o$"
if re.match(pattern, "foo" ):
print("Match 1")
if re.match(pattern, "koi" ):
print("Match 2")
ഔട്ട്പുട്ട്:
Match 1
|
()
|
വ്യത്യസ്തമായ ആയ കുറെയധികം പാറ്റേണും ഘടകങ്ങളെ ഒരുമിച്ചു കൂടുന്നു. റെഗുലർ എക്സ്പ്രഷനുകളിലെ ‘Group function ’ എന്നതിലും ഉപയോഗിക്കാറുണ്ട് . | |
[...]
|
ഒരു പ്രത്യേക വിഭാഗത്തിൽ പെടുന്ന സാധ്യമായ പാറ്റേണുകൾ സൂചിപ്പിക്കുന്നു. [A-Z] എന്നത് എല്ലാ ഇംഗ്ലീഷ് വലിയ അക്ഷരങ്ങളെയും സൂചിപ്പിക്കുന്നു.
|
pattern = r"[A-Z][A-Z][1-9]"
if re.match(pattern, "MH3" ):
print("Match 1")
if re.match(pattern, "Mh3" ):
print("Match 2")
ഔട്ട്പുട്ട്:
Match 1
|
സ്പെഷ്യൽ സീക്വൻസുകൾ
[തിരുത്തുക]റെഗുലർ എക്സ്പ്രഷനിൽ ഉപയോഗിക്കുന്ന മറ്റൊരു കൂട്ടം പ്രതീകങ്ങളെയാണ് ആണ് സ്പെഷ്യൽ സീക്വൻസുകൾ എന്ന് പറയുന്നത്. സാധാരണയായി ആയി ഒരു ഒരു ബാക് സ്ലാഷ് (\) ശേഷം സംഖ്യ അല്ലെങ്കിൽ അക്ഷരം എന്ന രൂപത്തിലാണ് ഇത് കാണപ്പെടുന്നത്.
| സ്പെഷ്യൽ സീക്വൻസുകൾ | |
|---|---|
\s
|
വൈറ്റ് സ്പേസിനെ സൂചിപ്പിക്കുന്നു |
\S
|
വൈറ്റ് സ്പേസ് അല്ലാത്ത എല്ലാത്തിനെയും പൊരുത്തപ്പെടുന്നു |
\w
|
എല്ലാ ആൽഫ-ന്യൂമെറിക് അടയാളങ്ങളെയും സൂചിപ്പിക്കുന്നു |
\W
|
അൽഫ-ന്യൂമെറിക് അല്ലാത്ത എല്ലാത്തിനെയും ഉൾക്കൊള്ളുന്നു |
\d
|
എല്ലാ അക്കങ്ങളുടെയും സൂചിപ്പിക്കുന്നു |
\D
|
അക്കങ്ങൾ അല്ലാത്ത എല്ലാത്തിനെയും ഉൾക്കൊള്ളുന്നു |
അവലംബം
[തിരുത്തുക]- ↑ "Regular expression", Wikipedia (in ഇംഗ്ലീഷ്), 2022-06-27, retrieved 2022-07-23
- ↑ Leung, Hing (16 സെപ്റ്റംബർ 2010). "Regular Languages and Finite Automata" (PDF). New Mexico State University. Archived from the original (PDF) on 5 ഡിസംബർ 2013. Retrieved 13 ഓഗസ്റ്റ് 2019.
The concept of regular events was introduced by Kleene via the definition of regular expressions.
- ↑ "Metacharacters". www.ibm.com (in അമേരിക്കൻ ഇംഗ്ലീഷ്). 2017-07-06. Retrieved 2022-07-23.