Bagaimana Anda menemukan pola antara dua string di python?

Dokumen ini adalah tutorial pengantar untuk menggunakan ekspresi reguler di Python dengan modul. Ini memberikan pengantar yang lebih lembut daripada bagian yang sesuai di Referensi Perpustakaan

pengantar

Ekspresi reguler (disebut RE, atau regex, atau pola regex) pada dasarnya adalah bahasa pemrograman kecil yang sangat terspesialisasi yang disematkan di dalam Python dan tersedia melalui modul. Dengan menggunakan bahasa kecil ini, Anda menentukan aturan untuk sekumpulan kemungkinan string yang ingin Anda cocokkan; . Anda kemudian dapat mengajukan pertanyaan seperti "Apakah string ini cocok dengan polanya?", atau "Apakah ada kecocokan untuk pola di mana pun dalam string ini?". Anda juga dapat menggunakan RE untuk memodifikasi string atau memisahkannya dengan berbagai cara

Pola ekspresi reguler dikompilasi menjadi serangkaian bytecode yang kemudian dieksekusi oleh mesin pencocokan yang ditulis dalam C. Untuk penggunaan tingkat lanjut, mungkin perlu memperhatikan dengan seksama bagaimana mesin akan mengeksekusi RE yang diberikan, dan menulis RE dengan cara tertentu untuk menghasilkan bytecode yang berjalan lebih cepat. Pengoptimalan tidak tercakup dalam dokumen ini, karena Anda harus memiliki pemahaman yang baik tentang bagian dalam mesin pencocokan

Bahasa ekspresi reguler relatif kecil dan terbatas, sehingga tidak semua kemungkinan tugas pemrosesan string dapat dilakukan menggunakan ekspresi reguler. Ada juga tugas yang bisa dilakukan dengan ekspresi reguler, tetapi ekspresinya ternyata sangat rumit. Dalam kasus ini, Anda mungkin lebih baik menulis kode Python untuk melakukan pemrosesan;

Pola Sederhana

Kita akan mulai dengan mempelajari tentang ekspresi reguler yang paling sederhana. Karena ekspresi reguler digunakan untuk mengoperasikan string, kita akan mulai dengan tugas yang paling umum. karakter yang cocok

Untuk penjelasan mendetail tentang ilmu komputer yang mendasari ekspresi reguler (finite automata deterministik dan non-deterministik), Anda dapat merujuk ke hampir semua buku teks tentang kompiler penulisan

Mencocokkan Karakter

Sebagian besar huruf dan karakter hanya akan cocok dengan dirinya sendiri. Misalnya, ekspresi reguler

>>> p.match("")
>>> print(p.match(""))
None

_7 akan sama persis dengan string

>>> p.match("")
>>> print(p.match(""))
None

7. (Anda dapat mengaktifkan mode case-insensitive yang memungkinkan RE ini cocok dengan

>>> p.match("")
>>> print(p.match(""))
None

9 atau

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

0 juga; lebih lanjut tentang ini nanti. )

Ada pengecualian untuk aturan ini; . Alih-alih, mereka menandakan bahwa beberapa hal yang tidak biasa harus dicocokkan, atau mereka mempengaruhi bagian lain dari RE dengan mengulanginya atau mengubah maknanya. Banyak dari dokumen ini dikhususkan untuk membahas berbagai karakter meta dan apa yang mereka lakukan

Berikut daftar lengkap dari metakarakter;

. ^ $ * + ? { } [ ] \ | ( )

Metakarakter pertama yang akan kita lihat adalah

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

1 dan

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

2. Mereka digunakan untuk menentukan kelas karakter, yang merupakan sekumpulan karakter yang ingin Anda cocokkan. Karakter dapat dicantumkan secara individual, atau rentang karakter dapat ditunjukkan dengan memberikan dua karakter dan memisahkannya dengan

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

3. Misalnya,

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

_4 akan cocok dengan salah satu karakter

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

6, atau

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

7; . Jika Anda hanya ingin mencocokkan huruf kecil, RE Anda akan menjadi

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

Metakarakter (kecuali

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

_0) tidak aktif di dalam kelas. Misalnya,

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

_1 akan cocok dengan salah satu karakter

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

4, atau

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

Anda dapat mencocokkan karakter yang tidak tercantum dalam kelas dengan melengkapi set. Ini ditunjukkan dengan menyertakan

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

_7 sebagai karakter pertama kelas. Misalnya,

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

_8 akan cocok dengan karakter apa pun kecuali

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

9. Jika tanda sisipan muncul di tempat lain di kelas karakter, itu tidak memiliki arti khusus. Sebagai contoh.

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

0 akan cocok dengan

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

9 atau

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

Mungkin karakter meta yang paling penting adalah garis miring terbalik,

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

0. Seperti dalam literal string Python, backslash dapat diikuti oleh berbagai karakter untuk menandakan berbagai urutan khusus. Ini juga digunakan untuk menghindari semua karakter meta sehingga Anda masih bisa mencocokkannya dalam pola; .

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

6 atau

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

Beberapa urutan khusus yang dimulai dengan

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

8 mewakili kumpulan karakter yang ditentukan sebelumnya yang sering berguna, seperti kumpulan angka, kumpulan huruf, atau kumpulan apa pun yang bukan spasi putih

Mari kita ambil contoh.

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

9 cocok dengan karakter alfanumerik apa pun. Jika pola regex dinyatakan dalam byte, ini setara dengan kelas

p = re.compile( ... )
m = p.match( 'string goes here' )
if m:
    print('Match found: ', m.group())
else:
    print('No match')

0. Jika pola regex berupa string,

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

9 akan cocok dengan semua karakter yang ditandai sebagai huruf dalam database Unicode yang disediakan oleh modul. Anda dapat menggunakan definisi yang lebih terbatas dari

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

_9 dalam pola string dengan menyediakan flag saat mengkompilasi ekspresi reguler

Daftar urutan khusus berikut tidak lengkap. Untuk daftar lengkap urutan dan definisi kelas yang diperluas untuk pola string Unicode, lihat bagian terakhir dari referensi Perpustakaan Standar. Secara umum, versi Unicode cocok dengan karakter apa pun yang berada dalam kategori yang sesuai di basis data Unicode

p = re.compile( ... )
m = p.match( 'string goes here' )
if m:
    print('Match found: ', m.group())
else:
    print('No match')

Cocok dengan digit desimal apa pun;

p = re.compile( ... )
m = p.match( 'string goes here' )
if m:
    print('Match found: ', m.group())
else:
    print('No match')

Cocok dengan karakter non-digit apa pun;

p = re.compile( ... )
m = p.match( 'string goes here' )
if m:
    print('Match found: ', m.group())
else:
    print('No match')

Cocok dengan karakter spasi apa pun;

>>> p = re.compile(r'\d+')
>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
['12', '11', '10']

Cocok dengan karakter non-spasi apa pun;

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

Cocok dengan karakter alfanumerik apa pun;

>>> p = re.compile(r'\d+')
>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
['12', '11', '10']

Cocok dengan karakter non-alfanumerik apa pun;

Urutan ini dapat dimasukkan ke dalam kelas karakter. Misalnya,

>>> p = re.compile(r'\d+')
>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
['12', '11', '10']

_7 adalah kelas karakter yang akan cocok dengan karakter spasi apa pun, atau

>>> p = re.compile(r'\d+')
>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
['12', '11', '10']

8 atau

>>> p = re.compile(r'\d+')
>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
['12', '11', '10']

Metakarakter terakhir di bagian ini adalah

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

00. Itu cocok dengan apa pun kecuali karakter baris baru, dan ada mode alternatif () yang cocok bahkan dengan baris baru.

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_00 sering digunakan di mana Anda ingin mencocokkan "karakter apa pun"

Mengulangi Hal

Mampu mencocokkan kumpulan karakter yang bervariasi adalah hal pertama yang dapat dilakukan ekspresi reguler yang belum mungkin dilakukan dengan metode yang tersedia pada string. Namun, jika itu adalah satu-satunya kemampuan tambahan dari regex, mereka tidak akan banyak kemajuan. Kemampuan lainnya adalah Anda dapat menentukan bahwa bagian dari RE harus diulang beberapa kali

Karakter meta pertama untuk mengulangi hal-hal yang akan kita lihat adalah

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

03.

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_03 tidak cocok dengan karakter literal

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

05;

Misalnya,

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

06 akan cocok dengan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

07 (0

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

2 karakter),

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

09 (1

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

2),

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

11 (3

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

2 karakter), dan seterusnya

Pengulangan seperti

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_03 serakah; . Jika nanti bagian dari pola tidak cocok, mesin pencocokan akan mencadangkan dan mencoba lagi dengan pengulangan yang lebih sedikit

Contoh langkah demi langkah akan membuat ini lebih jelas. Mari pertimbangkan ungkapan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

14. Ini cocok dengan huruf

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

_2, nol atau lebih huruf dari kelas

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

16, dan diakhiri dengan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

17. Sekarang bayangkan mencocokkan RE ini dengan string

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Melangkah

Cocok

Penjelasan

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

_5 dalam pertandingan RE

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_21

Mesinnya cocok dengan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

22, pergi sejauh mungkin, yaitu sampai ke ujung tali

Kegagalan

Mesin mencoba mencocokkan

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

6, tetapi posisi saat ini berada di ujung string, sehingga gagal

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_24

Cadangkan, sehingga ________ 52 ______ 22 cocok dengan satu karakter yang lebih sedikit

Kegagalan

Coba

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

_6 lagi, tetapi posisi saat ini berada di karakter terakhir, yaitu

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_28

Cadangkan lagi, sehingga

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

22 hanya cocok dengan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_24

Coba

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

_6 lagi. Kali ini karakter pada posisi sekarang adalah

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

17, jadi berhasil

Akhir dari RE sekarang telah tercapai, dan cocok dengan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

34. Ini menunjukkan bagaimana mesin pencocokan berjalan sejauh mungkin pada awalnya, dan jika tidak ada kecocokan yang ditemukan, mesin tersebut akan secara progresif mencadangkan dan mencoba kembali sisa RE lagi dan lagi. Ini akan mencadangkan hingga mencoba nol kecocokan untuk ________ 52 _______ 22, dan jika kemudian gagal, mesin akan menyimpulkan bahwa string tidak cocok dengan RE sama sekali

Metakarakter berulang lainnya adalah

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

36, yang cocok satu kali atau lebih. Perhatikan baik-baik perbedaan antara

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

03 dan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

36; . Untuk menggunakan contoh serupa,

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_41 akan cocok dengan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

09 (1

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

2),

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

11 (3

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

2s), tetapi tidak akan cocok dengan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Ada dua operator berulang atau pembilang. Karakter tanda tanya,

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_47, cocok sekali atau nol kali; . Misalnya,

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

48 cocok dengan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

49 atau

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Kuantor yang paling rumit adalah

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_51, di mana m dan n adalah bilangan bulat desimal. Penghitung ini berarti harus ada setidaknya m pengulangan, dan paling banyak n. Misalnya,

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_52 akan cocok dengan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

53,

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

54, dan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

55. Ini tidak cocok dengan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_56, yang tidak memiliki garis miring, atau

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

57, yang memiliki empat

Anda dapat menghilangkan m atau n; . Menghilangkan m diartikan sebagai batas bawah 0, sedangkan menghilangkan n menghasilkan batas atas tak terhingga

Pembaca dari kecenderungan reduksionis mungkin memperhatikan bahwa ketiga bilangan lainnya semuanya dapat diekspresikan menggunakan notasi ini.

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_58 sama dengan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

03,

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

60 sama dengan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

36, dan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

62 sama dengan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

47. Lebih baik menggunakan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_03,

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

36, atau

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

47 saat Anda bisa, hanya karena lebih pendek dan lebih mudah dibaca

Menggunakan Ekspresi Reguler

Sekarang setelah kita melihat beberapa ekspresi reguler sederhana, bagaimana sebenarnya kita menggunakannya di Python?

Mengompilasi Ekspresi Reguler

Ekspresi reguler dikompilasi menjadi objek pola, yang memiliki metode untuk berbagai operasi seperti mencari kecocokan pola atau melakukan penggantian string

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

juga menerima argumen flag opsional, yang digunakan untuk mengaktifkan berbagai fitur khusus dan variasi sintaks. Kami akan membahas pengaturan yang tersedia nanti, tetapi untuk saat ini satu contoh sudah cukup

>>> p = re.compile('ab*', re.IGNORECASE)

RE diteruskan ke sebagai string. RE ditangani sebagai string karena ekspresi reguler bukan bagian dari inti bahasa Python, dan tidak ada sintaks khusus yang dibuat untuk mengekspresikannya. (Ada aplikasi yang tidak membutuhkan RE sama sekali, jadi tidak perlu membengkakkan spesifikasi bahasa dengan memasukkannya. ) Alih-alih, modulnya hanyalah modul ekstensi C yang disertakan dengan Python, seperti halnya modul or

Menempatkan RE dalam string membuat bahasa Python lebih sederhana, tetapi memiliki satu kelemahan yang merupakan topik dari bagian selanjutnya

Wabah Backslash

Seperti yang dinyatakan sebelumnya, ekspresi reguler menggunakan karakter garis miring terbalik (

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

8) untuk menunjukkan bentuk khusus atau untuk mengizinkan karakter khusus digunakan tanpa menyebutkan arti khusus mereka. Ini bertentangan dengan penggunaan karakter yang sama oleh Python untuk tujuan yang sama dalam literal string

Katakanlah Anda ingin menulis RE yang cocok dengan string

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

74, yang mungkin ditemukan dalam file LaTeX. Untuk mengetahui apa yang harus ditulis dalam kode program, mulailah dengan string yang diinginkan untuk dicocokkan. Selanjutnya, Anda harus menghindari garis miring terbalik dan karakter meta lainnya dengan mengawalinya dengan garis miring terbalik, menghasilkan string

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

75. Hasil string yang harus diteruskan harus

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

75. Namun, untuk menyatakan ini sebagai literal string Python, kedua garis miring terbalik harus di-escape lagi

Karakter

Panggung

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_74

String teks yang akan dicocokkan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_75

Tanda garis miring terbalik untuk

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_81

Garis miring terbalik yang lolos untuk string literal

Singkatnya, untuk mencocokkan backslash literal, seseorang harus menulis

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

82 sebagai string RE, karena ekspresi reguler harus

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

7, dan setiap backslash harus dinyatakan sebagai

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

7 di dalam string Python reguler literal. Dalam RE yang menampilkan garis miring terbalik berulang kali, hal ini menyebabkan banyak garis miring terbalik berulang dan membuat string yang dihasilkan sulit dipahami

Solusinya adalah menggunakan notasi string mentah Python untuk ekspresi reguler; . Ekspresi reguler akan sering ditulis dalam kode Python menggunakan notasi string mentah ini

Selain itu, sekuens escape khusus yang valid dalam ekspresi reguler, tetapi tidak valid sebagai literal string Python, sekarang menghasilkan a dan pada akhirnya akan menjadi a , yang berarti sekuens tersebut akan menjadi tidak valid jika notasi string mentah atau pelolosan garis miring terbalik tidak digunakan

Tali Biasa

Tali mentah

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_92

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_93

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_81

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_95

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_96

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_97

Melakukan Pertandingan

Setelah Anda memiliki objek yang mewakili ekspresi reguler terkompilasi, apa yang Anda lakukan dengannya? . Hanya yang paling signifikan yang akan dibahas di sini;

Metode/Atribut

Tujuan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_99

Tentukan apakah RE cocok di awal string

>>> p = re.compile('ab*', re.IGNORECASE)

_00

Pindai melalui string, cari lokasi mana pun yang cocok dengan RE ini

>>> p = re.compile('ab*', re.IGNORECASE)

_01

Temukan semua substring di mana RE cocok, dan kembalikan sebagai daftar

>>> p = re.compile('ab*', re.IGNORECASE)

_02

Temukan semua substring di mana RE cocok, dan kembalikan sebagai

dan kembalikan

>>> p = re.compile('ab*', re.IGNORECASE)

05 jika tidak ada kecocokan yang dapat ditemukan. Jika berhasil, sebuah instance dikembalikan, berisi informasi tentang kecocokan. di mana itu dimulai dan diakhiri, substring yang cocok, dan banyak lagi

Anda dapat mempelajarinya dengan bereksperimen secara interaktif dengan modul. Jika tersedia, Anda mungkin juga ingin melihat Tools/demo/redemo. py, program demonstrasi yang disertakan dengan distribusi Python. Ini memungkinkan Anda untuk memasukkan RE dan string, dan menampilkan apakah RE cocok atau gagal.

>>> p = re.compile('ab*', re.IGNORECASE)

_08 bisa sangat berguna saat mencoba men-debug RE yang rumit

HOWTO ini menggunakan interpreter Python standar untuk contohnya. Pertama, jalankan interpreter Python, impor modul, dan kompilasi RE

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

Sekarang, Anda dapat mencoba mencocokkan berbagai string dengan RE

>>> p = re.compile('ab*', re.IGNORECASE)

10. String kosong tidak boleh sama sekali, karena

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

36 berarti 'satu atau lebih pengulangan'. harus mengembalikan

>>> p = re.compile('ab*', re.IGNORECASE)

05 dalam hal ini, yang akan menyebabkan penerjemah tidak mencetak keluaran. Anda dapat secara eksplisit mencetak hasil

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

99 untuk memperjelasnya

>>> p.match("")
>>> print(p.match(""))
None

Sekarang, mari kita coba pada string yang seharusnya cocok, seperti

>>> p = re.compile('ab*', re.IGNORECASE)

15. Dalam hal ini, akan mengembalikan a , jadi Anda harus menyimpan hasilnya dalam variabel untuk digunakan nanti

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

Sekarang Anda dapat meminta informasi tentang string yang cocok. Instance objek yang cocok juga memiliki beberapa metode dan atribut;

Metode/Atribut

Tujuan

>>> p = re.compile('ab*', re.IGNORECASE)

_17

Kembalikan string yang cocok dengan RE

>>> p = re.compile('ab*', re.IGNORECASE)

_18

Kembalikan posisi awal pertandingan

>>> p = re.compile('ab*', re.IGNORECASE)

_19

Kembalikan posisi akhir pertandingan

>>> p = re.compile('ab*', re.IGNORECASE)

_20

Kembalikan tuple yang berisi posisi (mulai, akhir) dari pertandingan

Mencoba metode ini akan segera memperjelas artinya

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

mengembalikan substring yang cocok dengan RE. dan kembalikan indeks awal dan akhir pertandingan. mengembalikan indeks awal dan akhir dalam satu Tuple. Karena metode ini hanya memeriksa apakah RE cocok di awal string,

>>> p = re.compile('ab*', re.IGNORECASE)

18 akan selalu nol. Namun, metode pola memindai melalui string, sehingga kecocokan mungkin tidak dimulai dari nol dalam kasus tersebut

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

Dalam program sebenarnya, gaya yang paling umum adalah menyimpan the dalam sebuah variabel, lalu memeriksa apakah

>>> p = re.compile('ab*', re.IGNORECASE)

05. Ini biasanya terlihat seperti

p = re.compile( ... )
m = p.match( 'string goes here' )
if m:
    print('Match found: ', m.group())
else:
    print('No match')

Dua metode pola mengembalikan semua kecocokan untuk sebuah pola. mengembalikan daftar string yang cocok

>>> p = re.compile(r'\d+')
>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
['12', '11', '10']

Awalan

>>> p = re.compile('ab*', re.IGNORECASE)

30, membuat literal menjadi string literal mentah, diperlukan dalam contoh ini karena escape sequence dalam literal string "dimasak" normal yang tidak dikenali oleh Python, berlawanan dengan ekspresi reguler, sekarang menghasilkan a dan pada akhirnya akan menjadi a. Lihat

harus membuat seluruh daftar sebelum dapat dikembalikan sebagai hasilnya. Metode mengembalikan urutan instance sebagai

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Fungsi Tingkat Modul

Anda tidak perlu membuat objek pola dan memanggil metodenya; . Fungsi ini mengambil argumen yang sama dengan metode pola yang sesuai dengan string RE yang ditambahkan sebagai argumen pertama, dan masih mengembalikan

>>> p = re.compile('ab*', re.IGNORECASE)

05 atau instance

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Di bawah tenda, fungsi-fungsi ini hanya membuat objek pola untuk Anda dan memanggil metode yang sesuai di atasnya. Mereka juga menyimpan objek yang dikompilasi dalam cache, sehingga panggilan selanjutnya menggunakan RE yang sama tidak perlu mengurai pola berulang kali.

Haruskah Anda menggunakan fungsi tingkat modul ini, atau haruskah Anda mendapatkan pola dan memanggil metodenya sendiri? . Di luar loop, tidak banyak perbedaan berkat cache internal

Bendera kompilasi

Tanda kompilasi memungkinkan Anda memodifikasi beberapa aspek tentang cara kerja ekspresi reguler. Bendera tersedia dalam modul dengan dua nama, nama panjang seperti

>>> p = re.compile('ab*', re.IGNORECASE)

42 dan bentuk pendek satu huruf seperti

>>> p = re.compile('ab*', re.IGNORECASE)

43. (Jika Anda terbiasa dengan pengubah pola Perl, formulir satu huruf menggunakan huruf yang sama; bentuk singkatnya adalah , misalnya. ) Beberapa flag dapat ditentukan dengan bitwise OR-ing;

Berikut tabel bendera yang tersedia, diikuti dengan penjelasan yang lebih mendetail untuk masing-masing bendera

Bendera

Arti

>>> p = re.compile('ab*', re.IGNORECASE)

_49,

>>> p = re.compile('ab*', re.IGNORECASE)

Membuat beberapa pelarian seperti

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

_9,

>>> p = re.compile('ab*', re.IGNORECASE)

52,

p = re.compile( ... )
m = p.match( 'string goes here' )
if m:
    print('Match found: ', m.group())
else:
    print('No match')

9 dan

p = re.compile( ... )
m = p.match( 'string goes here' )
if m:
    print('Match found: ', m.group())
else:
    print('No match')

5 hanya cocok pada karakter ASCII dengan properti masing-masing

>>> p = re.compile('ab*', re.IGNORECASE)

_55,

>>> p = re.compile('ab*', re.IGNORECASE)

Jadikan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_00 cocok dengan karakter apa pun, termasuk baris baru

>>> p = re.compile('ab*', re.IGNORECASE)

_42,

>>> p = re.compile('ab*', re.IGNORECASE)

Lakukan pencocokan case-insensitive

>>> p = re.compile('ab*', re.IGNORECASE)

_60,

>>> p = re.compile('ab*', re.IGNORECASE)

Lakukan pencocokan sadar-lokal

>>> p = re.compile('ab*', re.IGNORECASE)

_62,

>>> p = re.compile('ab*', re.IGNORECASE)

Pencocokan beberapa baris, memengaruhi

>>> p = re.compile('ab*', re.IGNORECASE)

64 dan

>>> p = re.compile('ab*', re.IGNORECASE)

>>> p = re.compile('ab*', re.IGNORECASE)

_66,

>>> p = re.compile('ab*', re.IGNORECASE)

67 (untuk 'diperpanjang')

Aktifkan RES verbose, yang dapat diatur dengan lebih rapi dan mudah dipahami

SAYAABAIKAN KASUS

Lakukan pencocokan case-insensitive; . Misalnya,

>>> p = re.compile('ab*', re.IGNORECASE)

_68 juga akan cocok dengan huruf kecil. Pencocokan Unicode penuh juga berfungsi kecuali bendera

>>> p = re.compile('ab*', re.IGNORECASE)

49 digunakan untuk menonaktifkan kecocokan non-ASCII. Ketika pola Unicode

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

9 atau

>>> p = re.compile('ab*', re.IGNORECASE)

68 digunakan dalam kombinasi dengan bendera

>>> p = re.compile('ab*', re.IGNORECASE)

42, mereka akan cocok dengan 52 huruf ASCII dan 4 huruf non-ASCII tambahan. 'İ' (U+0130, huruf besar Latin I dengan titik di atas), 'ı' (U+0131, huruf Latin kecil tanpa titik i), 'ſ' (U+017F, huruf Latin kecil panjang s) dan 'K' .

>>> p = re.compile('ab*', re.IGNORECASE)

_73 akan cocok dengan

>>> p = re.compile('ab*', re.IGNORECASE)

74,

>>> p = re.compile('ab*', re.IGNORECASE)

75,

>>> p = re.compile('ab*', re.IGNORECASE)

76, atau

>>> p = re.compile('ab*', re.IGNORECASE)

77 (yang terakhir hanya cocok dalam mode Unicode). Huruf kecil ini tidak memperhitungkan lokal saat ini;

LLOKAL

Jadikan

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

_9,

>>> p = re.compile(r'\d+')
>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
['12', '11', '10']

>>> p = re.compile('ab*', re.IGNORECASE)

52,

>>> p = re.compile('ab*', re.IGNORECASE)

82 dan pencocokan case-insensitive bergantung pada lokal saat ini, bukan database Unicode

Lokal adalah fitur perpustakaan C yang dimaksudkan untuk membantu dalam menulis program yang mempertimbangkan perbedaan bahasa. Misalnya, jika Anda memproses teks Prancis yang disandikan, Anda ingin dapat menulis

>>> p = re.compile('ab*', re.IGNORECASE)

83 untuk mencocokkan kata, tetapi

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

9 hanya cocok dengan kelas karakter

>>> p = re.compile('ab*', re.IGNORECASE)

85 dalam pola byte; . Jika sistem Anda dikonfigurasi dengan benar dan lokal Prancis dipilih, fungsi C tertentu akan memberi tahu program bahwa byte yang sesuai dengan

>>> p = re.compile('ab*', re.IGNORECASE)

86 juga harus dianggap sebagai huruf. Menyetel flag

>>> p = re.compile('ab*', re.IGNORECASE)

60 saat mengkompilasi ekspresi reguler akan menyebabkan objek terkompilasi yang dihasilkan menggunakan fungsi C ini untuk

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

9; . Penggunaan flag ini tidak disarankan di Python 3 karena mekanisme lokal sangat tidak dapat diandalkan, hanya menangani satu "budaya" pada satu waktu, dan hanya bekerja dengan lokal 8-bit. Pencocokan Unicode sudah diaktifkan secara default di Python 3 untuk pola Unicode (str), dan mampu menangani berbagai lokal/bahasa

MMULTILINE

(

>>> p = re.compile('ab*', re.IGNORECASE)

_64 dan

>>> p = re.compile('ab*', re.IGNORECASE)

65 belum dijelaskan; mereka akan diperkenalkan di bagian. )

Biasanya

>>> p = re.compile('ab*', re.IGNORECASE)

64 hanya cocok di awal string, dan

>>> p = re.compile('ab*', re.IGNORECASE)

65 hanya cocok di akhir string dan tepat sebelum baris baru (jika ada) di akhir string. Saat bendera ini ditentukan,

>>> p = re.compile('ab*', re.IGNORECASE)

_64 cocok di awal string dan di awal setiap baris dalam string, langsung mengikuti setiap baris baru. Demikian pula, metakarakter

>>> p = re.compile('ab*', re.IGNORECASE)

65 cocok di akhir string dan di akhir setiap baris (tepat sebelum setiap baris baru)

SDOTALL

Membuat karakter khusus

>>> p = re.compile(r'\d+')
>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
['12', '11', '10']

_9 cocok dengan karakter apa pun, termasuk baris baru;

AASCII

Jadikan

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

_9,

>>> p = re.compile(r'\d+')
>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
['12', '11', '10']

>>> p = re.compile('ab*', re.IGNORECASE)

52,

>>> p = re.compile('ab*', re.IGNORECASE)

82,

p = re.compile( ... )
m = p.match( 'string goes here' )
if m:
    print('Match found: ', m.group())
else:
    print('No match')

9 dan

>>> p = re.compile(r'\d+')
>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
['12', '11', '10']

1 melakukan pencocokan khusus ASCII alih-alih pencocokan Unicode penuh. Ini hanya berarti untuk pola Unicode, dan diabaikan untuk pola byte

XVERBOSE

Tanda ini memungkinkan Anda menulis ekspresi reguler yang lebih mudah dibaca dengan memberi Anda lebih banyak fleksibilitas dalam cara memformatnya. Saat flag ini telah ditentukan, spasi putih di dalam string RE diabaikan, kecuali jika spasi putih ada di kelas karakter atau didahului dengan garis miring terbalik yang tidak lolos; . Bendera ini juga memungkinkan Anda memberi komentar di dalam RE yang akan diabaikan oleh mesin;

Misalnya, inilah RE yang menggunakan ;

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Tanpa pengaturan verbose, RE akan terlihat seperti ini

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Dalam contoh di atas, rangkaian literal string otomatis Python telah digunakan untuk memecah RE menjadi bagian-bagian yang lebih kecil, tetapi masih lebih sulit untuk dipahami daripada versi yang menggunakan

Lebih Banyak Kekuatan Pola

Sejauh ini kami hanya membahas sebagian dari fitur ekspresi reguler. Di bagian ini, kami akan membahas beberapa karakter meta baru, dan cara menggunakan grup untuk mengambil bagian teks yang cocok

Lebih Banyak Metakarakter

Ada beberapa karakter meta yang belum kami bahas. Sebagian besar dari mereka akan dibahas di bagian ini

Beberapa karakter meta yang tersisa untuk didiskusikan adalah pernyataan dengan lebar nol. Mereka tidak menyebabkan mesin maju melalui tali; . Misalnya,

>>> p = re.compile('ab*', re.IGNORECASE)

_52 adalah pernyataan bahwa posisi saat ini terletak di batas kata; . Ini berarti bahwa pernyataan dengan lebar nol tidak boleh diulang, karena jika mereka cocok sekali di lokasi tertentu, mereka jelas dapat dicocokkan berkali-kali.

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_11

Pergantian, atau operator "atau". Jika A dan B adalah ekspresi reguler,

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

12 akan cocok dengan string apa pun yang cocok dengan A atau B.

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_11 memiliki prioritas yang sangat rendah untuk membuatnya berfungsi secara wajar saat Anda mengganti string multi-karakter.

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_14 akan cocok dengan

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

15 atau

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

16, bukan

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

17,

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

18 atau

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

19, dan

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

Untuk mencocokkan

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

21 literal, gunakan

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

22, atau sertakan di dalam kelas karakter, seperti pada

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

>>> p = re.compile('ab*', re.IGNORECASE)

_64

Cocok di awal baris. Kecuali bendera

>>> p = re.compile('ab*', re.IGNORECASE)

62 telah ditetapkan, ini hanya akan cocok di awal string. Dalam mode

>>> p = re.compile('ab*', re.IGNORECASE)

_62, ini juga cocok segera setelah setiap baris baru dalam string

Misalnya, jika Anda ingin mencocokkan kata

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

27 hanya di awal baris, RE yang digunakan adalah

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Untuk mencocokkan

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

_7 literal, gunakan

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

>>> p = re.compile('ab*', re.IGNORECASE)

_65

Cocok di akhir baris, yang didefinisikan sebagai akhir string, atau lokasi apa pun yang diikuti oleh karakter baris baru

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Untuk mencocokkan

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

5 literal, gunakan

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

33 atau sertakan di dalam kelas karakter, seperti pada

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_35

Cocok hanya di awal string. Saat tidak dalam mode

>>> p = re.compile('ab*', re.IGNORECASE)

62,

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

35 dan

>>> p = re.compile('ab*', re.IGNORECASE)

64 secara efektif sama. Dalam mode

>>> p = re.compile('ab*', re.IGNORECASE)

_62, keduanya berbeda.

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_35 masih cocok hanya di awal string, tapi

>>> p = re.compile('ab*', re.IGNORECASE)

64 mungkin cocok di setiap lokasi di dalam string yang mengikuti karakter baris baru

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_42

Cocok hanya di akhir string

>>> p = re.compile('ab*', re.IGNORECASE)

_52

Batas kata. Ini adalah pernyataan dengan lebar nol yang hanya cocok di awal atau akhir kata. Kata didefinisikan sebagai urutan karakter alfanumerik, sehingga akhir kata ditunjukkan dengan spasi putih atau karakter non-alfanumerik

Contoh berikut cocok dengan

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_44 hanya jika itu adalah kata yang lengkap;

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Ada dua kehalusan yang harus Anda ingat saat menggunakan urutan khusus ini. Pertama, ini adalah tabrakan terburuk antara string literal Python dan urutan ekspresi reguler. Dalam literal string Python,

>>> p = re.compile('ab*', re.IGNORECASE)

52 adalah karakter backspace, nilai ASCII 8. Jika Anda tidak menggunakan string mentah, maka Python akan mengonversi

>>> p = re.compile('ab*', re.IGNORECASE)

52 menjadi backspace, dan RE Anda tidak akan cocok seperti yang Anda harapkan. Contoh berikut terlihat sama dengan RE kita sebelumnya, tetapi menghilangkan

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

85 di depan string RE

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Kedua, di dalam kelas karakter, di mana tidak ada gunanya untuk pernyataan ini,

>>> p = re.compile('ab*', re.IGNORECASE)

52 mewakili karakter backspace, untuk kompatibilitas dengan string literal Python

>>> p = re.compile('ab*', re.IGNORECASE)

_82

Penegasan lebar nol lainnya, ini kebalikan dari

>>> p = re.compile('ab*', re.IGNORECASE)

52, hanya cocok jika posisi saat ini tidak berada pada batas kata

Pengelompokan

Seringkali Anda perlu mendapatkan informasi lebih dari sekadar apakah RE cocok atau tidak. Ekspresi reguler sering digunakan untuk membedah string dengan menulis RE yang dibagi menjadi beberapa subgrup yang cocok dengan komponen minat yang berbeda. Misalnya, baris header RFC-822 dibagi menjadi nama header dan nilai, dipisahkan oleh

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_51, seperti ini

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Ini dapat ditangani dengan menulis ekspresi reguler yang cocok dengan seluruh baris tajuk, dan memiliki satu grup yang cocok dengan nama tajuk, dan grup lain yang cocok dengan nilai tajuk

Grup ditandai dengan

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_52,

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

53 metakarakter.

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_52 dan

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

53 memiliki banyak arti yang sama seperti yang mereka lakukan dalam ekspresi matematika; . Misalnya,

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_60 akan cocok dengan nol atau lebih pengulangan dari

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

Grup yang ditunjukkan dengan

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

52,

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

53 juga menangkap indeks awal dan akhir teks yang cocok; . Grup diberi nomor mulai dari 0. Grup 0 selalu hadir; . Nanti kita akan melihat cara mengekspresikan grup yang tidak menangkap rentang teks yang cocok

>>> p = re.compile('ab*', re.IGNORECASE)

Subkelompok diberi nomor dari kiri ke kanan, dari 1 ke atas. Grup dapat disarangkan;

>>> p = re.compile('ab*', re.IGNORECASE)

dapat melewati beberapa nomor grup sekaligus, dalam hal ini akan mengembalikan tuple yang berisi nilai yang sesuai untuk grup tersebut

>>> p = re.compile('ab*', re.IGNORECASE)

Metode ini mengembalikan tuple yang berisi string untuk semua subgrup, dari 1 hingga berapa pun jumlahnya

>>> p = re.compile('ab*', re.IGNORECASE)

Referensi balik dalam sebuah pola memungkinkan Anda menentukan bahwa konten dari grup penangkap sebelumnya juga harus ditemukan di lokasi saat ini dalam string. Misalnya,

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

70 akan berhasil jika konten persis grup 1 dapat ditemukan di posisi saat ini, dan gagal sebaliknya. Ingat bahwa literal string Python juga menggunakan garis miring terbalik diikuti dengan angka untuk memungkinkan menyertakan karakter arbitrer dalam string, jadi pastikan untuk menggunakan string mentah saat memasukkan referensi balik dalam RE

Misalnya, RE berikut mendeteksi kata ganda dalam sebuah string

>>> p = re.compile('ab*', re.IGNORECASE)

Referensi balik seperti ini seringkali tidak berguna hanya untuk menelusuri string — ada beberapa format teks yang mengulangi data dengan cara ini — tetapi Anda akan segera mengetahui bahwa referensi tersebut sangat berguna saat melakukan penggantian string

Non-menangkap dan Grup Bernama

RE yang rumit dapat menggunakan banyak grup, baik untuk menangkap substring yang diminati, maupun untuk mengelompokkan dan menyusun RE itu sendiri. Dalam RES kompleks, menjadi sulit untuk melacak nomor grup. Ada dua fitur yang membantu mengatasi masalah ini. Keduanya menggunakan sintaks umum untuk ekstensi ekspresi reguler, jadi kita akan melihatnya terlebih dahulu

Perl 5 terkenal dengan penambahannya yang kuat pada ekspresi reguler standar. Untuk fitur baru ini, pengembang Perl tidak dapat memilih metakarakter penekanan tombol tunggal baru atau urutan khusus baru yang dimulai dengan

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

0 tanpa membuat ekspresi reguler Perl berbeda secara membingungkan dari RE standar. Jika mereka memilih

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

72 sebagai karakter meta baru, misalnya, ekspresi lama akan mengasumsikan bahwa

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

72 adalah karakter biasa dan tidak akan menghindarinya dengan menulis

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

74 atau

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

Solusi yang dipilih oleh pengembang Perl adalah menggunakan

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

76 sebagai sintaks ekstensi.

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_47 segera setelah tanda kurung adalah kesalahan sintaksis karena

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

47 tidak akan mengulangi apa pun, jadi ini tidak menimbulkan masalah kompatibilitas. Karakter segera setelah

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_47 menunjukkan ekstensi apa yang digunakan, jadi

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

80 adalah satu hal (pernyataan lookahead positif) dan

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

81 adalah sesuatu yang lain (grup non-menangkap yang berisi subekspresi

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

82)

Python mendukung beberapa ekstensi Perl dan menambahkan sintaks ekstensi ke sintaks ekstensi Perl. Jika karakter pertama setelah tanda tanya adalah

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

83, Anda tahu bahwa itu adalah ekstensi khusus untuk Python

Sekarang setelah kita melihat sintaks ekstensi umum, kita dapat kembali ke fitur yang menyederhanakan bekerja dengan grup dalam RE yang kompleks

Terkadang Anda ingin menggunakan grup untuk menunjukkan bagian dari ekspresi reguler, tetapi tidak tertarik untuk mengambil konten grup. Anda dapat memperjelas fakta ini dengan menggunakan grup yang tidak menangkap.

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_84, tempat Anda dapat mengganti

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

85 dengan ekspresi reguler lainnya

>>> p = re.compile('ab*', re.IGNORECASE)

Kecuali fakta bahwa Anda tidak dapat mengambil konten dari grup yang cocok, grup yang tidak menangkap berperilaku persis sama dengan grup yang menangkap; .

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_84 sangat berguna saat memodifikasi pola yang ada, karena Anda dapat menambahkan grup baru tanpa mengubah cara semua grup lain diberi nomor. Harus disebutkan bahwa tidak ada perbedaan performa dalam pencarian antara grup yang menangkap dan yang tidak menangkap;

Fitur yang lebih signifikan adalah grup bernama. alih-alih merujuknya dengan angka, grup dapat direferensikan dengan nama

Sintaks untuk grup bernama adalah salah satu ekstensi khusus Python.

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_88. nama, jelas, nama grup. Grup bernama berperilaku persis seperti menangkap grup, dan juga mengaitkan nama dengan grup. Metode yang menangani grup penangkap semuanya menerima bilangan bulat yang merujuk ke grup dengan angka atau string yang berisi nama grup yang diinginkan. Grup bernama masih diberi nomor, jadi Anda bisa mengambil informasi tentang grup dengan dua cara

>>> p = re.compile('ab*', re.IGNORECASE)

Selain itu, Anda dapat mengambil grup bernama sebagai kamus dengan

>>> p = re.compile('ab*', re.IGNORECASE)

Grup bernama berguna karena memungkinkan Anda menggunakan nama yang mudah diingat, alih-alih harus mengingat angka. Berikut adalah contoh RE dari modul

>>> p = re.compile('ab*', re.IGNORECASE)

Jelas jauh lebih mudah untuk mengambil

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

91, daripada harus ingat untuk mengambil grup 9

Sintaks untuk referensi balik dalam ekspresi seperti

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

92 mengacu pada nomor grup. Tentu saja ada varian yang menggunakan nama grup, bukan nomor. Ini adalah ekstensi Python lainnya.

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_93 menunjukkan bahwa isi grup yang disebut nama harus dicocokkan lagi pada titik saat ini. Ekspresi reguler untuk menemukan kata ganda,

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

94 juga dapat ditulis sebagai

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

>>> p = re.compile('ab*', re.IGNORECASE)

Pernyataan Lihat ke Depan

Penegasan lebar nol lainnya adalah pernyataan lookahead. Penegasan lookahead tersedia dalam bentuk positif dan negatif, dan terlihat seperti ini

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_96

Penegasan lookahead positif. Ini berhasil jika ekspresi reguler yang terkandung, diwakili di sini oleh

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

85, berhasil cocok di lokasi saat ini, dan gagal sebaliknya. Tapi, begitu ekspresi yang terkandung dicoba, mesin pencocokan tidak maju sama sekali;

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_98

Penegasan lookahead negatif. Ini kebalikan dari pernyataan positif;

Untuk membuatnya konkret, mari kita lihat kasus di mana lookahead berguna. Pertimbangkan pola sederhana untuk mencocokkan nama file dan pisahkan menjadi nama dasar dan ekstensi, dipisahkan oleh

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

00. Misalnya, di

>>> p.match("")
>>> print(p.match(""))
None

00,

>>> p.match("")
>>> print(p.match(""))
None

01 adalah nama dasar, dan

>>> p.match("")
>>> print(p.match(""))
None

02 adalah ekstensi nama file

Pola untuk mencocokkan ini cukup sederhana

>>> p.match("")
>>> print(p.match(""))
None

_03

Perhatikan bahwa

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_00 perlu diperlakukan secara khusus karena itu adalah metakarakter, jadi di dalam kelas karakter hanya cocok dengan karakter tertentu itu. Perhatikan juga tanda

>>> p = re.compile('ab*', re.IGNORECASE)

_65; . Ekspresi reguler ini cocok dengan

>>> p.match("")
>>> print(p.match(""))
None

06 dan

>>> p.match("")
>>> print(p.match(""))
None

07 dan

>>> p.match("")
>>> print(p.match(""))
None

08 dan

>>> p.match("")
>>> print(p.match(""))
None

Sekarang, pertimbangkan untuk sedikit memperumit masalah;

>>> p.match("")
>>> print(p.match(""))
None

11 Upaya pertama di atas mencoba untuk mengecualikan

>>> p.match("")
>>> print(p.match(""))
None

10 dengan mengharuskan karakter pertama dari ekstensi bukan

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

6. Ini salah, karena polanya juga tidak cocok

>>> p.match("")
>>> print(p.match(""))
None

>>> p.match("")
>>> print(p.match(""))
None

_15

Ekspresi menjadi lebih berantakan ketika Anda mencoba menambal solusi pertama dengan meminta salah satu kasus berikut untuk dicocokkan. karakter pertama ekstensi bukan

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

6; . Ini menerima

>>> p.match("")
>>> print(p.match(""))
None

_06 dan menolak

>>> p.match("")
>>> print(p.match(""))
None

07, tetapi membutuhkan ekstensi tiga huruf dan tidak akan menerima nama file dengan ekstensi dua huruf seperti

>>> p.match("")
>>> print(p.match(""))
None

08. Kami akan memperumit pola lagi dalam upaya untuk memperbaikinya

>>> p.match("")
>>> print(p.match(""))
None

_22

Pada upaya ketiga, huruf kedua dan ketiga semuanya dibuat opsional untuk memungkinkan pencocokan ekstensi yang lebih pendek dari tiga karakter, seperti

>>> p.match("")
>>> print(p.match(""))
None

Polanya menjadi sangat rumit sekarang, yang membuatnya sulit untuk dibaca dan dipahami. Lebih buruk lagi, jika masalahnya berubah dan Anda ingin mengecualikan

>>> p.match("")
>>> print(p.match(""))
None

10 dan

>>> p.match("")
>>> print(p.match(""))
None

25 sebagai ekstensi, polanya akan menjadi lebih rumit dan membingungkan

Pandangan ke depan yang negatif memotong semua kebingungan ini

>>> p.match("")
>>> print(p.match(""))
None

26 Arti pandangan ke depan negatif. jika ekspresi

>>> p.match("")
>>> print(p.match(""))
None

10 tidak cocok pada titik ini, coba sisa polanya; . Trailing

>>> p = re.compile('ab*', re.IGNORECASE)

65 diperlukan untuk memastikan bahwa sesuatu seperti

>>> p.match("")
>>> print(p.match(""))
None

30, di mana ekstensi hanya dimulai dengan

>>> p.match("")
>>> print(p.match(""))
None

10, akan diizinkan.

>>> p.match("")
>>> print(p.match(""))
None

32 memastikan bahwa pola tersebut berfungsi saat ada banyak titik di nama file

Mengecualikan ekstensi nama file lain kini menjadi mudah; . Pola berikut mengecualikan nama file yang diakhiri dengan

>>> p.match("")
>>> print(p.match(""))
None

10 atau

>>> p.match("")
>>> print(p.match(""))
None

>>> p.match("")
>>> print(p.match(""))
None

_35

Memodifikasi String

Hingga saat ini, kami hanya melakukan penelusuran terhadap string statis. Ekspresi reguler juga biasa digunakan untuk memodifikasi string dengan berbagai cara, menggunakan metode pola berikut

Metode/Atribut

Tujuan

>>> p.match("")
>>> print(p.match(""))
None

_36

Pisahkan string menjadi daftar, pisahkan di mana pun RE cocok

>>> p = re.compile('ab*', re.IGNORECASE)

_39

Temukan semua substring di mana RE cocok, dan ganti dengan string yang berbeda

>>> p.match("")
>>> print(p.match(""))
None

_38

Melakukan hal yang sama seperti

>>> p = re.compile('ab*', re.IGNORECASE)

39, tetapi mengembalikan string baru dan jumlah penggantian

Pemisahan String

Metode pola memisahkan string di mana pun RE cocok, mengembalikan daftar potongan. Ini mirip dengan metode string tetapi memberikan lebih banyak keumuman dalam pembatas yang dapat Anda pisahkan; . Seperti yang Anda harapkan, ada juga fungsi tingkat modul

. pisah(string[ , maxsplit=0])

Pisahkan string dengan kecocokan ekspresi reguler. Jika tanda kurung penangkap digunakan dalam RE, maka isinya juga akan dikembalikan sebagai bagian dari daftar yang dihasilkan. Jika maxsplit bukan nol, paling banyak maxsplit split dilakukan

Anda dapat membatasi jumlah pemisahan yang dilakukan, dengan memberikan nilai untuk pemisahan maksimal. Ketika maxsplit bukan nol, paling banyak pemisahan maxsplit akan dibuat, dan sisa string dikembalikan sebagai elemen terakhir dari daftar. Dalam contoh berikut, pembatas adalah urutan karakter non-alfanumerik

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

Terkadang Anda tidak hanya tertarik dengan teks di antara pembatas, tetapi juga perlu mengetahui pembatas itu. Jika menangkap tanda kurung digunakan dalam RE, maka nilainya juga dikembalikan sebagai bagian dari daftar. Bandingkan panggilan berikut

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

Fungsi tingkat modul menambahkan RE untuk digunakan sebagai argumen pertama, tetapi sebaliknya sama

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

Cari dan Ganti

Tugas umum lainnya adalah menemukan semua kecocokan untuk sebuah pola, dan menggantinya dengan string yang berbeda. Metode mengambil nilai pengganti, yang bisa berupa string atau fungsi, dan string yang akan diproses

. sub(pengganti , string[, count=0])

Mengembalikan string yang diperoleh dengan mengganti kejadian RE yang tidak tumpang tindih paling kiri dalam string dengan penggantian pengganti. Jika pola tidak ditemukan, string dikembalikan tanpa perubahan

Hitungan argumen opsional adalah jumlah maksimum kemunculan pola yang akan diganti; . Nilai default 0 berarti mengganti semua kejadian

Berikut adalah contoh sederhana penggunaan metode ini. Ini menggantikan nama warna dengan kata

>>> p.match("")
>>> print(p.match(""))
None

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

Metode melakukan pekerjaan yang sama, tetapi mengembalikan 2-tuple yang berisi nilai string baru dan jumlah penggantian yang dilakukan

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

Pencocokan kosong diganti hanya jika tidak bersebelahan dengan pencocokan kosong sebelumnya

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

Jika penggantian adalah string, garis miring terbalik apa pun yang lolos di dalamnya akan diproses. Yaitu,

>>> p.match("")
>>> print(p.match(""))
None

_49 diubah menjadi satu karakter baris baru,

>>> p.match("")
>>> print(p.match(""))
None

50 diubah menjadi carriage return, dan seterusnya. Pelarian yang tidak diketahui seperti

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

_74 dibiarkan sendiri. Referensi balik, seperti

>>> p.match("")
>>> print(p.match(""))
None

_52, diganti dengan substring yang cocok dengan grup yang sesuai di RE. Ini memungkinkan Anda menggabungkan bagian dari teks asli dalam string pengganti yang dihasilkan

Contoh ini cocok dengan kata

>>> p.match("")
>>> print(p.match(""))
None

53 diikuti dengan string yang disertakan dalam

>>> p.match("")
>>> print(p.match(""))
None

54,

>>> p.match("")
>>> print(p.match(""))
None

55, dan mengubah

>>> p.match("")
>>> print(p.match(""))
None

53 menjadi

>>> p.match("")
>>> print(p.match(""))
None

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

Ada juga sintaks untuk merujuk ke grup bernama seperti yang didefinisikan oleh sintaks ________147______88.

>>> p.match("")
>>> print(p.match(""))
None

_59 akan menggunakan substring yang cocok dengan grup bernama

>>> p.match("")
>>> print(p.match(""))
None

60, dan

>>> p.match("")
>>> print(p.match(""))
None

61 menggunakan nomor grup yang sesuai.

>>> p.match("")
>>> print(p.match(""))
None

_62 oleh karena itu setara dengan

>>> p.match("")
>>> print(p.match(""))
None

63, tetapi tidak ambigu dalam string pengganti seperti

>>> p.match("")
>>> print(p.match(""))
None

64. (

>>> p.match("")
>>> print(p.match(""))
None

65 akan ditafsirkan sebagai referensi ke grup 20, bukan referensi ke grup 2 diikuti oleh karakter literal

>>> p.match("")
>>> print(p.match(""))
None

66. ) Substitusi berikut semuanya setara, tetapi gunakan ketiga variasi string pengganti

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

penggantian juga bisa menjadi fungsi, yang memberi Anda lebih banyak kendali. Jika penggantian adalah sebuah fungsi, fungsi tersebut dipanggil untuk setiap kemunculan pola yang tidak tumpang tindih. Pada setiap pemanggilan, fungsi diberikan argumen untuk kecocokan dan dapat menggunakan informasi ini untuk menghitung string pengganti yang diinginkan dan mengembalikannya

Dalam contoh berikut, fungsi penggantian menerjemahkan desimal menjadi heksadesimal

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

Saat menggunakan fungsi tingkat modul, pola diteruskan sebagai argumen pertama. Pola dapat diberikan sebagai objek atau sebagai string; . g.

>>> p.match("")
>>> print(p.match(""))
None

_68 mengembalikan

>>> p.match("")
>>> print(p.match(""))
None

Masalah umum

Ekspresi reguler adalah alat yang ampuh untuk beberapa aplikasi, tetapi dalam beberapa hal perilakunya tidak intuitif dan terkadang tidak berperilaku seperti yang Anda harapkan. Bagian ini akan menunjukkan beberapa jebakan yang paling umum

Gunakan Metode String

Terkadang menggunakan modul adalah suatu kesalahan. Jika Anda mencocokkan string tetap, atau kelas karakter tunggal, dan Anda tidak menggunakan fitur apa pun seperti bendera, maka kekuatan penuh dari ekspresi reguler mungkin tidak diperlukan. String memiliki beberapa metode untuk melakukan operasi dengan string tetap dan biasanya jauh lebih cepat, karena penerapannya adalah loop C kecil tunggal yang telah dioptimalkan untuk tujuan tersebut, bukan mesin ekspresi reguler yang besar dan lebih umum.

Salah satu contoh mungkin mengganti satu string tetap dengan yang lain; . sepertinya fungsi yang digunakan untuk ini, tetapi pertimbangkan metodenya. Perhatikan bahwa

>>> p.match("")
>>> print(p.match(""))
None

_76 juga akan menggantikan

>>> p.match("")
>>> print(p.match(""))
None

73 di dalam kata-kata, mengubah

>>> p.match("")
>>> print(p.match(""))
None

79 menjadi

>>> p.match("")
>>> print(p.match(""))
None

80, tetapi RE naif

>>> p.match("")
>>> print(p.match(""))
None

73 akan melakukan itu juga. (Untuk menghindari melakukan substitusi pada bagian kata, polanya harus

>>> p.match("")
>>> print(p.match(""))
None

82, untuk mensyaratkan bahwa

>>> p.match("")
>>> print(p.match(""))
None

73 memiliki batas kata di kedua sisi. Ini mengambil pekerjaan di luar kemampuan

>>> p.match("")
>>> print(p.match(""))
None

_76. )

Tugas umum lainnya adalah menghapus setiap kemunculan karakter tunggal dari sebuah string atau menggantinya dengan karakter tunggal lainnya. Anda mungkin melakukan ini dengan sesuatu seperti

>>> p.match("")
>>> print(p.match(""))
None

_85, tetapi mampu melakukan kedua tugas dan akan lebih cepat daripada operasi ekspresi reguler apa pun

Singkatnya, sebelum beralih ke modul, pertimbangkan apakah masalah Anda dapat diselesaikan dengan metode string yang lebih cepat dan sederhana

cocok() versus pencarian()

Fungsi hanya memeriksa apakah RE cocok di awal string sementara akan memindai ke depan melalui string untuk mencari kecocokan. Penting untuk mengingat perbedaan ini. Ingat,

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

_99 hanya akan melaporkan pertandingan sukses yang akan dimulai dari 0;

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

Di sisi lain, akan memindai ke depan melalui string, melaporkan kecocokan pertama yang ditemukannya

>>> p.match("")
>>> print(p.match(""))
None

Terkadang Anda akan tergoda untuk tetap menggunakan , dan tambahkan saja

>>> p.match("")
>>> print(p.match(""))
None

94 ke depan RE Anda. Tahan godaan ini dan gunakan sebagai gantinya. Kompiler ekspresi reguler melakukan beberapa analisis RE untuk mempercepat proses pencarian kecocokan. Salah satu analisis semacam itu menentukan karakter pertama dari suatu pertandingan; . Analisis memungkinkan mesin dengan cepat memindai melalui string mencari karakter awal, hanya mencoba kecocokan penuh jika

>>> p.match("")
>>> print(p.match(""))
None

97 ditemukan

Menambahkan

>>> p.match("")
>>> print(p.match(""))
None

_94 mengalahkan pengoptimalan ini, membutuhkan pemindaian hingga akhir string dan kemudian mundur untuk menemukan kecocokan untuk sisa RE. Gunakan sebagai gantinya

Serakah versus Tidak Serakah

Saat mengulangi ekspresi reguler, seperti pada

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

01, tindakan yang dihasilkan adalah menggunakan pola sebanyak mungkin. Fakta ini sering mengganggu Anda saat Anda mencoba mencocokkan sepasang pembatas yang seimbang, seperti tanda kurung sudut yang mengelilingi tag HTML. Pola naif untuk mencocokkan satu tag HTML tidak berfungsi karena sifat serakah dari

>>> p.match("")
>>> print(p.match(""))
None

>>> p.match("")
>>> print(p.match(""))
None

RE cocok dengan

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

03 di

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

04, dan

>>> p.match("")
>>> print(p.match(""))
None

94 menggunakan sisa string. Namun, masih ada lagi yang tersisa di RE, dan

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

06 tidak dapat cocok di akhir string, jadi mesin ekspresi reguler harus mundur karakter demi karakter hingga menemukan kecocokan untuk

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

06. Pertandingan final dimulai dari

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

_03 di

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

04 hingga

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

10 di

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

11, yang bukan itu yang Anda inginkan

Dalam hal ini, solusinya adalah dengan menggunakan pembilang non-rakus

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

12,

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

13,

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

14, atau

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

15, yang cocok dengan teks sesedikit mungkin. Dalam contoh di atas,

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

_10 dicoba segera setelah

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

_03 pertama cocok, dan ketika gagal, mesin memajukan karakter pada satu waktu, mencoba lagi

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

10 di setiap langkah. Ini menghasilkan hasil yang tepat

>>> p.match("")
>>> print(p.match(""))
None

(Perhatikan bahwa mem-parsing HTML atau XML dengan ekspresi reguler itu menyakitkan. Pola cepat dan kotor akan menangani kasus umum, tetapi HTML dan XML memiliki kasus khusus yang akan merusak ekspresi reguler yang jelas; . Gunakan modul pengurai HTML atau XML untuk tugas semacam itu. )

Menggunakan re. VERBOSE

Sekarang Anda mungkin telah memperhatikan bahwa ekspresi reguler adalah notasi yang sangat ringkas, tetapi tidak terlalu mudah dibaca. RE dengan kompleksitas sedang dapat menjadi kumpulan garis miring terbalik, tanda kurung, dan karakter meta yang panjang, membuatnya sulit untuk dibaca dan dipahami

Untuk RE seperti itu, menentukan flag saat mengompilasi ekspresi reguler dapat membantu, karena memungkinkan Anda untuk memformat ekspresi reguler dengan lebih jelas

Bendera

>>> p = re.compile('ab*', re.IGNORECASE)

_44 memiliki beberapa efek. Spasi kosong dalam ekspresi reguler yang tidak ada di dalam kelas karakter akan diabaikan. Ini berarti ekspresi seperti

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

_21 setara dengan

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

22 yang kurang mudah dibaca, tetapi

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

23 akan tetap cocok dengan karakter

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

17, atau spasi. Selain itu, Anda juga dapat memasukkan komentar ke dalam RE; . Saat digunakan dengan string dengan kutip tiga, ini memungkinkan RE diformat dengan lebih rapi

>>> p.match("")
>>> print(p.match(""))
None

Ini jauh lebih mudah dibaca daripada

>>> p.match("")
>>> print(p.match(""))
None

Masukan

Ekspresi reguler adalah topik yang rumit. Apakah dokumen ini membantu Anda memahaminya?

Buku terlengkap tentang ekspresi reguler hampir pasti adalah Mastering Regular Expressions karya Jeffrey Friedl, diterbitkan oleh O'Reilly. Sayangnya, ini secara eksklusif berkonsentrasi pada ekspresi reguler Perl dan Java, dan tidak mengandung materi Python sama sekali, sehingga tidak akan berguna sebagai referensi untuk pemrograman dengan Python. (Edisi pertama mencakup modul

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

27 Python yang sekarang sudah dihapus, yang tidak akan banyak membantu Anda. ) Pertimbangkan untuk memeriksanya dari perpustakaan Anda

Bagaimana Anda menemukan kecocokan antara dua string dengan Python?

Anda dapat membandingkan string dengan Python menggunakan persamaan ( == ) dan perbandingan ( < , > ,. = , . Tidak ada metode khusus untuk membandingkan dua string. Dalam artikel ini, Anda akan mempelajari cara kerja masing-masing operator saat membandingkan string.

Bagaimana cara menemukan pola yang cocok dengan Python?

Cara melakukan pencocokan pola dengan Python .

Menggunakan re. fungsi pencarian()

Menggunakan re. pertandingan() Fungsi

Menggunakan re. fullmatch() Fungsi

Menggunakan re. findall() Fungsi

Menggunakan re. finditer() Fungsi

Bagaimana cara mengekstrak pola tertentu dari sebuah string dengan Python?

Gunakan kembali. search() untuk mengekstrak substring yang cocok dengan pola ekspresi reguler . Tentukan pola ekspresi reguler sebagai parameter pertama dan string target sebagai parameter kedua. \d cocok dengan karakter digit, dan + cocok dengan satu atau lebih pengulangan dari pola sebelumnya.