Python müntəzəm ifadə modulundan necə istifadə etmək olar (uyğunluq, axtarış, alt və s.)

Biznes

Python-da müntəzəm ifadə emalını həyata keçirmək üçün standart kitabxananın re modulundan istifadə edirik. Bu, müntəzəm ifadə nümunələrindən istifadə edərək sətirləri çıxarmağa, dəyişdirməyə və bölməyə imkan verir.

Bu bölmədə biz əvvəlcə re modulunun funksiyalarını və üsullarını izah edəcəyik.

  • Normal ifadə nümunələrinin tərtib edilməsi:compile()
  • uyğun obyekt
  • Sətin başlanğıcının uyğun olub olmadığını yoxlayın, çıxarın:match()
  • Başlanğıc ilə məhdudlaşmayan uyğunluqları yoxlayın:search()
  • Bütün sətirin uyğun olub olmadığını yoxlayın:fullmatch()
  • Bütün uyğun hissələrin siyahısını əldə edin:findall()
  • Bütün uyğun hissələri iterator kimi əldə edin:finditer()
  • Uyğun hissəni dəyişdirin:sub(),subn()
  • Müntəzəm ifadə nümunələri ilə sətirlərin bölünməsi:split()

Bundan sonra re modulunda istifadə oluna bilən meta simvolları (xüsusi simvollar) və müntəzəm ifadələrin xüsusi ardıcıllıqlarını izah edəcəyəm. Əsasən, bu, standart müntəzəm ifadə sintaksisidir, lakin bayraqları təyin edərkən diqqətli olun (xüsusilə re.ASCII).

  • Python-da müntəzəm ifadə meta simvolları, xüsusi ardıcıllıqlar və xəbərdarlıqlar
  • Bayrağın qurulması
    • ASCII simvolları ilə məhdudlaşır:re.ASCII
    • Hərflərə həssas deyil:re.IGNORECASE
    • Hər sətrin əvvəlini və sonunu uyğunlaşdırın:re.MULTILINE
    • Çoxlu bayraqları təyin edin
  • Acgöz və acgöz olmayan matçlar

Normal ifadə nümunəsini tərtib edin: compile()

re modulunda müntəzəm ifadə emalını yerinə yetirməyin iki yolu var.

Funksiya ilə işləyin

Birincisi funksiyadır.re.match(),re.sub()Bu kimi funksiyalar müntəzəm ifadə nümunələrindən istifadə edərək çıxarma, dəyişdirmə və digər prosesləri yerinə yetirmək üçün mövcuddur.

Funksiyaların təfərrüatları daha sonra təsvir olunacaq, lakin onların hamısında birinci arqument müntəzəm ifadə modelinin sətridir, ondan sonra emal ediləcək sətir və s. Məsələn, əvəzetməni həyata keçirən re.sub() funksiyasında ikinci arqument əvəzedici sətir, üçüncü arqument isə emal ediləcək sətirdir.

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

Qeyd edək ki, bu misaldakı müntəzəm ifadə nümunəsindəki [a-z] a-dan z-ə qədər hər hansı simvol (yəni kiçik hərflər) deməkdir və + əvvəlki nümunənin (bu halda [a-z]) bir və ya bir neçə dəfə təkrarlanması deməkdir. [a-z]+ bir və ya bir neçə kiçik əlifba simvolunu təkrarlayan istənilən sətirlə uyğun gəlir.

. meta simvoldur (xüsusi məna daşıyan simvol) və əks kəsik işarəsi ilə qaçmaq lazımdır.

Müntəzəm ifadə nümunəsi sətirləri tez-tez çoxlu əks xətlərdən istifadə etdiyi üçün nümunədəki kimi xam sətirlərdən istifadə etmək rahatdır.

Normal ifadə nümunəsi obyektinin metodunda çalışır

re modulunda müntəzəm ifadələri emal etməyin ikinci yolu müntəzəm ifadə nümunəsi obyekt metodudur.

re.compile() istifadə edərək müntəzəm ifadə nümunəsi obyekti yaratmaq üçün müntəzəm ifadə nümunəsi sətirini tərtib edə bilərsiniz.

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əsələn, bu funksiyalarla eyni proses müntəzəm ifadə obyektlərinin uyğunluğu(),sub() metodları kimi icra oluna bilər.

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

Aşağıda təsvir edilən bütün re.xxx() funksiyaları müntəzəm ifadə obyektinin metodları kimi də təqdim olunur.

Eyni nümunədən istifadə edən prosesi təkrar edirsinizsə, re.compile() ilə müntəzəm ifadə obyekti yaratmaq və onu ətrafında istifadə etmək daha səmərəlidir.

Aşağıdakı nümunə kodda funksiya rahatlıq üçün tərtib edilmədən istifadə olunur, lakin eyni nümunəni təkrar istifadə etmək istəyirsinizsə, onu əvvəlcədən tərtib etmək və müntəzəm ifadə obyektinin metodu kimi icra etmək tövsiyə olunur.

uyğun obyekt

match(), search() və s. uyğunluq obyekti qaytarır.

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

Uyğun sətir və mövqe uyğunluq obyektinin aşağıdakı üsullarından istifadə etməklə əldə edilir.

  • Matçın yerini əldə edin:start(),end(),span()
  • Uyğun sətir alın:group()
  • Hər qrup üçün sətir alın:groups()
print(m.start())
# 0

print(m.end())
# 11

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

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

Normal ifadə nümunəsinin bir hissəsini mötərizə() ilə sətirə əlavə etsəniz, hissə qrup kimi işlənəcək. Bu halda, group()-da hər bir qrupa uyğun gələn hissənin sətri tuple kimi əldə edilə bilər.

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ətin başlanğıcının uyğun olub olmadığını yoxlayın, çıxarın: match()

match() sətirin başlanğıcı naxışa uyğun gəlirsə, uyğunluq obyektini qaytarır.

Yuxarıda qeyd edildiyi kimi, uyğunluq obyekti uyğun gələn alt sətri çıxarmaq və ya sadəcə uyğunluğun olub olmadığını yoxlamaq üçün istifadə edilə bilər.

match() yalnız başlanğıcı yoxlayacaq. Başlanğıcda uyğun gələn sətir yoxdursa, o, Yox qaytarır.

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

Başlanğıc ilə məhdudlaşmayan uyğunluqları yoxlayın, çıxarın: search()

match() kimi, uyğun gələrsə, uyğunluq obyektini qaytarır.

Bir neçə uyğun gələn hissə varsa, yalnız birinci uyğun gələn hissə qaytarılacaq.

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

Bütün uyğun hissələri əldə etmək istəyirsinizsə, aşağıda təsvir edildiyi kimi findall() və ya finditer() istifadə edin.

Bütün sətirin uyğun olub olmadığını yoxlayın: fullmatch()

Bütün sətirin normal ifadə nümunəsinə uyğun olub olmadığını yoxlamaq üçün fullmatch() istifadə edin. Bu, məsələn, sətirin e-poçt ünvanı kimi etibarlı olub olmadığını yoxlamaq üçün faydalıdır.

Bütün sətir uyğun gəlirsə, uyğunluq obyekti qaytarılır.

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

Uyğun olmayan hissələr varsa (yalnız qismən uyğunluqlar və ya heç bir uyğunluq yoxdur), Heç biri qaytarılmır.

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

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

Fullmatch() Python 3.4-də əlavə edildi. Əgər əvvəlki versiyalarda eyni şeyi etmək istəyirsinizsə, sonunda match() və uyğun meta simvolu $ istifadə edin. Başdan sona bütün sətir uyğun gəlmirsə, o, Yox qaytarır.

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

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

Bütün uyğun hissələrin siyahısını əldə edin: findall()

findall() bütün uyğun gələn alt sətirlərin siyahısını qaytarır. Qeyd edək ki, siyahının elementləri uyğun obyektlər deyil, sətirlərdir.

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

Uyğun hissələrin sayı siyahıdakı elementlərin sayını qaytaran daxili funksiya len() vasitəsilə yoxlanıla bilər.

print(len(result))
# 3

Normal ifadə nümunəsində mötərizələrlə() qruplaşdırma elementləri hər qrupun sətirləri olan dəstlərin siyahısını qaytarır. Bu, uyğunluq obyektindəki qruplara() bərabərdir.

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

Qrup mötərizələri () iç-içə ola bilər, buna görə də bütün uyğunluğu əldə etmək istəyirsinizsə, sadəcə olaraq bütün uyğunluğu mötərizə () içərisinə daxil edin.

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

Heç bir uyğunluq tapılmazsa, boş dəst qaytarılır.

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

Bütün uyğun hissələri iterator kimi əldə edin: finditer()

finditer() iterator kimi bütün uyğun hissələri qaytarır. Elementlər findall() kimi sətirlər deyil, uyğun obyektlərdir, beləliklə siz uyğun hissələrin mövqeyini (indeksini) əldə edə bilərsiniz.

İteratorun özü məzmununu əldə etmək üçün print() ilə çap edilə bilməz. Daxili funksiyadan next() və ya for ifadəsindən istifadə etsəniz, məzmunu bir-bir əldə edə bilərsiniz.

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

O, həmçinin list() ilə siyahıya çevrilə bilər.

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)

Bütün uyğun gələn hissələrin mövqeyini əldə etmək istəyirsinizsə, siyahı başa düşmə notasiyası list() funksiyasından daha rahatdır.

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

İterator elementləri sıra ilə çıxarır. Nəzərə alın ki, sona çatdıqdan sonra daha çox element çıxarmağa çalışsanız, heç bir şey qalmayacaq.

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

Uyğun hissələri dəyişdirin: sub(), subn()

Sub() funksiyasından istifadə edərək, uyğun gələn hissəni başqa sətirlə əvəz edə bilərsiniz. Əvəz edilmiş sətir geri qaytarılacaq.

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

Mötərizələr() ilə qruplaşdırarkən uyğun gələn sətir dəyişdirilmiş sətirdə istifadə edilə bilər.

Varsayılan olaraq, aşağıdakılar dəstəklənir: Nəzərə alın ki, xam sətirlər olmayan normal sətirlər üçün tərs xəttdən qaçmaq üçün tərs kəsişmədən əvvəl əks xətt qeyd edilməlidir.

\1Birinci mötərizə
\2İkinci mötərizə
\3Üçüncü mötərizə
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>
Bunu müntəzəm ifadə nümunəsinin mötərizələrinin əvvəlinə yazaraq qrupu adlandırsanız, aşağıda göstərildiyi kimi onu nömrə əvəzinə addan istifadə edərək təyin edə bilərsiniz.
\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

Arqumentlərin sayı dəyişdirmələrin maksimum sayını təyin edir. Yalnız sol tərəfdən sayı əvəz olunacaq.

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() əvəz edilmiş sətirin cərgəsini (sub() funksiyasının qaytarılması dəyəri ilə eyni) və əvəz edilmiş hissələrin sayını (naxışa uyğun gələn nömrə) qaytarır.

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

Arqumentlərin təyin edilməsi üsulu sub() ilə eynidir. Mötərizədə qruplaşdırılmış hissədən istifadə edə və ya arqumentlərin sayını təyin edə bilərsiniz.

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)

Normal ifadə nümunələri ilə sətirlərin bölünməsi: split()

split() sətri naxışa uyğun gələn hissəyə bölür və onu siyahı kimi qaytarır.

Nəzərə alın ki, ilk və son uyğunluqlar nəticələnən siyahının əvvəlində və sonunda boş sətirlərdən ibarət olacaq.

s = '111aaa222bbb333'

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

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

Maxsplit arqumenti bölünmələrin (parçaların) maksimum sayını təyin edir. Yalnız sol tərəfdən sayı bölünəcək.

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

Python-da müntəzəm ifadə meta simvolları, xüsusi ardıcıllıqlar və xəbərdarlıqlar

Python 3 re modulunda istifadə edilə bilən əsas müntəzəm ifadə meta simvolları (xüsusi simvollar) və xüsusi ardıcıllıqlar aşağıdakılardır.

metaxarakterməzmunu
.Yeni sətirdən başqa hər hansı bir simvol (DOTALL bayrağı ilə yeni sətir daxil olmaqla)
^Sətirin başlanğıcı (həmçinin MULTILINE bayrağı ilə hər sətrin əvvəlinə uyğun gəlir)
$Sətirin sonu (həmçinin MULTILINE bayrağı ilə hər sətrin sonuna uyğun gəlir)
*Əvvəlki nümunəni 0 dəfədən çox təkrarlayın
+Əvvəlki nümunəni ən azı bir dəfə təkrarlayın.
?Əvvəlki nümunəni 0 və ya 1 dəfə təkrarlayın
{m}Əvvəlki nümunəni m dəfə təkrarlayın
{m, n}Son model.m~ntəkrarlamaq
[]Simvollar toplusu[]Bu simvollardan hər hansı birinə uyğun gəlir
|YAA|BA və ya B nümunəsinə uyğun gəlir
xüsusi ardıcıllıqməzmunu
\dUnicode decimal ədədləri (ASCII bayrağı ilə ASCII nömrələri ilə məhdudlaşır)
\D\dBunun əksini nəzərdə tutur.
\sUnicode boşluq simvolları (ASCII bayrağı ilə ASCII boşluq simvolları ilə məhdudlaşır)
\S\sBunun əksini nəzərdə tutur.
\wUnicode söz simvolları və alt xətt (ASCII alfasayı simvolları və ASCII bayrağı ilə alt xətt ilə məhdudlaşır)
\W\wBunun əksini nəzərdə tutur.

Onların hamısı bu cədvəldə göstərilməyib. Tam siyahı üçün rəsmi sənədlərə baxın.

Python 2-də bəzi mənaların fərqli olduğunu da nəzərə alın.

Bayrağın qurulması

Yuxarıdakı cədvəldə göstərildiyi kimi, bəzi meta simvollar və xüsusi ardıcıllıqlar bayraqdan asılı olaraq öz rejimini dəyişir.

Burada yalnız əsas bayraqlar əhatə olunub. Qalanları üçün rəsmi sənədlərə baxın.

ASCII simvolları ilə məhdudlaşır: re.ASCII

\wBu, həmçinin Python 3 sətirləri üçün defolt olaraq cüt baytlı kanci, alfasayısal simvollar və s. uyğun olacaq. Standart normal ifadə olmadığı üçün aşağıdakılara ekvivalent deyil.[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

Hər bir funksiyada arqument bayraqları üçün re.ASCII təyin etsəniz və ya müntəzəm ifadə nümunəsi sətirinin əvvəlinə aşağıdakı daxili bayrağı əlavə etsəniz, o, yalnız ASCII simvollarına uyğun olacaq (iki baytlıq Yapon, alfasayısal simvollar və s. uyğun gəlməyəcək) .).
(?a)
Bu halda, aşağıdakı ikisi ekvivalentdir.
\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

Eyni şey re.compile() ilə tərtib edərkən də tətbiq olunur. Arqument bayraqlarından və ya daxili bayraqlardan istifadə edin.

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 də qısa forma re kimi mövcuddur. A. Siz hər ikisindən istifadə edə bilərsiniz.

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

\W-nin əksi olan \W re.ASCII və daxili bayraqlardan da təsirlənir.

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 ilə olduğu kimi, aşağıdakı ikisi defolt olaraq həm tək baytlıq, həm də iki baytlıq simvollara uyğun gəlir, lakin re.ASCII və ya sətirli bayraqlar təyin olunarsa, tək baytlıq simvollarla məhdudlaşır.

  • Rəqəmləri uyğunlaşdırın\d
  • Boş yerə uyğun gəlir\s
  • Qeyri-rəqəmlərə uyğun gəlir\D
  • İstənilən boş yerə uyğun gəlir.\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

Hərflərə həssas deyil:re.IGNORECASE

Varsayılan olaraq, hərflərə həssasdır. Hər ikisini uyğunlaşdırmaq üçün naxışa həm böyük, həm də kiçik hərfləri daxil etməlisiniz.

re.IGNORECASEBu qeyd olunarsa, o, hərf hərfi ilə uyğunlaşacaq. Standart normal ifadələrdə i bayrağına bərabərdir.

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

Siz az və ya bərabər istifadə edə bilərsiniz.

  • daxili bayraq(?i)
  • abbreviaturare.I

Hər sətrin əvvəlini və sonunu uyğunlaşdırın:re.MULTILINE

^Bu müntəzəm ifadədəki meta simvollar sətrin əvvəlinə uyğun gəlir.

Varsayılan olaraq, yalnız bütün sətirin başlanğıcı uyğun gəlir, lakin aşağıdakılar da hər bir sətrin əvvəlinə uyğun olacaq. Standart normal ifadələrdə m bayrağına bərabərdir.
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']

$Sətirin sonuna uyğun gəlir. Varsayılan olaraq, bütün sətirin yalnız sonu uyğun gəlir.
re.MULTILINEBunu qeyd etsəniz, o, hər sətrin sonuna da uyğun olacaq.

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

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

Siz az və ya bərabər istifadə edə bilərsiniz.

  • daxili bayraq(?m)
  • abbreviaturare.M

Çoxlu bayraqları təyin edin

|Eyni anda birdən çox bayrağı aktivləşdirmək istəyirsinizsə, bundan istifadə edin. Daxil edilmiş bayraqlar vəziyyətində, aşağıda göstərildiyi kimi hər simvoldan sonra hərf gəlməlidir.
(?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']

Acgöz və acgöz olmayan matçlar

Bu, normal ifadələrlə bağlı ümumi problemdir, sadəcə Python ilə bağlı problem deyil, amma bu barədə yazacam, çünki bu, məni problemə salır.

Varsayılan olaraq, aşağıdakı mümkün olan ən uzun sətirə uyğun gələn acgöz uyğunluqdur.

  • *
  • +
  • ?
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

? sonra mümkün olan ən qısa sətirə uyğun gələn acgöz, minimal uyğunluqla nəticələnəcək.

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

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

Qeyd edək ki, standart acgöz uyğunluq gözlənilməz sətirlərə uyğun ola bilər.

Copied title and URL