Prinsip asasnya ialah menggunakan satu siri aksara dan sintaks khas untuk memadankan dan memanipulasi data teks. Ungkapan biasa biasanya terdiri daripada rentetan corak yang menerangkan corak teks yang akan dipadankan, dan satu atau lebih aksara dan sintaks khas yang mengawal bagaimana dan apakah hasilnya. Ungkapan biasa dalam Python biasanya dilaksanakan menggunakan modul semula

Apakah ungkapan biasa?

Ungkapan biasa, juga dikenali sebagai ungkapan biasa, (Bahasa Inggeris: Regular Expression, sering disingkat sebagai regex, regexp atau RE dalam kod), ia adalah konsep dalam sains komputer. Ungkapan biasa sering digunakan untuk mendapatkan dan menggantikan teks yang sepadan dengan corak tertentu. Banyak bahasa pengaturcaraan menyokong manipulasi rentetan menggunakan ungkapan biasa. Contohnya, Perl mempunyai enjin ekspresi biasa yang berkuasa terbina di dalamnya. Konsep ungkapan biasa pada asalnya dipopularkan oleh perisian alat dalam Unix. Ungkapan biasa ialah formula logik yang beroperasi pada rentetan (termasuk aksara biasa (contohnya, huruf antara a hingga z) dan aksara khas (dipanggil "metacharacters")), yang menggunakan beberapa aksara khusus yang dipratentukan dan gabungan khusus ini aksara membentuk "rentetan peraturan" ini "rentetan peraturan" digunakan untuk menyatakan logik penapisan untuk rentetan. Ungkapan biasa ialah corak teks yang menerangkan satu atau lebih rentetan untuk dipadankan semasa mencari teks.

1. Memperkenalkan contoh

Selepas bercakap banyak perkara yang tidak masuk akal, anda mungkin masih keliru , kita masukkan sekeping teks.

hello, nama saya Tina, nombor telefon saya 123456 dan web saya ialah http://tina.com.

                               [a-zA-z]+://[^\s]*

Kita boleh dapatkan pautan web, Iaitu, url dalam teks bukankah ia menakjubkan?

Ini kerana ia mempunyai peraturan padanannya sendiri, antaranya adalah seperti berikut.

模式	描述
.	任意字符
*	0个或者多个表达式
+	一个或者多个表达式

Anda boleh menyemak lebih banyak peraturan padanan sendiri.

?,*+,d,w adakah semua aksara yang setara

adalah bersamaan dengan panjang yang sepadan {0,1}

* bersamaan dengan panjang yang sepadan {0,}

+ bersamaan dengan panjang yang sepadan {1, }

d bersamaan dengan [0-9]

D bersamaan dengan [^0-9]

w bersamaan dengan [A-Za-z_0-9]

W bersamaan dengan [^A-Za-z_0-9]

2.match()

Di sini kami memperkenalkan kaedah padanan yang biasa digunakan - match(). Dengan menghantar rentetan untuk dipadankan dan ungkapan biasa, anda boleh mengesan ungkapan biasa . Sama ada ungkapan itu sepadan dengan rentetan.

Sasaran yang sepadan

res = re.match('hello\s(\d+)sword')

Padanan tamak

res = re.match('hello.*(\d+)sword')

3.findall()

Ini adalah perkara yang paling kami gunakan, mari lihat cara ini digunakan.

import re
 
useData = str(input('请输入字符串数据:'))
 
'''
匹配字符串中的数字,+是匹配前面的子表达式一次或多次
'''
digital = re.findall('\d+',useData)
 
print(digital)

Mari kita lihat hasil yang sedang dijalankan

Fungsi findall() mengembalikan semua rentetan yang dipadankan dan jenis data nilai pulangan ialah senarai.

Simbol biasa

Mari kita bincangkan tentang simbol biasa ungkapan biasa.

Watak "." sepadan dengan mana-mana watak tunggal.

Watak "" ialah watak melarikan diri.

"[…]" ialah set watak.

“(.*?)” ialah aksara yang paling biasa digunakan dalam perangkak ular sawa Ia dipanggil algoritma tamak dan boleh memadankan mana-mana aksara.

Mari lihat contoh kod di bawah.

import re
 
a=‘xxixxjshdxxlovexxsfhxxpythonxx'
 
data=re.findall(‘xx(.*?)xx')
 
print(data)

Jom jalankan dan lihat kesannya.

Hasil jalankan
[‘I’,‘love’,‘python’]

Watak istimewa

Kononnya aksara khas , iaitu aksara dengan makna istimewa, seperti yang terdapat dalam runoo*b Secara ringkasnya, ia mewakili makna mana-mana rentetan. Jika anda ingin mencari simbol * dalam rentetan, anda perlu melepaskan *, iaitu, tambah sebelum itu, runo*ob sepadan dengan runo*ob rentetan.

Banyak aksara meta memerlukan layanan istimewa apabila cuba memadankannya. Untuk memadankan watak istimewa ini, anda mesti terlebih dahulu "melarikan diri" watak itu, iaitu, mendahuluinya dengan aksara sengkang terbalik. Jadual berikut menyenaraikan aksara khas dalam ungkapan biasa:

Watak Khas

Penerangan

$

特别字符	描述
$	匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 ‘n’ 或 ‘r’。要匹配 $ 字符本身，请使用 $。
()	标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 ( 和 )。
*	匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 *。
+	匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 +。
.	匹配除换行符 n 之外的任何单字符。要匹配 . ，请使用 . 。

Padankan hujung rentetan input. Jika sifat Multiline objek RegExp ditetapkan, $ juga sepadan dengan ‘n’ atau ‘r’. Untuk memadankan aksara $ itu sendiri, gunakan $.

()

Menandai permulaan dan akhir subungkapan. Subungkapan boleh diperolehi untuk kegunaan kemudian. Untuk memadankan aksara ini, gunakan ( dan ).

*

Padan dengan subungkapan sebelumnya sifar atau lebih kali. Untuk memadankan aksara *, gunakan *.

+

Memadankan subungkapan sebelumnya satu kali atau lebih. Untuk memadankan aksara +, gunakan +.

.

Memadankan mana-mana aksara tunggal kecuali aksara baris baharu n. Untuk memadankan , gunakan .

 概念说了一大堆，大家可能也记不住，我直接说几个案例，大家就能明白其他的道理。

这是某网的HTML，部分片段如下：

<span class=“price”>§<i>123</i></span>
 
<span class=“price”>§<i>133</i></span>
 
<span class=“price”>§<i>156</i></span>
 
<span class=“price”>§<i>189</i></span>

   大家会发现只有中间的一段不一样，而不一样的数据就是我们想要的，我们怎么用正则表达式提取出来呢.

<span class=“price”>§<i>(.*?)</i></span>

就可以了，我们看看效果吧。

123
133
156
189

Atas ialah kandungan terperinci Prinsip asasnya ialah menggunakan satu siri aksara dan sintaks khas untuk memadankan dan memanipulasi data teks. Ungkapan biasa biasanya terdiri daripada rentetan corak yang menerangkan corak teks yang akan dipadankan, dan satu atau lebih aksara dan sintaks khas yang mengawal bagaimana dan apakah hasilnya. Ungkapan biasa dalam Python biasanya dilaksanakan menggunakan modul semula. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!