Expressions régulières Python

Introduction

Le traitement ODOMA et la vérification des entrées utilisateur sont des liens clés de la programmation, en particulier lors de la création d'applications qui nécessitent une interaction utilisateur. Python fournit des outils puissants pour effectuer ces tâches. Cet article explorera le monde des anomalies de Python et des expressions régulières, expliquera leur importance, fournira des exemples pratiques et s'assure que votre code est solide et efficace.

Comprendre les anomalies python

Avant d'étudier dans la recherche en profondeur, nous devons comprendre les concepts d'anomalies anormales dans Python. Anormal est un événement qui interrompt le processus normal. Ces événements sont généralement causés par des erreurs, telles que la réduction des documents qui n'existent pas avec zéro ou accès.

Traitement anormal de base

Python fournit des blocs d'essai à l'exception pour gérer les anomalies. Ceci est un exemple simple:

Dans cet exemple, si l'utilisateur essaie de supprimer le non-Integer avec zéro ou entrée, le programme capturera les anomalies et la gérera avec élégance.

<code class="language-python">try:
    分子 = int(input("请输入分子："))
    分母 = int(input("请输入分母："))
    结果 = 分子 / 分母
    print(f"结果是 {结果}")
except ZeroDivisionError:
    print("错误：不能除以零！")
except ValueError:
    print("错误：请输入有效的整数！")</code>

L'importance du traitement anormal

Dans le développement de logiciels, le traitement anormal correct est essentiel car il peut empêcher la procédure de s'effondrer accidentellement. Il fournit également un moyen de transmettre des erreurs aux utilisateurs pour les aider à comprendre quels problèmes et comment le résoudre.

Expression régulière plus profonde

L'expression régulière, généralement appelée "regex", est une séquence de caractères définie par le mode de recherche. Ils sont très utiles pour la vérification et le fonctionnement de la chaîne dans Python.

Pourquoi utiliser des expressions régulières?

Considérez une scène qui doit vérifier l'adresse e-mail. S'il n'y a pas d'expression régulière, vous pouvez éventuellement écrire un grand nombre de code pour vérifier l'existence du symbole "@" et de la période ("."). Cependant, même cela peut ne pas être suffisant pour s'assurer que l'adresse e-mail est efficace. Des expressions régulières vous permettent d'écrire des règles de vérification simples et puissantes.

Exemple d'expression régulière de base

Commençons par un exemple d'expression régulière simple pour vérifier l'adresse e-mail:

Dans cet exemple, R "^ W @W .W $" est un mode d'expression régulière.

<code class="language-python">import re

邮箱 = input("您的邮箱地址是？").strip()

if re.search(r"^\w+@\w+\.\w+$", 邮箱):
    print("有效的邮箱地址")
else:
    print("无效的邮箱地址")</code>

^ Assurez-vous que le mode commence à partir du début de la chaîne. W correspond à un ou plusieurs caractères de mots (lettres, chiffres et lignes inférieures). @ "@" Symbole. . Le $ assure la fin du motif à la fin de la chaîne.

Vérification avancée des e-mails

L'expression régulière de base ci-dessus ne peut pas capturer tous les formats de messagerie non valides. Par exemple, il permet plusieurs symboles "@", qui ne sont pas autorisés dans une adresse e-mail efficace. Ceci est une version améliorée:

Ce mode d'expression régulière est plus robuste:

• [^ @] Assurez-vous que le contenu avant et après le symbole "@" ne contient pas un autre "@".
• w {2,} Assurez-vous qu'il y a au moins deux caractères dans la partie du nom de domaine (après la période).

Traitement des pièges communs

La fonction d'expression régulière est puissante, mais elles peuvent être délicates. Par exemple, la période dans les expressions régulières (.) Correspond à tous les personnages autres que le changement du personnage. Pour correspondre à la période réelle de la chaîne, vous devez utiliser la pente arrière (.) Pour faire une justice. De plus, le mode d'expression régulière distingue le cas, mais vous pouvez utiliser le logo re.ignorcase pour résoudre ce problème.

Bourse de l'affaire

<code class="language-python">try:
    分子 = int(input("请输入分子："))
    分母 = int(input("请输入分母："))
    结果 = 分子 / 分母
    print(f"结果是 {结果}")
except ZeroDivisionError:
    print("错误：不能除以零！")
except ValueError:
    print("错误：请输入有效的整数！")</code>

En utilisant le logo re.ignorcase, l'expression régulière ne se distingue pas par le cas, et les "com" et "com" sont considérés comme les mêmes.

Extraire les informations de l'utilisateur

L'expression régulière est non seulement utilisée pour vérifier; il est également utilisé pour extraire les parties spécifiques de la chaîne. Supposons que vous souhaitiez extraire le nom d'utilisateur de Twitter URL:

Ce code extrait le nom d'utilisateur Twitter en faisant correspondre la partie pertinente de l'URL. (W) Capturez le nom d'utilisateur, c'est le deuxième groupe de matchs (groupe (2)).

<code class="language-python">import re

邮箱 = input("您的邮箱地址是？").strip()

if re.search(r"^\w+@\w+\.\w+$", 邮箱):
    print("有效的邮箱地址")
else:
    print("无效的邮箱地址")</code>

Optimiser le code avec une expression régulière

Utilisez la chaîne d'origine

Lors du traitement des expressions régulières, il est préférable d'utiliser la chaîne d'origine (R "). La chaîne primitive regarde la pente arrière comme caractère texte pour éviter les séquences de transition accidentelles. Par exemple:

Évitez les erreurs courantes

<code class="language-python">import re

邮箱 = input("您的邮箱地址是？").strip()

if re.search(r"^[^@]+@[^@]+\.\w{2,}$", 邮箱):
    print("有效的邮箱地址")
else:
    print("无效的邮箱地址")</code>

Rendez le mode trop compliqué: à partir de simples, augmentez la complexité que lorsque cela est nécessaire.

• Ignorer les performances: les expressions régulières peuvent être lentes lors de l'utilisation du mode complexe ou du grand texte. En minimisant l'optimisation rétrospective.
• lisibilité: maintenir la lisibilité en décomposant les modèles d'expression régulière complexes en utilisant des annotations ou des modèles détaillés pour maintenir la lisibilité.
Application réelle: Nettoyez l'entrée de l'utilisateur

Les utilisateurs entrent généralement des données dans des formats inattendus. Les expressions régulières peuvent aider à standardiser ces entrées. Considérez un programme pour un nom de format:

Ce code sera réécrit comme "nom nommé" dans le nom "nom de famille, nom".

<code class="language-python">import re

邮箱 = input("您的邮箱地址是？").strip()

if re.search(r"^\w+@\w+\.\w+$", 邮箱, re.IGNORECASE):
    print("有效的邮箱地址")
else:
    print("无效的邮箱地址")</code>

Optimisation SEO et utilisation réelle

L'expression régulière peut également jouer un rôle dans le référencement. Par exemple, ils peuvent être utilisés pour la capture du réseau, extraire des balises META ou un contenu spécifique à partir de HTML pour garantir que le contenu réseau est optimisé pour les moteurs de recherche.

Cet exemple est la description de l'élément de la marque HTML, qui est essentiel pour le référencement.

<code class="language-python">import re

网址 = input("请输入您的 Twitter 个人资料网址：").strip()

匹配 = re.search(r"^https?://(www\.)?twitter\.com/(\w+)", 网址)
if 匹配:
    用户名 = 匹配.group(2)
    print(f"用户名：{用户名}")
else:
    print("无效的网址")</code>

Conclusion

Comprendre et maîtriser l'expression régulière dans Python pour ouvrir un monde plein de possibilités, de la vérification simple aux tâches de traitement de texte complexes. Combiné avec le traitement anormal correct, vous pouvez créer une application solide, efficace et conviviale. Continuez à essayer différents modèles d'expression réguliers.

En maîtrisant ces concepts, vous pouvez non seulement écrire du code plus concis et plus efficace, mais aussi obtenir les avantages du développement d'applications qui peuvent gérer élégamment l'entrée du monde réel.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!