પાયથોન રેગ્યુલર એક્સપ્રેશન મોડ્યુલનો ઉપયોગ કેવી રીતે કરવો (મેચ, સર્ચ, સબ, વગેરે)

Python માં રેગ્યુલર એક્સપ્રેશન પ્રોસેસિંગ કરવા માટે, અમે સ્ટાન્ડર્ડ લાઇબ્રેરીમાંથી re મોડ્યુલનો ઉપયોગ કરીએ છીએ. તે તમને રેગ્યુલર એક્સપ્રેશન પેટર્નનો ઉપયોગ કરીને શબ્દમાળાઓ કાઢવા, બદલવા અને વિભાજિત કરવાની મંજૂરી આપે છે.

• re — Regular expression operations — Python 3.10.0 Documentation
• Regular Expression HOWTO — Python 3.10.0 Documentation

આ વિભાગમાં, અમે પહેલા re મોડ્યુલના કાર્યો અને પદ્ધતિઓ સમજાવીશું.

• નિયમિત અભિવ્યક્તિ પેટર્નનું સંકલન:compile()
• મેચ ઑબ્જેક્ટ
• સ્ટ્રિંગની શરૂઆત મેળ ખાય છે કે કેમ તે તપાસો, બહાર કાઢો:match()
• મેચો માટે તપાસો જે શરૂઆત સુધી મર્યાદિત નથી:search()
• તપાસો કે શું સમગ્ર સ્ટ્રિંગ મેળ ખાય છે:fullmatch()
• બધા મેળ ખાતા ભાગોની સૂચિ મેળવો:findall()
• ઇટરરેટર તરીકે બધા મેળ ખાતા ભાગો મેળવો:finditer()
• મેળ ખાતા ભાગને બદલો:sub(),subn()
• રેગ્યુલર એક્સપ્રેશન પેટર્ન સાથે સ્પ્લિટિંગ સ્ટ્રિંગ્સ:split()

તે પછી, હું મેટા કેરેક્ટર (વિશેષ અક્ષરો) અને રેગ્યુલર એક્સપ્રેશનના ખાસ સિક્વન્સ સમજાવીશ જેનો re મોડ્યુલમાં ઉપયોગ કરી શકાય છે. મૂળભૂત રીતે, તે પ્રમાણભૂત નિયમિત અભિવ્યક્તિ વાક્યરચના છે, પરંતુ ફ્લેગ્સ સેટ કરવામાં સાવચેત રહો (ખાસ કરીને re.ASCII).

• પાયથોનમાં નિયમિત અભિવ્યક્તિ મેટાકેરેક્ટર, ખાસ સિક્વન્સ અને ચેતવણીઓ
• ધ્વજ સેટિંગ
  • ASCII અક્ષરો સુધી મર્યાદિત:re.ASCII
  • કેસ-સંવેદનશીલ નથી:re.IGNORECASE
  • દરેક લાઇનની શરૂઆત અને અંતને મેચ કરો:re.MULTILINE
  • બહુવિધ ફ્લેગ્સ સ્પષ્ટ કરો
• લોભી અને બિન-લોભી મેળ

રેગ્યુલર એક્સપ્રેશન પેટર્ન કમ્પાઇલ કરો: compile()

રી મોડ્યુલમાં રેગ્યુલર એક્સપ્રેશન પ્રોસેસિંગ કરવાની બે રીત છે.

કાર્ય સાથે ચલાવો

પ્રથમ એક કાર્ય છે.re.match(),re.sub()આના જેવા કાર્યો નિયમિત અભિવ્યક્તિ પેટર્નનો ઉપયોગ કરીને નિષ્કર્ષણ, રિપ્લેસમેન્ટ અને અન્ય પ્રક્રિયાઓ કરવા માટે ઉપલબ્ધ છે.

વિધેયોની વિગતો પછીથી વર્ણવવામાં આવશે, પરંતુ તે બધામાં, પ્રથમ દલીલ એ રેગ્યુલર એક્સપ્રેશન પેટર્નની સ્ટ્રિંગ છે, ત્યારબાદ પ્રક્રિયા કરવાની સ્ટ્રિંગ અને તેથી વધુ. ઉદાહરણ તરીકે, re.sub(), જે અવેજી કરે છે, બીજી દલીલ એ અવેજી શબ્દમાળા છે, અને ત્રીજી દલીલ પ્રક્રિયા કરવાની સ્ટ્રિંગ છે.

import re

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

m = re.match(r'([a-z]+)@([a-z]+)\.com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

result = re.sub(r'([a-z]+)@([a-z]+)\.com', 'new-address', s)
print(result)
# new-address, new-address, ccc@zzz.net

નોંધ કરો કે આ ઉદાહરણમાં રેગ્યુલર એક્સપ્રેશન પેટર્નમાં [a-z] નો અર્થ એ છે કે a થી z (એટલે ​​​​કે લોઅરકેસ મૂળાક્ષર) કોઈપણ અક્ષર, અને + નો અર્થ છે પાછલી પેટર્નનું પુનરાવર્તન (આ કિસ્સામાં [a-z]) એક અથવા વધુ વખત. [a-z]+ કોઈપણ શબ્દમાળા સાથે મેળ ખાય છે જે એક અથવા વધુ લોઅરકેસ આલ્ફાબેટીક અક્ષરોનું પુનરાવર્તન કરે છે.

. મેટા કેરેક્ટર છે (વિશેષ અર્થ ધરાવતું પાત્ર) અને બેકસ્લેશથી બચવું આવશ્યક છે.

રેગ્યુલર એક્સપ્રેશન પેટર્ન સ્ટ્રીંગ્સ ઘણી વખત બેકસ્લેશનો ઉપયોગ કરતી હોવાથી, ઉદાહરણની જેમ કાચી સ્ટ્રિંગ્સનો ઉપયોગ કરવો અનુકૂળ છે.

નિયમિત અભિવ્યક્તિ પેટર્ન ઑબ્જેક્ટની પદ્ધતિમાં ચાલે છે

રે મોડ્યુલમાં રેગ્યુલર એક્સપ્રેશન પર પ્રક્રિયા કરવાની બીજી રીત રેગ્યુલર એક્સપ્રેશન પેટર્ન ઑબ્જેક્ટ મેથડ છે.

re.compile(), નો ઉપયોગ કરીને તમે રેગ્યુલર એક્સપ્રેશન પેટર્ન ઓબ્જેક્ટ બનાવવા માટે રેગ્યુલર એક્સપ્રેશન પેટર્ન સ્ટ્રિંગ કમ્પાઈલ કરી શકો છો.

p = re.compile(r'([a-z]+)@([a-z]+)\.com')

print(p)
# re.compile('([a-z]+)@([a-z]+)\\.com')

print(type(p))
# <class 're.Pattern'>

re.match(),re.sub()ઉદાહરણ તરીકે, રેગ્યુલર એક્સપ્રેશન ઑબ્જેક્ટની મેથડ મેચ(),સબ() તરીકે આ ફંક્શન્સ જેવી જ પ્રક્રિયા એક્ઝિક્યુટ કરી શકાય છે.

m = p.match(s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

result = p.sub('new-address', s)
print(result)
# new-address, new-address, ccc@zzz.net

નીચે વર્ણવેલ તમામ re.xxx() ફંક્શન પણ રેગ્યુલર એક્સપ્રેશન ઑબ્જેક્ટની પદ્ધતિઓ તરીકે પ્રદાન કરવામાં આવ્યા છે.

જો તમે સમાન પેટર્નનો ઉપયોગ કરતી પ્રક્રિયાને પુનરાવર્તિત કરી રહ્યાં હોવ, તો re.compile() વડે રેગ્યુલર એક્સપ્રેશન ઑબ્જેક્ટ જનરેટ કરવું અને તેનો ઉપયોગ કરવો વધુ કાર્યક્ષમ છે.

નીચેના નમૂના કોડમાં, સુવિધા માટે કમ્પાઇલ કર્યા વિના ફંક્શનનો ઉપયોગ કરવામાં આવે છે, પરંતુ જો તમે એક જ પેટર્નનો વારંવાર ઉપયોગ કરવા માંગતા હો, તો તેને અગાઉથી કમ્પાઇલ કરવાની અને તેને નિયમિત અભિવ્યક્તિ ઑબ્જેક્ટની પદ્ધતિ તરીકે ચલાવવાની ભલામણ કરવામાં આવે છે.

મેચ ઑબ્જેક્ટ

મેચ(), શોધ(), વગેરે મેચ ઓબ્જેક્ટ પરત કરો.

s = 'aaa@xxx.com'

m = re.match(r'[a-z]+@[a-z]+\.[a-z]+', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

print(type(m))
# <class 're.Match'>

મેળ ખાતી સ્ટ્રિંગ અને પોઝિશન મેચ ઑબ્જેક્ટની નીચેની પદ્ધતિઓનો ઉપયોગ કરીને મેળવવામાં આવે છે.

• મેચનું સ્થાન મેળવો:start(),end(),span()
• મેળ ખાતી સ્ટ્રિંગ મેળવો:group()
• દરેક જૂથ માટે શબ્દમાળા મેળવો:groups()

print(m.start())
# 0

print(m.end())
# 11

print(m.span())
# (0, 11)

print(m.group())
# aaa@xxx.com

જો તમે નિયમિત અભિવ્યક્તિ પેટર્નના ભાગને કૌંસ () સાથેની સ્ટ્રિંગમાં બંધ કરો છો, તો તે ભાગને જૂથ તરીકે પ્રક્રિયા કરવામાં આવશે. આ કિસ્સામાં, દરેક જૂથ સાથે મેળ ખાતા ભાગની સ્ટ્રિંગ જૂથ()માં ટપલ તરીકે મેળવી શકાય છે.

m = re.match(r'([a-z]+)@([a-z]+)\.([a-z]+)', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

print(m.groups())
# ('aaa', 'xxx', 'com')

સ્ટ્રિંગની શરૂઆત મેળ ખાય છે કે કેમ તે તપાસો, અર્ક: મેચ()

મેચ() જો સ્ટ્રિંગની શરૂઆત પેટર્ન સાથે મેળ ખાતી હોય તો મેચ ઓબ્જેક્ટ પરત કરે છે.

ઉપર જણાવ્યા મુજબ, મેચ ઑબ્જેક્ટનો ઉપયોગ મેળ ખાતી સબસ્ટ્રિંગને કાઢવા માટે અથવા ફક્ત મેચ કરવામાં આવી છે કે કેમ તે તપાસવા માટે થઈ શકે છે.

મેચ() માત્ર શરૂઆત તપાસશે. જો શરૂઆતમાં કોઈ મેળ ખાતી સ્ટ્રિંગ ન હોય, તો તે કંઈ નહીં આપે.

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

m = re.match(r'[a-z]+@[a-z]+\.com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

m = re.match(r'[a-z]+@[a-z]+\.net', s)
print(m)
# None

મેચો માટે તપાસો જે શરૂઆત સુધી મર્યાદિત નથી, અર્ક: શોધ()

મેચ()ની જેમ, જો તે મેળ ખાય તો તે મેચ ઓબ્જેક્ટ પરત કરે છે.

જો ત્યાં બહુવિધ મેચિંગ ભાગો હોય, તો માત્ર પ્રથમ મેચિંગ ભાગ પરત કરવામાં આવશે.

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

m = re.search(r'[a-z]+@[a-z]+\.net', s)
print(m)
# <re.Match object; span=(26, 37), match='ccc@zzz.net'>

m = re.search(r'[a-z]+@[a-z]+\.com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

જો તમે બધા મેળ ખાતા ભાગો મેળવવા માંગતા હો, તો નીચે વર્ણવ્યા પ્રમાણે Findall() અથવા Finditer() નો ઉપયોગ કરો.

તપાસો કે શું સમગ્ર શબ્દમાળા મેળ ખાય છે: fullmatch()

સમગ્ર શબ્દમાળા નિયમિત અભિવ્યક્તિ પેટર્ન સાથે મેળ ખાય છે કે કેમ તે તપાસવા માટે, fullmatch() નો ઉપયોગ કરો. આ ઉપયોગી છે, ઉદાહરણ તરીકે, સ્ટ્રીંગ ઇમેઇલ સરનામાં તરીકે માન્ય છે કે નહીં તે તપાસવા માટે.

જો સમગ્ર શબ્દમાળા મેળ ખાય છે, તો મેચ ઑબ્જેક્ટ પરત કરવામાં આવે છે.

s = 'aaa@xxx.com'

m = re.fullmatch(r'[a-z]+@[a-z]+\.com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

જો ત્યાં મેળ ન ખાતા ભાગો હોય (માત્ર આંશિક મેચો અથવા બિલકુલ મેળ ન હોય), તો કોઈ પરત કરવામાં આવતું નથી.

s = '!!!aaa@xxx.com!!!'

m = re.fullmatch(r'[a-z]+@[a-z]+\.com', s)
print(m)
# None

Python 3.4 માં fullmatch() ઉમેરવામાં આવ્યું હતું. જો તમે પહેલાનાં વર્ઝનમાં આવું કરવા માંગતા હો, તો અંતે મેચ() અને મેચિંગ મેટા કેરેક્ટર $ નો ઉપયોગ કરો. જો શરૂઆતથી અંત સુધીની સંપૂર્ણ સ્ટ્રિંગ મેળ ખાતી નથી, તો તે કંઈ નહીં આપે.

s = '!!!aaa@xxx.com!!!'

m = re.match(r'[a-z]+@[a-z]+\.com$', s)
print(m)
# None

બધા મેળ ખાતા ભાગોની સૂચિ મેળવો: findall()

findall() બધા મેળ ખાતા સબસ્ટ્રિંગની યાદી આપે છે. નોંધ કરો કે સૂચિના ઘટકો મેળ ખાતી વસ્તુઓ નથી પરંતુ શબ્દમાળાઓ છે.

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

result = re.findall(r'[a-z]+@[a-z]+\.[a-z]+', s)
print(result)
# ['aaa@xxx.com', 'bbb@yyy.com', 'ccc@zzz.net']

મેળ ખાતા ભાગોની સંખ્યા બિલ્ટ-ઇન ફંક્શન len() નો ઉપયોગ કરીને ચકાસી શકાય છે, જે સૂચિમાં ઘટકોની સંખ્યા પરત કરે છે.

print(len(result))
# 3

નિયમિત અભિવ્યક્તિ પેટર્નમાં કૌંસ () સાથે જૂથબદ્ધ કરવાથી ટ્યુપલ્સની સૂચિ મળે છે કે જેના તત્વો દરેક જૂથના તાર છે. આ મેચ ઑબ્જેક્ટમાં જૂથો() ની સમકક્ષ છે.

result = re.findall(r'([a-z]+)@([a-z]+)\.([a-z]+)', s)
print(result)
# [('aaa', 'xxx', 'com'), ('bbb', 'yyy', 'com'), ('ccc', 'zzz', 'net')]

જૂથ કૌંસ () નેસ્ટેડ કરી શકાય છે, તેથી જો તમે આખી મેચ પણ મેળવવા માંગતા હો, તો ફક્ત કૌંસમાં સમગ્ર મેચને બંધ કરો ().

result = re.findall(r'(([a-z]+)@([a-z]+)\.([a-z]+))', s)
print(result)
# [('aaa@xxx.com', 'aaa', 'xxx', 'com'), ('bbb@yyy.com', 'bbb', 'yyy', 'com'), ('ccc@zzz.net', 'ccc', 'zzz', 'net')]

જો કોઈ મેળ ન મળે, તો ખાલી ટપલ પરત કરવામાં આવે છે.

result = re.findall('[0-9]+', s)
print(result)
# []

ઇટરરેટર તરીકે બધા મેળ ખાતા ભાગો મેળવો: શોધક()

finditer() બધા મેળ ખાતા ભાગોને પુનરાવર્તક તરીકે પરત કરે છે. તત્વો findall() જેવા સ્ટ્રિંગ નથી, પરંતુ ઑબ્જેક્ટ્સ સાથે મેળ ખાય છે, જેથી તમે મેળ ખાતા ભાગોની સ્થિતિ (ઇન્ડેક્સ) મેળવી શકો.

ઇટરરેટરને તેની સામગ્રીઓ મેળવવા માટે પ્રિન્ટ() વડે પ્રિન્ટ આઉટ કરી શકાતું નથી. જો તમે બિલ્ટ-ઇન ફંક્શન નેક્સ્ટ() અથવા ફોર સ્ટેટમેન્ટનો ઉપયોગ કરો છો, તો તમે એક પછી એક સામગ્રી મેળવી શકો છો.

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

result = re.finditer(r'[a-z]+@[a-z]+\.[a-z]+', s)
print(result)
# <callable_iterator object at 0x10b0efa90>

print(type(result))
# <class 'callable_iterator'>

for m in result:
    print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>
# <re.Match object; span=(13, 24), match='bbb@yyy.com'>
# <re.Match object; span=(26, 37), match='ccc@zzz.net'>

તેને list() સાથે સૂચિમાં પણ રૂપાંતરિત કરી શકાય છે.

l = list(re.finditer(r'[a-z]+@[a-z]+\.[a-z]+', s))
print(l)
# [<re.Match object; span=(0, 11), match='aaa@xxx.com'>, <re.Match object; span=(13, 24), match='bbb@yyy.com'>, <re.Match object; span=(26, 37), match='ccc@zzz.net'>]

print(l[0])
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

print(type(l[0]))
# <class 're.Match'>

print(l[0].span())
# (0, 11)

જો તમે બધા મેળ ખાતા ભાગોની સ્થિતિ મેળવવા માંગતા હો, તો સૂચિની સમજણ સૂચિ () કરતાં વધુ અનુકૂળ છે.

print([m.span() for m in re.finditer(r'[a-z]+@[a-z]+\.[a-z]+', s)])
# [(0, 11), (13, 24), (26, 37)]

પુનરાવર્તક તત્વોને ક્રમમાં બહાર કાઢે છે. નોંધ કરો કે જો તમે અંત સુધી પહોંચ્યા પછી વધુ તત્વો કાઢવાનો પ્રયાસ કરશો, તો તમારી પાસે કંઈ જ બાકી રહેશે નહીં.

result = re.finditer(r'[a-z]+@[a-z]+\.[a-z]+', s)

for m in result:
    print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>
# <re.Match object; span=(13, 24), match='bbb@yyy.com'>
# <re.Match object; span=(26, 37), match='ccc@zzz.net'>

print(list(result))
# []

મેળ ખાતા ભાગોને બદલો: સબ(), સબન()

સબ() નો ઉપયોગ કરીને, તમે મેળ ખાતા ભાગને બીજી સ્ટ્રિંગ સાથે બદલી શકો છો. બદલાયેલ શબ્દમાળા પરત કરવામાં આવશે.

s = 'aaa@xxx.com, bbb@yyy.com, ccc@zzz.net'

result = re.sub(r'[a-z]+@[a-z]+\.com', 'new-address', s)
print(result)
# new-address, new-address, ccc@zzz.net

print(type(result))
# <class 'str'>

જ્યારે કૌંસ () સાથે જૂથબદ્ધ કરવામાં આવે છે, ત્યારે બદલાયેલી સ્ટ્રિંગમાં મેળ ખાતી સ્ટ્રિંગનો ઉપયોગ કરી શકાય છે.

ડિફૉલ્ટ રૂપે, નીચે આપેલ સપોર્ટેડ છે: નોંધ કરો કે સામાન્ય સ્ટ્રિંગ્સ માટે કે જે કાચી સ્ટ્રિંગ્સ નથી, બેકસ્લેશથી બચવા માટે બેકસ્લેશ પહેલાં બેકસ્લેશ સૂચિબદ્ધ હોવું આવશ્યક છે.

result = re.sub(r'([a-z]+)@([a-z]+)\.com', r'\1@\2.net', s)
print(result)
# aaa@xxx.net, bbb@yyy.net, ccc@zzz.net

?P<xxx>
જો તમે નિયમિત અભિવ્યક્તિ પેટર્નના કૌંસની શરૂઆતમાં આ લખીને જૂથનું નામ આપો છો, તો તમે નીચે બતાવ્યા પ્રમાણે, નંબરને બદલે નામનો ઉપયોગ કરીને તેનો ઉલ્લેખ કરી શકો છો.
\g<xxx>

result = re.sub(r'(?P<local>[a-z]+)@(?P<SLD>[a-z]+)\.com', r'\g<local>@\g<SLD>.net', s)
print(result)
# aaa@xxx.net, bbb@yyy.net, ccc@zzz.net

દલીલની ગણતરી રિપ્લેસમેન્ટની મહત્તમ સંખ્યાનો ઉલ્લેખ કરે છે. માત્ર ડાબી બાજુથી ગણતરી બદલવામાં આવશે.

result = re.sub(r'[a-z]+@[a-z]+\.com', 'new-address', s, count=1)
print(result)
# new-address, bbb@yyy.com, ccc@zzz.net

subn() અવેજી કરેલ સ્ટ્રિંગનો ટુપલ (sub() ના વળતર મૂલ્ય સમાન) અને અવેજી કરેલ ભાગોની સંખ્યા (પેટર્ન સાથે મેળ ખાતી સંખ્યા) આપે છે.

result = re.subn(r'[a-z]+@[a-z]+\.com', 'new-address', s)
print(result)
# ('new-address, new-address, ccc@zzz.net', 2)

દલીલો સ્પષ્ટ કરવાની પદ્ધતિ સબ() જેવી જ છે. તમે કૌંસ દ્વારા જૂથબદ્ધ કરેલ ભાગનો ઉપયોગ કરી શકો છો અથવા દલીલની ગણતરીનો ઉલ્લેખ કરી શકો છો.

result = re.subn(r'(?P<local>[a-z]+)@(?P<SLD>[a-z]+)\.com', r'\g<local>@\g<SLD>.net', s)
print(result)
# ('aaa@xxx.net, bbb@yyy.net, ccc@zzz.net', 2)

result = re.subn(r'[a-z]+@[a-z]+\.com', 'new-address', s, count=1)
print(result)
# ('new-address, bbb@yyy.com, ccc@zzz.net', 1)

રેગ્યુલર એક્સપ્રેશન પેટર્ન સાથે સ્પ્લિટિંગ સ્ટ્રિંગ્સ: split()

split() સ્ટ્રિંગને તે ભાગ પર વિભાજિત કરે છે જે પેટર્ન સાથે મેળ ખાય છે, અને તેને સૂચિ તરીકે પરત કરે છે.

નોંધ કરો કે પ્રથમ અને છેલ્લી મેચોમાં પરિણામી સૂચિની શરૂઆતમાં અને અંતે ખાલી સ્ટ્રીંગ્સ હશે.

s = '111aaa222bbb333'

result = re.split('[a-z]+', s)
print(result)
# ['111', '222', '333']

result = re.split('[0-9]+', s)
print(result)
# ['', 'aaa', 'bbb', '']

મહત્તમ સ્પ્લિટ દલીલ વિભાજન (ટુકડાઓ) ની મહત્તમ સંખ્યાનો ઉલ્લેખ કરે છે. માત્ર ડાબી બાજુથી ગણતરી વિભાજિત કરવામાં આવશે.

result = re.split('[a-z]+', s, 1)
print(result)
# ['111', '222bbb333']

પાયથોનમાં નિયમિત અભિવ્યક્તિ મેટાકેરેક્ટર, ખાસ સિક્વન્સ અને ચેતવણીઓ

મુખ્ય નિયમિત અભિવ્યક્તિ મેટા અક્ષરો (વિશેષ અક્ષરો) અને વિશિષ્ટ ક્રમ કે જેનો ઉપયોગ Python 3 re મોડ્યુલમાં થઈ શકે છે તે નીચે મુજબ છે

તે બધા આ કોષ્ટકમાં સૂચિબદ્ધ નથી. સંપૂર્ણ સૂચિ માટે અધિકૃત દસ્તાવેજીકરણ જુઓ.

• re — Regular expression operations — Regular Expression Syntax — Python 3.10.0 Documentation

એ પણ નોંધો કે Python 2 માં કેટલાક અર્થો અલગ છે.

• 7.2. re — Regular expression operations — Regular Expression Syntax — Python 2.7.18 Documentation

ધ્વજ સેટિંગ

ઉપરના કોષ્ટકમાં બતાવ્યા પ્રમાણે, કેટલાક મેટા અક્ષરો અને વિશિષ્ટ ક્રમ ધ્વજના આધારે તેમના મોડમાં ફેરફાર કરે છે.

અહીં ફક્ત મુખ્ય ધ્વજ આવરી લેવામાં આવ્યા છે. બાકીના માટે સત્તાવાર દસ્તાવેજો જુઓ.

• re — Regular expression operations — Module Contents — Python 3.10.0 Documentation

ASCII અક્ષરો સુધી મર્યાદિત: re.ASCII

\wઆ પાયથોન 3 સ્ટ્રીંગ્સ માટે ડિફોલ્ટ રૂપે ડબલ-બાઈટ કાંજી, આલ્ફાન્યૂમેરિક અક્ષરો વગેરે સાથે પણ મેળ ખાશે. તે નીચેનાની સમકક્ષ નથી કારણ કે તે પ્રમાણભૂત નિયમિત અભિવ્યક્તિ નથી.[a-zA-Z0-9_]

m = re.match(r'\w+', '漢字ＡＢＣ１２３')
print(m)
# <re.Match object; span=(0, 11), match='漢字ＡＢＣ１２３'>

m = re.match('[a-zA-Z0-9_]+', '漢字ＡＢＣ１２３')
print(m)
# None

જો તમે દરેક ફંક્શનમાં દલીલ ફ્લેગ્સ માટે re.ASCII નો ઉલ્લેખ કરો છો, અથવા રેગ્યુલર એક્સપ્રેશન પેટર્ન સ્ટ્રિંગની શરૂઆતમાં નીચેના ઇનલાઇન ફ્લેગ ઉમેરો છો, તો તે ફક્ત ASCII અક્ષરો સાથે મેળ ખાશે (તે ડબલ-બાઇટ જાપાનીઝ, આલ્ફાન્યૂમેરિક અક્ષરો વગેરે સાથે મેળ ખાશે નહીં. .).
(?a)
આ કિસ્સામાં, નીચેના બે સમકક્ષ છે.
\w#ERROR![a-zA-Z0-9_]

m = re.match(r'\w+', '漢字ＡＢＣ１２３', flags=re.ASCII)
print(m)
# None

m = re.match(r'(?a)\w+', '漢字ＡＢＣ１２３')
print(m)
# None

re.compile() સાથે કમ્પાઇલ કરતી વખતે આ જ લાગુ પડે છે. દલીલ ફ્લેગ્સ અથવા ઇનલાઇન ફ્લેગ્સનો ઉપયોગ કરો.

p = re.compile(r'\w+', flags=re.ASCII)
print(p)
# re.compile('\\w+', re.ASCII)

print(p.match('漢字ＡＢＣ１２３'))
# None

p = re.compile(r'(?a)\w+')
print(p)
# re.compile('(?a)\\w+', re.ASCII)

print(p.match('漢字ＡＢＣ１２３'))
# None

ASCII ટૂંકા સ્વરૂપ re તરીકે પણ ઉપલબ્ધ છે. A. તમે ક્યાં તો ઉપયોગ કરી શકો છો.

print(re.ASCII is re.A)
# True

print(re.ASCII is re.A)
# True

\W, \W ની વિરુદ્ધ, પણ re.ASCII અને ઇનલાઇન ફ્લેગ્સથી પ્રભાવિત થાય છે.

m = re.match(r'\W+', '漢字ＡＢＣ１２３')
print(m)
# None

m = re.match(r'\W+', '漢字ＡＢＣ１２３', flags=re.ASCII)
print(m)
# <re.Match object; span=(0, 11), match='漢字ＡＢＣ１２３'>

\w ની જેમ, નીચેના બે સિંગલ-બાઇટ અને ડબલ-બાઇટ અક્ષરો ડિફૉલ્ટ રૂપે બંને સાથે મેળ ખાય છે, પરંતુ જો re.ASCII અથવા ઇનલાઇન ફ્લેગ્સ ઉલ્લેખિત હોય તો સિંગલ-બાઇટ અક્ષરો સુધી મર્યાદિત છે.

• સંખ્યાઓ સાથે મેળ કરો\d
• ખાલી જગ્યા સાથે મેળ ખાય છે\s
• બિન-નંબરો સાથે મેળ ખાય છે\D
• કોઈપણ બિન-જગ્યા સાથે મેળ ખાય છે.\S

m = re.match(r'\d+', '123')
print(m)
# <re.Match object; span=(0, 3), match='123'>

m = re.match(r'\d+', '１２３')
print(m)
# <re.Match object; span=(0, 3), match='１２３'>

m = re.match(r'\d+', '123', flags=re.ASCII)
print(m)
# <re.Match object; span=(0, 3), match='123'>

m = re.match(r'\d+', '１２３', flags=re.ASCII)
print(m)
# None

m = re.match(r'\s+', '　')  # full-width space
print(m)
# <re.Match object; span=(0, 1), match='\u3000'>

m = re.match(r'\s+', '　', flags=re.ASCII)
print(m)
# None

કેસ-સંવેદનશીલ નથી:re.IGNORECASE

મૂળભૂત રીતે, તે કેસ-સંવેદનશીલ છે. બંનેને મેચ કરવા માટે, તમારે પેટર્નમાં અપરકેસ અને લોઅરકેસ બંને અક્ષરોનો સમાવેશ કરવાની જરૂર છે.

re.IGNORECASEજો આ ઉલ્લેખિત છે, તો તે કેસ-સંવેદનશીલ રીતે મેળ ખાશે. પ્રમાણભૂત રેગ્યુલર એક્સપ્રેશનમાં i ફ્લેગની સમકક્ષ.

m = re.match('[a-zA-Z]+', 'abcABC')
print(m)
# <re.Match object; span=(0, 6), match='abcABC'>

m = re.match('[a-z]+', 'abcABC', flags=re.IGNORECASE)
print(m)
# <re.Match object; span=(0, 6), match='abcABC'>

m = re.match('[A-Z]+', 'abcABC', flags=re.IGNORECASE)
print(m)
# <re.Match object; span=(0, 6), match='abcABC'>

તમે તેનાથી ઓછા અથવા તેના સમાન ઉપયોગ કરી શકો છો.

• ઇનલાઇન ધ્વજ(?i)
• સંક્ષિપ્તre.I

દરેક લાઇનની શરૂઆત અને અંતને મેચ કરો:re.MULTILINE

^આ નિયમિત અભિવ્યક્તિમાંના મેટા અક્ષરો સ્ટ્રિંગની શરૂઆત સાથે મેળ ખાય છે.

મૂળભૂત રીતે, સમગ્ર સ્ટ્રીંગની માત્ર શરૂઆત મેચ થાય છે, પરંતુ નીચેની દરેક લાઇનની શરૂઆત સાથે પણ મેળ ખાશે. પ્રમાણભૂત નિયમિત અભિવ્યક્તિઓમાં m ધ્વજની સમકક્ષ.
re.MULTILINE

s = '''aaa-xxx
bbb-yyy
ccc-zzz'''

print(s)
# aaa-xxx
# bbb-yyy
# ccc-zzz

result = re.findall('[a-z]+', s)
print(result)
# ['aaa', 'xxx', 'bbb', 'yyy', 'ccc', 'zzz']

result = re.findall('^[a-z]+', s)
print(result)
# ['aaa']

result = re.findall('^[a-z]+', s, flags=re.MULTILINE)
print(result)
# ['aaa', 'bbb', 'ccc']

$શબ્દમાળાના અંત સાથે મેળ ખાય છે. મૂળભૂત રીતે, સમગ્ર શબ્દમાળાનો માત્ર અંત મેળ ખાય છે.
re.MULTILINEજો તમે આનો ઉલ્લેખ કરો છો, તો તે દરેક લાઇનના અંત સાથે પણ મેળ ખાશે.

result = re.findall('[a-z]+$', s)
print(result)
# ['zzz']

result = re.findall('[a-z]+$', s, flags=re.MULTILINE)
print(result)
# ['xxx', 'yyy', 'zzz']

તમે તેનાથી ઓછા અથવા તેના સમાન ઉપયોગ કરી શકો છો.

• ઇનલાઇન ધ્વજ(?m)
• સંક્ષિપ્તre.M

બહુવિધ ફ્લેગ્સ સ્પષ્ટ કરો

|જો તમે એક જ સમયે બહુવિધ ફ્લેગ્સ સક્ષમ કરવા માંગતા હો, તો આનો ઉપયોગ કરો. ઇનલાઇન ફ્લેગ્સના કિસ્સામાં, દરેક અક્ષર નીચે બતાવ્યા પ્રમાણે એક અક્ષર દ્વારા અનુસરવામાં આવશ્યક છે.
(?am)

s = '''aaa-xxx
漢漢漢-字字字
bbb-zzz'''

print(s)
# aaa-xxx
# 漢漢漢-字字字
# bbb-zzz

result = re.findall(r'^\w+', s, flags=re.M)
print(result)
# ['aaa', '漢漢漢', 'bbb']

result = re.findall(r'^\w+', s, flags=re.M | re.A)
print(result)
# ['aaa', 'bbb']

result = re.findall(r'(?am)^\w+', s)
print(result)
# ['aaa', 'bbb']

લોભી અને બિન-લોભી મેળ

આ રેગ્યુલર એક્સપ્રેશનની સામાન્ય સમસ્યા છે, માત્ર પાયથોનની સમસ્યા નથી, પરંતુ હું તેના વિશે લખીશ કારણ કે તે મને મુશ્કેલીમાં મૂકે છે.

મૂળભૂત રીતે, નીચેની એક લોભી મેચ છે, જે સૌથી લાંબી શક્ય સ્ટ્રિંગ સાથે મેળ ખાય છે.

• *
• +
• ?

s = 'aaa@xxx.com, bbb@yyy.com'

m = re.match(r'.+com', s)
print(m)
# <re.Match object; span=(0, 24), match='aaa@xxx.com, bbb@yyy.com'>

print(m.group())
# aaa@xxx.com, bbb@yyy.com

આ ? પછી તે બિન-લોભી, ન્યૂનતમ મેચમાં પરિણમશે, જે ટૂંકી શક્ય સ્ટ્રિંગ સાથે મેળ ખાય છે.

• *?
• +?
• ??

m = re.match(r'.+?com', s)
print(m)
# <re.Match object; span=(0, 11), match='aaa@xxx.com'>

print(m.group())
# aaa@xxx.com

નોંધ કરો કે ડિફૉલ્ટ લોભી મેચ અનપેક્ષિત સ્ટ્રિંગ્સ સાથે મેળ ખાતી હોઈ શકે છે.