aperçu
En Python, les expressions régulières sont un outil puissant pour manipuler les chaînes. search() et match() sont deux méthodes d'expression régulière couramment utilisées dans le module re de la bibliothèque standard Python. Cet article vous expliquera en détail l'utilisation de ces deux méthodes, de l'entrée à la maîtrise.
Table des matières
-
Introduction aux expressions régulières
-
Utilisation de la méthode search()
-
Utilisation de la méthode match()
-
Métacaractères importants des expressions régulières
-
La différence entre rechercher() et match()
-
Utiliser des expressions régulières compilées
-
Exemple : Correspondance d'adresses e-mail valides
-
Exemple : format de date correspondant
-
Résumer
1. Introduction aux expressions régulières
Une expression régulière est une expression qui décrit un modèle de chaîne et est utilisée pour rechercher, mettre en correspondance et remplacer des chaînes dans le texte. Il utilise des règles de grammaire spécifiques pour définir un modèle pour une séquence de caractères. En Python, le module re prend en charge les expressions régulières. En utilisant les méthodes search() et match(), nous pouvons effectuer des correspondances et des recherches de chaînes.
2. Utilisation de la méthode search()
La méthode search() est utilisée pour rechercher dans toute la chaîne la première occurrence d'une expression régulière correspondante. Renvoie un objet match si une sous-chaîne correspondante est trouvée, ou None dans le cas contraire.
import re
# 定义正则表达式
pattern = r'\d+'
# 定义目标字符串
text = "Hello 123 World 456"
# 使用search()方法搜索匹配的子串
match = re.search(pattern, text)
if match:
print("找到匹配的子串:", match.group()) # 输出：找到匹配的子串: 123
else:
print("未找到匹配的子串")
Dans le code ci-dessus, nous définissons d'abord une expression régulière simple r'\d+' pour faire correspondre un ou plusieurs nombres. Ensuite, nous définissons le texte de la chaîne cible, qui contient le nombre "123". Utilisez la méthode search() pour rechercher la première sous-chaîne correspondante dans la chaîne cible et afficher le résultat.
3. Utilisation de la méthode match()
La méthode match() est utilisée pour faire correspondre l'expression régulière depuis le début de la chaîne. Renvoie un objet match si une sous-chaîne correspondante est trouvée, ou None dans le cas contraire.
import re
# 定义正则表达式
pattern = r'\d+'
# 定义目标字符串
text = "123 Hello World 456"
# 使用match()方法从字符串开头开始匹配
match = re.match(pattern, text)
if match:
print("找到匹配的子串:", match.group()) # 输出：找到匹配的子串: 123
else:
print("未找到匹配的子串")
Dans le code ci-dessus, nous mettons le nombre "123" dans le texte de la chaîne cible au début de la chaîne. Utilisez la méthode match() pour commencer la correspondance depuis le début et trouvez la sous-chaîne correspondante "123".
4. Métacaractères importants des expressions régulières
Dans les expressions régulières, il existe des caractères spéciaux appelés métacaractères, qui ont des significations particulières. Voici quelques métacaractères importants dans les expressions régulières :
-
. : Correspond à n'importe quel caractère sauf le retour à la ligne.
-
* : correspond au caractère précédent 0 fois ou plus.
-
+ : correspond au caractère précédent 1 ou plusieurs fois.
-
? : Correspond au caractère précédent 0 ou 1 fois.
-
^ : correspond au début de la chaîne.
-
$ : correspond à la fin de la chaîne.
-
[] : correspond à n'importe quel caractère entre crochets.
-
| : correspond à l'une des deux expressions ou plus.
Ces métacaractères sont disponibles à la fois dans les méthodes search() et match().
5. La différence entre rechercher() et match()
La principale différence entre les méthodes search() et match() est la position de départ de la recherche :
-
La méthode search() recherche la chaîne entière pour la première sous-chaîne correspondante, sans limiter la position de départ de la recherche.
-
La méthode match() commence la correspondance à partir du début de la chaîne et ne trouve que les sous-chaînes correspondantes au début de la chaîne.
import re
# 定义正则表达式
pattern = r'\d+'
# 定义目标字符串
text = "123 Hello World 456"
# 使用search()方法搜索匹配的子串
match_search = re.search(pattern, text)
# 使用match()方法从字符串开头开始匹配
match_match = re.match(pattern, text)
if match_search:
print("search()找到匹配的子串:", match_search.group()) # 输出：search()找到匹配的子串: 123
else:
print("search()未找到匹配的子串")
if match_match:
print("match()找到匹配的子串:", match_match.group()) # 输出：match()找到匹配的子串: 123
else:
print("match()未找到匹配的子串")
Dans le code ci-dessus, nous utilisons les méthodes search() et match() pour rechercher séparément. La sous-chaîne correspondante "123" peut être trouvée à l'aide de la méthode search(), et la sous-chaîne correspondante "123" est également trouvée à l'aide de la méthode match(), car "123" se trouve au début de la chaîne.
6. Utiliser des expressions régulières compilées
Lorsque nous devons utiliser la même expression régulière plusieurs fois, nous pouvons d'abord compiler l'expression régulière pour améliorer l'efficacité.
import re
# 定义正则表达式
pattern = r'\d+'
# 定义目标字符串
text = "Hello 123 World 456"
# 编译正则表达式
regex = re.compile(pattern)
# 使用编译后的正则表达式进行搜索
match = regex.search(text)
if match:
print("找到匹配的子串:", match.group()) # 输出：找到匹配的子串: 123
else:
print("未找到匹配的子串")
Dans le code ci-dessus, nous utilisons d'abord la fonction re.compile() pour compiler l'expression régulière afin d'obtenir une regex d'objet d'expression régulière compilée. Nous pouvons ensuite utiliser cet objet regex plusieurs fois pour effectuer une recherche, ce qui améliore l'efficacité.
7. Exemple : Correspondance d'adresses e-mail valides
Comprenons plus en profondeur l'utilisation des méthodes search() et match() à travers un exemple. Écrivons une expression régulière qui correspond à des adresses e-mail valides.
import re
# 定义正则表达式
pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
# 定义目标字符串
emails = [
"[email protected]",
"[email protected]",
"[email protected]",
"[email protected]",
"invalid_email"
]
# 使用search()方法匹配有效的邮箱地址
for email in emails:
match = re.search(pattern, email)
if match:
print("有效的邮箱地址:", match.group())
else:
print("无效的邮箱地址")
Dans le code ci-dessus, nous définissons une expression régulière complexe pour faire correspondre les adresses e-mail valides. Ensuite, nous définissons une liste d'e-mails, qui contient certaines adresses e-mail. Utilisez la méthode search () pour faire correspondre les adresses e-mail une par une et afficher les résultats.
8. Exemple : correspondre au format de la date
Regardons un autre exemple, nous écrivons une expression régulière pour correspondre au format de la date.
import re
# 定义正则表达式
pattern = r'\d{4}-\d{2}-\d{2}'
# 定义目标字符串
dates = [
"2023-07-30",
"2023/07/30",
"30-07-2023",
"07-30-2023",
"2023-13-30"
]
# 使用search()方法匹配日期格式
for date in dates:
match = re.search(pattern, date)
if match:
print("匹配的日期格式:", match.group())
else:
print("无效的日期格式")
Dans le code ci-dessus, nous définissons une expression régulière simple r'\d{4}-\d{2}-\d{2}' pour faire correspondre les dates au format "AAAA-MM-JJ". Ensuite, nous définissons une liste de dates, qui contient des chaînes de date. Utilisez la méthode search() pour faire correspondre les formats de date un par un et afficher le résultat.
9. Résumé
Grâce à l'explication de cet article, nous avons appris l'utilisation de search() et match(), deux méthodes d'expression régulière couramment utilisées en Python, de l'entrée à la maîtrise.
-
La méthode search() est utilisée pour rechercher dans toute la chaîne la première occurrence d'une expression régulière correspondante.
-
La méthode match() est utilisée pour faire correspondre l'expression régulière depuis le début de la chaîne.
Nous avons également découvert certains métacaractères importants des expressions régulières et comment utiliser des expressions régulières compilées pour être plus efficaces. Enfin, à travers des exemples, nous avons une compréhension approfondie de l'utilisation des méthodes search() et match() dans des applications pratiques. Après avoir maîtrisé les connaissances de base et les méthodes de ces expressions régulières, nous pouvons mieux traiter les chaînes, effectuer des opérations de correspondance et de recherche efficaces, et ainsi écrire du code Python efficace et flexible.