ਪਾਈਥਨ ਨਿਯਮਤ ਸਮੀਕਰਨ ਮੋਡੀਊਲ ਰੀ (ਮੇਲ, ਖੋਜ, ਉਪ, ਆਦਿ) ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ

ਕਾਰੋਬਾਰ

ਪਾਈਥਨ ਵਿੱਚ ਰੈਗੂਲਰ ਐਕਸਪ੍ਰੈਸ਼ਨ ਪ੍ਰੋਸੈਸਿੰਗ ਕਰਨ ਲਈ, ਅਸੀਂ ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ ਤੋਂ ਰੀ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਇਹ ਤੁਹਾਨੂੰ ਰੈਗੂਲਰ ਸਮੀਕਰਨ ਪੈਟਰਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਟ੍ਰਿੰਗਾਂ ਨੂੰ ਐਕਸਟਰੈਕਟ ਕਰਨ, ਬਦਲਣ ਅਤੇ ਵੰਡਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

ਇਸ ਭਾਗ ਵਿੱਚ, ਅਸੀਂ ਪਹਿਲਾਂ ਰੀ ਮੋਡੀਊਲ ਦੇ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਢੰਗਾਂ ਦੀ ਵਿਆਖਿਆ ਕਰਾਂਗੇ।

  • ਰੈਗੂਲਰ ਸਮੀਕਰਨ ਪੈਟਰਨ ਕੰਪਾਇਲ ਕਰਨਾ:compile()
  • ਮੇਲ ਆਬਜੈਕਟ
  • ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਸਤਰ ਦੀ ਸ਼ੁਰੂਆਤ ਮੇਲ ਖਾਂਦੀ ਹੈ, ਐਕਸਟਰੈਕਟ:match()
  • ਸ਼ੁਰੂਆਤ ਤੱਕ ਸੀਮਿਤ ਨਾ ਹੋਣ ਵਾਲੇ ਮੈਚਾਂ ਦੀ ਜਾਂਚ ਕਰੋ:search()
  • ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਸਾਰੀ ਸਤਰ ਮੇਲ ਖਾਂਦੀ ਹੈ:fullmatch()
  • ਸਾਰੇ ਮੇਲ ਖਾਂਦੇ ਹਿੱਸਿਆਂ ਦੀ ਸੂਚੀ ਪ੍ਰਾਪਤ ਕਰੋ:findall()
  • ਇੱਕ ਦੁਹਰਾਓ ਦੇ ਤੌਰ ਤੇ ਸਾਰੇ ਮੇਲ ਖਾਂਦੇ ਹਿੱਸੇ ਪ੍ਰਾਪਤ ਕਰੋ:finditer()
  • ਮੇਲ ਖਾਂਦੇ ਹਿੱਸੇ ਨੂੰ ਬਦਲੋ:sub(),subn()
  • ਨਿਯਮਤ ਸਮੀਕਰਨ ਪੈਟਰਨਾਂ ਦੇ ਨਾਲ ਸਤਰ ਵੰਡਣਾ:split()

ਉਸ ਤੋਂ ਬਾਅਦ, ਮੈਂ ਮੈਟਾ ਅੱਖਰ (ਵਿਸ਼ੇਸ਼ ਅੱਖਰ) ਅਤੇ ਰੈਗੂਲਰ ਸਮੀਕਰਨਾਂ ਦੇ ਵਿਸ਼ੇਸ਼ ਕ੍ਰਮਾਂ ਦੀ ਵਿਆਖਿਆ ਕਰਾਂਗਾ ਜੋ ਰੀ ਮੋਡੀਊਲ ਵਿੱਚ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਅਸਲ ਵਿੱਚ, ਇਹ ਮਿਆਰੀ ਨਿਯਮਤ ਸਮੀਕਰਨ ਸੰਟੈਕਸ ਹੈ, ਪਰ ਫਲੈਗ (ਖਾਸ ਕਰਕੇ 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()ਉਦਾਹਰਨ ਲਈ, ਇਹਨਾਂ ਫੰਕਸ਼ਨਾਂ ਵਾਲੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਨਿਯਮਤ ਸਮੀਕਰਨ ਆਬਜੈਕਟ ਦੇ ਮੇਲ(),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() ਨਾਲ ਇੱਕ ਨਿਯਮਤ ਸਮੀਕਰਨ ਆਬਜੈਕਟ ਤਿਆਰ ਕਰਨਾ ਅਤੇ ਇਸਦੇ ਆਲੇ ਦੁਆਲੇ ਵਰਤਣਾ ਵਧੇਰੇ ਕੁਸ਼ਲ ਹੈ।

ਨਿਮਨਲਿਖਤ ਨਮੂਨਾ ਕੋਡ ਵਿੱਚ, ਸਹੂਲਤ ਲਈ ਫੰਕਸ਼ਨ ਨੂੰ ਕੰਪਾਇਲ ਕੀਤੇ ਬਿਨਾਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਇੱਕੋ ਪੈਟਰਨ ਨੂੰ ਵਾਰ-ਵਾਰ ਵਰਤਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇਸ ਨੂੰ ਪਹਿਲਾਂ ਤੋਂ ਕੰਪਾਇਲ ਕਰਨ ਅਤੇ ਨਿਯਮਤ ਸਮੀਕਰਨ ਆਬਜੈਕਟ ਦੀ ਇੱਕ ਵਿਧੀ ਵਜੋਂ ਚਲਾਉਣ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਮੇਲ ਆਬਜੈਕਟ

match(), search(), ਆਦਿ ਇੱਕ ਮੈਚ ਆਬਜੈਕਟ ਵਾਪਸ ਕਰੋ।

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')

ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਇੱਕ ਸਤਰ ਦੀ ਸ਼ੁਰੂਆਤ ਮੇਲ ਖਾਂਦੀ ਹੈ, ਐਕਸਟਰੈਕਟ: match()

match() ਇੱਕ ਮੈਚ ਆਬਜੈਕਟ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਸਤਰ ਦੀ ਸ਼ੁਰੂਆਤ ਪੈਟਰਨ ਨਾਲ ਮੇਲ ਖਾਂਦੀ ਹੈ।

ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਮੈਚ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਮੇਲ ਖਾਂਦੀ ਸਬਸਟ੍ਰਿੰਗ ਨੂੰ ਐਕਸਟਰੈਕਟ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਜਾਂ ਸਿਰਫ਼ ਇਹ ਦੇਖਣ ਲਈ ਕਿ ਕੀ ਕੋਈ ਮੇਲ ਬਣਾਇਆ ਗਿਆ ਸੀ।

match() ਸਿਰਫ ਸ਼ੁਰੂਆਤ ਦੀ ਜਾਂਚ ਕਰੇਗਾ। ਜੇਕਰ ਸ਼ੁਰੂ ਵਿੱਚ ਕੋਈ ਮੇਲ ਖਾਂਦੀ ਸਤਰ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਹ ਕੋਈ ਨਹੀਂ ਵਾਪਸ ਕਰਦਾ ਹੈ।

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

ਸ਼ੁਰੂਆਤ ਤੱਕ ਸੀਮਿਤ ਨਾ ਹੋਣ ਵਾਲੇ ਮੈਚਾਂ ਦੀ ਜਾਂਚ ਕਰੋ, ਐਕਸਟਰੈਕਟ ਕਰੋ: search()

ਮੈਚ() ਵਾਂਗ, ਇਹ ਮੈਚ ਆਬਜੈਕਟ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਇਹ ਮੇਲ ਖਾਂਦਾ ਹੈ।

ਜੇਕਰ ਕਈ ਮੇਲ ਖਾਂਦੇ ਹਿੱਸੇ ਹਨ, ਤਾਂ ਸਿਰਫ਼ ਪਹਿਲਾ ਮੇਲ ਖਾਂਦਾ ਹਿੱਸਾ ਹੀ ਵਾਪਸ ਕੀਤਾ ਜਾਵੇਗਾ।

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

ਫੁਲਮੈਚ() ਨੂੰ ਪਾਈਥਨ 3.4 ਵਿੱਚ ਜੋੜਿਆ ਗਿਆ ਸੀ। ਜੇਕਰ ਤੁਸੀਂ ਪਿਛਲੇ ਸੰਸਕਰਣਾਂ ਵਿੱਚ ਅਜਿਹਾ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਅੰਤ ਵਿੱਚ ਮੈਚ() ਅਤੇ ਇੱਕ ਮੇਲ ਖਾਂਦਾ ਮੈਟਾ ਅੱਖਰ $ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਜੇਕਰ ਸ਼ੁਰੂ ਤੋਂ ਅੰਤ ਤੱਕ ਸਾਰੀ ਸਤਰ ਮੇਲ ਨਹੀਂ ਖਾਂਦੀ, ਤਾਂ ਇਹ ਕੋਈ ਨਹੀਂ ਵਾਪਸ ਕਰਦਾ ਹੈ।

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()

finditer() ਸਾਰੇ ਮੇਲ ਖਾਂਦੇ ਹਿੱਸੇ ਨੂੰ ਇੱਕ ਦੁਹਰਾਓ ਵਜੋਂ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਤੱਤ findall() ਵਰਗੀਆਂ ਸਟ੍ਰਿੰਗਾਂ ਨਹੀਂ ਹਨ, ਪਰ ਆਬਜੈਕਟ ਨਾਲ ਮੇਲ ਖਾਂਦੀਆਂ ਹਨ, ਤਾਂ ਜੋ ਤੁਸੀਂ ਮੇਲ ਖਾਂਦੇ ਹਿੱਸਿਆਂ ਦੀ ਸਥਿਤੀ (ਸੂਚਕਾਂਕ) ਪ੍ਰਾਪਤ ਕਰ ਸਕੋ।

ਇਸਦੀ ਸਮੱਗਰੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ iterator ਆਪਣੇ ਆਪ ਨੂੰ print() ਨਾਲ ਪ੍ਰਿੰਟ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ next() ਜਾਂ ਸਟੇਟਮੈਂਟ ਲਈ ਵਰਤਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇੱਕ-ਇੱਕ ਕਰਕੇ ਸਮੱਗਰੀ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ।

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))
# []

ਮੇਲ ਖਾਂਦੇ ਭਾਗਾਂ ਨੂੰ ਬਦਲੋ: sub(), subn()

ਸਬ() ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਤੁਸੀਂ ਮੇਲ ਖਾਂਦੇ ਹਿੱਸੇ ਨੂੰ ਕਿਸੇ ਹੋਰ ਸਤਰ ਨਾਲ ਬਦਲ ਸਕਦੇ ਹੋ। ਬਦਲੀ ਗਈ ਸਤਰ ਵਾਪਸ ਕਰ ਦਿੱਤੀ ਜਾਵੇਗੀ।

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'>

ਜਦੋਂ ਬਰੈਕਟਾਂ () ਨਾਲ ਗਰੁੱਪਿੰਗ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਮੇਲ ਖਾਂਦੀ ਸਟ੍ਰਿੰਗ ਨੂੰ ਬਦਲੀ ਗਈ ਸਤਰ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਮੂਲ ਰੂਪ ਵਿੱਚ, ਹੇਠਾਂ ਦਿੱਤੇ ਸਮਰਥਿਤ ਹਨ: ਨੋਟ ਕਰੋ ਕਿ ਆਮ ਸਤਰਾਂ ਲਈ ਜੋ ਕੱਚੀਆਂ ਸਤਰ ਨਹੀਂ ਹਨ, ਬੈਕਸਲੈਸ਼ ਤੋਂ ਬਚਣ ਲਈ ਬੈਕਸਲੈਸ਼ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ ਬੈਕਸਲੈਸ਼ ਸੂਚੀਬੱਧ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

\1ਪਹਿਲਾ ਬਰੈਕਟ
\2ਦੂਜਾ ਬਰੈਕਟ
\3ਤੀਜਾ ਬਰੈਕਟ
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', '']

maxsplit ਆਰਗੂਮੈਂਟ ਸਪਲਿਟਸ (ਟੁਕੜਿਆਂ) ਦੀ ਅਧਿਕਤਮ ਸੰਖਿਆ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ। ਸਿਰਫ਼ ਖੱਬੇ ਪਾਸੇ ਤੋਂ ਗਿਣਤੀ ਵੰਡੀ ਜਾਵੇਗੀ।

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

ਪਾਈਥਨ ਵਿੱਚ ਨਿਯਮਤ ਸਮੀਕਰਨ ਮੈਟਾ-ਅੱਖਰ, ਵਿਸ਼ੇਸ਼ ਕ੍ਰਮ, ਅਤੇ ਚੇਤਾਵਨੀਆਂ

ਮੁੱਖ ਨਿਯਮਤ ਸਮੀਕਰਨ ਮੈਟਾ ਅੱਖਰ (ਵਿਸ਼ੇਸ਼ ਅੱਖਰ) ਅਤੇ ਵਿਸ਼ੇਸ਼ ਕ੍ਰਮ ਜੋ ਪਾਈਥਨ 3 ਰੀ ਮੋਡੀਊਲ ਵਿੱਚ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ ਹੇਠਾਂ ਦਿੱਤੇ ਅਨੁਸਾਰ ਹਨ

metacharacterਸਮੱਗਰੀ
.ਨਵੀਂ ਲਾਈਨ ਤੋਂ ਇਲਾਵਾ ਕੋਈ ਵੀ ਇੱਕ ਅੱਖਰ (ਡੋਟੈਲ ਫਲੈਗ ਵਾਲੀ ਨਵੀਂ ਲਾਈਨ ਸਮੇਤ)
^ਸਤਰ ਦੀ ਸ਼ੁਰੂਆਤ (ਮਲਟੀਲਾਈਨ ਫਲੈਗ ਨਾਲ ਹਰੇਕ ਲਾਈਨ ਦੀ ਸ਼ੁਰੂਆਤ ਨਾਲ ਵੀ ਮੇਲ ਖਾਂਦੀ ਹੈ)
$ਸਤਰ ਦਾ ਅੰਤ (ਮਲਟੀਲਾਈਨ ਫਲੈਗ ਨਾਲ ਹਰੇਕ ਲਾਈਨ ਦੇ ਅੰਤ ਨਾਲ ਵੀ ਮੇਲ ਖਾਂਦਾ ਹੈ)
*ਪਿਛਲੇ ਪੈਟਰਨ ਨੂੰ 0 ਤੋਂ ਵੱਧ ਵਾਰ ਦੁਹਰਾਓ
+ਪਿਛਲੇ ਪੈਟਰਨ ਨੂੰ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਵਾਰ ਦੁਹਰਾਓ।
?ਪਿਛਲੇ ਪੈਟਰਨ ਨੂੰ 0 ਜਾਂ 1 ਵਾਰ ਦੁਹਰਾਓ
{m}ਪਿਛਲੇ ਪੈਟਰਨ m ਵਾਰ ਦੁਹਰਾਓ
{m, n}ਆਖਰੀ ਪੈਟਰਨ.m~nਦੁਹਰਾਓ
[]ਅੱਖਰਾਂ ਦਾ ਇੱਕ ਸਮੂਹ[]ਇਹਨਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਅੱਖਰ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ
|ਜਾਂA|BA ਜਾਂ B ਪੈਟਰਨ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ
ਵਿਸ਼ੇਸ਼ ਕ੍ਰਮਸਮੱਗਰੀ
\dਯੂਨੀਕੋਡ ਦਸ਼ਮਲਵ ਨੰਬਰ (ASCII ਫਲੈਗ ਦੁਆਰਾ ASCII ਨੰਬਰਾਂ ਤੱਕ ਸੀਮਿਤ)
\D\dਇਸ ਦੇ ਉਲਟ ਮਤਲਬ.
\sਯੂਨੀਕੋਡ ਵ੍ਹਾਈਟਸਪੇਸ ਅੱਖਰ (ASCII ਫਲੈਗ ਦੁਆਰਾ ASCII ਵ੍ਹਾਈਟਸਪੇਸ ਅੱਖਰਾਂ ਤੱਕ ਸੀਮਿਤ)
\S\sਇਸ ਦੇ ਉਲਟ ਮਤਲਬ.
\wਯੂਨੀਕੋਡ ਸ਼ਬਦ ਅੱਖਰ ਅਤੇ ਅੰਡਰਸਕੋਰ (ASCII ਵਰਣਮਾਲਾ ਅੱਖਰਾਂ ਤੱਕ ਸੀਮਿਤ ਅਤੇ ASCII ਫਲੈਗ ਦੁਆਰਾ ਅੰਡਰਸਕੋਰ)
\W\wਇਸ ਦੇ ਉਲਟ ਮਤਲਬ.

ਉਹ ਸਾਰੇ ਇਸ ਸਾਰਣੀ ਵਿੱਚ ਸੂਚੀਬੱਧ ਨਹੀਂ ਹਨ। ਪੂਰੀ ਸੂਚੀ ਲਈ ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ ਵੇਖੋ।

ਇਹ ਵੀ ਨੋਟ ਕਰੋ ਕਿ ਪਾਈਥਨ 2 ਵਿੱਚ ਕੁਝ ਅਰਥ ਵੱਖਰੇ ਹਨ।

ਝੰਡਾ ਸੈੱਟ ਕਰਨਾ

ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦਿੱਤੀ ਸਾਰਣੀ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ, ਕੁਝ ਮੈਟਾ ਅੱਖਰ ਅਤੇ ਵਿਸ਼ੇਸ਼ ਕ੍ਰਮ ਫਲੈਗ ਦੇ ਆਧਾਰ ‘ਤੇ ਆਪਣਾ ਮੋਡ ਬਦਲਦੇ ਹਨ।

ਇੱਥੇ ਸਿਰਫ਼ ਮੁੱਖ ਝੰਡੇ ਹੀ ਢਕੇ ਹੋਏ ਹਨ। ਬਾਕੀ ਦੇ ਲਈ ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ ਵੇਖੋ।

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 ਸ਼ਾਰਟ ਫਾਰਮ ਰੀ ਦੇ ਰੂਪ ਵਿੱਚ ਵੀ ਉਪਲਬਧ ਹੈ। A. ਤੁਸੀਂ ਜਾਂ ਤਾਂ ਵਰਤ ਸਕਦੇ ਹੋ।

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

ਨੋਟ ਕਰੋ ਕਿ ਡਿਫੌਲਟ ਲਾਲਚੀ ਮੇਲ ਅਚਾਨਕ ਸਟ੍ਰਿੰਗਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।

Copied title and URL