Hogyan használjuk a Python reguláris kifejezés modul re (match, search, sub, stb.)

Üzleti

A szabályos kifejezések Pythonban történő feldolgozásához a standard könyvtár re modulját használjuk. Ez lehetővé teszi a karakterláncok kivonását, cseréjét és szétválasztását szabályos kifejezések mintáival.

Ebben a szakaszban először a re modul funkcióit és módszereit ismertetjük.

  • Szabályos kifejezésminták összeállítása:compile()
  • match objektum
  • Ellenőrizze, hogy a karakterlánc eleje megegyezik-e, kivonatolja:match()
  • Ellenőrizze, hogy a mérkőzések nem korlátozódnak-e az elejére:search()
  • Ellenőrizze, hogy a teljes karakterlánc egyezik-e:fullmatch()
  • Szerezzen be egy listát az összes megfelelő alkatrészről:findall()
  • Az összes egyező alkatrész kinyerése iterátorként:finditer()
  • Cserélje ki a megfelelő alkatrészt:sub(),subn()
  • Szövegek szétválasztása reguláris kifejezésmintákkal:split()

Ezt követően ismertetem a metakaraktereket (speciális karakterek) és a reguláris kifejezések speciális szekvenciáit, amelyek a re modulban használhatók. Alapvetően ez a standard reguláris kifejezések szintaxisa, de vigyázzunk a zászlók beállításával (különösen a re.ASCII).

  • Szabályos kifejezések metakarakterei, speciális szekvenciák és figyelmeztetések Pythonban
  • A zászló beállítása
    • ASCII karakterekre korlátozódik:re.ASCII
    • Nem érzékeny a nagy- és kisbetűkre:re.IGNORECASE
    • Párosítsa az egyes sorok elejét és végét:re.MULTILINE
    • Több zászló megadása
  • Kapzsi és nem kapzsi mérkőzések

A reguláris kifejezés mintájának lefordítása: compile()

A re modulban a reguláris kifejezések feldolgozásának két módja van.

Futtatás funkcióval

Az első egy függvény.re.match(),re.sub()Az ehhez hasonló függvények rendelkezésre állnak a kivonás, a csere és egyéb folyamatok elvégzéséhez a reguláris kifejezések mintáinak felhasználásával.

A függvények részleteit később ismertetjük, de mindegyikben az első argumentum a reguláris kifejezés mintájának karakterlánca, majd a feldolgozandó karakterlánc, és így tovább. Például a re.sub()-ban, amely a helyettesítést végzi, a második argumentum a helyettesítési karakterlánc, a harmadik pedig a feldolgozandó karakterlánc.

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

Vegyük észre, hogy az [a-z] ebben a példában a szabályos kifejezés mintájában az a-tól z-ig terjedő bármely karaktert (azaz a kisbetűs ábécét) jelenti, a + pedig azt, hogy az előző mintát (ebben az esetben az [a-z]) egy vagy több alkalommal megismétli. Az [a-z]+ minden olyan karakterláncra illik, amely egy vagy több kisbetűs ábécé karaktert ismétel.

. egy meta karakter (különleges jelentéssel bíró karakter), és backslash-szel kell elkerülni.

Mivel a reguláris kifejezésminták karakterláncai gyakran sok backslashes karakterláncot használnak, célszerű nyers karakterláncokat használni, mint a példában.

Egy reguláris kifejezésminta objektum metódusában fut

A reguláris kifejezések feldolgozásának második módja a re modulban a regular expression pattern object módszer.

Az re.compile() segítségével összeállíthat egy reguláris kifejezésmintát tartalmazó karakterláncot, hogy létrehozzon egy reguláris kifejezésmintát tartalmazó objektumot.

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()Például ugyanaz a folyamat, mint ezek a függvények, a reguláris kifejezés objektumok match(),sub() metódusaiként is végrehajtható.

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

Az alább ismertetett re.xxx() függvények mindegyike a reguláris kifejezés objektum metódusaként is rendelkezésre áll.

Ha ugyanazt a mintát használó folyamatot ismétli, hatékonyabb, ha a re.compile() segítségével létrehoz egy reguláris kifejezés objektumot, és azt használja körbe.

A következő mintakódban a függvényt a kényelem érdekében fordítás nélkül használjuk, de ha ugyanazt a mintát többször szeretnénk használni, akkor ajánlott előre lefordítani és egy reguláris kifejezés objektum metódusaként végrehajtani.

match objektum

match(), search(), stb. egy match objektumot adnak vissza.

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

Az illesztett karakterláncot és a pozíciót a match objektum következő metódusai segítségével kapjuk meg.

  • A mérkőzés helyszínének lekérdezése:start(),end(),span()
  • A megfelelő karakterlánc kinyerése:group()
  • Az egyes csoportok karakterláncának lekérdezése:groups()
print(m.start())
# 0

print(m.end())
# 11

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

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

Ha egy reguláris kifejezés mintájának egy részét zárójelekkel() zárja be egy karakterláncba, akkor a rész csoportként kerül feldolgozásra. Ebben az esetben a groups()-ban az egyes csoportoknak megfelelő rész stringje tuple-ként kapható.

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

Ellenőrizze, hogy a karakterlánc eleje egyezik-e, kivonat: match()

A match() egy match objektumot ad vissza, ha a karakterlánc eleje megegyezik a mintával.

Mint fentebb említettük, a match objektum használható az illeszkedő részlánc kivonására, vagy egyszerűen csak annak ellenőrzésére, hogy megtörtént-e az egyezés.

A match() csak az elejét ellenőrzi. Ha nincs megfelelő karakterlánc az elején, akkor None-t ad vissza.

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

Nem csak az elejére korlátozódó találatok keresése, kivonat: search()

A match()-hez hasonlóan ez is egy match objektumot ad vissza, ha egyezik.

Ha több egyező rész van, csak az első egyező rész lesz visszaküldve.

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

Ha az összes egyező részt szeretné megkapni, használja a findall() vagy finditer() parancsot az alábbiakban leírtak szerint.

A teljes karakterlánc egyezésének ellenőrzése: fullmatch()

Annak ellenőrzéséhez, hogy a teljes karakterlánc megfelel-e a reguláris kifejezés mintájának, használja a fullmatch() funkciót. Ez hasznos például annak ellenőrzésére, hogy egy karakterlánc érvényes-e e-mail címként vagy sem.

Ha a teljes karakterlánc egyezik, egy match objektumot kapunk vissza.

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

Ha vannak nem egyező részek (csak részleges egyezés vagy egyáltalán nincs egyezés), a None értéket kapja vissza.

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

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

A fullmatch() a Python 3.4-ben került be. Ha a korábbi verziókban is ezt akarod csinálni, használd a match()-t és a megfelelő meta karaktert $ a végén. Ha a teljes karakterlánc az elejétől a végéig nem egyezik, akkor None-t ad vissza.

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

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

Az összes egyező alkatrész listájának lekérdezése: findall()

A findall() az összes egyező részlánc listáját adja vissza. Vegyük észre, hogy a lista elemei nem match objektumok, hanem karakterláncok.

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

Az illeszkedő részek száma ellenőrizhető a beépített len() függvény segítségével, amely a lista elemeinek számát adja vissza.

print(len(result))
# 3

A zárójelekkel() történő csoportosítás egy reguláris kifejezésmintában olyan tuplik listáját adja vissza, amelyek elemei az egyes csoportok karakterláncai. Ez egyenértékű a group() funkcióval a match objektumban.

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

A csoportos zárójelek () egymásba ágyazhatók, így ha a teljes egyezést is meg akarja kapni, csak zárójelbe () kell zárni a teljes egyezést.

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

Ha nem talál egyezést, egy üres tuple-t kap vissza.

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

Az összes egyező rész kinyerése iterátorként: finditer()

A finditer() iterátorként adja vissza az összes egyező részt. Az elemek nem karakterláncok, mint a findall(), hanem egyezés objektumok, így megkaphatjuk az egyező részek pozícióját (indexét).

Maga az iterátor nem nyomtatható ki a print() segítségével, hogy megkapjuk a tartalmát. Ha a beépített next() függvényt vagy a for utasítást használjuk, akkor egyenként kaphatjuk meg a tartalmát.

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

A list() segítségével listává is alakítható.

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)

Ha az összes egyező rész pozícióját szeretnénk megkapni, akkor a listát megértő jelölés kényelmesebb, mint a list().

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

Az iterátor sorrendben veszi ki az elemeket. Vegye figyelembe, hogy ha a végére érve további elemeket próbál kivenni, akkor nem marad semmi.

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

A megfelelő részek cseréje: sub(), subn()

A sub() használatával a megfeleltetett részt egy másik karakterlánccal helyettesítheti. A helyettesített karakterláncot kapjuk vissza.

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

A zárójelekkel() történő csoportosítás esetén az illesztett karakterlánc felhasználható a helyettesített karakterláncban.

Alapértelmezés szerint a következők támogatottak: A normál karakterláncok esetében, amelyek nem nyers karakterláncok, a backslash előtt egy backslash-t kell felsorolni a backslash kikerüléséhez.

\1Az első zárójel
\2A második zárójel
\3A harmadik zárójel
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>
Ha a csoportot úgy nevezi el, hogy ezt a szabályos kifejezés mintájának zárójelébe írja, akkor a szám helyett a névvel adhatja meg, ahogy az alábbiakban látható.
\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

A count argumentum a cserék maximális számát adja meg. Csak a bal oldali számolás lesz kicserélve.

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

A subn() a helyettesített karakterlánc (ugyanaz, mint a sub() visszatérési értéke) és a helyettesített részek száma (a mintának megfelelő részek száma).

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

Az argumentumok megadásának módja megegyezik a sub() módszerével. Használhatja a zárójelekbe csoportosított részt, vagy megadhatja az argumentumok számát.

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)

Szövegek szétválasztása reguláris kifejezésmintákkal: split()

A split() felosztja a karakterláncot a mintának megfelelő résznél, és listaként adja vissza.

Vegye figyelembe, hogy az első és az utolsó találat üres karakterláncokat fog tartalmazni a lista elején és végén.

s = '111aaa222bbb333'

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

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

A maxsplit argumentum megadja a felosztások (darabok) maximális számát. Csak a bal oldali számolás lesz felosztva.

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

Szabályos kifejezések metakarakterei, speciális szekvenciák és figyelmeztetések Pythonban

A Python 3 re modulban használható főbb reguláris kifejezések metakarakterei (speciális karakterek) és speciális szekvenciái a következők

metacharaktertartalom
.Bármely, az újsoron kívüli karakter (beleértve a DOTALL jelű újsorokat is)
^A karakterlánc eleje (a MULTILINE jelzővel rendelkező sorok elejére is illeszkedik)
$A karakterlánc vége (a MULTILINE jelzővel rendelkező sorok végére is illeszkedik)
*Ismételje meg az előző mintát 0-nál többször.
+Ismételje meg az előző mintát legalább egyszer.
?Ismételje meg az előző mintát 0 vagy 1 alkalommal.
{m}Ismételje meg az előző mintát m-szer
{m, n}Az utolsó minta.m~nismétlés
[]Karakterek halmaza[]Megfelel az alábbi karakterek bármelyikének
|VAGYA|BEgyezik az A vagy a B mintával
speciális szekvenciatartalom
\dUnicode decimális számok (ASCII-jelzővel ASCII-számokra korlátozva)
\D\dEnnek az ellenkezőjét jelenti.
\sUnicode szóköz karakterek (ASCII jelzővel ASCII szóköz karakterekre korlátozva)
\S\sEnnek az ellenkezőjét jelenti.
\wUnicode szó karakterek és aláhúzások (ASCII alfanumerikus karakterekre és aláhúzásokra korlátozva az ASCII flag által)
\W\wEnnek az ellenkezőjét jelenti.

Nem mindegyik szerepel ebben a táblázatban. A teljes lista a hivatalos dokumentációban található.

Vegye figyelembe azt is, hogy a Python 2-ben néhány jelentés eltér.

A zászló beállítása

Amint a fenti táblázatban látható, néhány metakarakter és speciális szekvencia a jelzőtől függően változtatja a módját.

Itt csak a fő zászlókkal foglalkozunk. A többit lásd a hivatalos dokumentációban.

ASCII karakterekre korlátozva: re.ASCII

\wEz a Python 3 karakterláncok esetében alapértelmezés szerint a kétbájtos kanjikra, alfanumerikus karakterekre stb. is megfelel. Nem egyenértékű a következőkkel, mert ez nem egy szabványos reguláris kifejezés.[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

Ha a re.ASCII-t adja meg az egyes függvények argumentum-jelzői között, vagy a következő inline-jelzőt adja hozzá a reguláris kifejezés mintázó karakterláncának elejéhez, akkor csak ASCII karakterekre fog illeszkedni (nem illeszkedik a kétbájtos japán, alfanumerikus stb. karakterekre).
(?a)
Ebben az esetben a következő kettő egyenértékű.
\w=[a-zA-Z0-9_]

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

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

Ugyanez vonatkozik a re.compile() segítségével történő fordításra is. Használja a flags vagy az inline flags argumentumot.

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

Az ASCII rövid formában is elérhető re. A. Használhatja bármelyiket.

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

A \W, az \W ellentéte, a re.ASCII és az inline zászlók is befolyásolják.

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='漢字ＡＢＣ１２３'>

A \w-hoz hasonlóan a következő kettő alapértelmezés szerint egybájtos és kétbájtos karakterekre is illeszkedik, de a re.ASCII vagy az inline flagek megadása esetén csak egybájtos karakterekre korlátozódik.

  • Párosítsa a számokat\d
  • Egyezik az üres helyekkel\s
  • Megfelel a nem számoknak\D
  • Bármely nem szóközre illeszkedik.\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

Nem érzékeny a nagy- és kisbetűkre:re.IGNORECASE

Alapértelmezés szerint nagy- és kisbetű-érzékeny. Ha mindkettővel egyezni szeretne, akkor a mintában kis- és nagybetűket is szerepeltetnie kell.

re.IGNORECASEHa ez meg van adva, akkor az esetekre való tekintet nélkül fog megfelelni. A szabványos reguláris kifejezések i flagjével egyenértékű.

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

Használhatja a kevesebb, mint vagy egyenlő.

  • inline jelző(?i)
  • rövidítésre.I

Párosítsa az egyes sorok elejét és végét:re.MULTILINE

^A meta karakterek ebben a reguláris kifejezésben a karakterlánc elejére illeszkednek.

Alapértelmezés szerint csak a teljes karakterlánc eleje illeszkedik, de a következőkben az egyes sorok eleje is illeszkedik. A szabványos reguláris kifejezések m jelzőjével egyenértékű.
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']

$A karakterlánc végére illeszkedik. Alapértelmezés szerint csak a teljes karakterlánc vége kerül egyeztetésre.
re.MULTILINEHa ezt adja meg, akkor minden sor végére is illeszkedni fog.

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

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

Használhatja a kevesebb, mint vagy egyenlő.

  • inline jelző(?m)
  • rövidítésre.M

Több zászló megadása

|Ha egyszerre több zászlót szeretne engedélyezni, használja ezt. A soron belüli zászlók esetében minden egyes karaktert egy betűnek kell követnie, ahogy az alábbiakban látható.
(?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']

Kapzsi és nem kapzsi mérkőzések

Ez egy általános probléma a reguláris kifejezésekkel, nem csak a Python problémája, de azért írok róla, mert hajlamos vagyok bajba kerülni.

Alapértelmezés szerint a következő egy mohó egyezés, amely a lehető leghosszabb karakterlánccal egyezik meg.

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

Az utána lévő ? egy nem mohó, minimális egyezést eredményez, amely a lehető legrövidebb karakterláncra illeszkedik.

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

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

Vegye figyelembe, hogy az alapértelmezett mohó egyezés váratlan karakterláncokra is illeszkedhet.