Python düzenli ifade modülü yeniden nasıl kullanılır (eşleştirme, arama, alt, vb.)

iş

Python’da normal ifade işlemeyi gerçekleştirmek için standart kitaplıktan re modülünü kullanıyoruz. Normal ifade kalıplarını kullanarak dizeleri çıkarmanıza, değiştirmenize ve bölmenize olanak tanır.

Bu bölümde öncelikle re modülünün fonksiyonlarını ve yöntemlerini açıklayacağız.

  • Düzenli ifade kalıplarının derlenmesi:compile()
  • eşleşme nesnesi
  • Dizenin başlangıcının eşleşip eşleşmediğini kontrol edin, şunu çıkarın:match()
  • Başlangıçla sınırlı olmayan eşleşmeleri kontrol edin:search()
  • Tüm dizenin eşleşip eşleşmediğini kontrol edin:fullmatch()
  • Tüm eşleşen parçaların bir listesini alın:findall()
  • Eşleşen tüm parçaları yineleyici olarak alın:finditer()
  • Eşleşen parçayı değiştirin:sub(),subn()
  • Dizeleri düzenli ifade kalıplarıyla bölme:split()

Bundan sonra re modülünde kullanılabilecek meta karakterleri (özel karakterler) ve düzenli ifadelerin özel dizilerini açıklayacağım. Temel olarak, standart normal ifade sözdizimidir, ancak bayrakları ayarlarken dikkatli olun (özellikle re.ASCII).

  • Python’da normal ifade meta karakterleri, özel diziler ve uyarılar
  • Bayrağın ayarlanması
    • ASCII karakterleriyle sınırlıdır:re.ASCII
    • Büyük küçük harf duyarlı değil:re.IGNORECASE
    • Her satırın başlangıcını ve sonunu eşleştirin:re.MULTILINE
    • Birden çok bayrak belirtin
  • Açgözlü ve açgözlü olmayan eşleşmeler

Normal ifade modelini derleyin: compile()

re modülünde normal ifade işlemeyi gerçekleştirmenin iki yolu vardır.

İşlevle çalıştır

Birincisi bir fonksiyondur.re.match(),re.sub()Bunun gibi işlevler, normal ifade kalıplarını kullanarak çıkarma, değiştirme ve diğer işlemleri gerçekleştirmek için kullanılabilir.

İşlevlerin ayrıntıları daha sonra açıklanacaktır, ancak hepsinde, ilk argüman düzenli ifade modelinin dizesidir, ardından işlenecek dize vb. Örneğin, ikame gerçekleştiren re.sub()’da, ikinci argüman ikame dizesidir ve üçüncü argüman işlenecek dizedir.

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

Bu örnekteki normal ifade kalıbındaki [a-z]’nin a’dan z’ye herhangi bir karakter (yani küçük harfli alfabe) anlamına geldiğini ve +’nın önceki kalıbı (bu durumda [a-z]) bir veya daha fazla kez tekrarlamak anlamına geldiğini unutmayın. [a-z]+, bir veya daha fazla küçük harfli alfabetik karakteri tekrar eden herhangi bir dizeyle eşleşir.

. bir meta karakterdir (özel anlamı olan bir karakterdir) ve ters eğik çizgi ile kaçılmalıdır.

Normal ifade desen dizileri genellikle çok sayıda ters eğik çizgi kullandığından, örnekte olduğu gibi ham dizeleri kullanmak uygundur.

Normal ifade desen nesnesinin bir yönteminde çalışır

re modülünde düzenli ifadeleri işlemenin ikinci yolu, düzenli ifade desen nesne yöntemidir.

re.compile()’i kullanarak, bir normal ifade kalıbı nesnesi oluşturmak için bir normal ifade kalıbı dizesini derleyebilirsiniz.

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()Örneğin, bu işlevlerle aynı işlem, normal ifade nesnelerinin match(),sub() yöntemleri olarak yürütülebilir.

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 açıklanan tüm re.xxx() işlevleri, normal ifade nesnesinin yöntemleri olarak da sağlanır.

Aynı kalıbı kullanan bir işlemi tekrarlıyorsanız, re.compile() ile bir normal ifade nesnesi oluşturmak ve onu kullanmak daha verimlidir.

Aşağıdaki örnek kodda, işlev kolaylık olması açısından derleme yapılmadan kullanılmıştır, ancak aynı kalıbı tekrar tekrar kullanmak istiyorsanız, önceden derlemeniz ve normal ifade nesnesinin bir yöntemi olarak çalıştırmanız önerilir.

eşleşme nesnesi

match(), search(), vb. bir eşleşme nesnesi döndürü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'>

Eşleşen dize ve konum, eşleşme nesnesinin aşağıdaki yöntemleri kullanılarak elde edilir.

  • Maçın yerini öğrenin:start(),end(),span()
  • Eşleşen dizeyi alın:group()
  • Her grup için dizeyi alın:groups()
print(m.start())
# 0

print(m.end())
# 11

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

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

Normal ifade deseninin bir bölümünü parantez() ile bir dizge içine alırsanız, bölüm bir grup olarak işlenir. Bu durumda, groups() içindeki her grupla eşleşen parçanın dizesi bir tanımlama grubu olarak elde edilebilir.

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

Bir dizgenin başlangıcının eşleşip eşleşmediğini kontrol edin, şunu çıkarın: match()

match(), dizenin başlangıcı modelle eşleşiyorsa bir eşleşme nesnesi döndürür.

Yukarıda bahsedildiği gibi, eşleşme nesnesi, eşleşen alt dizeyi çıkarmak veya yalnızca bir eşleşmenin yapılıp yapılmadığını kontrol etmek için kullanılabilir.

match() yalnızca başlangıcı kontrol eder. Başlangıçta eşleşen bir dize yoksa, Yok değerini döndürü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şlangıçla sınırlı olmayan eşleşmeleri kontrol edin, şunu çıkarın: search()

Match() gibi, eşleşirse bir eşleşme nesnesi döndürür.

Birden fazla eşleşen parça varsa, yalnızca ilk eşleşen parça döndürülür.

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

Tüm eşleşen parçaları almak istiyorsanız, aşağıda açıklandığı gibi findall() veya finditer() kullanın.

Tüm dizenin eşleşip eşleşmediğini kontrol edin: fullmatch()

Tüm dizenin normal ifade modeliyle eşleşip eşleşmediğini kontrol etmek için fullmatch() kullanın. Bu, örneğin bir dizenin e-posta adresi olarak geçerli olup olmadığını kontrol etmek için kullanışlıdır.

Tüm dize eşleşirse, bir eşleşme nesnesi döndürü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'>

Eşleşmeyen parçalar varsa (yalnızca kısmi eşleşmeler veya hiç eşleşme yok), Yok döndürülür.

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

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

Fullmatch() Python 3.4’e eklendi. Aynısını önceki sürümlerde yapmak istiyorsanız, match() ve sonunda eşleşen bir meta karakter $ kullanın. Tüm dize baştan sona eşleşmiyorsa, Yok değerini döndürür.

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

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

Tüm eşleşen parçaların bir listesini alın: findall()

findall() eşleşen tüm alt dizelerin bir listesini döndürür. Listenin öğelerinin eşleşen nesneler değil, dizeler olduğuna dikkat edin.

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

Eşleşen parçaların sayısı, listedeki öğelerin sayısını döndüren yerleşik len() işlevi kullanılarak kontrol edilebilir.

print(len(result))
# 3

Normal ifade modelinde parantez() ile gruplandırma, öğeleri her grubun dizeleri olan bir demet listesi döndürür. Bu, eşleşme nesnesindeki gruplar() ile eşdeğerdir.

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

Grup parantezleri () iç içe yerleştirilebilir, bu nedenle tüm eşleşmeyi de almak istiyorsanız, tüm eşleşmeyi parantez () içine alın.

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

Eşleşme bulunamazsa boş bir demet döndürülür.

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

Eşleşen tüm parçaları yineleyici olarak alın: finditer()

finditer(), eşleşen tüm parçaları yineleyici olarak döndürür. Öğeler findall() gibi dizeler değil, eşleşen nesnelerdir, böylece eşleşen parçaların konumunu (dizini) elde edebilirsiniz.

İçeriğini almak için yineleyicinin kendisi print() ile yazdırılamaz. Yerleşik next() işlevini veya for deyimini kullanırsanız, içerikleri tek tek alabilirsiniz.

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

Ayrıca list() ile bir listeye dönüştürülebilir.

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)

Tüm eşleşen parçaların konumunu almak istiyorsanız, liste anlama notasyonu list()’ten daha uygundur.

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

Yineleyici, öğeleri sırayla alır. Sona ulaştıktan sonra daha fazla öğe çıkarmaya çalışırsanız, elinizde hiçbir şey kalmayacağını unutmayın.

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

Eşleşen parçaları değiştirin: sub(), subn()

sub()’ı kullanarak eşleşen parçayı başka bir dizeyle değiştirebilirsiniz. Değiştirilen dize döndürülür.

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

Parantez() ile gruplanırken, eşleşen dize değiştirilen dizede kullanılabilir.

Varsayılan olarak, aşağıdakiler desteklenir: Ham dizeler olmayan normal dizeler için, ters eğik çizgiden kaçmak için ters eğik çizgiden önce bir ters eğik çizgi listelenmesi gerektiğini unutmayın.

\1ilk parantez
\2ikinci parantez
\3üçüncü parantez
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>
Normal ifade kalıbının parantezlerinin başına bunu yazarak grubu adlandırırsanız, aşağıda gösterildiği gibi sayı yerine adı kullanarak grubu belirtebilirsiniz.
\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

Bağımsız değişken sayısı, maksimum değiştirme sayısını belirtir. Yalnızca sol taraftaki sayı değiştirilecektir.

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(), değiştirilen dizenin bir demetini (sub()’nin dönüş değeriyle aynı) ve değiştirilen parçaların sayısını (kalıpla eşleşen sayı) döndürür.

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

Argüman belirtme yöntemi sub() ile aynıdır. Parantez içinde gruplanmış kısmı kullanabilir veya argüman sayısını belirtebilirsiniz.

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)

Dizeleri düzenli ifade kalıplarıyla bölme: split()

split(), dizgiyi kalıba uyan kısımda böler ve onu bir liste olarak döndürür.

İlk ve son eşleşmelerin, sonuç listesinin başında ve sonunda boş dizeler içereceğini unutmayın.

s = '111aaa222bbb333'

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

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

maxsplit argümanı maksimum bölme (parça) sayısını belirtir. Yalnızca sol taraftaki sayı bölünecektir.

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

Python’da normal ifade meta karakterleri, özel diziler ve uyarılar

Python 3 re modülünde kullanılabilecek ana düzenli ifade meta karakterleri (özel karakterler) ve özel diziler aşağıdaki gibidir.

meta karakteriçindekiler
.Yeni satır dışında herhangi bir tek karakter (DOTALL bayrağına sahip yeni satır dahil)
^Dizenin başlangıcı (ayrıca her satırın başlangıcıyla MULTILINE bayrağıyla eşleşir)
$Dizenin sonu (ayrıca her satırın sonuyla MULTILINE bayrağıyla eşleşir)
*Önceki deseni 0 defadan fazla tekrarlayın
+Önceki deseni en az bir kez tekrarlayın.
?Önceki deseni 0 veya 1 kez tekrarlayın
{m}Önceki deseni m kez tekrarlayın
{m, n}Son desen.m~ntekrarlamak
[]Bir dizi karakter[]Bu karakterlerden herhangi biriyle eşleşir
|VEYAA|BA veya B modeliyle eşleşir
özel diziiçindekiler
\dUnicode ondalık sayılar (ASCII bayrağıyla ASCII sayılarıyla sınırlıdır)
\D\dBunun tersi anlamına gelir.
\sUnicode boşluk karakterleri (ASCII bayrağı ile ASCII boşluk karakterleriyle sınırlıdır)
\S\sBunun tersi anlamına gelir.
\wUnicode sözcük karakterleri ve alt çizgiler (ASCII alfasayısal karakterlerle ve ASCII bayrağıyla alt çizgilerle sınırlıdır)
\W\wBunun tersi anlamına gelir.

Hepsi bu tabloda listelenmemiştir. Tam bir liste için resmi belgelere bakın.

Ayrıca Python 2’de bazı anlamların farklı olduğunu unutmayın.

Bayrağın ayarlanması

Yukarıdaki tabloda gösterildiği gibi, bazı meta karakterler ve özel diziler, bayrağa bağlı olarak modlarını değiştirir.

Burada sadece ana bayraklar kaplıdır. Geri kalanı için resmi belgelere bakın.

ASCII karakterleriyle sınırlıdır: re.ASCII

\wBu ayrıca Python 3 dizeleri için varsayılan olarak çift baytlı kanji, alfasayısal karakterler vb. ile eşleşir. Standart bir normal ifade olmadığı için aşağıdakine eşdeğer değildir.[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

Her işlevde bağımsız değişken bayrakları için re.ASCII belirtirseniz veya aşağıdaki satır içi bayrağı normal ifade kalıbı dizesinin başına eklerseniz, yalnızca ASCII karakterleriyle eşleşir (çift baytlı Japonca, alfasayısal karakterler vb. ile eşleşmez). .).
(?a)
Bu durumda, aşağıdaki ikisi eşdeğerdir.
\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

Aynısı re.compile() ile derleme yaparken de geçerlidir. Argüman bayraklarını veya satır içi bayrakları kullanın.

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 ayrıca kısa form re olarak da mevcuttur. A. İkisinden birini kullanabilirsiniz.

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

\W’nin tersi olan \W, re.ASCII ve satır içi bayraklardan da etkilenir.

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’de olduğu gibi, aşağıdaki ikisi varsayılan olarak hem tek baytlık hem de çift baytlık karakterlerle eşleşir, ancak re.ASCII veya satır içi bayraklar belirtilmişse tek baytlık karakterlerle sınırlıdır.

  • Numaraları eşleştir\d
  • Boş bir alanla eşleşir\s
  • Sayı olmayanlarla eşleşir\D
  • Herhangi bir boşlukla eşleşir.\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

Büyük küçük harf duyarlı değil:Büyük küçük harf duyarlı değil:re.IGNORECASE

Varsayılan olarak, büyük/küçük harf duyarlıdır. Her ikisini de eşleştirmek için, desene hem büyük hem de küçük harfleri eklemeniz gerekir.

re.IGNORECASEBu belirtilirse, büyük/küçük harfe duyarsız olarak eşleşir. Standart normal ifadelerdeki i bayrağına eşdeğerdir.

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

Daha az veya eşittir kullanabilirsiniz.

  • satır içi bayrak(?i)
  • kısaltmare.I

Her satırın başlangıcını ve sonunu eşleştirin:re.MULTILINE

^Bu normal ifadedeki meta karakterler, dizenin başlangıcıyla eşleşir.

Varsayılan olarak, tüm dizenin yalnızca başlangıcı eşleştirilir, ancak aşağıdakiler de her satırın başlangıcıyla eşleşir. Standart düzenli ifadelerde m bayrağına eşdeğerdir.
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']

$Dizenin sonuyla eşleşir. Varsayılan olarak, yalnızca tüm dizenin sonu eşleştirilir.
re.MULTILINEBunu belirtirseniz, her satırın sonuyla da eşleşir.

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

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

Daha az veya eşittir kullanabilirsiniz.

  • satır içi bayrak(?m)
  • kısaltmare.M

Birden çok bayrak belirtin

|Aynı anda birden fazla bayrağı etkinleştirmek istiyorsanız, bunu kullanın. Satır içi bayraklarda, her karakterden sonra aşağıda gösterildiği gibi bir harf gelmelidir.
(?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']

Açgözlü ve açgözlü olmayan eşleşmeler

Bu normal ifadelerle ilgili genel bir problem, sadece Python ile ilgili bir problem değil, ama bu konuda yazacağım çünkü başımı belaya sokma eğiliminde.

Varsayılan olarak, aşağıdaki olası en uzun dizeyle eşleşen açgözlü bir eşleşmedir.

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

NS ? sonra, mümkün olan en kısa dizeyle eşleşen, açgözlü olmayan, minimum bir eşleşmeyle sonuçlanacaktır.

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

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

Varsayılan açgözlü eşleşmenin beklenmeyen dizelerle eşleşebileceğini unutmayın.

Copied title and URL