String ganti python case tidak sensitif
|
Baik pola maupun string yang akan dicari dapat berupa string Unicode() maupun string 8-bit(). Namun, string Unicode dan string 8-bit tidak dapat dicampur. yaitu, Anda tidak dapat mencocokkan string Unicode dengan pola byte atau sebaliknya; Show
Ekspresi reguler menggunakan karakter garis miring terbalik ( prog = re.compile(pattern) result = prog.match(string)4) untuk menunjukkan bentuk khusus atau untuk mengizinkan karakter khusus digunakan tanpa menyebutkan arti khusus mereka. Ini bertabrakan dengan penggunaan karakter yang sama oleh Python untuk tujuan yang sama dalam literal string; . Juga, harap perhatikan bahwa urutan escape yang tidak valid dalam penggunaan garis miring terbalik di Python dalam string literal sekarang menghasilkan a dan di masa mendatang ini akan menjadi a. Perilaku ini akan terjadi meskipun merupakan urutan escape yang valid untuk ekspresi reguler Solusinya adalah menggunakan notasi string mentah Python untuk pola ekspresi reguler; . Jadi result = re.match(pattern, string)_1 adalah string dua karakter yang berisi prog = re.compile(pattern) result = prog.match(string)4 dan result = re.match(pattern, string)3, sedangkan result = re.match(pattern, string)4 adalah string satu karakter yang berisi baris baru. Biasanya pola akan diekspresikan dalam kode Python menggunakan notasi string mentah ini Penting untuk dicatat bahwa sebagian besar operasi ekspresi reguler tersedia sebagai fungsi dan metode tingkat modul. Fungsinya adalah pintasan yang tidak mengharuskan Anda untuk mengompilasi objek regex terlebih dahulu, tetapi melewatkan beberapa parameter penyempurnaan Lihat juga Modul regex pihak ketiga, yang memiliki API yang kompatibel dengan modul pustaka standar, tetapi menawarkan fungsionalitas tambahan dan dukungan Unicode yang lebih menyeluruh Sintaks Ekspresi RegulerEkspresi reguler (atau RE) menentukan sekumpulan string yang cocok dengannya; Ekspresi reguler dapat digabungkan untuk membentuk ekspresi reguler baru; . Secara umum, jika senar p cocok dengan A dan senar lain q cocok dengan B, maka senar pq akan cocok dengan AB. Ini berlaku kecuali A atau B berisi operasi dengan prioritas rendah; . Dengan demikian, ekspresi kompleks dapat dengan mudah dibangun dari ekspresi primitif yang lebih sederhana seperti yang dijelaskan di sini. Untuk perincian teori dan implementasi ekspresi reguler, lihat buku Friedl , atau hampir semua buku teks tentang konstruksi kompiler Penjelasan singkat tentang format ekspresi reguler berikut. Untuk informasi lebih lanjut dan presentasi yang lebih lembut, lihat Ekspresi reguler dapat berisi karakter khusus dan biasa. Sebagian besar karakter biasa, seperti result = re.match(pattern, string)_6, result = re.match(pattern, string)7, atau result = re.match(pattern, string)8, adalah ekspresi reguler yang paling sederhana; . Anda dapat menggabungkan karakter biasa, jadi result = re.match(pattern, string)9 cocok dengan string >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']0. (Di sisa bagian ini, kami akan menulis RE di >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']1, biasanya tanpa tanda kutip, dan string untuk dicocokkan >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']2. ) Beberapa karakter, seperti >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']_3 atau >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']4, bersifat spesial. Karakter khusus mewakili kelas karakter biasa, atau memengaruhi cara ekspresi reguler di sekitarnya ditafsirkan Pengulangan operator atau bilangan ( >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']5, >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']6, >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']7, >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']8, dll) tidak dapat langsung disarangkan. Ini menghindari ambiguitas dengan akhiran pengubah non-rakus >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']7, dan dengan pengubah lain dalam implementasi lain. Untuk menerapkan pengulangan kedua ke pengulangan dalam, tanda kurung dapat digunakan. Misalnya, ekspresi >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']_0 cocok dengan kelipatan enam result = re.match(pattern, string)7 karakter Karakter khusus adalah >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']_2 (Dot. ) Dalam mode default, ini cocok dengan karakter apa pun kecuali baris baru. Jika flag telah ditentukan, ini cocok dengan karakter apa pun termasuk baris baru >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']_4 (Tanda sisipan. ) Cocok dengan awal string, dan dalam mode juga cocok segera setelah setiap baris baru >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']_6 Mencocokkan akhir string atau tepat sebelum baris baru di akhir string, dan dalam mode juga cocok sebelum baris baru. >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']8 cocok dengan 'foo' dan 'foobar', sedangkan ekspresi reguler >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']9 hanya cocok dengan 'foo'. Lebih menarik lagi, mencari >>> re.split(r'\b', 'Words, words, words.') ['', 'Words', ', ', 'words', ', ', 'words', '.'] >>> re.split(r'\W*', '...words...') ['', '', 'w', 'o', 'r', 'd', 's', '', ''] >>> re.split(r'(\W*)', '...words...') ['', '...', '', '', 'w', '', 'o', '', 'r', '', 'd', '', 's', '...', '', '', '']_0 di >>> re.split(r'\b', 'Words, words, words.') ['', 'Words', ', ', 'words', ', ', 'words', '.'] >>> re.split(r'\W*', '...words...') ['', '', 'w', 'o', 'r', 'd', 's', '', ''] >>> re.split(r'(\W*)', '...words...') ['', '...', '', '', 'w', '', 'o', '', 'r', '', 'd', '', 's', '...', '', '', '']1 biasanya cocok dengan 'foo2', tetapi 'foo1' dalam mode; . satu tepat sebelum baris baru, dan satu lagi di akhir string >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']5 Menyebabkan RE yang dihasilkan cocok dengan 0 atau lebih pengulangan dari RE sebelumnya, sebanyak mungkin pengulangan. >>> re.split(r'\b', 'Words, words, words.') ['', 'Words', ', ', 'words', ', ', 'words', '.'] >>> re.split(r'\W*', '...words...') ['', '', 'w', 'o', 'r', 'd', 's', '', ''] >>> re.split(r'(\W*)', '...words...') ['', '...', '', '', 'w', '', 'o', '', 'r', '', 'd', '', 's', '...', '', '', '']6 akan cocok dengan 'a', 'ab', atau 'a' diikuti dengan sejumlah 'b' >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']6 Menyebabkan RE yang dihasilkan cocok dengan 1 atau lebih pengulangan dari RE sebelumnya. >>> re.split(r'\b', 'Words, words, words.') ['', 'Words', ', ', 'words', ', ', 'words', '.'] >>> re.split(r'\W*', '...words...') ['', '', 'w', 'o', 'r', 'd', 's', '', ''] >>> re.split(r'(\W*)', '...words...') ['', '...', '', '', 'w', '', 'o', '', 'r', '', 'd', '', 's', '...', '', '', '']8 akan cocok dengan 'a' diikuti dengan angka 'b' yang bukan nol; >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']7 Menyebabkan RE yang dihasilkan cocok dengan 0 atau 1 pengulangan dari RE sebelumnya. >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'00 akan cocok dengan 'a' atau 'ab' >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'01, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'02, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'03 Kuantifikasi >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'_04, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'05, dan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'06 semuanya serakah; . Terkadang perilaku ini tidak diinginkan; . Menambahkan >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']_7 setelah quantifier membuatnya melakukan pertandingan dengan cara yang tidak serakah atau minimal; . Menggunakan RE >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'_11 hanya akan cocok dengan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'09 >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'13, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'14, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'15 Seperti bilangan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'04, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'05, dan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'06, yang mana >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'05 ditambahkan juga cocok sebanyak mungkin. Namun, tidak seperti bilangan serakah yang sebenarnya, ini tidak memungkinkan pelacakan balik ketika ekspresi yang mengikutinya gagal untuk dicocokkan. Ini dikenal sebagai bilangan posesif. Misalnya, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'20 akan cocok dengan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'21 karena >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'22 akan cocok dengan semua 4 result = re.match(pattern, string)7s, tetapi, ketika result = re.match(pattern, string)7 terakhir ditemukan, ekspresi mundur sehingga pada akhirnya >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'2__ akhirnya cocok dengan 3 result = re.match(pattern, string)4_______4 yang cocok dengan__7s total, dan total _______4____7s keempat, dan total _______4____7s keempat . Namun, ketika >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'29 digunakan untuk mencocokkan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'21, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'31 akan cocok dengan semua 4 result = re.match(pattern, string)7, tetapi ketika result = re.match(pattern, string)7 terakhir gagal menemukan karakter lain untuk dicocokkan, ekspresi tidak dapat dilacak mundur dan karenanya akan gagal untuk dicocokkan. >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'34, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'35 dan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'36 setara dengan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'37, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'38 dan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'39.
>>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'_40 Menentukan bahwa tepat m salinan dari RE sebelumnya harus dicocokkan; . Misalnya, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'41 akan sama persis dengan enam result = re.match(pattern, string)7 karakter, tetapi bukan lima >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']8 Menyebabkan RE yang dihasilkan cocok dari m ke n repetisi dari RE sebelumnya, berusaha mencocokkan repetisi sebanyak mungkin. Misalnya, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'44 akan cocok dari 3 hingga 5 result = re.match(pattern, string)7 karakter. Menghilangkan m menentukan batas bawah nol, dan menghilangkan n menentukan batas atas tak hingga. Sebagai contoh, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'46 akan cocok dengan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'47 atau seribu result = re.match(pattern, string)7 karakter diikuti dengan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'49, tetapi bukan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'50. Koma tidak boleh dihilangkan atau pengubah akan bingung dengan bentuk yang dijelaskan sebelumnya >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'51 Menyebabkan RE yang dihasilkan cocok dari pengulangan m ke n dari RE sebelumnya, berusaha untuk mencocokkan pengulangan sesedikit mungkin. Ini adalah versi non-rakus dari quantifier sebelumnya. Misalnya, pada string 6 karakter >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'52, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'44 akan cocok dengan 5 result = re.match(pattern, string)7 karakter, sedangkan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'55 hanya akan cocok dengan 3 karakter >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'56 Menyebabkan RE yang dihasilkan cocok dari m ke n repetisi dari RE sebelumnya, berusaha mencocokkan repetisi sebanyak mungkin tanpa membuat titik backtracking. Ini adalah versi posesif dari quantifier di atas. Misalnya, pada string 6 karakter >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'52, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'58 mencoba mencocokkan 5 result = re.match(pattern, string)7 karakter, kemudian, membutuhkan 2 result = re.match(pattern, string)7 lagi, akan membutuhkan lebih banyak karakter daripada yang tersedia dan dengan demikian gagal, sementara >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'61 akan cocok dengan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'44 menangkap 5, lalu 4 _____________ . >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'66 setara dengan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'67 Baru di versi 3. 11 >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'_68 Entah lolos dari karakter khusus (memungkinkan Anda untuk mencocokkan karakter seperti >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'04, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'06, dan sebagainya), atau menandakan urutan khusus; Jika Anda tidak menggunakan string mentah untuk mengekspresikan pola, ingatlah bahwa Python juga menggunakan garis miring terbalik sebagai escape sequence dalam literal string; . Namun, jika Python mengenali urutan yang dihasilkan, garis miring terbalik harus diulang dua kali. Ini rumit dan sulit dipahami, jadi sangat disarankan agar Anda menggunakan string mentah untuk semua ekspresi kecuali yang paling sederhana >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'71 Digunakan untuk menunjukkan sekumpulan karakter. Dalam satu set
Berubah di versi 3. 7. dimunculkan jika kumpulan karakter berisi konstruksi yang akan berubah secara semantik di masa mendatang. \a \b \f \n \N \r \t \u \U \v \x \\_12 \a \b \f \n \N \r \t \u \U \v \x \\_13, di mana A dan B dapat berupa RE arbitrer, membuat ekspresi reguler yang cocok dengan A atau B. Jumlah RE yang berubah-ubah dapat dipisahkan oleh >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']3 dengan cara ini. Ini juga dapat digunakan di dalam grup (lihat di bawah). Saat string target dipindai, RE yang dipisahkan oleh >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']3 dicoba dari kiri ke kanan. Ketika satu pola benar-benar cocok, cabang itu diterima. Ini berarti bahwa setelah A cocok, B tidak akan diuji lebih lanjut, meskipun akan menghasilkan kecocokan keseluruhan yang lebih lama. Dengan kata lain, operator >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']_3 tidak pernah serakah. Untuk mencocokkan >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']_3 literal, gunakan \a \b \f \n \N \r \t \u \U \v \x \\18, atau sertakan di dalam kelas karakter, seperti pada \a \b \f \n \N \r \t \u \U \v \x \\19 \a \b \f \n \N \r \t \u \U \v \x \\_20 Mencocokkan ekspresi reguler apa pun yang ada di dalam tanda kurung, dan menunjukkan awal dan akhir grup; . Untuk mencocokkan literal >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']_4 atau >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'91, gunakan \a \b \f \n \N \r \t \u \U \v \x \\24 atau \a \b \f \n \N \r \t \u \U \v \x \\25, atau sertakan di dalam kelas karakter. \a \b \f \n \N \r \t \u \U \v \x \\_26, \a \b \f \n \N \r \t \u \U \v \x \\27 \a \b \f \n \N \r \t \u \U \v \x \\_28 Ini adalah notasi ekstensi (a >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'06 setelah >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']4 tidak berarti sebaliknya). Karakter pertama setelah >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'_06 menentukan apa arti dan sintaks konstruk lebih lanjut. Ekstensi biasanya tidak membuat grup baru; . Berikut ini adalah ekstensi yang saat ini didukung \a \b \f \n \N \r \t \u \U \v \x \\_33 (Satu atau lebih huruf dari himpunan result = re.match(pattern, string)7, \a \b \f \n \N \r \t \u \U \v \x \\35, \a \b \f \n \N \r \t \u \U \v \x \\36, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'74, \a \b \f \n \N \r \t \u \U \v \x \\38, \a \b \f \n \N \r \t \u \U \v \x \\39, \a \b \f \n \N \r \t \u \U \v \x \\40. ) Grup cocok dengan string kosong; . (pencocokan khusus ASCII), (abaikan huruf besar/kecil), (bergantung pada lokal), (multi-baris), (titik cocok dengan semua), \a \b \f \n \N \r \t \u \U \v \x \\46 (pencocokan Unicode), dan (verbose), untuk seluruh ekspresi reguler. (Bendera dijelaskan dalam. ) Ini berguna jika Anda ingin menyertakan flag sebagai bagian dari ekspresi reguler, alih-alih meneruskan argumen flag ke fungsi. Bendera harus digunakan terlebih dahulu dalam string ekspresi Berubah di versi 3. 11. Konstruksi ini hanya dapat digunakan di awal ekspresi. \a \b \f \n \N \r \t \u \U \v \x \\_49 Versi tanda kurung biasa yang tidak menangkap. Mencocokkan ekspresi reguler apa pun yang ada di dalam tanda kurung, tetapi substring yang cocok dengan grup tidak dapat diambil setelah melakukan pencocokan atau direferensikan nanti dalam pola \a \b \f \n \N \r \t \u \U \v \x \\_50 (Zero or more letters from the set result = re.match(pattern, string)7, \a \b \f \n \N \r \t \u \U \v \x \\35, \a \b \f \n \N \r \t \u \U \v \x \\36, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'74, \a \b \f \n \N \r \t \u \U \v \x \\38, \a \b \f \n \N \r \t \u \U \v \x \\39, \a \b \f \n \N \r \t \u \U \v \x \\40, optionally followed by >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'76 followed by one or more letters from the \a \b \f \n \N \r \t \u \U \v \x \\35, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'74, \a \b \f \n \N \r \t \u \U \v \x \\38, \a \b \f \n \N \r \t \u \U \v \x \\40. ) Huruf mengatur atau menghapus bendera yang sesuai. (pencocokan khusus ASCII), (abaikan huruf besar/kecil), (bergantung pada lokal), (multi-baris), (titik cocok dengan semua), \a \b \f \n \N \r \t \u \U \v \x \\46 (pencocokan Unicode), dan (verbose), untuk bagian ekspresi. (Bendera dijelaskan dalam. ) Huruf result = re.match(pattern, string)_7, \a \b \f \n \N \r \t \u \U \v \x \\36 dan \a \b \f \n \N \r \t \u \U \v \x \\39 saling eksklusif saat digunakan sebagai bendera sebaris, sehingga tidak dapat digabungkan atau mengikuti >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'76. Alih-alih, ketika salah satu dari mereka muncul di grup sebaris, mode pencocokan di grup terlampir akan diganti. Dalam pola Unicode \a \b \f \n \N \r \t \u \U \v \x \\_74 beralih ke pencocokan khusus ASCII, dan \a \b \f \n \N \r \t \u \U \v \x \\75 beralih ke pencocokan Unicode (default). Dalam pola byte \a \b \f \n \N \r \t \u \U \v \x \\76 beralih ke pencocokan tergantung lokal, dan \a \b \f \n \N \r \t \u \U \v \x \\74 beralih ke pencocokan khusus ASCII (default). Penimpaan ini hanya berlaku untuk grup sebaris sempit, dan mode pencocokan asli dipulihkan di luar grup Baru di versi 3. 6 Berubah di versi 3. 7. Huruf result = re.match(pattern, string)7, \a \b \f \n \N \r \t \u \U \v \x \\36 dan \a \b \f \n \N \r \t \u \U \v \x \\39 juga dapat digunakan dalam grup. \a \b \f \n \N \r \t \u \U \v \x \\_81 Upaya untuk mencocokkan \a \b \f \n \N \r \t \u \U \v \x \\_82 seolah-olah itu adalah ekspresi reguler yang terpisah, dan jika berhasil, terus mencocokkan sisa pola yang mengikutinya. Jika pola selanjutnya gagal untuk dicocokkan, tumpukan hanya dapat dibatalkan ke titik sebelum \a \b \f \n \N \r \t \u \U \v \x \\81 karena setelah keluar, ekspresi, yang dikenal sebagai grup atom, telah membuang semua titik tumpukan di dalam dirinya sendiri. Jadi, \a \b \f \n \N \r \t \u \U \v \x \\84 tidak akan pernah cocok dengan apa pun karena pertama \a \b \f \n \N \r \t \u \U \v \x \\85 akan cocok dengan semua karakter yang mungkin, kemudian, karena tidak ada yang tersisa untuk dicocokkan, >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']2 terakhir akan gagal cocok. Karena tidak ada titik tumpukan yang disimpan di Grup Atom, dan tidak ada titik tumpukan sebelumnya, seluruh ekspresi akan gagal dicocokkan Baru di versi 3. 11 \a \b \f \n \N \r \t \u \U \v \x \\_32 Mirip dengan tanda kurung biasa, tetapi substring yang cocok dengan grup dapat diakses melalui nama nama grup simbolik. Nama grup harus berupa pengidentifikasi Python yang valid, dan setiap nama grup harus ditentukan hanya sekali dalam ekspresi reguler. Grup simbolik juga merupakan grup bernomor, sama seperti jika grup tersebut tidak diberi nama Grup bernama dapat dirujuk dalam tiga konteks. Jika polanya adalah \a \b \f \n \N \r \t \u \U \v \x \\_88 (i. e. mencocokkan string yang dikutip dengan tanda kutip tunggal atau ganda) Konteks referensi ke grup "kutipan" Cara untuk merujuknya dalam pola yang sama itu sendiri
saat memproses objek yang cocok m
dalam sebuah string diteruskan ke argumen repl dari \a \b \f \n \N \r \t \u \U \v \x \\93
Tidak digunakan lagi sejak versi 3. 11. Nama grup berisi karakter non-ASCII dalam pola byte. \a \b \f \n \N \r \t \u \U \v \x \\_97 Referensi balik ke grup bernama; \a \b \f \n \N \r \t \u \U \v \x \\_98 Komentar; \a \b \f \n \N \r \t \u \U \v \x \\_99 Cocok jika \a \b \f \n \N \r \t \u \U \v \x \\82 cocok berikutnya, tetapi tidak menggunakan string apa pun. Ini disebut pernyataan lookahead. Misalnya, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_01 akan cocok dengan def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)02 hanya jika diikuti oleh def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)03 def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_04 Cocok jika \a \b \f \n \N \r \t \u \U \v \x \\_82 tidak cocok berikutnya. Ini adalah pernyataan pandangan ke depan yang negatif. Misalnya, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)06 akan cocok dengan def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)02 hanya jika tidak diikuti oleh def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)03 def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_09 Cocok jika posisi saat ini dalam string didahului oleh kecocokan untuk \a \b \f \n \N \r \t \u \U \v \x \\82 yang berakhir pada posisi saat ini. Ini disebut pernyataan pandangan positif di balik. def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_11 akan menemukan kecocokan di def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)12, karena lookbehind akan mencadangkan 3 karakter dan memeriksa apakah pola yang ada cocok. Pola yang terkandung hanya boleh cocok dengan string dengan panjang tetap, artinya def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)13 atau def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)14 diperbolehkan, tetapi >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'22 dan def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)16 tidak. Perhatikan bahwa pola yang dimulai dengan pernyataan lookbehind positif tidak akan cocok di awal string yang dicari; >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def' Contoh ini mencari kata setelah tanda hubung >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg' Berubah di versi 3. 5. Menambahkan dukungan untuk referensi grup dengan panjang tetap. def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_19 Cocok jika posisi saat ini dalam string tidak didahului oleh kecocokan untuk \a \b \f \n \N \r \t \u \U \v \x \\82. Ini disebut pandangan negatif di balik pernyataan. Mirip dengan pernyataan lookbehind positif, pola yang terkandung hanya harus cocok dengan string dengan panjang tetap. Pola yang dimulai dengan pernyataan lookbehind negatif mungkin cocok di awal string yang sedang dicari def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_21 Akan mencoba mencocokkan dengan def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_22 jika grup dengan id atau nama yang diberikan ada, dan dengan def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)23 jika tidak. def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_23 adalah opsional dan dapat dihilangkan. Misalnya, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_25 adalah pola pencocokan email yang buruk, yang akan cocok dengan def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)26 serta def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)27, tetapi tidak dengan def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)28 atau def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)29 Tidak digunakan lagi sejak versi 3. 11. Id grup berisi apa pun kecuali digit ASCII. Urutan khusus terdiri dari prog = re.compile(pattern) result = prog.match(string)_4 dan karakter dari daftar di bawah ini. Jika karakter biasa bukan digit ASCII atau huruf ASCII, maka RE yang dihasilkan akan cocok dengan karakter kedua. Misalnya, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_31 cocok dengan karakter def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)32 \a \b \f \n \N \r \t \u \U \v \x \\_21 Mencocokkan isi grup dengan nomor yang sama. Kelompok diberi nomor mulai dari 1. Misalnya, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)34 cocok dengan def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)35 atau def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)36, tetapi tidak def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)37 (perhatikan spasi setelah grup). Urutan khusus ini hanya dapat digunakan untuk mencocokkan salah satu dari 99 grup pertama. Jika digit pertama angka adalah 0, atau angka panjangnya 3 digit oktal, itu tidak akan ditafsirkan sebagai pasangan yang cocok, tetapi sebagai karakter dengan angka nilai oktal. Di dalam \a \b \f \n \N \r \t \u \U \v \x \\06 dan \a \b \f \n \N \r \t \u \U \v \x \\02 dari kelas karakter, semua pelolosan numerik diperlakukan sebagai karakter def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_40 Cocok hanya di awal string def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_41 Mencocokkan string kosong, tetapi hanya di awal atau akhir kata. Kata didefinisikan sebagai urutan karakter kata. Perhatikan bahwa secara formal, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_41 didefinisikan sebagai batas antara >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'92 dan def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)44 karakter (atau sebaliknya), atau antara >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'92 dan awal/akhir string. Ini berarti bahwa def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_46 cocok dengan def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)47, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)48, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)49, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)50 tetapi tidak def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)51 atau def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)52 Secara default, alfanumerik Unicode adalah yang digunakan dalam pola Unicode, tetapi ini dapat diubah dengan menggunakan flag. Batas kata ditentukan oleh lokal saat ini jika bendera digunakan. Di dalam rentang karakter, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_41 mewakili karakter backspace, untuk kompatibilitas dengan literal string Python def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_56 Mencocokkan string kosong, tetapi hanya jika tidak berada di awal atau akhir kata. Ini berarti bahwa def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_57 cocok dengan def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)58, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)59, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)60, tetapi tidak def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)61, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)62, atau def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)63. def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_56 adalah kebalikan dari def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)41, jadi karakter kata dalam pola Unicode adalah alfanumerik Unicode atau garis bawah, meskipun ini dapat diubah dengan menggunakan bendera. Batas kata ditentukan oleh lokal saat ini jika bendera digunakan def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_68Untuk pola Unicode (str). Cocok dengan digit desimal Unicode apa pun (yaitu, karakter apa pun dalam kategori karakter Unicode [Nd]). Ini termasuk def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_69, dan juga banyak karakter digit lainnya. Jika bendera yang digunakan hanya ________223______69 yang cocokUntuk pola 8-bit (byte). Cocok dengan digit desimal apa pun; def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_73 Mencocokkan karakter apa pun yang bukan angka desimal. Ini kebalikan dari def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_68. Jika bendera digunakan, ini menjadi setara dengan def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)76 def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_77Untuk pola Unicode (str). Mencocokkan karakter spasi putih Unicode (termasuk def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)78, dan juga banyak karakter lainnya, misalnya spasi tanpa putus yang diamanatkan oleh aturan tipografi dalam banyak bahasa). Jika bendera digunakan, hanya ________223______78 yang cocokUntuk pola 8-bit (byte). Mencocokkan karakter yang dianggap spasi kosong dalam rangkaian karakter ASCII; >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'_93 Cocok dengan karakter apa pun yang bukan karakter spasi. Ini kebalikan dari def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)77. Jika bendera digunakan, ini menjadi setara dengan def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)85 >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'92Untuk pola Unicode (str). Mencocokkan karakter kata Unicode; . Jika bendera digunakan, hanya ________223______90 yang cocok Untuk pola 8-bit (byte).Mencocokkan karakter yang dianggap alfanumerik dalam kumpulan karakter ASCII; . Jika flag digunakan, cocokkan dengan karakter yang dianggap alfanumerik di lokal saat ini dan garis bawah def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_44 Cocok dengan karakter apa pun yang bukan karakter kata. Ini kebalikan dari >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'_92. Jika bendera digunakan, ini menjadi setara dengan def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)96. Jika flag digunakan, cocokkan dengan karakter yang bukan alfanumerik di lokal saat ini maupun garis bawah def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_98 Cocok hanya di akhir string Sebagian besar pelolosan standar yang didukung oleh literal string Python juga diterima oleh parser ekspresi reguler \a \b \f \n \N \r \t \u \U \v \x \\ (Perhatikan bahwa def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)41 digunakan untuk mewakili batas kata, dan berarti "menghapus" hanya di dalam kelas karakter. ) a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_00, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")01, dan a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")02 escape sequence hanya dikenali dalam pola Unicode. Dalam pola byte mereka adalah kesalahan. Pelepasan huruf ASCII yang tidak diketahui dicadangkan untuk penggunaan di masa mendatang dan diperlakukan sebagai kesalahan Pelepasan oktal disertakan dalam bentuk terbatas. Jika digit pertama adalah 0, atau jika ada tiga digit oktal, ini dianggap sebagai pelarian oktal. Kalau tidak, itu adalah referensi grup. Sedangkan untuk literal string, escape oktal selalu memiliki panjang paling banyak tiga digit Berubah di versi 3. 3. Escape sequence a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")00 dan a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")01 telah ditambahkan. Berubah di versi 3. 6. Pelolosan tidak dikenal yang terdiri dari prog = re.compile(pattern) result = prog.match(string)4 dan huruf ASCII sekarang adalah kesalahan. Berubah di versi 3. 8. Urutan escape a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")06 telah ditambahkan. Seperti dalam string literal, ini diperluas ke karakter Unicode bernama (mis. g. a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_07). Isi ModulModul mendefinisikan beberapa fungsi, konstanta, dan pengecualian. Beberapa fungsi adalah versi sederhana dari metode berfitur lengkap untuk ekspresi reguler terkompilasi. Sebagian besar aplikasi non-sepele selalu menggunakan formulir yang dikompilasi BenderaBerubah di versi 3. 6. Konstanta flag sekarang adalah turunan dari , yang merupakan subkelas dari. kelas re. RegexFlagKelas yang berisi opsi regex yang tercantum di bawah ini Baru di versi 3. 11. - ditambahkan ke a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")11re. Are. ASCII Jadikan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'_92, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)44, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)41, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)56, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)68, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)73, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)77 dan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'93 melakukan pencocokan khusus ASCII, bukan pencocokan penuh ASCII. Ini hanya berarti untuk pola Unicode, dan diabaikan untuk pola byte. Sesuai dengan bendera sebaris a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")20 Perhatikan bahwa untuk kompatibilitas mundur, flag \a \b \f \n \N \r \t \u \U \v \x \\_46 masih ada (serta sinonimnya a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")22 dan pasangan tersematnya a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")23), tetapi ini berlebihan dalam Python 3 karena kecocokan adalah Unicode secara default untuk string (dan pencocokan Unicode tidak diizinkan untuk byte re. DEBUG Tampilkan informasi debug tentang ekspresi yang dikompilasi. Tidak ada bendera sebaris yang sesuai re. Sayakembali. ABAIKAN KASUSLakukan pencocokan case-insensitive; . Pencocokan Unicode penuh (seperti a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")25 pencocokan a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")26) juga berfungsi kecuali bendera digunakan untuk menonaktifkan kecocokan non-ASCII. Lokal saat ini tidak mengubah efek dari flag ini kecuali jika flag tersebut juga digunakan. Sesuai dengan bendera sebaris a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")29 Perhatikan bahwa ketika pola Unicode >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'77 atau a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")24 digunakan dalam kombinasi dengan bendera, mereka akan cocok dengan 52 huruf ASCII dan 4 huruf non-ASCII tambahan. 'İ' (U+0130, huruf kapital Latin I dengan titik di atas), 'ı' (U+0131, huruf Latin kecil tanpa titik i), 'ſ' (U+017F, huruf Latin kecil panjang s) dan 'K' . Jika bendera digunakan, hanya huruf 'a' hingga 'z' dan 'A' hingga 'Z' yang cocokre. Lre. LOKAL Jadikan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'_92, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)44, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)41, def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)56 dan pencocokan peka huruf besar-kecil bergantung pada lokal saat ini. Bendera ini hanya dapat digunakan dengan pola byte. Penggunaan flag ini tidak disarankan 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. Sesuai dengan bendera sebaris a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")38 Berubah di versi 3. 6. hanya dapat digunakan dengan pola byte dan tidak kompatibel dengan. Berubah di versi 3. 7. Objek ekspresi reguler yang dikompilasi dengan flag tidak lagi bergantung pada lokal pada waktu kompilasi. Hanya lokal pada waktu pencocokan yang memengaruhi hasil pencocokan. re. Mre. MULTILINESaat ditentukan, karakter pola >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'_96 cocok di awal string dan di awal setiap baris (segera mengikuti setiap baris baru); . Secara default, >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'96 hanya cocok di awal string, dan def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)32 hanya di akhir string dan tepat sebelum baris baru (jika ada) di akhir string. Sesuai dengan bendera sebaris a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")46re. NOFLAG Menunjukkan tidak ada bendera yang diterapkan, nilainya adalah a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")47. Bendera ini dapat digunakan sebagai nilai default untuk argumen kata kunci fungsi atau sebagai nilai dasar yang akan di-OR secara kondisional dengan bendera lain. Contoh penggunaan sebagai nilai default def myfunc(text, flag=re.NOFLAG): return re.match(text, flag) Baru di versi 3. 11 re. Sre. DOTALLJadikan karakter khusus a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_48 cocok dengan karakter apa pun, termasuk baris baru; . Sesuai dengan bendera sebaris a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")50re. Xre. VERBOSE Bendera ini memungkinkan Anda untuk menulis ekspresi reguler yang terlihat lebih bagus dan lebih mudah dibaca dengan memungkinkan Anda memisahkan bagian logis dari pola secara visual dan menambahkan komentar. Spasi kosong di dalam pola diabaikan, kecuali saat berada di kelas karakter, atau saat didahului oleh garis miring terbalik yang tidak lolos, atau di dalam token seperti >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'01, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")52 atau a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")53. Misalnya, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_54 dan a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")55 tidak diperbolehkan. Ketika sebuah baris berisi a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_56 yang tidak ada dalam kelas karakter dan tidak didahului oleh garis miring terbalik yang tidak lolos, semua karakter dari paling kiri seperti a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")56 hingga akhir baris akan diabaikan Ini berarti bahwa dua objek ekspresi reguler berikut yang cocok dengan angka desimal secara fungsional sama a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*") Sesuai dengan bendera sebaris a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")58 Fungsire. kompilasi(pola , flags=0)Kompilasi pola ekspresi reguler menjadi , yang dapat digunakan untuk pencocokan menggunakan , dan metode lainnya, yang dijelaskan di bawah Perilaku ekspresi dapat dimodifikasi dengan menentukan nilai bendera. Nilai dapat berupa salah satu dari variabel berikut, digabungkan menggunakan bitwise OR (operator \a \b \f \n \N \r \t \u \U \v \x \\12) Urutannya prog = re.compile(pattern) result = prog.match(string) setara dengan result = re.match(pattern, string)_ tetapi menggunakan dan menyimpan objek ekspresi reguler yang dihasilkan untuk digunakan kembali akan lebih efisien bila ekspresi akan digunakan beberapa kali dalam satu program Catatan Versi terkompilasi dari pola terbaru diteruskan ke dan fungsi pencocokan tingkat modul di-cache, sehingga program yang hanya menggunakan beberapa ekspresi reguler pada satu waktu tidak perlu khawatir tentang kompilasi ekspresi reguler re. telusuri(pola , string, flags=0)Pindai melalui string untuk mencari lokasi pertama tempat pola ekspresi reguler menghasilkan kecocokan, dan kembalikan yang sesuai. Kembalikan a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_64 jika tidak ada posisi dalam string yang cocok dengan pola; re. cocok(pola , string, flags=0) Jika nol atau lebih karakter di awal string cocok dengan pola ekspresi reguler, kembalikan yang sesuai. Kembalikan a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_64 jika string tidak cocok dengan polanya; Perhatikan bahwa bahkan dalam mode, hanya akan cocok di awal string dan bukan di awal setiap baris Jika Anda ingin menemukan kecocokan di mana saja dalam string, gunakan sebagai gantinya (lihat juga ) re. pencocokan penuh(pola , string, flags=0)Jika seluruh string cocok dengan pola ekspresi reguler, kembalikan yang sesuai. Kembalikan a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_64 jika string tidak cocok dengan polanya; Baru di versi 3. 4 re. pisah(pola , string, maxsplit=0, flags=0)Pisahkan string dengan kemunculan pola. Jika tanda kurung penangkap digunakan dalam pola, maka teks dari semua grup dalam pola juga dikembalikan sebagai bagian dari daftar yang dihasilkan. Jika maxsplit bukan nol, paling banyak pemisahan maxsplit terjadi, dan sisa string dikembalikan sebagai elemen terakhir dari daftar >>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9'] Jika ada grup penangkap di pemisah dan cocok dengan awal string, hasilnya akan dimulai dengan string kosong. Hal yang sama berlaku untuk akhir string >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', ''] Dengan begitu, komponen pemisah selalu ditemukan pada indeks relatif yang sama di dalam daftar hasil Pencocokan kosong untuk pola memisahkan string hanya jika tidak bersebelahan dengan pencocokan kosong sebelumnya >>> re.split(r'\b', 'Words, words, words.') ['', 'Words', ', ', 'words', ', ', 'words', '.'] >>> re.split(r'\W*', '...words...') ['', '', 'w', 'o', 'r', 'd', 's', '', ''] >>> re.split(r'(\W*)', '...words...') ['', '...', '', '', 'w', '', 'o', '', 'r', '', 'd', '', 's', '...', '', '', ''] Berubah di versi 3. 1. Menambahkan argumen flag opsional. Berubah di versi 3. 7. Menambahkan dukungan pemisahan pada pola yang dapat cocok dengan string kosong. re. findall(pola , string, flags=0)Kembalikan semua kecocokan pola yang tidak tumpang tindih dalam string, sebagai daftar string atau tupel. String dipindai dari kiri ke kanan, dan kecocokan dikembalikan dalam urutan yang ditemukan. Pertandingan kosong disertakan dalam hasil Hasilnya tergantung pada jumlah grup penangkap dalam pola. Jika tidak ada grup, kembalikan daftar string yang cocok dengan keseluruhan pola. Jika hanya ada satu grup, kembalikan daftar string yang cocok dengan grup tersebut. Jika ada beberapa grup, kembalikan daftar tupel string yang cocok dengan grup. Grup yang tidak menangkap tidak memengaruhi bentuk hasil >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'0 Berubah di versi 3. 7. Pertandingan tidak kosong sekarang dapat dimulai tepat setelah pertandingan kosong sebelumnya. re. pencari(pola , string, flags=0)Mengembalikan hasil atas semua kecocokan yang tidak tumpang tindih untuk pola RE dalam string. String dipindai dari kiri ke kanan, dan kecocokan dikembalikan dalam urutan yang ditemukan. Pertandingan kosong disertakan dalam hasil Berubah di versi 3. 7. Pertandingan tidak kosong sekarang dapat dimulai tepat setelah pertandingan kosong sebelumnya. re. sub(pola , repl, string, count=0, flags=0)Kembalikan string yang diperoleh dengan mengganti kemunculan pola paling kiri yang tidak tumpang tindih dalam string dengan repl pengganti. Jika pola tidak ditemukan, string dikembalikan tidak berubah. repl bisa berupa string atau fungsi; . Yaitu, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_70 diubah menjadi satu karakter baris baru, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")71 diubah menjadi carriage return, dan seterusnya. Pelepasan huruf ASCII yang tidak diketahui dicadangkan untuk penggunaan di masa mendatang dan diperlakukan sebagai kesalahan. Pelarian lain yang tidak diketahui seperti a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_72 dibiarkan sendiri. Referensi balik, seperti a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")73, diganti dengan substring yang cocok dengan grup 6 dalam pola. Sebagai contoh >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'1 Jika repl adalah sebuah fungsi, ia dipanggil untuk setiap kemunculan pola yang tidak tumpang tindih. Fungsi mengambil satu argumen, dan mengembalikan string pengganti. Sebagai contoh >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'2 Polanya mungkin berupa string atau a Hitungan argumen opsional adalah jumlah maksimum kemunculan pola yang akan diganti; . Jika dihilangkan atau nol, semua kejadian akan diganti. Kecocokan kosong untuk pola diganti hanya jika tidak bersebelahan dengan kecocokan kosong sebelumnya, jadi a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")74 mengembalikan a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")75 Dalam argumen repl tipe string, selain karakter yang lolos dan referensi balik yang dijelaskan di atas, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")76 akan menggunakan substring yang cocok dengan grup bernama a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")77, seperti yang didefinisikan oleh sintaks \a \b \f \n \N \r \t \u \U \v \x \\32. a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_79 menggunakan nomor grup yang sesuai; . a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_83 akan ditafsirkan sebagai referensi ke grup 20, bukan referensi ke grup 2 diikuti oleh karakter literal result = re.match(pattern, string)8. Backreference a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_85 pengganti di seluruh substring cocok dengan RE Berubah di versi 3. 1. Menambahkan argumen flag opsional. Berubah di versi 3. 5. Grup yang tidak cocok diganti dengan string kosong. Berubah di versi 3. 6. Pelolosan yang tidak diketahui dalam pola yang terdiri dari prog = re.compile(pattern) result = prog.match(string)4 dan huruf ASCII sekarang adalah kesalahan. Berubah di versi 3. 7. Lolos yang tidak diketahui dalam repl yang terdiri dari prog = re.compile(pattern) result = prog.match(string)4 dan huruf ASCII sekarang adalah kesalahan. Berubah di versi 3. 7. Empty matches for the pattern are replaced when adjacent to a previous non-empty match. Tidak digunakan lagi sejak versi 3. 11. Id grup berisi apa pun kecuali digit ASCII. Nama grup yang berisi karakter non-ASCII dalam string pengganti byte. re. subn(pola , repl, string, count=0, flags=0)Lakukan operasi yang sama seperti , tetapi kembalikan tuple a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")89 Berubah di versi 3. 1. Menambahkan argumen flag opsional. Berubah di versi 3. 5. Grup yang tidak cocok diganti dengan string kosong. re. melarikan diri(pola)Melarikan diri dari karakter khusus dalam pola. Ini berguna jika Anda ingin mencocokkan sembarang string literal yang mungkin memiliki karakter meta ekspresi reguler di dalamnya. Sebagai contoh >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'3 Fungsi ini tidak boleh digunakan untuk string pengganti di dalam dan , hanya garis miring terbalik yang harus di-escape. Sebagai contoh >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'4 Berubah di versi 3. 3. Karakter a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")92 tidak lagi lolos. Berubah di versi 3. 7. Hanya karakter yang memiliki arti khusus dalam ekspresi reguler yang diloloskan. Akibatnya, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")93, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")94, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")95, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")96, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")97, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")___0____0____0____0____0____0________________ __________0 __________________0 ______________________________ ______. re. bersihkan() Kosongkan cache ekspresi reguler Pengecualianpengecualian re. kesalahan(pesan , pola=None, pos=None)Pengecualian muncul saat string diteruskan ke salah satu fungsi di sini bukan ekspresi reguler yang valid (misalnya, mungkin berisi tanda kurung yang tidak cocok) atau saat terjadi kesalahan lain selama kompilasi atau pencocokan. Tidak pernah ada kesalahan jika sebuah string tidak mengandung kecocokan untuk suatu pola. Contoh kesalahan memiliki atribut tambahan berikut pesanPesan kesalahan yang tidak diformat polaPola ekspresi reguler posIndeks dalam pola di mana kompilasi gagal (mungkin a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")64)lineno Baris yang sesuai dengan pos (mungkin a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")64)colno Kolom yang sesuai dengan pos (mungkin a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")64) Berubah di versi 3. 5. Menambahkan atribut tambahan. Objek Ekspresi RegulerObjek ekspresi reguler yang dikompilasi mendukung metode dan atribut berikut Pola. telusuri(string[ , pos[, endpos]])Pindai melalui string untuk mencari lokasi pertama tempat ekspresi reguler ini menghasilkan kecocokan, dan kembalikan yang sesuai. Kembalikan a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_64 jika tidak ada posisi dalam string yang cocok dengan pola; The optional second parameter pos gives an index in the string where the search is to start; it defaults to a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")47. Ini tidak sepenuhnya sama dengan memotong string; Endpos parameter opsional membatasi seberapa jauh string akan dicari; . Jika endpos kurang dari pos, tidak ada kecocokan yang akan ditemukan; >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'5Pola. cocokkan(string[ , pos[, endpos]]) Jika nol atau lebih karakter di awal string cocok dengan ekspresi reguler ini, kembalikan yang sesuai. Kembalikan a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_64 jika string tidak cocok dengan polanya; Parameter opsional pos dan endpos memiliki arti yang sama dengan metode >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'6 Jika Anda ingin menemukan kecocokan di mana saja dalam string, gunakan sebagai gantinya (lihat juga ) Pola. pencocokan penuh(string[ , pos[, endpos]])Jika seluruh string cocok dengan ekspresi reguler ini, kembalikan yang sesuai. Kembalikan a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_64 jika string tidak cocok dengan polanya; Parameter opsional pos dan endpos memiliki arti yang sama dengan metode >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'7 Baru di versi 3. 4 Pola. pisah(string , maxsplit=0)Identik dengan fungsi, menggunakan pola yang dikompilasi Pola. findall(string[ , pos[, endpos]])Mirip dengan fungsinya, menggunakan pola yang dikompilasi, tetapi juga menerima parameter pos dan endpos opsional yang membatasi wilayah pencarian seperti untuk Pola. pencari(string[ , pos[, endpos]])Mirip dengan fungsinya, menggunakan pola yang dikompilasi, tetapi juga menerima parameter pos dan endpos opsional yang membatasi wilayah pencarian seperti untuk Pola. sub(repl , string, count=0)Identik dengan fungsi, menggunakan pola yang dikompilasi Pola. subn(repl , string, count=0)Identik dengan fungsi, menggunakan pola yang dikompilasi Pola. benderaBendera pencocokan regex. Ini adalah kombinasi dari flag yang diberikan ke , \a \b \f \n \N \r \t \u \U \v \x \\28 flag sebaris apa pun dalam pola, dan flag implisit seperti prog = re.compile(pattern) result = prog.match(string)29 jika polanya adalah string UnicodePola. grup Jumlah kelompok penangkap dalam pola Pola. indeksgrupKamus memetakan nama grup simbolik apa pun yang ditentukan oleh prog = re.compile(pattern) result = prog.match(string)30 ke nomor grup. Kamus kosong jika tidak ada grup simbol yang digunakan dalam polaPola. pola String pola tempat objek pola dikompilasi Berubah di versi 3. 7. Menambahkan dukungan dan. Objek ekspresi reguler yang dikompilasi dianggap atomik. Mencocokkan ObjekObjek yang cocok selalu memiliki nilai boolean prog = re.compile(pattern) result = prog.match(string)33. Sejak dan mengembalikan a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_64 ketika tidak ada kecocokan, Anda dapat menguji apakah ada kecocokan dengan pernyataan prog = re.compile(pattern) result = prog.match(string)37 sederhana >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'8 Objek yang cocok mendukung metode dan atribut berikut Cocok. perluas(templat)Mengembalikan string yang diperoleh dengan melakukan substitusi backslash pada template string template, seperti yang dilakukan oleh metode. Pelarian seperti a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")70 dikonversi ke karakter yang sesuai, dan referensi balik numerik ( \a \b \f \n \N \r \t \u \U \v \x \\90, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")81) dan referensi balik bernama ( \a \b \f \n \N \r \t \u \U \v \x \\95, a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")76) diganti dengan konten grup yang sesuai Berubah di versi 3. 5. Grup yang tidak cocok diganti dengan string kosong. Cocok. grup([grup1 , . ...])Mengembalikan satu atau beberapa subgrup dari kecocokan. Jika ada satu argumen, hasilnya adalah satu string; . Tanpa argumen, grup1 default ke nol (seluruh kecocokan dikembalikan). Jika argumen groupN adalah nol, nilai pengembalian yang sesuai adalah seluruh string yang cocok; . 99], itu adalah string yang cocok dengan grup dalam tanda kurung yang sesuai. Jika nomor grup negatif atau lebih besar dari jumlah grup yang ditentukan dalam pola, pengecualian akan dimunculkan. Jika sebuah grup berisi bagian dari pola yang tidak cocok, hasil yang sesuai adalah a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")64. Jika grup terdapat di bagian pola yang cocok berkali-kali, kecocokan terakhir akan dikembalikan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'_9 Jika ekspresi reguler menggunakan sintaks \a \b \f \n \N \r \t \u \U \v \x \\32, argumen groupN juga dapat berupa string yang mengidentifikasi grup berdasarkan nama grupnya. Jika argumen string tidak digunakan sebagai nama grup dalam pola, pengecualian akan dimunculkan Contoh yang cukup rumit \a \b \f \n \N \r \t \u \U \v \x \\_0 Grup bernama juga dapat disebut dengan indeks mereka \a \b \f \n \N \r \t \u \U \v \x \\_1 Jika grup cocok berkali-kali, hanya pertandingan terakhir yang dapat diakses \a \b \f \n \N \r \t \u \U \v \x \\_2Cocok. __getitem__(g) Ini identik dengan prog = re.compile(pattern) result = prog.match(string)_48. Ini memungkinkan akses yang lebih mudah ke grup individu dari pertandingan \a \b \f \n \N \r \t \u \U \v \x \\_3 Grup bernama juga didukung \a \b \f \n \N \r \t \u \U \v \x \\_4 Baru di versi 3. 6 Cocok. grup(default=Tidak ada)Mengembalikan tuple yang berisi semua subgrup dari kecocokan, dari 1 hingga berapa pun grup yang ada dalam pola. Argumen default digunakan untuk grup yang tidak berpartisipasi dalam pertandingan; Sebagai contoh \a \b \f \n \N \r \t \u \U \v \x \\_5 Jika kita membuat tempat desimal dan setelahnya opsional, tidak semua grup dapat berpartisipasi dalam pertandingan. Grup ini akan default ke a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_64 kecuali jika argumen default diberikan \a \b \f \n \N \r \t \u \U \v \x \\_6Cocok. groupdict(default=Tidak ada) Kembalikan kamus yang berisi semua subgrup bernama dari kecocokan, yang dikunci dengan nama subgrup. Argumen default digunakan untuk grup yang tidak berpartisipasi dalam pertandingan; . Sebagai contoh \a \b \f \n \N \r \t \u \U \v \x \\_7Cocok. mulai([grup] . )Match.akhir([grup]) Mengembalikan indeks awal dan akhir substring yang cocok dengan grup; . Kembalikan prog = re.compile(pattern) result = prog.match(string)_52 jika grup ada tetapi tidak berkontribusi pada pertandingan. Untuk objek pencocokan m, dan grup g yang berkontribusi pada pencocokan, substring yang dicocokkan dengan grup g (setara dengan prog = re.compile(pattern) result = prog.match(string)48) adalah \a \b \f \n \N \r \t \u \U \v \x \\_8 Perhatikan bahwa prog = re.compile(pattern) result = prog.match(string)_54 akan sama dengan prog = re.compile(pattern) result = prog.match(string)55 jika grup cocok dengan string nol. Misalnya, setelah prog = re.compile(pattern) result = prog.match(string)56, prog = re.compile(pattern) result = prog.match(string)57 adalah 1, prog = re.compile(pattern) result = prog.match(string)58 adalah 2, prog = re.compile(pattern) result = prog.match(string)59 dan prog = re.compile(pattern) result = prog.match(string)60 keduanya adalah 2, dan prog = re.compile(pattern) result = prog.match(string)61 memunculkan pengecualian Contoh yang akan menghapus remove_this dari alamat email \a \b \f \n \N \r \t \u \U \v \x \\_9Cocok. span([grup]) Untuk kecocokan m, kembalikan 2-tuple prog = re.compile(pattern) result = prog.match(string)63. Perhatikan bahwa jika grup tidak berkontribusi pada pertandingan, ini adalah prog = re.compile(pattern) result = prog.match(string)64. grup default ke nol, seluruh pertandinganCocok. pos Nilai pos yang diteruskan ke atau metode a. Ini adalah indeks ke string di mana mesin RE mulai mencari kecocokan Cocok. endposNilai endpos yang diteruskan ke atau metode a. Ini adalah indeks ke dalam string di mana mesin RE tidak akan pergi Cocok. indeks terakhirIndeks bilangan bulat dari grup penangkap terakhir yang cocok, atau a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")64 jika tidak ada grup yang cocok sama sekali. Misalnya, ekspresi prog = re.compile(pattern) result = prog.match(string)70, prog = re.compile(pattern) result = prog.match(string)71, dan prog = re.compile(pattern) result = prog.match(string)72 akan memiliki prog = re.compile(pattern) result = prog.match(string)73 jika diterapkan pada string prog = re.compile(pattern) result = prog.match(string)74, sedangkan ekspresi prog = re.compile(pattern) result = prog.match(string)75 akan memiliki prog = re.compile(pattern) result = prog.match(string)76, jika diterapkan pada string yang samaCocok. grup terakhir Nama grup penangkap terakhir yang cocok, atau a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")64 jika grup tidak memiliki nama, atau jika tidak ada grup yang cocok sama sekaliCocok. kembali Yang atau metodenya menghasilkan contoh kecocokan ini Cocok. stringString diteruskan ke atau Berubah di versi 3. 7. Menambahkan dukungan dan. Objek yang cocok dianggap atom. Contoh Ekspresi RegulerMemeriksa PasanganDalam contoh ini, kami akan menggunakan fungsi pembantu berikut untuk menampilkan objek yang cocok dengan sedikit lebih anggun def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)0 Misalkan Anda sedang menulis program poker di mana tangan pemain direpresentasikan sebagai string 5 karakter dengan masing-masing karakter mewakili kartu, "a" untuk ace, "k" untuk king, "q" untuk queen, "j" untuk jack, Untuk melihat apakah string yang diberikan adalah tangan yang valid, seseorang dapat melakukan hal berikut def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_1 Tangan terakhir itu, prog = re.compile(pattern) result = prog.match(string)84, berisi sepasang, atau dua kartu dengan nilai yang sama. Untuk mencocokkan ini dengan ekspresi reguler, seseorang dapat menggunakan referensi balik seperti itu def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)2 Untuk mengetahui pasangan terdiri dari kartu apa, seseorang dapat menggunakan metode objek pencocokan dengan cara berikut def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_3 Mensimulasikan scanf()Python saat ini tidak memiliki persamaan dengan ________0______86. Ekspresi reguler umumnya lebih kuat, meskipun juga lebih bertele-tele, daripada string format prog = re.compile(pattern) result = prog.match(string)86. Tabel di bawah menawarkan beberapa pemetaan setara yang kurang lebih antara prog = re.compile(pattern) result = prog.match(string)86 format token dan ekspresi reguler prog = re.compile(pattern) result = prog.match(string)_86 Token Ekspresi Reguler prog = re.compile(pattern) result = prog.match(string)_90 >>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']_2 prog = re.compile(pattern) result = prog.match(string)_92 prog = re.compile(pattern) result = prog.match(string)_93 prog = re.compile(pattern) result = prog.match(string)_94 prog = re.compile(pattern) result = prog.match(string)_95 prog = re.compile(pattern) result = prog.match(string)_96, prog = re.compile(pattern) result = prog.match(string)97, prog = re.compile(pattern) result = prog.match(string)98, prog = re.compile(pattern) result = prog.match(string)99 result = re.match(pattern, string)_00 result = re.match(pattern, string)_01 result = re.match(pattern, string)_02 result = re.match(pattern, string)_03 result = re.match(pattern, string)_04 result = re.match(pattern, string)_05 result = re.match(pattern, string)_06 result = re.match(pattern, string)_07 result = re.match(pattern, string)_08 result = re.match(pattern, string)_09, result = re.match(pattern, string)10 result = re.match(pattern, string)_11 Untuk mengekstrak nama file dan angka dari string seperti def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_4 Anda akan menggunakan format prog = re.compile(pattern) result = prog.match(string)_86 seperti def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)5 Ekspresi reguler yang setara adalah def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_6 cari() vs. cocok()Python menawarkan operasi primitif yang berbeda berdasarkan ekspresi reguler
Sebagai contoh def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_7 Ekspresi reguler yang dimulai dengan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'_96 dapat digunakan dengan untuk membatasi kecocokan di awal string def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_8 Namun perhatikan bahwa dalam mode hanya cocok di awal string, sedangkan menggunakan dengan ekspresi reguler yang dimulai dengan >>> m = re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'96 akan cocok di awal setiap baris def myfunc(text, flag=re.NOFLAG): return re.match(text, flag)_9 Membuat Buku Teleponmembagi string menjadi daftar yang dibatasi oleh pola yang diteruskan. Metode ini sangat berharga untuk mengonversi data tekstual menjadi struktur data yang dapat dengan mudah dibaca dan dimodifikasi oleh Python seperti yang ditunjukkan dalam contoh berikut yang membuat buku telepon Pertama, inilah inputnya. Biasanya itu mungkin berasal dari file, di sini kita menggunakan sintaks string yang dikutip tiga kali lipat a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_0 Entri dipisahkan oleh satu atau lebih baris baru. Sekarang kami mengonversi string menjadi daftar dengan setiap baris kosong memiliki entri sendiri a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_1 Terakhir, bagi setiap entri menjadi daftar dengan nama depan, nama belakang, nomor telepon, dan alamat. Kami menggunakan parameter result = re.match(pattern, string)_23 karena alamat memiliki spasi, pola pemisahan kami, di dalamnya a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_2 Pola result = re.match(pattern, string)25 cocok dengan titik dua setelah nama belakang, sehingga tidak muncul di daftar hasil. Dengan result = re.match(pattern, string)_23 dari result = re.match(pattern, string)27, kita dapat memisahkan nomor rumah dari nama jalan a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_3 Teks Mungingmengganti setiap kemunculan pola dengan string atau hasil dari suatu fungsi. Contoh ini mendemonstrasikan penggunaan dengan fungsi untuk "munge" teks, atau mengacak urutan semua karakter di setiap kata dalam kalimat kecuali karakter pertama dan terakhir a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_4 Menemukan semua kata keterangancocok dengan semua kemunculan pola, bukan hanya yang pertama. Misalnya, jika seorang penulis ingin menemukan semua kata keterangan dalam beberapa teks, mereka mungkin menggunakan cara berikut a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_5 Menemukan semua Keterangan dan Posisi merekaJika seseorang menginginkan lebih banyak informasi tentang semua kecocokan suatu pola daripada teks yang cocok, ini berguna karena menyediakannya sebagai pengganti string. Melanjutkan contoh sebelumnya, jika seorang penulis ingin menemukan semua kata keterangan dan posisinya dalam beberapa teks, mereka akan menggunakan cara berikut a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_6 Notasi String MentahNotasi string mentah ( result = re.match(pattern, string)35) membuat ekspresi reguler tetap waras. Tanpanya, setiap backslash ( prog = re.compile(pattern) result = prog.match(string)_4) dalam ekspresi reguler harus diawali dengan yang lain untuk menghindarinya. Misalnya, dua baris kode berikut identik secara fungsional a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_7 Ketika seseorang ingin mencocokkan backslash literal, itu harus diloloskan dalam ekspresi reguler. Dengan notasi string mentah, ini berarti result = re.match(pattern, string)37. Tanpa notasi string mentah, seseorang harus menggunakan result = re.match(pattern, string)38, membuat baris kode berikut identik secara fungsional a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_8 Menulis TokenizerTokenizer atau pemindai menganalisis string untuk mengkategorikan grup karakter. Ini adalah langkah pertama yang berguna dalam menulis kompiler atau juru bahasa Kategori teks ditentukan dengan ekspresi reguler. Tekniknya adalah menggabungkannya menjadi ekspresi reguler master tunggal dan mengulangi kecocokan yang berurutan a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")_9 Tokenizer menghasilkan output berikut prog = re.compile(pattern) result = prog.match(string)0 Friedl, Jeffrey. Menguasai Ekspresi Reguler. edisi ke-3. , O'Reilly Media, 2009. Edisi ketiga buku ini tidak lagi mencakup Python sama sekali, tetapi edisi pertama mencakup penulisan pola ekspresi reguler yang baik dengan sangat detail Bagaimana Anda membuat casing penggantiIGNORECASE + re . Dalam hal ini, sub() dari regex digunakan untuk melakukan tugas penggantian, dan IGNORECASE mengabaikan kasus dan melakukan penggantian case-insensitive.
Apakah string ganti caseReplace() memungkinkan Anda untuk dengan mudah mengganti substring dengan substring lain, atau karakter dengan karakter lain, di dalam konten objek String. Metode ini sangat praktis, tetapi selalu peka huruf besar kecil . Jadi saya pikir akan menarik untuk membuat versi case-insensitive dari metode ini.
Bagaimana Anda membuat kotak centang stringPython String sama dengan pemeriksaan case-insensitive
. use casefold() , lower() or upper() functions for case-insensitive equality check.
Bagaimana Anda membuat string dalam kasus perbandinganCara paling dasar untuk melakukan perbandingan string case-insensitive di JavaScript adalah menggunakan metode toLowerCase() atau toUpperCase() untuk memastikan kedua string semuanya huruf kecil atau huruf besar semua . . |
